src/hotspot/share/classfile/javaClasses.cpp

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

*** 2592,2606 ****
    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);
      java_lang_StackTraceElement::set_moduleName(element(), module_name);
      oop module_version;
      if (module->version() != NULL) {
!       module_version = StringTable::intern(module->version(), CHECK);
      } else {
        module_version = NULL;
      }
      java_lang_StackTraceElement::set_moduleVersion(element(), module_version);
    }
--- 2592,2615 ----
    java_lang_StackTraceElement::set_methodName(element(), methodname);
  
    // Fill in module name and version
    ModuleEntry* module = holder->module();
    if (module->is_named()) {
!     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) {
!       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,3110 ****
--- 3110,3120 ----
  }
  
  
  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,3122 ****
                            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)
  
  void java_lang_Module::compute_offsets() {
    InstanceKlass* k = SystemDictionary::Module_klass();
    MODULE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
    MODULE_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
--- 3122,3133 ----
                            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(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,3156 ****
--- 3158,3173 ----
  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,3180 ****
--- 3188,3257 ----
    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);