jdk-sandbox: comparison hotspot/src/share/vm/classfile/javaClasses.cpp

equal deleted inserted replaced

-:7e8e5ceecf99
+:0553e129e0ec
 // Initialize static fields
 InstanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, mirror, CHECK);
 }
-// Set the java.lang.reflect.Module module field in the java_lang_Class mirror
+// Set the java.lang.Module module field in the java_lang_Class mirror
 void java_lang_Class::set_mirror_module_field(KlassHandle k, Handle mirror, Handle module, TRAPS) {
 if (module.is_null()) {
 // During startup, the module may be NULL only if java.base has not been defined yet.
-// Put the class on the fixup_module_list to patch later when the java.lang.reflect.Module
+// Put the class on the fixup_module_list to patch later when the java.lang.Module
 // for java.base is known.
-assert(!Universe::is_module_initialized(), "Incorrect java.lang.reflect.Module pre module system initialization");
+assert(!Universe::is_module_initialized(), "Incorrect java.lang.Module pre module system initialization");
 bool javabase_was_defined = false;
 {
 MutexLocker m1(Module_lock, THREAD);
 // Keep list of classes needing java.base module fixup
 }
 } else {
 assert(Universe::is_module_initialized() ||
 (ModuleEntryTable::javabase_defined() &&
 (module() == JNIHandles::resolve(ModuleEntryTable::javabase_moduleEntry()->module()))),
-"Incorrect java.lang.reflect.Module specification while creating mirror");
+"Incorrect java.lang.Module specification while creating mirror");
 set_module(mirror(), module());
 }
 }
 void java_lang_Class::create_mirror(KlassHandle k, Handle class_loader,
 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
 param->obj_field_put(executable_offset, value);
 }
-int java_lang_reflect_Module::loader_offset;
+int java_lang_Module::loader_offset;
-int java_lang_reflect_Module::name_offset;
+int java_lang_Module::name_offset;
-int java_lang_reflect_Module::_module_entry_offset = -1;
+int java_lang_Module::_module_entry_offset = -1;
-Handle java_lang_reflect_Module::create(Handle loader, Handle module_name, TRAPS) {
+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");
-Symbol* name = vmSymbols::java_lang_reflect_Module();
+Symbol* name = vmSymbols::java_lang_Module();
 Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
 instanceKlassHandle klass (THREAD, k);
-Handle jlrmh = klass->allocate_instance_handle(CHECK_NH);
+Handle jlmh = klass->allocate_instance_handle(CHECK_NH);
 JavaValue result(T_VOID);
-JavaCalls::call_special(&result, jlrmh, KlassHandle(THREAD, klass()),
+JavaCalls::call_special(&result, jlmh, KlassHandle(THREAD, klass()),
 vmSymbols::object_initializer_name(),
-vmSymbols::java_lang_reflect_module_init_signature(),
+vmSymbols::java_lang_module_init_signature(),
 loader, module_name, CHECK_NH);
-return jlrmh;
+return jlmh;
 }
-void java_lang_reflect_Module::compute_offsets() {
+void java_lang_Module::compute_offsets() {
-Klass* k = SystemDictionary::reflect_Module_klass();
+Klass* k = SystemDictionary::Module_klass();
 if(NULL != k) {
 compute_offset(loader_offset,  k, vmSymbols::loader_name(),  vmSymbols::classloader_signature());
 compute_offset(name_offset,    k, vmSymbols::name_name(),    vmSymbols::string_signature());
 MODULE_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
 }
 }
-oop java_lang_reflect_Module::loader(oop module) {
+oop java_lang_Module::loader(oop module) {
 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
 return module->obj_field(loader_offset);
 }
-void java_lang_reflect_Module::set_loader(oop module, oop value) {
+void java_lang_Module::set_loader(oop module, oop value) {
 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
 module->obj_field_put(loader_offset, value);
 }
-oop java_lang_reflect_Module::name(oop module) {
+oop java_lang_Module::name(oop module) {
 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
 return module->obj_field(name_offset);
 }
-void java_lang_reflect_Module::set_name(oop module, oop value) {
+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);
 }
-ModuleEntry* java_lang_reflect_Module::module_entry(oop module, TRAPS) {
+ModuleEntry* java_lang_Module::module_entry(oop module, TRAPS) {
 assert(_module_entry_offset != -1, "Uninitialized module_entry_offset");
 assert(module != NULL, "module can't be null");
 assert(module->is_oop(), "module must be oop");
 ModuleEntry* module_entry = (ModuleEntry*)module->address_field(_module_entry_offset);
 if (module_entry == NULL) {
 // If the inject field containing the ModuleEntry* is null then return the
 // class loader's unnamed module.
-oop loader = java_lang_reflect_Module::loader(module);
+oop loader = java_lang_Module::loader(module);
 Handle h_loader = Handle(THREAD, loader);
 ClassLoaderData* loader_cld = SystemDictionary::register_loader(h_loader, CHECK_NULL);
 return loader_cld->modules()->unnamed_module();
 }
 return module_entry;
 }
-void java_lang_reflect_Module::set_module_entry(oop module, ModuleEntry* module_entry) {
+void java_lang_Module::set_module_entry(oop module, ModuleEntry* module_entry) {
 assert(_module_entry_offset != -1, "Uninitialized module_entry_offset");
 assert(module != NULL, "module can't be null");
 assert(module->is_oop(), "module must be oop");
 module->address_field_put(_module_entry_offset, (address)module_entry);
 }
 java_lang_reflect_Field::compute_offsets();
 java_nio_Buffer::compute_offsets();
 reflect_ConstantPool::compute_offsets();
 reflect_UnsafeStaticFieldAccessorImpl::compute_offsets();
 java_lang_reflect_Parameter::compute_offsets();
-java_lang_reflect_Module::compute_offsets();
+java_lang_Module::compute_offsets();
 java_lang_StackFrameInfo::compute_offsets();
 java_lang_LiveStackFrameInfo::compute_offsets();
 // generated interpreter code wants to know about the offsets we just computed:
 AbstractAssembler::update_delayed_values();

changeset 44520	0553e129e0ec
parent 43929	9a572e758c9b
child 46388	d7a164ad6b7f