jdk8-mips64-public/hotspot: comparison src/share/vm/classfile/javaClasses.cpp

-:1f6d42899c3a
+:4ce7240d622c
 Handle java_lang_String::basic_create(int length, bool tenured, TRAPS) {
 // Create the String object first, so there's a chance that the String
 // and the char array it points to end up in the same cache line.
 oop obj;
 if (tenured) {
-obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_permanent_instance(CHECK_NH);
+obj = instanceKlass::cast(SystemDictionary::String_klass())->allocate_permanent_instance(CHECK_NH);
 } else {
-obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_instance(CHECK_NH);
+obj = instanceKlass::cast(SystemDictionary::String_klass())->allocate_instance(CHECK_NH);
 }
 // Create the char array.  The String object must be handlized here
 // because GC can happen as a result of the allocation attempt.
 Handle h_obj(THREAD, obj);
 return UNICODE::as_utf8(position, len);
 }
 bool java_lang_String::equals(oop java_string, jchar* chars, int len) {
 assert(SharedSkipVerify ||
-java_string->klass() == SystemDictionary::string_klass(),
+java_string->klass() == SystemDictionary::String_klass(),
 "must be java_string");
 typeArrayOop value  = java_lang_String::value(java_string);
 int          offset = java_lang_String::offset(java_string);
 int          length = java_lang_String::length(java_string);
 if (length != len) {
 return true;
 }
 void java_lang_String::print(Handle java_string, outputStream* st) {
 oop          obj    = java_string();
-assert(obj->klass() == SystemDictionary::string_klass(), "must be java_string");
+assert(obj->klass() == SystemDictionary::String_klass(), "must be java_string");
 typeArrayOop value  = java_lang_String::value(obj);
 int          offset = java_lang_String::offset(obj);
 int          length = java_lang_String::length(obj);
 int end = MIN2(length, 100);
 // to support Class.getModifiers().  Instance classes recalculate
 // the cached flags after the class file is parsed, but before the
 // class is put into the system dictionary.
 int computed_modifiers = k->compute_modifier_flags(CHECK_0);
 k->set_modifier_flags(computed_modifiers);
-if (SystemDictionary::class_klass_loaded()) {
+if (SystemDictionary::Class_klass_loaded()) {
 // Allocate mirror (java.lang.Class instance)
-Handle mirror = instanceKlass::cast(SystemDictionary::class_klass())->allocate_permanent_instance(CHECK_0);
+Handle mirror = instanceKlass::cast(SystemDictionary::Class_klass())->allocate_permanent_instance(CHECK_0);
 // Setup indirections
 mirror->obj_field_put(klass_offset,  k());
 k->set_java_mirror(mirror());
 // It might also have a component mirror.  This mirror must already exist.
 if (k->oop_is_javaArray()) {
 oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {
 // This should be improved by adding a field at the Java level or by
 // introducing a new VM klass (see comment in ClassFileParser)
-oop java_class = instanceKlass::cast(SystemDictionary::class_klass())->allocate_permanent_instance(CHECK_0);
+oop java_class = instanceKlass::cast(SystemDictionary::Class_klass())->allocate_permanent_instance(CHECK_0);
 if (type != T_VOID) {
 klassOop aklass = Universe::typeArrayKlassObj(type);
 assert(aklass != NULL, "correct bootstrap");
 set_array_klass(java_class, aklass);
 }
 }
 oop java_lang_Class::primitive_mirror(BasicType t) {
 oop mirror = Universe::java_mirror(t);
-assert(mirror != NULL && mirror->is_a(SystemDictionary::class_klass()), "must be a Class");
+assert(mirror != NULL && mirror->is_a(SystemDictionary::Class_klass()), "must be a Class");
 assert(java_lang_Class::is_primitive(mirror), "must be primitive");
 return mirror;
 }
 bool java_lang_Class::offsets_computed = false;
 void java_lang_Class::compute_offsets() {
 assert(!offsets_computed, "offsets should be initialized only once");
 offsets_computed = true;
-klassOop k = SystemDictionary::class_klass();
+klassOop k = SystemDictionary::Class_klass();
 // The classRedefinedCount field is only present starting in 1.5,
 // so don't go fatal.
 compute_optional_offset(classRedefinedCount_offset,
 k, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature());
 // The field indicating parallelCapable (parallelLockMap) is only present starting in 7,
-klassOop k1 = SystemDictionary::classloader_klass();
+klassOop k1 = SystemDictionary::ClassLoader_klass();
 compute_optional_offset(parallelCapable_offset,
 k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature());
 }
 // For class loader classes, parallelCapable defined
 void java_lang_Thread::compute_offsets() {
 assert(_group_offset == 0, "offsets should be initialized only once");
-klassOop k = SystemDictionary::thread_klass();
+klassOop k = SystemDictionary::Thread_klass();
 compute_offset(_name_offset,      k, vmSymbols::name_name(),      vmSymbols::char_array_signature());
 compute_offset(_group_offset,     k, vmSymbols::group_name(),     vmSymbols::threadgroup_signature());
 compute_offset(_contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature());
 compute_offset(_inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature());
 compute_offset(_priority_offset,  k, vmSymbols::priority_name(),  vmSymbols::int_signature());
 }
 void java_lang_ThreadGroup::compute_offsets() {
 assert(_parent_offset == 0, "offsets should be initialized only once");
-klassOop k = SystemDictionary::threadGroup_klass();
+klassOop k = SystemDictionary::ThreadGroup_klass();
 compute_offset(_parent_offset,      k, vmSymbols::parent_name(),      vmSymbols::threadgroup_signature());
 compute_offset(_name_offset,        k, vmSymbols::name_name(),        vmSymbols::string_signature());
 compute_offset(_threads_offset,     k, vmSymbols::threads_name(),     vmSymbols::thread_array_signature());
 compute_offset(_groups_offset,      k, vmSymbols::groups_name(),      vmSymbols::threadgroup_array_signature());
 // Fill in stack trace into preallocated backtrace (no GC)
 // No-op if stack trace is disabled
 if (!StackTraceInThrowable) return;
-assert(throwable->is_a(SystemDictionary::throwable_klass()), "sanity check");
+assert(throwable->is_a(SystemDictionary::Throwable_klass()), "sanity check");
 oop backtrace = java_lang_Throwable::backtrace(throwable());
 assert(backtrace != NULL, "backtrace not preallocated");
 oop m = objArrayOop(backtrace)->obj_at(trace_methods_offset);
 oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) {
 // SystemDictionary::stackTraceElement_klass() will be null for pre-1.4 JDKs
 assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4");
 // Allocate java.lang.StackTraceElement instance
-klassOop k = SystemDictionary::stackTraceElement_klass();
+klassOop k = SystemDictionary::StackTraceElement_klass();
 assert(k != NULL, "must be loaded in 1.4+");
 instanceKlassHandle ik (THREAD, k);
 if (ik->should_be_initialized()) {
 ik->initialize(CHECK_0);
 }
 return element();
 }
 void java_lang_reflect_AccessibleObject::compute_offsets() {
-klassOop k = SystemDictionary::reflect_accessible_object_klass();
+klassOop k = SystemDictionary::reflect_AccessibleObject_klass();
 compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature());
 }
 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
 reflect->bool_field_put(override_offset, (int) value);
 }
 void java_lang_reflect_Method::compute_offsets() {
-klassOop k = SystemDictionary::reflect_method_klass();
+klassOop k = SystemDictionary::reflect_Method_klass();
 compute_offset(clazz_offset,          k, vmSymbols::clazz_name(),          vmSymbols::class_signature());
 compute_offset(name_offset,           k, vmSymbols::name_name(),           vmSymbols::string_signature());
 compute_offset(returnType_offset,     k, vmSymbols::returnType_name(),     vmSymbols::class_signature());
 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature());
 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature());
 compute_optional_offset(annotation_default_offset,    k, vmSymbols::annotation_default_name(),    vmSymbols::byte_array_signature());
 }
 Handle java_lang_reflect_Method::create(TRAPS) {
 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
-klassOop klass = SystemDictionary::reflect_method_klass();
+klassOop klass = SystemDictionary::reflect_Method_klass();
 // This class is eagerly initialized during VM initialization, since we keep a refence
 // to one of the methods
 assert(instanceKlass::cast(klass)->is_initialized(), "must be initialized");
 return instanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH);
 }
 assert(has_annotation_default_field(), "annotation default field must be present");
 method->obj_field_put(annotation_default_offset, value);
 }
 void java_lang_reflect_Constructor::compute_offsets() {
-klassOop k = SystemDictionary::reflect_constructor_klass();
+klassOop k = SystemDictionary::reflect_Constructor_klass();
 compute_offset(clazz_offset,          k, vmSymbols::clazz_name(),          vmSymbols::class_signature());
 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature());
 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature());
 compute_offset(slot_offset,           k, vmSymbols::slot_name(),           vmSymbols::int_signature());
 compute_offset(modifiers_offset,      k, vmSymbols::modifiers_name(),      vmSymbols::int_signature());
 assert(has_parameter_annotations_field(), "parameter annotations field must be present");
 method->obj_field_put(parameter_annotations_offset, value);
 }
 void java_lang_reflect_Field::compute_offsets() {
-klassOop k = SystemDictionary::reflect_field_klass();
+klassOop k = SystemDictionary::reflect_Field_klass();
 compute_offset(clazz_offset,     k, vmSymbols::clazz_name(),     vmSymbols::class_signature());
 compute_offset(name_offset,      k, vmSymbols::name_name(),      vmSymbols::string_signature());
 compute_offset(type_offset,      k, vmSymbols::type_name(),      vmSymbols::class_signature());
 compute_offset(slot_offset,      k, vmSymbols::slot_name(),      vmSymbols::int_signature());
 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
 field->obj_field_put(annotations_offset, value);
 }
 void sun_reflect_ConstantPool::compute_offsets() {
-klassOop k = SystemDictionary::reflect_constant_pool_klass();
+klassOop k = SystemDictionary::reflect_ConstantPool_klass();
 // This null test can be removed post beta
 if (k != NULL) {
 compute_offset(_cp_oop_offset, k, vmSymbols::constantPoolOop_name(), vmSymbols::object_signature());
 }
 }
 Handle sun_reflect_ConstantPool::create(TRAPS) {
 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
-klassOop k = SystemDictionary::reflect_constant_pool_klass();
+klassOop k = SystemDictionary::reflect_ConstantPool_klass();
 instanceKlassHandle klass (THREAD, k);
 // Ensure it is initialized
 klass->initialize(CHECK_NH);
 return klass->allocate_instance_handle(CHECK_NH);
 }
 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
 reflect->obj_field_put(_cp_oop_offset, value);
 }
 void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() {
-klassOop k = SystemDictionary::reflect_unsafe_static_field_accessor_impl_klass();
+klassOop k = SystemDictionary::reflect_UnsafeStaticFieldAccessorImpl_klass();
 // This null test can be removed post beta
 if (k != NULL) {
 compute_offset(_base_offset, k,
 vmSymbols::base_name(), vmSymbols::object_signature());
 }
 }
 // Support for java_lang_ref_Reference
 oop java_lang_ref_Reference::pending_list_lock() {
-instanceKlass* ik = instanceKlass::cast(SystemDictionary::reference_klass());
+instanceKlass* ik = instanceKlass::cast(SystemDictionary::Reference_klass());
 char *addr = (((char *)ik->start_of_static_fields()) + static_lock_offset);
 if (UseCompressedOops) {
 return oopDesc::load_decode_heap_oop((narrowOop *)addr);
 } else {
 return oopDesc::load_decode_heap_oop((oop*)addr);
 }
 }
 HeapWord *java_lang_ref_Reference::pending_list_addr() {
-instanceKlass* ik = instanceKlass::cast(SystemDictionary::reference_klass());
+instanceKlass* ik = instanceKlass::cast(SystemDictionary::Reference_klass());
 char *addr = (((char *)ik->start_of_static_fields()) + static_pending_offset);
 // XXX This might not be HeapWord aligned, almost rather be char *.
 return (HeapWord*)addr;
 }
 jlong java_lang_ref_SoftReference::timestamp(oop ref) {
 return ref->long_field(timestamp_offset);
 }
 jlong java_lang_ref_SoftReference::clock() {
-instanceKlass* ik = instanceKlass::cast(SystemDictionary::soft_reference_klass());
+instanceKlass* ik = instanceKlass::cast(SystemDictionary::SoftReference_klass());
 int offset = ik->offset_of_static_fields() + static_clock_offset;
-return SystemDictionary::soft_reference_klass()->long_field(offset);
+return SystemDictionary::SoftReference_klass()->long_field(offset);
 }
 void java_lang_ref_SoftReference::set_clock(jlong value) {
-instanceKlass* ik = instanceKlass::cast(SystemDictionary::soft_reference_klass());
+instanceKlass* ik = instanceKlass::cast(SystemDictionary::SoftReference_klass());
 int offset = ik->offset_of_static_fields() + static_clock_offset;
-SystemDictionary::soft_reference_klass()->long_field_put(offset, value);
+SystemDictionary::SoftReference_klass()->long_field_put(offset, value);
 }
 // Support for java_dyn_MethodHandle
 if (loader != NULL) {
 // See whether this is one of the class loaders associated with
 // the generated bytecodes for reflection, and if so, "magically"
 // delegate to its parent to prevent class loading from occurring
 // in places where applications using reflection didn't expect it.
-klassOop delegating_cl_class = SystemDictionary::reflect_delegating_classloader_klass();
+klassOop delegating_cl_class = SystemDictionary::reflect_DelegatingClassLoader_klass();
 // This might be null in non-1.4 JDKs
 if (delegating_cl_class != NULL && loader->is_a(delegating_cl_class)) {
 return parent(loader);
 }
 }
 // Support for java_lang_System
 void java_lang_System::compute_offsets() {
 assert(offset_of_static_fields == 0, "offsets should be initialized only once");
-instanceKlass* ik = instanceKlass::cast(SystemDictionary::system_klass());
+instanceKlass* ik = instanceKlass::cast(SystemDictionary::System_klass());
 offset_of_static_fields = ik->offset_of_static_fields();
 }
 int java_lang_System::in_offset_in_bytes() {
 return (offset_of_static_fields + static_in_offset);

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/classfile/javaClasses.cpp

src/share/vm/classfile/javaClasses.cpp