jdk-sandbox: comparison hotspot/src/share/vm/memory/universe.cpp

equal deleted inserted replaced

-:f372ea9e5ed4
+:80b553bddc26
 vmSymbols::initialize(CHECK);
 SystemDictionary::initialize(CHECK);
-klassOop ok = SystemDictionary::object_klass();
+klassOop ok = SystemDictionary::Object_klass();
 _the_null_string            = StringTable::intern("null", CHECK);
 _the_min_jint_string       = StringTable::intern("-2147483648", CHECK);
 if (UseSharedSpaces) {
 // Verify shared interfaces array.
 assert(_the_array_interfaces_array->obj_at(0) ==
-SystemDictionary::cloneable_klass(), "u3");
+SystemDictionary::Cloneable_klass(), "u3");
 assert(_the_array_interfaces_array->obj_at(1) ==
-SystemDictionary::serializable_klass(), "u3");
+SystemDictionary::Serializable_klass(), "u3");
 // Verify element klass for system obj array klass
 assert(objArrayKlass::cast(_systemObjArrayKlassObj)->element_klass() == ok, "u1");
 assert(objArrayKlass::cast(_systemObjArrayKlassObj)->bottom_klass() == ok, "u2");
 assert(Klass::cast(longArrayKlassObj()     )->super() == ok, "u3");
 assert(Klass::cast(constantPoolKlassObj()  )->super() == ok, "u3");
 assert(Klass::cast(systemObjArrayKlassObj())->super() == ok, "u3");
 } else {
 // Set up shared interfaces array.  (Do this before supers are set up.)
-_the_array_interfaces_array->obj_at_put(0, SystemDictionary::cloneable_klass());
+_the_array_interfaces_array->obj_at_put(0, SystemDictionary::Cloneable_klass());
-_the_array_interfaces_array->obj_at_put(1, SystemDictionary::serializable_klass());
+_the_array_interfaces_array->obj_at_put(1, SystemDictionary::Serializable_klass());
 // Set element klass for system obj array klass
 objArrayKlass::cast(_systemObjArrayKlassObj)->set_element_klass(ok);
 objArrayKlass::cast(_systemObjArrayKlassObj)->set_bottom_klass(ok);
 } // end of core bootstrapping
 // Initialize _objectArrayKlass after core bootstraping to make
 // sure the super class is set up properly for _objectArrayKlass.
 _objectArrayKlassObj = instanceKlass::
-cast(SystemDictionary::object_klass())->array_klass(1, CHECK);
+cast(SystemDictionary::Object_klass())->array_klass(1, CHECK);
 // Add the class to the class hierarchy manually to make sure that
 // its vtable is initialized after core bootstrapping is completed.
 Klass::cast(_objectArrayKlassObj)->append_to_sibling_list();
 // Compute is_jdk version flags.
 objArrayHandle dummy_array(THREAD, naked_array);
 int i = 0;
 while (i < size) {
 if (!UseConcMarkSweepGC) {
 // Allocate dummy in old generation
-oop dummy = instanceKlass::cast(SystemDictionary::object_klass())->allocate_instance(CHECK);
+oop dummy = instanceKlass::cast(SystemDictionary::Object_klass())->allocate_instance(CHECK);
 dummy_array->obj_at_put(i++, dummy);
 }
 // Allocate dummy in permanent generation
-oop dummy = instanceKlass::cast(SystemDictionary::object_klass())->allocate_permanent_instance(CHECK);
+oop dummy = instanceKlass::cast(SystemDictionary::Object_klass())->allocate_permanent_instance(CHECK);
 dummy_array->obj_at_put(i++, dummy);
 }
 {
 // Only modify the global variable inside the mutex.
 // If we had a race to here, the other dummy_array instances
 void Universe::fixup_mirrors(TRAPS) {
 // Bootstrap problem: all classes gets a mirror (java.lang.Class instance) assigned eagerly,
 // but we cannot do that for classes created before java.lang.Class is loaded. Here we simply
 // walk over permanent objects created so far (mostly classes) and fixup their mirrors. Note
 // that the number of objects allocated at this point is very small.
-assert(SystemDictionary::class_klass_loaded(), "java.lang.Class should be loaded");
+assert(SystemDictionary::Class_klass_loaded(), "java.lang.Class should be loaded");
 FixupMirrorClosure blk;
 Universe::heap()->permanent_object_iterate(&blk);
 }
 // Called on VM exit. This ought to be run in a separate thread.
 if (TraceReferenceGC) tty->print_cr("Callback to run finalizers on exit");
 {
 PRESERVE_EXCEPTION_MARK;
-KlassHandle finalizer_klass(THREAD, SystemDictionary::finalizer_klass());
+KlassHandle finalizer_klass(THREAD, SystemDictionary::Finalizer_klass());
 JavaValue result(T_VOID);
 JavaCalls::call_static(
 &result,
 finalizer_klass,
 vmSymbolHandles::run_finalizers_on_exit_name(),
 Universe::_fully_initialized = true;
 EXCEPTION_MARK;
 { ResourceMark rm;
 Interpreter::initialize();      // needed for interpreter entry points
 if (!UseSharedSpaces) {
-KlassHandle ok_h(THREAD, SystemDictionary::object_klass());
+KlassHandle ok_h(THREAD, SystemDictionary::Object_klass());
 Universe::reinitialize_vtable_of(ok_h, CHECK_false);
 Universe::reinitialize_itables(CHECK_false);
 }
 }
 klassOop k;
 instanceKlassHandle k_h;
 if (!UseSharedSpaces) {
 // Setup preallocated empty java.lang.Class array
-Universe::_the_empty_class_klass_array = oopFactory::new_objArray(SystemDictionary::class_klass(), 0, CHECK_false);
+Universe::_the_empty_class_klass_array = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_false);
 // Setup preallocated OutOfMemoryError errors
 k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_OutOfMemoryError(), true, CHECK_false);
 k_h = instanceKlassHandle(THREAD, k);
 Universe::_out_of_memory_error_java_heap = k_h->allocate_permanent_instance(CHECK_false);
 Universe::_out_of_memory_error_perm_gen = k_h->allocate_permanent_instance(CHECK_false);
 // Setup static method for registering finalizers
 // The finalizer klass must be linked before looking up the method, in
 // case it needs to get rewritten.
-instanceKlass::cast(SystemDictionary::finalizer_klass())->link_class(CHECK_false);
+instanceKlass::cast(SystemDictionary::Finalizer_klass())->link_class(CHECK_false);
-methodOop m = instanceKlass::cast(SystemDictionary::finalizer_klass())->find_method(
+methodOop m = instanceKlass::cast(SystemDictionary::Finalizer_klass())->find_method(
 vmSymbols::register_method_name(),
 vmSymbols::register_method_signature());
 if (m == NULL || !m->is_static()) {
 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodException(),
 "java.lang.ref.Finalizer.register", false);
 }
 Universe::_finalizer_register_cache->init(
-SystemDictionary::finalizer_klass(), m, CHECK_false);
+SystemDictionary::Finalizer_klass(), m, CHECK_false);
 // Resolve on first use and initialize class.
 // Note: No race-condition here, since a resolve will always return the same result
 // Setup method for security checks
 "java.lang.reflect.Method.invoke", false);
 }
 Universe::_reflect_invoke_cache->init(k_h(), m, CHECK_false);
 // Setup method for registering loaded classes in class loader vector
-instanceKlass::cast(SystemDictionary::classloader_klass())->link_class(CHECK_false);
+instanceKlass::cast(SystemDictionary::ClassLoader_klass())->link_class(CHECK_false);
-m = instanceKlass::cast(SystemDictionary::classloader_klass())->find_method(vmSymbols::addClass_name(), vmSymbols::class_void_signature());
+m = instanceKlass::cast(SystemDictionary::ClassLoader_klass())->find_method(vmSymbols::addClass_name(), vmSymbols::class_void_signature());
 if (m == NULL || m->is_static()) {
 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodException(),
 "java.lang.ClassLoader.addClass", false);
 }
 Universe::_loader_addClass_cache->init(
-SystemDictionary::classloader_klass(), m, CHECK_false);
+SystemDictionary::ClassLoader_klass(), m, CHECK_false);
 // The folowing is initializing converter functions for serialization in
 // JVM.cpp. If we clean up the StrictMath code above we may want to find
 // a better solution for this as well.
 initialize_converter_functions();

changeset 4571	80b553bddc26
parent 4450	6d700b859b3e
child 5420	586d3988e72b