src/hotspot/share/classfile/javaClasses.cpp

rev 53275 : 8216307: StackTraceElement::fill_in can use existing Module name and version
Reviewed-by: XXX

@@ -2592,15 +2592,24 @@
   java_lang_StackTraceElement::set_methodName(element(), methodname);
 
   // Fill in module name and version
   ModuleEntry* module = holder->module();
   if (module->is_named()) {
-    oop module_name = StringTable::intern(module->name(), CHECK);
+    oop module_name = java_lang_Module::name(module->module());
+    assert(module_name != NULL, "module name is set");
     java_lang_StackTraceElement::set_moduleName(element(), module_name);
     oop module_version;
     if (module->version() != NULL) {
-      module_version = StringTable::intern(module->version(), CHECK);
+      oop md = java_lang_Module::module_descriptor(module->module());
+      assert(md != NULL, "module descriptor is set");
+      oop mdv = java_lang_module_ModuleDescriptor::version(md);
+      if (mdv != NULL) {
+        module_version = java_lang_module_ModuleDescriptor_Version::version(mdv);
+      } else {
+        module_version = java_lang_module_ModuleDescriptor::raw_version(md);
+      }
+      assert(module_version != NULL, "module version string is set");
     } else {
       module_version = NULL;
     }
     java_lang_StackTraceElement::set_moduleVersion(element(), module_version);
   }

@@ -3101,10 +3110,11 @@
 }
 
 
 int java_lang_Module::loader_offset;
 int java_lang_Module::name_offset;
+int java_lang_Module::module_descriptor_offset;
 int java_lang_Module::_module_entry_offset = -1;
 
 Handle java_lang_Module::create(Handle loader, Handle module_name, TRAPS) {
   assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
   return JavaCalls::construct_new_instance(SystemDictionary::Module_klass(),

@@ -3112,11 +3122,12 @@
                           loader, module_name, CHECK_NH);
 }
 
 #define MODULE_FIELDS_DO(macro) \
   macro(loader_offset,  k, vmSymbols::loader_name(),  classloader_signature, false); \
-  macro(name_offset,    k, vmSymbols::name_name(),    string_signature,      false)
+  macro(name_offset,              k, vmSymbols::name_name(),       string_signature,            false); \
+  macro(module_descriptor_offset, k, vmSymbols::descriptor_name(), module_descriptor_signature, false); \
 
 void java_lang_Module::compute_offsets() {
   InstanceKlass* k = SystemDictionary::Module_klass();
   MODULE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
   MODULE_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);

@@ -3147,10 +3158,16 @@
 void java_lang_Module::set_name(oop module, oop value) {
   assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
   module->obj_field_put(name_offset, value);
 }
 
+oop java_lang_Module::module_descriptor(oop module) {
+  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
+  assert(java_lang_Module::is_instance(module), "sanity");
+  return module->obj_field(module_descriptor_offset);
+}
+
 ModuleEntry* java_lang_Module::module_entry(oop module) {
   assert(_module_entry_offset != -1, "Uninitialized module_entry_offset");
   assert(module != NULL, "module can't be null");
   assert(oopDesc::is_oop(module), "module must be oop");
 

@@ -3171,10 +3188,70 @@
   assert(module != NULL, "module can't be null");
   assert(oopDesc::is_oop(module), "module must be oop");
   module->address_field_put(_module_entry_offset, (address)module_entry);
 }
 
+int java_lang_module_ModuleDescriptor::version_offset;
+int java_lang_module_ModuleDescriptor::raw_version_offset;
+
+#define MODULE_DESCRIPTOR_FIELDS_DO(macro) \
+  macro(version_offset,     k, vmSymbols::version_name(),            module_descriptor_version_signature, false); \
+  macro(raw_version_offset, k, vmSymbols::raw_version_string_name(), string_signature,                    false); \
+
+void java_lang_module_ModuleDescriptor::compute_offsets() {
+  InstanceKlass* k = SystemDictionary::ModuleDescriptor_klass();
+  MODULE_DESCRIPTOR_FIELDS_DO(FIELD_COMPUTE_OFFSET);
+}
+
+#if INCLUDE_CDS
+void java_lang_module_ModuleDescriptor::serialize_offsets(SerializeClosure* f) {
+  MODULE_DESCRIPTOR_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
+}
+#endif
+
+inline bool java_lang_module_ModuleDescriptor::is_instance(oop obj) {
+  return obj != NULL && obj->klass() == SystemDictionary::ModuleDescriptor_klass();
+}
+
+oop java_lang_module_ModuleDescriptor::version(oop module_descriptor) {
+  assert(java_lang_module_ModuleDescriptor::is_instance(module_descriptor), "sanity");
+  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
+  return module_descriptor->obj_field(version_offset);
+}
+
+oop java_lang_module_ModuleDescriptor::raw_version(oop module_descriptor) {
+  assert(java_lang_module_ModuleDescriptor::is_instance(module_descriptor), "sanity");
+  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
+  return module_descriptor->obj_field(raw_version_offset);
+}
+
+int java_lang_module_ModuleDescriptor_Version::version_offset;
+
+#define MODULE_DESCRIPTOR_VERSION_FIELDS_DO(macro) \
+  macro(version_offset, k, vmSymbols::version_name(),  string_signature, false); \
+
+void java_lang_module_ModuleDescriptor_Version::compute_offsets() {
+  InstanceKlass* k = SystemDictionary::ModuleDescriptor_Version_klass();
+  MODULE_DESCRIPTOR_VERSION_FIELDS_DO(FIELD_COMPUTE_OFFSET);
+}
+
+#if INCLUDE_CDS
+void java_lang_module_ModuleDescriptor_Version::serialize_offsets(SerializeClosure* f) {
+  MODULE_DESCRIPTOR_VERSION_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
+}
+#endif
+
+inline bool java_lang_module_ModuleDescriptor_Version::is_instance(oop obj) {
+  return obj != NULL && obj->klass() == SystemDictionary::ModuleDescriptor_Version_klass();
+}
+
+oop java_lang_module_ModuleDescriptor_Version::version(oop module_descriptor_version) {
+  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
+  assert(java_lang_module_ModuleDescriptor_Version::is_instance(module_descriptor_version), "sanity");
+  return module_descriptor_version->obj_field(version_offset);
+}
+
 Handle reflect_ConstantPool::create(TRAPS) {
   assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
   InstanceKlass* k = SystemDictionary::reflect_ConstantPool_klass();
   // Ensure it is initialized
   k->initialize(CHECK_NH);