infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-03-24 06:40:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Tom Rodriguez 2010-01-06 14:25:03 -08:00
commit ac5dfe00c7
64 changed files with 361 additions and 443 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
hotspot/agent/src/share/classes/sun/jvm/hotspot/memory/SystemDictionary.java
View File

@ -63,12 +63,12 @@ public class SystemDictionary {
javaSystemLoaderField = type.getOopField("_java_system_loader");
nofBuckets = db.lookupIntConstant("SystemDictionary::_nof_buckets").intValue();
objectKlassField = type.getOopField(WK_KLASS("object_klass"));
classLoaderKlassField = type.getOopField(WK_KLASS("classloader_klass"));
stringKlassField = type.getOopField(WK_KLASS("string_klass"));
systemKlassField = type.getOopField(WK_KLASS("system_klass"));
threadKlassField = type.getOopField(WK_KLASS("thread_klass"));
threadGroupKlassField = type.getOopField(WK_KLASS("threadGroup_klass"));
objectKlassField = type.getOopField(WK_KLASS("Object_klass"));
classLoaderKlassField = type.getOopField(WK_KLASS("ClassLoader_klass"));
stringKlassField = type.getOopField(WK_KLASS("String_klass"));
systemKlassField = type.getOopField(WK_KLASS("System_klass"));
threadKlassField = type.getOopField(WK_KLASS("Thread_klass"));
threadGroupKlassField = type.getOopField(WK_KLASS("ThreadGroup_klass"));
}
// This WK functions must follow the definitions in systemDictionary.hpp:

2
hotspot/src/share/vm/c1/c1_Runtime1.cpp
View File

@ -425,7 +425,7 @@ JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* t
assert(exception.not_null(), "NULL exceptions should be handled by throw_exception");
assert(exception->is_oop(), "just checking");
// Check that exception is a subclass of Throwable, otherwise we have a VerifyError
if (!(exception->is_a(SystemDictionary::throwable_klass()))) {
if (!(exception->is_a(SystemDictionary::Throwable_klass()))) {
if (ExitVMOnVerifyError) vm_exit(-1);
ShouldNotReachHere();
}

15
hotspot/src/share/vm/ci/ciEnv.cpp
View File

@ -38,18 +38,9 @@ ciInstanceKlassKlass* ciEnv::_instance_klass_klass_instance;
ciTypeArrayKlassKlass* ciEnv::_type_array_klass_klass_instance;
ciObjArrayKlassKlass* ciEnv::_obj_array_klass_klass_instance;
ciInstanceKlass* ciEnv::_ArrayStoreException;
ciInstanceKlass* ciEnv::_Class;
ciInstanceKlass* ciEnv::_ClassCastException;
ciInstanceKlass* ciEnv::_InvokeDynamic;
ciInstanceKlass* ciEnv::_Object;
ciInstanceKlass* ciEnv::_Throwable;
ciInstanceKlass* ciEnv::_Thread;
ciInstanceKlass* ciEnv::_OutOfMemoryError;
ciInstanceKlass* ciEnv::_String;
ciInstanceKlass* ciEnv::_StringBuffer;
ciInstanceKlass* ciEnv::_StringBuilder;
ciInstanceKlass* ciEnv::_Integer;
#define WK_KLASS_DEFN(name, ignore_s, ignore_o) ciInstanceKlass* ciEnv::_##name = NULL;
WK_KLASSES_DO(WK_KLASS_DEFN)
#undef WK_KLASS_DEFN
ciSymbol* ciEnv::_unloaded_cisymbol = NULL;
ciInstanceKlass* ciEnv::_unloaded_ciinstance_klass = NULL;

56
hotspot/src/share/vm/ci/ciEnv.hpp
View File

@ -74,18 +74,9 @@ private:
static ciTypeArrayKlassKlass* _type_array_klass_klass_instance;
static ciObjArrayKlassKlass* _obj_array_klass_klass_instance;
static ciInstanceKlass* _ArrayStoreException;
static ciInstanceKlass* _Class;
static ciInstanceKlass* _ClassCastException;
static ciInstanceKlass* _InvokeDynamic;
static ciInstanceKlass* _Object;
static ciInstanceKlass* _Throwable;
static ciInstanceKlass* _Thread;
static ciInstanceKlass* _OutOfMemoryError;
static ciInstanceKlass* _String;
static ciInstanceKlass* _StringBuffer;
static ciInstanceKlass* _StringBuilder;
static ciInstanceKlass* _Integer;
#define WK_KLASS_DECL(name, ignore_s, ignore_o) static ciInstanceKlass* _##name;
WK_KLASSES_DO(WK_KLASS_DECL)
#undef WK_KLASS_DECL
static ciSymbol* _unloaded_cisymbol;
static ciInstanceKlass* _unloaded_ciinstance_klass;
@ -301,42 +292,13 @@ public:
// Access to certain well known ciObjects.
ciInstanceKlass* ArrayStoreException_klass() {
return _ArrayStoreException;
}
ciInstanceKlass* Class_klass() {
return _Class;
}
ciInstanceKlass* ClassCastException_klass() {
return _ClassCastException;
}
ciInstanceKlass* InvokeDynamic_klass() {
return _InvokeDynamic;
}
ciInstanceKlass* Object_klass() {
return _Object;
}
ciInstanceKlass* Throwable_klass() {
return _Throwable;
}
ciInstanceKlass* Thread_klass() {
return _Thread;
}
ciInstanceKlass* OutOfMemoryError_klass() {
return _OutOfMemoryError;
}
ciInstanceKlass* String_klass() {
return _String;
}
ciInstanceKlass* StringBuilder_klass() {
return _StringBuilder;
}
ciInstanceKlass* StringBuffer_klass() {
return _StringBuffer;
}
ciInstanceKlass* Integer_klass() {
return _Integer;
#define WK_KLASS_FUNC(name, ignore_s, ignore_o) \
ciInstanceKlass* name() { \
return _##name;\
}
WK_KLASSES_DO(WK_KLASS_FUNC)
#undef WK_KLASS_FUNC
ciInstance* NullPointerException_instance() {
assert(_NullPointerException_instance != NULL, "initialization problem");
return _NullPointerException_instance;

4
hotspot/src/share/vm/ci/ciField.cpp
View File

@ -192,8 +192,8 @@ void ciField::initialize_from(fieldDescriptor* fd) {
// java.lang.System.out, and java.lang.System.err.
klassOop k = _holder->get_klassOop();
assert( SystemDictionary::system_klass() != NULL, "Check once per vm");
if( k == SystemDictionary::system_klass() ) {
assert( SystemDictionary::System_klass() != NULL, "Check once per vm");
if( k == SystemDictionary::System_klass() ) {
// Check offsets for case 2: System.in, System.out, or System.err
if( _offset == java_lang_System::in_offset_in_bytes() ||
_offset == java_lang_System::out_offset_in_bytes() ||

2
hotspot/src/share/vm/ci/ciInstance.cpp
View File

@ -36,7 +36,7 @@ ciType* ciInstance::java_mirror_type() {
VM_ENTRY_MARK;
oop m = get_oop();
// Return NULL if it is not java.lang.Class.
if (m == NULL || m->klass() != SystemDictionary::class_klass()) {
if (m == NULL || m->klass() != SystemDictionary::Class_klass()) {
return NULL;
}
// Return either a primitive type or a klass.

2
hotspot/src/share/vm/ci/ciInstanceKlass.cpp
View File

@ -75,7 +75,7 @@ ciInstanceKlass::ciInstanceKlass(KlassHandle h_k) :
_java_mirror = NULL;
if (is_shared()) {
if (h_k() != SystemDictionary::object_klass()) {
if (h_k() != SystemDictionary::Object_klass()) {
super();
}
java_mirror();

46
hotspot/src/share/vm/ci/ciObjectFactory.cpp
View File

@ -144,43 +144,13 @@ void ciObjectFactory::init_shared_objects() {
ciEnv::_obj_array_klass_klass_instance =
get(Universe::objArrayKlassKlassObj())
->as_obj_array_klass_klass();
ciEnv::_ArrayStoreException =
get(SystemDictionary::ArrayStoreException_klass())
->as_instance_klass();
ciEnv::_Class =
get(SystemDictionary::class_klass())
->as_instance_klass();
ciEnv::_ClassCastException =
get(SystemDictionary::ClassCastException_klass())
->as_instance_klass();
if (EnableInvokeDynamic) {
ciEnv::_InvokeDynamic =
get(SystemDictionary::InvokeDynamic_klass())->as_instance_klass();
}
ciEnv::_Object =
get(SystemDictionary::object_klass())
->as_instance_klass();
ciEnv::_Throwable =
get(SystemDictionary::throwable_klass())
->as_instance_klass();
ciEnv::_Thread =
get(SystemDictionary::thread_klass())
->as_instance_klass();
ciEnv::_OutOfMemoryError =
get(SystemDictionary::OutOfMemoryError_klass())
->as_instance_klass();
ciEnv::_String =
get(SystemDictionary::string_klass())
->as_instance_klass();
ciEnv::_StringBuffer =
get(SystemDictionary::stringBuffer_klass())
->as_instance_klass();
ciEnv::_StringBuilder =
get(SystemDictionary::StringBuilder_klass())
->as_instance_klass();
ciEnv::_Integer =
get(SystemDictionary::int_klass())
->as_instance_klass();
#define WK_KLASS_DEFN(name, ignore_s, opt) \
if (SystemDictionary::name() != NULL) \
ciEnv::_##name = get(SystemDictionary::name())->as_instance_klass();
WK_KLASSES_DO(WK_KLASS_DEFN)
#undef WK_KLASS_DEFN
for (int len = -1; len != _ci_objects->length(); ) {
len = _ci_objects->length();
@ -588,7 +558,7 @@ ciObjectFactory::NonPermObject* &ciObjectFactory::find_non_perm(oop key) {
if (key->is_perm() && _non_perm_count == 0) {
return emptyBucket;
} else if (key->is_instance()) {
if (key->klass() == SystemDictionary::class_klass()) {
if (key->klass() == SystemDictionary::Class_klass()) {
// class mirror instances are always perm
return emptyBucket;
}

2
hotspot/src/share/vm/ci/ciType.cpp
View File

@ -111,7 +111,7 @@ ciType* ciType::make(BasicType t) {
// short, etc.
// Note: Bare T_ADDRESS means a raw pointer type, not a return_address.
assert((uint)t < T_CONFLICT+1, "range check");
if (t == T_OBJECT) return ciEnv::_Object; // java/lang/Object
if (t == T_OBJECT) return ciEnv::_Object_klass; // java/lang/Object
assert(_basic_types[t] != NULL, "domain check");
return _basic_types[t];
}

2
hotspot/src/share/vm/ci/ciUtilities.hpp
View File

@ -79,7 +79,7 @@
THREAD); \
if (HAS_PENDING_EXCEPTION) { \
if (PENDING_EXCEPTION->klass() == \
SystemDictionary::threaddeath_klass()) { \
SystemDictionary::ThreadDeath_klass()) { \
/* Kill the compilation. */ \
fatal("unhandled ci exception"); \
return (result); \

8
hotspot/src/share/vm/classfile/classFileParser.cpp
View File

@ -430,7 +430,7 @@ void ClassFileParser::patch_constant_pool(constantPoolHandle cp, int index, Hand
case JVM_CONSTANT_UnresolvedClass :
// Patching a class means pre-resolving it.
// The name in the constant pool is ignored.
if (patch->klass() == SystemDictionary::class_klass()) { // %%% java_lang_Class::is_instance
if (patch->klass() == SystemDictionary::Class_klass()) { // %%% java_lang_Class::is_instance
guarantee_property(!java_lang_Class::is_primitive(patch()),
"Illegal class patch at %d in class file %s",
index, CHECK);
@ -3469,8 +3469,8 @@ void ClassFileParser::set_precomputed_flags(instanceKlassHandle k) {
#endif
// Check if this klass supports the java.lang.Cloneable interface
if (SystemDictionary::cloneable_klass_loaded()) {
if (k->is_subtype_of(SystemDictionary::cloneable_klass())) {
if (SystemDictionary::Cloneable_klass_loaded()) {
if (k->is_subtype_of(SystemDictionary::Cloneable_klass())) {
k->set_is_cloneable();
}
}
@ -4175,7 +4175,7 @@ char* ClassFileParser::skip_over_field_name(char* name, bool slash_ok, unsigned
// Check if ch is Java identifier start or is Java identifier part
// 4672820: call java.lang.Character methods directly without generating separate tables.
EXCEPTION_MARK;
instanceKlassHandle klass (THREAD, SystemDictionary::char_klass());
instanceKlassHandle klass (THREAD, SystemDictionary::Character_klass());
// return value
JavaValue result(T_BOOLEAN);

2
hotspot/src/share/vm/classfile/classLoader.cpp
View File

@ -819,7 +819,7 @@ objArrayOop ClassLoader::get_system_packages(TRAPS) {
_package_hash_table->copy_pkgnames(packages);
}
// Allocate objArray and fill with java.lang.String
objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(),
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
nof_entries, CHECK_0);
objArrayHandle result(THREAD, r);
for (int i = 0; i < nof_entries; i++) {

4
hotspot/src/share/vm/classfile/javaAssertions.cpp
View File

@ -95,14 +95,14 @@ oop JavaAssertions::createAssertionStatusDirectives(TRAPS) {
int len;
typeArrayOop t;
len = OptionList::count(_packages);
objArrayOop pn = oopFactory::new_objArray(SystemDictionary::string_klass(), len, CHECK_NULL);
objArrayOop pn = oopFactory::new_objArray(SystemDictionary::String_klass(), len, CHECK_NULL);
objArrayHandle pkgNames (THREAD, pn);
t = oopFactory::new_typeArray(T_BOOLEAN, len, CHECK_NULL);
typeArrayHandle pkgEnabled(THREAD, t);
fillJavaArrays(_packages, len, pkgNames, pkgEnabled, CHECK_NULL);
len = OptionList::count(_classes);
objArrayOop cn = oopFactory::new_objArray(SystemDictionary::string_klass(), len, CHECK_NULL);
objArrayOop cn = oopFactory::new_objArray(SystemDictionary::String_klass(), len, CHECK_NULL);
objArrayHandle classNames (THREAD, cn);
t = oopFactory::new_typeArray(T_BOOLEAN, len, CHECK_NULL);
typeArrayHandle classEnabled(THREAD, t);

60
hotspot/src/share/vm/classfile/javaClasses.cpp
View File

@ -68,9 +68,9 @@ Handle java_lang_String::basic_create(int length, bool tenured, TRAPS) {
// 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
@ -293,7 +293,7 @@ char* java_lang_String::as_utf8_string(oop java_string, int start, int 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);
@ -311,7 +311,7 @@ bool java_lang_String::equals(oop java_string, jchar* chars, int len) {
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);
@ -339,9 +339,9 @@ oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {
// 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());
@ -378,7 +378,7 @@ oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {
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");
@ -502,7 +502,7 @@ BasicType java_lang_Class::as_BasicType(oop java_class, klassOop* reference_klas
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;
}
@ -515,14 +515,14 @@ 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());
}
@ -588,7 +588,7 @@ int java_lang_Thread::_park_event_offset = 0 ;
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());
@ -847,7 +847,7 @@ bool java_lang_ThreadGroup::is_vmAllowSuspension(oop java_thread_group) {
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());
@ -1344,7 +1344,7 @@ void java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(Handle t
// 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");
@ -1449,7 +1449,7 @@ oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) {
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()) {
@ -1487,7 +1487,7 @@ oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) {
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());
}
@ -1502,7 +1502,7 @@ void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean valu
}
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());
@ -1523,7 +1523,7 @@ void java_lang_reflect_Method::compute_offsets() {
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");
@ -1665,7 +1665,7 @@ void java_lang_reflect_Method::set_annotation_default(oop method, oop 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());
@ -1789,7 +1789,7 @@ void java_lang_reflect_Constructor::set_parameter_annotations(oop method, oop va
}
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());
@ -1896,7 +1896,7 @@ void java_lang_reflect_Field::set_annotations(oop field, oop 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());
@ -1906,7 +1906,7 @@ void sun_reflect_ConstantPool::compute_offsets() {
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);
@ -1926,7 +1926,7 @@ void sun_reflect_ConstantPool::set_cp_oop(oop reflect, oop 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,
@ -2072,7 +2072,7 @@ void java_lang_boxing_object::print(BasicType type, jvalue* value, outputStream*
// 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);
@ -2082,7 +2082,7 @@ oop java_lang_ref_Reference::pending_list_lock() {
}
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;
@ -2105,17 +2105,17 @@ jlong java_lang_ref_SoftReference::timestamp(oop ref) {
}
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);
}
@ -2538,7 +2538,7 @@ oop java_lang_ClassLoader::non_reflection_class_loader(oop loader) {
// 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);
@ -2553,7 +2553,7 @@ oop java_lang_ClassLoader::non_reflection_class_loader(oop loader) {
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();
}

4
hotspot/src/share/vm/classfile/javaClasses.hpp
View File

@ -111,7 +111,7 @@ class java_lang_String : AllStatic {
// Testers
static bool is_instance(oop obj) {
return obj != NULL && obj->klass() == SystemDictionary::string_klass();
return obj != NULL && obj->klass() == SystemDictionary::String_klass();
}
// Debugging
@ -161,7 +161,7 @@ class java_lang_Class : AllStatic {
static void print_signature(oop java_class, outputStream *st);
// Testing
static bool is_instance(oop obj) {
return obj != NULL && obj->klass() == SystemDictionary::class_klass();
return obj != NULL && obj->klass() == SystemDictionary::Class_klass();
}
static bool is_primitive(oop java_class);
static BasicType primitive_type(oop java_class);

56
hotspot/src/share/vm/classfile/systemDictionary.cpp
View File

@ -60,10 +60,10 @@ oop SystemDictionary::java_system_loader() {
}
void SystemDictionary::compute_java_system_loader(TRAPS) {
KlassHandle system_klass(THREAD, WK_KLASS(classloader_klass));
KlassHandle system_klass(THREAD, WK_KLASS(ClassLoader_klass));
JavaValue result(T_OBJECT);
JavaCalls::call_static(&result,
KlassHandle(THREAD, WK_KLASS(classloader_klass)),
KlassHandle(THREAD, WK_KLASS(ClassLoader_klass)),
vmSymbolHandles::getSystemClassLoader_name(),
vmSymbolHandles::void_classloader_signature(),
CHECK);
@ -128,7 +128,7 @@ klassOop SystemDictionary::handle_resolution_exception(symbolHandle class_name,
// in which case we have to check whether the pending exception is a ClassNotFoundException,
// and if so convert it to a NoClassDefFoundError
// And chain the original ClassNotFoundException
if (throw_error && PENDING_EXCEPTION->is_a(SystemDictionary::classNotFoundException_klass())) {
if (throw_error && PENDING_EXCEPTION->is_a(SystemDictionary::ClassNotFoundException_klass())) {
ResourceMark rm(THREAD);
assert(klass_h() == NULL, "Should not have result with exception pending");
Handle e(THREAD, PENDING_EXCEPTION);
@ -359,7 +359,7 @@ void SystemDictionary::validate_protection_domain(instanceKlassHandle klass,
assert(class_loader() != NULL, "should not have non-null protection domain for null classloader");
KlassHandle system_loader(THREAD, SystemDictionary::classloader_klass());
KlassHandle system_loader(THREAD, SystemDictionary::ClassLoader_klass());
JavaCalls::call_special(&result,
class_loader,
system_loader,
@ -743,7 +743,7 @@ klassOop SystemDictionary::resolve_instance_class_or_null(symbolHandle class_nam
// Bootstrap goes through here to allow for an extra guarantee check
if (UnsyncloadClass || (class_loader.is_null())) {
if (k.is_null() && HAS_PENDING_EXCEPTION
&& PENDING_EXCEPTION->is_a(SystemDictionary::linkageError_klass())) {
&& PENDING_EXCEPTION->is_a(SystemDictionary::LinkageError_klass())) {
MutexLocker mu(SystemDictionary_lock, THREAD);
klassOop check = find_class(d_index, d_hash, name, class_loader);
if (check != NULL) {
@ -1367,7 +1367,7 @@ instanceKlassHandle SystemDictionary::load_instance_class(symbolHandle class_nam
JavaValue result(T_OBJECT);
KlassHandle spec_klass (THREAD, SystemDictionary::classloader_klass());
KlassHandle spec_klass (THREAD, SystemDictionary::ClassLoader_klass());
// Call public unsynchronized loadClass(String) directly for all class loaders
// for parallelCapable class loaders. JDK >=7, loadClass(String, boolean) will
@ -1944,13 +1944,13 @@ void SystemDictionary::initialize_wk_klasses_until(WKID limit_id, WKID &start_id
void SystemDictionary::initialize_preloaded_classes(TRAPS) {
assert(WK_KLASS(object_klass) == NULL, "preloaded classes should only be initialized once");
assert(WK_KLASS(Object_klass) == NULL, "preloaded classes should only be initialized once");
// Preload commonly used klasses
WKID scan = FIRST_WKID;
// first do Object, String, Class
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(class_klass), scan, CHECK);
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK);
debug_only(instanceKlass::verify_class_klass_nonstatic_oop_maps(WK_KLASS(class_klass)));
debug_only(instanceKlass::verify_class_klass_nonstatic_oop_maps(WK_KLASS(Class_klass)));
// Fixup mirrors for classes loaded before java.lang.Class.
// These calls iterate over the objects currently in the perm gen
@ -1961,17 +1961,17 @@ void SystemDictionary::initialize_preloaded_classes(TRAPS) {
Universe::fixup_mirrors(CHECK);
// do a bunch more:
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(reference_klass), scan, CHECK);
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Reference_klass), scan, CHECK);
// Preload ref klasses and set reference types
instanceKlass::cast(WK_KLASS(reference_klass))->set_reference_type(REF_OTHER);
instanceRefKlass::update_nonstatic_oop_maps(WK_KLASS(reference_klass));
instanceKlass::cast(WK_KLASS(Reference_klass))->set_reference_type(REF_OTHER);
instanceRefKlass::update_nonstatic_oop_maps(WK_KLASS(Reference_klass));
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(phantom_reference_klass), scan, CHECK);
instanceKlass::cast(WK_KLASS(soft_reference_klass))->set_reference_type(REF_SOFT);
instanceKlass::cast(WK_KLASS(weak_reference_klass))->set_reference_type(REF_WEAK);
instanceKlass::cast(WK_KLASS(final_reference_klass))->set_reference_type(REF_FINAL);
instanceKlass::cast(WK_KLASS(phantom_reference_klass))->set_reference_type(REF_PHANTOM);
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(PhantomReference_klass), scan, CHECK);
instanceKlass::cast(WK_KLASS(SoftReference_klass))->set_reference_type(REF_SOFT);
instanceKlass::cast(WK_KLASS(WeakReference_klass))->set_reference_type(REF_WEAK);
instanceKlass::cast(WK_KLASS(FinalReference_klass))->set_reference_type(REF_FINAL);
instanceKlass::cast(WK_KLASS(PhantomReference_klass))->set_reference_type(REF_PHANTOM);
WKID meth_group_start = WK_KLASS_ENUM_NAME(MethodHandle_klass);
WKID meth_group_end = WK_KLASS_ENUM_NAME(WrongMethodTypeException_klass);
@ -1996,14 +1996,14 @@ void SystemDictionary::initialize_preloaded_classes(TRAPS) {
initialize_wk_klasses_until(WKID_LIMIT, scan, CHECK);
_box_klasses[T_BOOLEAN] = WK_KLASS(boolean_klass);
_box_klasses[T_CHAR] = WK_KLASS(char_klass);
_box_klasses[T_FLOAT] = WK_KLASS(float_klass);
_box_klasses[T_DOUBLE] = WK_KLASS(double_klass);
_box_klasses[T_BYTE] = WK_KLASS(byte_klass);
_box_klasses[T_SHORT] = WK_KLASS(short_klass);
_box_klasses[T_INT] = WK_KLASS(int_klass);
_box_klasses[T_LONG] = WK_KLASS(long_klass);
_box_klasses[T_BOOLEAN] = WK_KLASS(Boolean_klass);
_box_klasses[T_CHAR] = WK_KLASS(Character_klass);
_box_klasses[T_FLOAT] = WK_KLASS(Float_klass);
_box_klasses[T_DOUBLE] = WK_KLASS(Double_klass);
_box_klasses[T_BYTE] = WK_KLASS(Byte_klass);
_box_klasses[T_SHORT] = WK_KLASS(Short_klass);
_box_klasses[T_INT] = WK_KLASS(Integer_klass);
_box_klasses[T_LONG] = WK_KLASS(Long_klass);
//_box_klasses[T_OBJECT] = WK_KLASS(object_klass);
//_box_klasses[T_ARRAY] = WK_KLASS(object_klass);
@ -2014,11 +2014,11 @@ void SystemDictionary::initialize_preloaded_classes(TRAPS) {
#endif // KERNEL
{ // Compute whether we should use loadClass or loadClassInternal when loading classes.
methodOop method = instanceKlass::cast(classloader_klass())->find_method(vmSymbols::loadClassInternal_name(), vmSymbols::string_class_signature());
methodOop method = instanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::loadClassInternal_name(), vmSymbols::string_class_signature());
_has_loadClassInternal = (method != NULL);
}
{ // Compute whether we should use checkPackageAccess or NOT
methodOop method = instanceKlass::cast(classloader_klass())->find_method(vmSymbols::checkPackageAccess_name(), vmSymbols::class_protectiondomain_signature());
methodOop method = instanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::checkPackageAccess_name(), vmSymbols::class_protectiondomain_signature());
_has_checkPackageAccess = (method != NULL);
}
}
@ -2374,7 +2374,7 @@ Handle SystemDictionary::compute_method_handle_type(symbolHandle signature,
TRAPS) {
Handle empty;
int npts = ArgumentCount(signature()).size();
objArrayHandle pts = oopFactory::new_objArray(SystemDictionary::class_klass(), npts, CHECK_(empty));
objArrayHandle pts = oopFactory::new_objArray(SystemDictionary::Class_klass(), npts, CHECK_(empty));
int arg = 0;
Handle rt; // the return type from the signature
for (SignatureStream ss(signature()); !ss.is_done(); ss.next()) {

98
hotspot/src/share/vm/classfile/systemDictionary.hpp
View File

@ -82,55 +82,55 @@ class SymbolPropertyTable;
#define WK_KLASSES_DO(template) \
/* well-known classes */ \
template(object_klass, java_lang_Object, Pre) \
template(string_klass, java_lang_String, Pre) \
template(class_klass, java_lang_Class, Pre) \
template(cloneable_klass, java_lang_Cloneable, Pre) \
template(classloader_klass, java_lang_ClassLoader, Pre) \
template(serializable_klass, java_io_Serializable, Pre) \
template(system_klass, java_lang_System, Pre) \
template(throwable_klass, java_lang_Throwable, Pre) \
template(error_klass, java_lang_Error, Pre) \
template(threaddeath_klass, java_lang_ThreadDeath, Pre) \
template(exception_klass, java_lang_Exception, Pre) \
template(runtime_exception_klass, java_lang_RuntimeException, Pre) \
template(protectionDomain_klass, java_security_ProtectionDomain, Pre) \
template(Object_klass, java_lang_Object, Pre) \
template(String_klass, java_lang_String, Pre) \
template(Class_klass, java_lang_Class, Pre) \
template(Cloneable_klass, java_lang_Cloneable, Pre) \
template(ClassLoader_klass, java_lang_ClassLoader, Pre) \
template(Serializable_klass, java_io_Serializable, Pre) \
template(System_klass, java_lang_System, Pre) \
template(Throwable_klass, java_lang_Throwable, Pre) \
template(Error_klass, java_lang_Error, Pre) \
template(ThreadDeath_klass, java_lang_ThreadDeath, Pre) \
template(Exception_klass, java_lang_Exception, Pre) \
template(RuntimeException_klass, java_lang_RuntimeException, Pre) \
template(ProtectionDomain_klass, java_security_ProtectionDomain, Pre) \
template(AccessControlContext_klass, java_security_AccessControlContext, Pre) \
template(classNotFoundException_klass, java_lang_ClassNotFoundException, Pre) \
template(noClassDefFoundError_klass, java_lang_NoClassDefFoundError, Pre) \
template(linkageError_klass, java_lang_LinkageError, Pre) \
template(ClassNotFoundException_klass, java_lang_ClassNotFoundException, Pre) \
template(NoClassDefFoundError_klass, java_lang_NoClassDefFoundError, Pre) \
template(LinkageError_klass, java_lang_LinkageError, Pre) \
template(ClassCastException_klass, java_lang_ClassCastException, Pre) \
template(ArrayStoreException_klass, java_lang_ArrayStoreException, Pre) \
template(virtualMachineError_klass, java_lang_VirtualMachineError, Pre) \
template(VirtualMachineError_klass, java_lang_VirtualMachineError, Pre) \
template(OutOfMemoryError_klass, java_lang_OutOfMemoryError, Pre) \
template(StackOverflowError_klass, java_lang_StackOverflowError, Pre) \
template(IllegalMonitorStateException_klass, java_lang_IllegalMonitorStateException, Pre) \
template(reference_klass, java_lang_ref_Reference, Pre) \
template(Reference_klass, java_lang_ref_Reference, Pre) \
\
/* Preload ref klasses and set reference types */ \
template(soft_reference_klass, java_lang_ref_SoftReference, Pre) \
template(weak_reference_klass, java_lang_ref_WeakReference, Pre) \
template(final_reference_klass, java_lang_ref_FinalReference, Pre) \
template(phantom_reference_klass, java_lang_ref_PhantomReference, Pre) \
template(finalizer_klass, java_lang_ref_Finalizer, Pre) \
template(SoftReference_klass, java_lang_ref_SoftReference, Pre) \
template(WeakReference_klass, java_lang_ref_WeakReference, Pre) \
template(FinalReference_klass, java_lang_ref_FinalReference, Pre) \
template(PhantomReference_klass, java_lang_ref_PhantomReference, Pre) \
template(Finalizer_klass, java_lang_ref_Finalizer, Pre) \
\
template(thread_klass, java_lang_Thread, Pre) \
template(threadGroup_klass, java_lang_ThreadGroup, Pre) \
template(properties_klass, java_util_Properties, Pre) \
template(reflect_accessible_object_klass, java_lang_reflect_AccessibleObject, Pre) \
template(reflect_field_klass, java_lang_reflect_Field, Pre) \
template(reflect_method_klass, java_lang_reflect_Method, Pre) \
template(reflect_constructor_klass, java_lang_reflect_Constructor, Pre) \
template(Thread_klass, java_lang_Thread, Pre) \
template(ThreadGroup_klass, java_lang_ThreadGroup, Pre) \
template(Properties_klass, java_util_Properties, Pre) \
template(reflect_AccessibleObject_klass, java_lang_reflect_AccessibleObject, Pre) \
template(reflect_Field_klass, java_lang_reflect_Field, Pre) \
template(reflect_Method_klass, java_lang_reflect_Method, Pre) \
template(reflect_Constructor_klass, java_lang_reflect_Constructor, Pre) \
\
/* NOTE: needed too early in bootstrapping process to have checks based on JDK version */ \
/* Universe::is_gte_jdk14x_version() is not set up by this point. */ \
/* It's okay if this turns out to be NULL in non-1.4 JDKs. */ \
template(reflect_magic_klass, sun_reflect_MagicAccessorImpl, Opt) \
template(reflect_method_accessor_klass, sun_reflect_MethodAccessorImpl, Opt_Only_JDK14NewRef) \
template(reflect_constructor_accessor_klass, sun_reflect_ConstructorAccessorImpl, Opt_Only_JDK14NewRef) \
template(reflect_delegating_classloader_klass, sun_reflect_DelegatingClassLoader, Opt) \
template(reflect_constant_pool_klass, sun_reflect_ConstantPool, Opt_Only_JDK15) \
template(reflect_unsafe_static_field_accessor_impl_klass, sun_reflect_UnsafeStaticFieldAccessorImpl, Opt_Only_JDK15) \
template(reflect_MagicAccessorImpl_klass, sun_reflect_MagicAccessorImpl, Opt) \
template(reflect_MethodAccessorImpl_klass, sun_reflect_MethodAccessorImpl, Opt_Only_JDK14NewRef) \
template(reflect_ConstructorAccessorImpl_klass, sun_reflect_ConstructorAccessorImpl, Opt_Only_JDK14NewRef) \
template(reflect_DelegatingClassLoader_klass, sun_reflect_DelegatingClassLoader, Opt) \
template(reflect_ConstantPool_klass, sun_reflect_ConstantPool, Opt_Only_JDK15) \
template(reflect_UnsafeStaticFieldAccessorImpl_klass, sun_reflect_UnsafeStaticFieldAccessorImpl, Opt_Only_JDK15) \
\
/* support for dynamic typing; it's OK if these are NULL in earlier JDKs */ \
template(MethodHandle_klass, java_dyn_MethodHandle, Opt) \
@ -147,13 +147,11 @@ class SymbolPropertyTable;
template(InvokeDynamic_klass, java_dyn_InvokeDynamic, Opt) \
/* Note: MethodHandle must be first, and Dynamic last in group */ \
\
template(vector_klass, java_util_Vector, Pre) \
template(hashtable_klass, java_util_Hashtable, Pre) \
template(stringBuffer_klass, java_lang_StringBuffer, Pre) \
template(StringBuffer_klass, java_lang_StringBuffer, Pre) \
template(StringBuilder_klass, java_lang_StringBuilder, Pre) \
\
/* It's NULL in non-1.4 JDKs. */ \
template(stackTraceElement_klass, java_lang_StackTraceElement, Opt) \
template(StackTraceElement_klass, java_lang_StackTraceElement, Opt) \
/* Universe::is_gte_jdk14x_version() is not set up by this point. */ \
/* It's okay if this turns out to be NULL in non-1.4 JDKs. */ \
template(java_nio_Buffer_klass, java_nio_Buffer, Opt) \
@ -164,14 +162,14 @@ class SymbolPropertyTable;
template(sun_jkernel_DownloadManager_klass, sun_jkernel_DownloadManager, Opt_Kernel) \
\
/* Preload boxing klasses */ \
template(boolean_klass, java_lang_Boolean, Pre) \
template(char_klass, java_lang_Character, Pre) \
template(float_klass, java_lang_Float, Pre) \
template(double_klass, java_lang_Double, Pre) \
template(byte_klass, java_lang_Byte, Pre) \
template(short_klass, java_lang_Short, Pre) \
template(int_klass, java_lang_Integer, Pre) \
template(long_klass, java_lang_Long, Pre) \
template(Boolean_klass, java_lang_Boolean, Pre) \
template(Character_klass, java_lang_Character, Pre) \
template(Float_klass, java_lang_Float, Pre) \
template(Double_klass, java_lang_Double, Pre) \
template(Byte_klass, java_lang_Byte, Pre) \
template(Short_klass, java_lang_Short, Pre) \
template(Integer_klass, java_lang_Integer, Pre) \
template(Long_klass, java_lang_Long, Pre) \
/*end*/
@ -438,8 +436,8 @@ public:
// Tells whether ClassLoader.checkPackageAccess is present
static bool has_checkPackageAccess() { return _has_checkPackageAccess; }
static bool class_klass_loaded() { return WK_KLASS(class_klass) != NULL; }
static bool cloneable_klass_loaded() { return WK_KLASS(cloneable_klass) != NULL; }
static bool Class_klass_loaded() { return WK_KLASS(Class_klass) != NULL; }
static bool Cloneable_klass_loaded() { return WK_KLASS(Cloneable_klass) != NULL; }
// Returns default system loader
static oop java_system_loader();

2
hotspot/src/share/vm/classfile/verifier.cpp
View File

@ -143,7 +143,7 @@ bool Verifier::verify(instanceKlassHandle klass, Verifier::Mode mode, bool shoul
bool Verifier::is_eligible_for_verification(instanceKlassHandle klass, bool should_verify_class) {
symbolOop name = klass->name();
klassOop refl_magic_klass = SystemDictionary::reflect_magic_klass();
klassOop refl_magic_klass = SystemDictionary::reflect_MagicAccessorImpl_klass();
return (should_verify_for(klass->class_loader(), should_verify_class) &&
// return if the class is a bootstrapping class

2
hotspot/src/share/vm/gc_interface/collectedHeap.cpp
View File

@ -274,7 +274,7 @@ CollectedHeap::fill_with_object_impl(HeapWord* start, size_t words)
fill_with_array(start, words);
} else if (words > 0) {
assert(words == min_fill_size(), "unaligned size");
post_allocation_setup_common(SystemDictionary::object_klass(), start,
post_allocation_setup_common(SystemDictionary::Object_klass(), start,
words);
}
}

6
hotspot/src/share/vm/interpreter/interpreterRuntime.cpp
View File

@ -353,7 +353,7 @@ IRT_ENTRY(address, InterpreterRuntime::exception_handler_for_exception(JavaThrea
assert(h_exception.not_null(), "NULL exceptions should be handled by athrow");
assert(h_exception->is_oop(), "just checking");
// Check that exception is a subclass of Throwable, otherwise we have a VerifyError
if (!(h_exception->is_a(SystemDictionary::throwable_klass()))) {
if (!(h_exception->is_a(SystemDictionary::Throwable_klass()))) {
if (ExitVMOnVerifyError) vm_exit(-1);
ShouldNotReachHere();
}
@ -585,7 +585,7 @@ IRT_ENTRY(void, InterpreterRuntime::new_illegal_monitor_state_exception(JavaThre
Handle exception(thread, thread->vm_result());
assert(exception() != NULL, "vm result should be set");
thread->set_vm_result(NULL); // clear vm result before continuing (may cause memory leaks and assert failures)
if (!exception->is_a(SystemDictionary::threaddeath_klass())) {
if (!exception->is_a(SystemDictionary::ThreadDeath_klass())) {
exception = get_preinitialized_exception(
SystemDictionary::IllegalMonitorStateException_klass(),
CATCH);
@ -660,7 +660,7 @@ IRT_ENTRY(void, InterpreterRuntime::resolve_invoke(JavaThread* thread, Bytecodes
tty->print_cr("Resolving: klass: %s to method: %s", info.resolved_klass()->name()->as_C_string(), info.resolved_method()->name()->as_C_string());
}
if (info.resolved_method()->method_holder() ==
SystemDictionary::object_klass()) {
SystemDictionary::Object_klass()) {
// NOTE: THIS IS A FIX FOR A CORNER CASE in the JVM spec
// (see also cpCacheOop.cpp for details)
methodHandle rm = info.resolved_method();

4
hotspot/src/share/vm/interpreter/linkResolver.cpp
View File

@ -55,7 +55,7 @@ void CallInfo::set_interface(KlassHandle resolved_klass, KlassHandle selected_kl
// we should pick the vtable index from the resolved method.
// Other than that case, there is no valid vtable index to specify.
int vtable_index = methodOopDesc::invalid_vtable_index;
if (resolved_method->method_holder() == SystemDictionary::object_klass()) {
if (resolved_method->method_holder() == SystemDictionary::Object_klass()) {
assert(resolved_method->vtable_index() == selected_method->vtable_index(), "sanity check");
vtable_index = resolved_method->vtable_index();
}
@ -193,7 +193,7 @@ void LinkResolver::check_method_accessability(KlassHandle ref_klass,
// We'll check for the method name first, as that's most likely
// to be false (so we'll short-circuit out of these tests).
if (sel_method->name() == vmSymbols::clone_name() &&
sel_klass() == SystemDictionary::object_klass() &&
sel_klass() == SystemDictionary::Object_klass() &&
resolved_klass->oop_is_array()) {
// We need to change "protected" to "public".
assert(flags.is_protected(), "clone not protected?");

2
hotspot/src/share/vm/memory/classify.cpp
View File

@ -49,7 +49,7 @@ object_type ClassifyObjectClosure::classify_object(oop obj, bool count) {
Klass* k = obj->blueprint();
if (k->as_klassOop() == SystemDictionary::object_klass()) {
if (k->as_klassOop() == SystemDictionary::Object_klass()) {
tty->print_cr("Found the class!");
}

8
hotspot/src/share/vm/memory/dump.cpp
View File

@ -63,7 +63,7 @@ public:
void do_oop(oop* p) {
if (p != NULL) {
oop obj = *p;
if (obj->klass() == SystemDictionary::string_klass()) {
if (obj->klass() == SystemDictionary::String_klass()) {
int hash;
typeArrayOop value = java_lang_String::value(obj);
@ -625,11 +625,11 @@ public:
if (obj->is_klass() || obj->is_instance()) {
if (obj->is_klass() ||
obj->is_a(SystemDictionary::class_klass()) ||
obj->is_a(SystemDictionary::throwable_klass())) {
obj->is_a(SystemDictionary::Class_klass()) ||
obj->is_a(SystemDictionary::Throwable_klass())) {
// Do nothing
}
else if (obj->is_a(SystemDictionary::string_klass())) {
else if (obj->is_a(SystemDictionary::String_klass())) {
// immutable objects.
} else {
// someone added an object we hadn't accounted for.

2
hotspot/src/share/vm/memory/referenceProcessor.cpp
View File

@ -71,7 +71,7 @@ void ReferenceProcessor::init_statics() {
assert(_sentinelRef == NULL, "should be initialized precisely once");
EXCEPTION_MARK;
_sentinelRef = instanceKlass::cast(
SystemDictionary::reference_klass())->
SystemDictionary::Reference_klass())->
allocate_permanent_instance(THREAD);
// Initialize the master soft ref clock.

2
hotspot/src/share/vm/memory/space.cpp
View File

@ -876,7 +876,7 @@ void ContiguousSpace::allocate_temporary_filler(int factor) {
instanceOop obj = (instanceOop) allocate(size);
obj->set_mark(markOopDesc::prototype());
obj->set_klass_gap(0);
obj->set_klass(SystemDictionary::object_klass());
obj->set_klass(SystemDictionary::Object_klass());
}
}

36
hotspot/src/share/vm/memory/universe.cpp
View File

@ -291,7 +291,7 @@ void Universe::genesis(TRAPS) {
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);
@ -299,9 +299,9 @@ void Universe::genesis(TRAPS) {
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");
@ -320,8 +320,8 @@ void Universe::genesis(TRAPS) {
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(1, SystemDictionary::serializable_klass());
_the_array_interfaces_array->obj_at_put(0, SystemDictionary::Cloneable_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);
@ -365,7 +365,7 @@ void Universe::genesis(TRAPS) {
// 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();
@ -426,11 +426,11 @@ void Universe::genesis(TRAPS) {
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);
}
{
@ -540,7 +540,7 @@ void Universe::fixup_mirrors(TRAPS) {
// 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);
}
@ -556,7 +556,7 @@ void Universe::run_finalizers_on_exit() {
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,
@ -950,7 +950,7 @@ bool universe_post_init() {
{ 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);
}
@ -960,7 +960,7 @@ bool universe_post_init() {
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);
@ -1027,8 +1027,8 @@ bool universe_post_init() {
// 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);
methodOop m = instanceKlass::cast(SystemDictionary::finalizer_klass())->find_method(
instanceKlass::cast(SystemDictionary::Finalizer_klass())->link_class(CHECK_false);
methodOop m = instanceKlass::cast(SystemDictionary::Finalizer_klass())->find_method(
vmSymbols::register_method_name(),
vmSymbols::register_method_signature());
if (m == NULL || !m->is_static()) {
@ -1036,7 +1036,7 @@ bool universe_post_init() {
"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
@ -1053,14 +1053,14 @@ bool universe_post_init() {
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);
m = instanceKlass::cast(SystemDictionary::classloader_klass())->find_method(vmSymbols::addClass_name(), vmSymbols::class_void_signature());
instanceKlass::cast(SystemDictionary::ClassLoader_klass())->link_class(CHECK_false);
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

10
hotspot/src/share/vm/oops/arrayKlass.cpp
View File

@ -43,7 +43,7 @@ klassOop arrayKlass::java_super() const {
if (super() == NULL) return NULL; // bootstrap case
// Array klasses have primary supertypes which are not reported to Java.
// Example super chain: String[][] -> Object[][] -> Object[] -> Object
return SystemDictionary::object_klass();
return SystemDictionary::Object_klass();
}
@ -82,7 +82,7 @@ const Klass_vtbl& cplusplus_vtbl, int header_size, KlassHandle klass, TRAPS) {
k = arrayKlassHandle(THREAD, base_klass());
assert(!k()->is_parsable(), "not expecting parsability yet.");
k->set_super(Universe::is_bootstrapping() ? (klassOop)NULL : SystemDictionary::object_klass());
k->set_super(Universe::is_bootstrapping() ? (klassOop)NULL : SystemDictionary::Object_klass());
k->set_layout_helper(Klass::_lh_neutral_value);
k->set_dimension(1);
k->set_higher_dimension(NULL);
@ -117,9 +117,9 @@ objArrayOop arrayKlass::compute_secondary_supers(int num_extra_slots, TRAPS) {
bool arrayKlass::compute_is_subtype_of(klassOop k) {
// An array is a subtype of Serializable, Clonable, and Object
return k == SystemDictionary::object_klass()
|| k == SystemDictionary::cloneable_klass()
|| k == SystemDictionary::serializable_klass();
return k == SystemDictionary::Object_klass()
|| k == SystemDictionary::Cloneable_klass()
|| k == SystemDictionary::Serializable_klass();
}

2
hotspot/src/share/vm/oops/arrayKlass.hpp
View File

@ -67,7 +67,7 @@ class arrayKlass: public Klass {
// Compiler/Interpreter offset
static ByteSize component_mirror_offset() { return byte_offset_of(arrayKlass, _component_mirror); }
virtual klassOop java_super() const;//{ return SystemDictionary::object_klass(); }
virtual klassOop java_super() const;//{ return SystemDictionary::Object_klass(); }
// Allocation
// Sizes points to the first dimension of the array, subsequent dimensions

2
hotspot/src/share/vm/oops/constantPoolOop.cpp
View File

@ -110,7 +110,7 @@ klassOop constantPoolOopDesc::klass_at_impl(constantPoolHandle this_oop, int whi
}
if (!PENDING_EXCEPTION->
is_a(SystemDictionary::linkageError_klass())) {
is_a(SystemDictionary::LinkageError_klass())) {
// Just throw the exception and don't prevent these classes from
// being loaded due to virtual machine errors like StackOverflow
// and OutOfMemoryError, etc, or if the thread was hit by stop()

14
hotspot/src/share/vm/oops/instanceKlass.cpp
View File

@ -383,7 +383,7 @@ void instanceKlass::initialize_impl(instanceKlassHandle this_oop, TRAPS) {
this_oop->set_initialization_state_and_notify(initialization_error, THREAD);
CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, class initialization error is thrown below
}
if (e->is_a(SystemDictionary::error_klass())) {
if (e->is_a(SystemDictionary::Error_klass())) {
THROW_OOP(e());
} else {
JavaCallArguments args(e);
@ -568,7 +568,7 @@ void instanceKlass::check_valid_for_instantiation(bool throwError, TRAPS) {
THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError()
: vmSymbols::java_lang_InstantiationException(), external_name());
}
if (as_klassOop() == SystemDictionary::class_klass()) {
if (as_klassOop() == SystemDictionary::Class_klass()) {
ResourceMark rm(THREAD);
THROW_MSG(throwError ? vmSymbols::java_lang_IllegalAccessError()
: vmSymbols::java_lang_IllegalAccessException(), external_name());
@ -2223,7 +2223,7 @@ void FieldPrinter::do_field(fieldDescriptor* fd) {
void instanceKlass::oop_print_on(oop obj, outputStream* st) {
Klass::oop_print_on(obj, st);
if (as_klassOop() == SystemDictionary::string_klass()) {
if (as_klassOop() == SystemDictionary::String_klass()) {
typeArrayOop value = java_lang_String::value(obj);
juint offset = java_lang_String::offset(obj);
juint length = java_lang_String::length(obj);
@ -2243,7 +2243,7 @@ void instanceKlass::oop_print_on(oop obj, outputStream* st) {
FieldPrinter print_nonstatic_field(st, obj);
do_nonstatic_fields(&print_nonstatic_field);
if (as_klassOop() == SystemDictionary::class_klass()) {
if (as_klassOop() == SystemDictionary::Class_klass()) {
st->print(BULLET"signature: ");
java_lang_Class::print_signature(obj, st);
st->cr();
@ -2270,7 +2270,7 @@ void instanceKlass::oop_print_value_on(oop obj, outputStream* st) {
st->print("a ");
name()->print_value_on(st);
obj->print_address_on(st);
if (as_klassOop() == SystemDictionary::string_klass()
if (as_klassOop() == SystemDictionary::String_klass()
&& java_lang_String::value(obj) != NULL) {
ResourceMark rm;
int len = java_lang_String::length(obj);
@ -2279,7 +2279,7 @@ void instanceKlass::oop_print_value_on(oop obj, outputStream* st) {
st->print(" = \"%s\"", str);
if (len > plen)
st->print("...[%d]", len);
} else if (as_klassOop() == SystemDictionary::class_klass()) {
} else if (as_klassOop() == SystemDictionary::Class_klass()) {
klassOop k = java_lang_Class::as_klassOop(obj);
st->print(" = ");
if (k != NULL) {
@ -2346,7 +2346,7 @@ void instanceKlass::verify_class_klass_nonstatic_oop_maps(klassOop k) {
// Check that we have the right class
static bool first_time = true;
guarantee(k == SystemDictionary::class_klass() && first_time, "Invalid verify of maps");
guarantee(k == SystemDictionary::Class_klass() && first_time, "Invalid verify of maps");
first_time = false;
const int extra = java_lang_Class::number_of_fake_oop_fields;
guarantee(ik->nonstatic_field_size() == extra, "just checking");

2
hotspot/src/share/vm/oops/instanceRefKlass.cpp
View File

@ -397,7 +397,7 @@ void instanceRefKlass::update_nonstatic_oop_maps(klassOop k) {
// Check that we have the right class
debug_only(static bool first_time = true);
assert(k == SystemDictionary::reference_klass() && first_time,
assert(k == SystemDictionary::Reference_klass() && first_time,
"Invalid update of maps");
debug_only(first_time = false);
assert(ik->nonstatic_oop_map_count() == 1, "just checking");

6
hotspot/src/share/vm/oops/klass.cpp
View File

@ -217,8 +217,8 @@ void Klass::initialize_supers(klassOop k, TRAPS) {
set_super(NULL);
oop_store_without_check((oop*) &_primary_supers[0], (oop) this->as_klassOop());
assert(super_depth() == 0, "Object must already be initialized properly");
} else if (k != super() || k == SystemDictionary::object_klass()) {
assert(super() == NULL || super() == SystemDictionary::object_klass(),
} else if (k != super() || k == SystemDictionary::Object_klass()) {
assert(super() == NULL || super() == SystemDictionary::Object_klass(),
"initialize this only once to a non-trivial value");
set_super(k);
Klass* sup = k->klass_part();
@ -370,7 +370,7 @@ void Klass::append_to_sibling_list() {
void Klass::remove_from_sibling_list() {
// remove receiver from sibling list
instanceKlass* super = superklass();
assert(super != NULL || as_klassOop() == SystemDictionary::object_klass(), "should have super");
assert(super != NULL || as_klassOop() == SystemDictionary::Object_klass(), "should have super");
if (super == NULL) return; // special case: class Object
if (super->subklass() == this) {
// first subklass

8
hotspot/src/share/vm/oops/methodOop.cpp
View File

@ -456,12 +456,12 @@ objArrayHandle methodOopDesc::resolved_checked_exceptions_impl(methodOop this_oo
return objArrayHandle(THREAD, Universe::the_empty_class_klass_array());
} else {
methodHandle h_this(THREAD, this_oop);
objArrayOop m_oop = oopFactory::new_objArray(SystemDictionary::class_klass(), length, CHECK_(objArrayHandle()));
objArrayOop m_oop = oopFactory::new_objArray(SystemDictionary::Class_klass(), length, CHECK_(objArrayHandle()));
objArrayHandle mirrors (THREAD, m_oop);
for (int i = 0; i < length; i++) {
CheckedExceptionElement* table = h_this->checked_exceptions_start(); // recompute on each iteration, not gc safe
klassOop k = h_this->constants()->klass_at(table[i].class_cp_index, CHECK_(objArrayHandle()));
assert(Klass::cast(k)->is_subclass_of(SystemDictionary::throwable_klass()), "invalid exception class");
assert(Klass::cast(k)->is_subclass_of(SystemDictionary::Throwable_klass()), "invalid exception class");
mirrors->obj_at_put(i, Klass::cast(k)->java_mirror());
}
return mirrors;
@ -1032,8 +1032,8 @@ bool methodOopDesc::load_signature_classes(methodHandle m, TRAPS) {
// We are loading classes eagerly. If a ClassNotFoundException or
// a LinkageError was generated, be sure to ignore it.
if (HAS_PENDING_EXCEPTION) {
if (PENDING_EXCEPTION->is_a(SystemDictionary::classNotFoundException_klass()) ||
PENDING_EXCEPTION->is_a(SystemDictionary::linkageError_klass())) {
if (PENDING_EXCEPTION->is_a(SystemDictionary::ClassNotFoundException_klass()) ||
PENDING_EXCEPTION->is_a(SystemDictionary::LinkageError_klass())) {
CLEAR_PENDING_EXCEPTION;
} else {
return false;

4
hotspot/src/share/vm/oops/objArrayKlass.cpp
View File

@ -246,8 +246,8 @@ objArrayOop objArrayKlass::compute_secondary_supers(int num_extra_slots, TRAPS)
} else {
objArrayOop sec_oop = oopFactory::new_system_objArray(num_secondaries, CHECK_NULL);
objArrayHandle secondaries(THREAD, sec_oop);
secondaries->obj_at_put(num_extra_slots+0, SystemDictionary::cloneable_klass());
secondaries->obj_at_put(num_extra_slots+1, SystemDictionary::serializable_klass());
secondaries->obj_at_put(num_extra_slots+0, SystemDictionary::Cloneable_klass());
secondaries->obj_at_put(num_extra_slots+1, SystemDictionary::Serializable_klass());
for (int i = 0; i < num_elem_supers; i++) {
klassOop elem_super = (klassOop) elem_supers->obj_at(i);
klassOop array_super = elem_super->klass_part()->array_klass_or_null();

2
hotspot/src/share/vm/oops/objArrayKlassKlass.cpp
View File

@ -99,7 +99,7 @@ klassOop objArrayKlassKlass::allocate_objArray_klass_impl(objArrayKlassKlassHand
}
} else {
// The element type is already Object. Object[] has direct super of Object.
super_klass = KlassHandle(THREAD, SystemDictionary::object_klass());
super_klass = KlassHandle(THREAD, SystemDictionary::Object_klass());
}
}

4
hotspot/src/share/vm/opto/runtime.cpp
View File

@ -790,7 +790,7 @@ JRT_ENTRY_NO_ASYNC(address, OptoRuntime::handle_exception_C_helper(JavaThread* t
NOT_PRODUCT(Exceptions::debug_check_abort(exception));
#ifdef ASSERT
if (!(exception->is_a(SystemDictionary::throwable_klass()))) {
if (!(exception->is_a(SystemDictionary::Throwable_klass()))) {
// should throw an exception here
ShouldNotReachHere();
}
@ -939,7 +939,7 @@ address OptoRuntime::rethrow_C(oopDesc* exception, JavaThread* thread, address r
#endif
assert (exception != NULL, "should have thrown a NULLPointerException");
#ifdef ASSERT
if (!(exception->is_a(SystemDictionary::throwable_klass()))) {
if (!(exception->is_a(SystemDictionary::Throwable_klass()))) {
// should throw an exception here
ShouldNotReachHere();
}

12
hotspot/src/share/vm/prims/jni.cpp
View File

@ -396,11 +396,11 @@ JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method))
oop mirror = NULL;
int slot = 0;
if (reflected->klass() == SystemDictionary::reflect_constructor_klass()) {
if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) {
mirror = java_lang_reflect_Constructor::clazz(reflected);
slot = java_lang_reflect_Constructor::slot(reflected);
} else {
assert(reflected->klass() == SystemDictionary::reflect_method_klass(), "wrong type");
assert(reflected->klass() == SystemDictionary::reflect_Method_klass(), "wrong type");
mirror = java_lang_reflect_Method::clazz(reflected);
slot = java_lang_reflect_Method::slot(reflected);
}
@ -496,7 +496,7 @@ JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub))
klassOop super = Klass::cast(k)->java_super();
// super2 is the value computed by the compiler's getSuperClass intrinsic:
debug_only(klassOop super2 = ( Klass::cast(k)->oop_is_javaArray()
? SystemDictionary::object_klass()
? SystemDictionary::Object_klass()
: Klass::cast(k)->super() ) );
assert(super == super2,
"java_super computation depends on interface, array, other super");
@ -584,7 +584,7 @@ JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
if (thread->has_pending_exception()) {
Handle ex(thread, thread->pending_exception());
thread->clear_pending_exception();
if (ex->is_a(SystemDictionary::threaddeath_klass())) {
if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
// Don't print anything if we are being killed.
} else {
jio_fprintf(defaultStream::error_stream(), "Exception ");
@ -593,12 +593,12 @@ JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
jio_fprintf(defaultStream::error_stream(),
"in thread \"%s\" ", thread->get_thread_name());
}
if (ex->is_a(SystemDictionary::throwable_klass())) {
if (ex->is_a(SystemDictionary::Throwable_klass())) {
JavaValue result(T_VOID);
JavaCalls::call_virtual(&result,
ex,
KlassHandle(THREAD,
SystemDictionary::throwable_klass()),
SystemDictionary::Throwable_klass()),
vmSymbolHandles::printStackTrace_name(),
vmSymbolHandles::void_method_signature(),
THREAD);

4
hotspot/src/share/vm/prims/jniCheck.cpp
View File

@ -341,7 +341,7 @@ klassOop jniCheck::validate_class(JavaThread* thr, jclass clazz, bool allow_prim
ReportJNIFatalError(thr, fatal_received_null_class);
}
if (mirror->klass() != SystemDictionary::class_klass()) {
if (mirror->klass() != SystemDictionary::Class_klass()) {
ReportJNIFatalError(thr, fatal_class_not_a_class);
}
@ -358,7 +358,7 @@ void jniCheck::validate_throwable_klass(JavaThread* thr, klassOop klass) {
assert(klass != NULL, "klass argument must have a value");
if (!Klass::cast(klass)->oop_is_instance() ||
!instanceKlass::cast(klass)->is_subclass_of(SystemDictionary::throwable_klass())) {
!instanceKlass::cast(klass)->is_subclass_of(SystemDictionary::Throwable_klass())) {
ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);
}
}

73
hotspot/src/share/vm/prims/jvm.cpp
View File

@ -80,7 +80,7 @@ static void trace_class_resolution_impl(klassOop to_class, TRAPS) {
while (!vfst.at_end()) {
methodOop m = vfst.method();
if (!vfst.method()->method_holder()->klass_part()->is_subclass_of(SystemDictionary::classloader_klass())&&
if (!vfst.method()->method_holder()->klass_part()->is_subclass_of(SystemDictionary::ClassLoader_klass())&&
!vfst.method()->method_holder()->klass_part()->is_subclass_of(access_controller_klass) &&
!vfst.method()->method_holder()->klass_part()->is_subclass_of(privileged_action_klass)) {
break;
@ -257,7 +257,7 @@ static void set_property(Handle props, const char* key, const char* value, TRAPS
Handle value_str = java_lang_String::create_from_platform_dependent_str((value != NULL ? value : ""), CHECK);
JavaCalls::call_virtual(&r,
props,
KlassHandle(THREAD, SystemDictionary::properties_klass()),
KlassHandle(THREAD, SystemDictionary::Properties_klass()),
vmSymbolHandles::put_name(),
vmSymbolHandles::object_object_object_signature(),
key_str,
@ -495,7 +495,7 @@ JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
guarantee(klass->is_cloneable(), "all arrays are cloneable");
} else {
guarantee(obj->is_instance(), "should be instanceOop");
bool cloneable = klass->is_subtype_of(SystemDictionary::cloneable_klass());
bool cloneable = klass->is_subtype_of(SystemDictionary::Cloneable_klass());
guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
}
#endif
@ -908,7 +908,7 @@ JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
// Special handling for primitive objects
if (java_lang_Class::is_primitive(mirror)) {
// Primitive objects does not have any interfaces
objArrayOop r = oopFactory::new_objArray(SystemDictionary::class_klass(), 0, CHECK_NULL);
objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
return (jobjectArray) JNIHandles::make_local(env, r);
}
@ -923,7 +923,7 @@ JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
}
// Allocate result array
objArrayOop r = oopFactory::new_objArray(SystemDictionary::class_klass(), size, CHECK_NULL);
objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), size, CHECK_NULL);
objArrayHandle result (THREAD, r);
// Fill in result
if (klass->oop_is_instance()) {
@ -934,8 +934,8 @@ JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
}
} else {
// All arrays implement java.lang.Cloneable and java.io.Serializable
result->obj_at_put(0, Klass::cast(SystemDictionary::cloneable_klass())->java_mirror());
result->obj_at_put(1, Klass::cast(SystemDictionary::serializable_klass())->java_mirror());
result->obj_at_put(0, Klass::cast(SystemDictionary::Cloneable_klass())->java_mirror());
result->obj_at_put(1, Klass::cast(SystemDictionary::Serializable_klass())->java_mirror());
}
return (jobjectArray) JNIHandles::make_local(env, result());
JVM_END
@ -1098,8 +1098,8 @@ JVM_ENTRY(jobject, JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, job
pending_exception = Handle(THREAD, PENDING_EXCEPTION);
CLEAR_PENDING_EXCEPTION;
if ( pending_exception->is_a(SystemDictionary::exception_klass()) &&
!pending_exception->is_a(SystemDictionary::runtime_exception_klass())) {
if ( pending_exception->is_a(SystemDictionary::Exception_klass()) &&
!pending_exception->is_a(SystemDictionary::RuntimeException_klass())) {
// Throw a java.security.PrivilegedActionException(Exception e) exception
JavaCallArguments args(pending_exception);
THROW_ARG_0(vmSymbolHandles::java_security_PrivilegedActionException(),
@ -1190,7 +1190,7 @@ JVM_ENTRY(jobject, JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls))
// the resource area must be registered in case of a gc
RegisterArrayForGC ragc(thread, local_array);
objArrayOop context = oopFactory::new_objArray(SystemDictionary::protectionDomain_klass(),
objArrayOop context = oopFactory::new_objArray(SystemDictionary::ProtectionDomain_klass(),
local_array->length(), CHECK_NULL);
objArrayHandle h_context(thread, context);
for (int index = 0; index < local_array->length(); index++) {
@ -1251,7 +1251,7 @@ JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass))
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
! Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) {
oop result = oopFactory::new_objArray(SystemDictionary::class_klass(), 0, CHECK_NULL);
oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
return (jobjectArray)JNIHandles::make_local(env, result);
}
@ -1259,7 +1259,7 @@ JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass))
if (k->inner_classes()->length() == 0) {
// Neither an inner nor outer class
oop result = oopFactory::new_objArray(SystemDictionary::class_klass(), 0, CHECK_NULL);
oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
return (jobjectArray)JNIHandles::make_local(env, result);
}
@ -1269,7 +1269,7 @@ JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass))
int length = icls->length();
// Allocate temp. result array
objArrayOop r = oopFactory::new_objArray(SystemDictionary::class_klass(), length/4, CHECK_NULL);
objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), length/4, CHECK_NULL);
objArrayHandle result (THREAD, r);
int members = 0;
@ -1299,7 +1299,7 @@ JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass))
if (members != length) {
// Return array of right length
objArrayOop res = oopFactory::new_objArray(SystemDictionary::class_klass(), members, CHECK_NULL);
objArrayOop res = oopFactory::new_objArray(SystemDictionary::Class_klass(), members, CHECK_NULL);
for(int i = 0; i < members; i++) {
res->obj_at_put(i, result->obj_at(i));
}
@ -1473,11 +1473,11 @@ static methodOop jvm_get_method_common(jobject method, TRAPS) {
oop mirror = NULL;
int slot = 0;
if (reflected->klass() == SystemDictionary::reflect_constructor_klass()) {
if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) {
mirror = java_lang_reflect_Constructor::clazz(reflected);
slot = java_lang_reflect_Constructor::slot(reflected);
} else {
assert(reflected->klass() == SystemDictionary::reflect_method_klass(),
assert(reflected->klass() == SystemDictionary::reflect_Method_klass(),
"wrong type");
mirror = java_lang_reflect_Method::clazz(reflected);
slot = java_lang_reflect_Method::slot(reflected);
@ -1533,7 +1533,7 @@ JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass,
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) {
// Return empty array
oop res = oopFactory::new_objArray(SystemDictionary::reflect_field_klass(), 0, CHECK_NULL);
oop res = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), 0, CHECK_NULL);
return (jobjectArray) JNIHandles::make_local(env, res);
}
@ -1561,13 +1561,13 @@ JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass,
} else {
num_fields = fields_len / instanceKlass::next_offset;
if (k() == SystemDictionary::throwable_klass()) {
if (k() == SystemDictionary::Throwable_klass()) {
num_fields--;
skip_backtrace = true;
}
}
objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_field_klass(), num_fields, CHECK_NULL);
objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), num_fields, CHECK_NULL);
objArrayHandle result (THREAD, r);
int out_idx = 0;
@ -1601,7 +1601,7 @@ JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass,
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass))
|| Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) {
// Return empty array
oop res = oopFactory::new_objArray(SystemDictionary::reflect_method_klass(), 0, CHECK_NULL);
oop res = oopFactory::new_objArray(SystemDictionary::reflect_Method_klass(), 0, CHECK_NULL);
return (jobjectArray) JNIHandles::make_local(env, res);
}
@ -1625,7 +1625,7 @@ JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass,
}
// Allocate result
objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_method_klass(), num_methods, CHECK_NULL);
objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_Method_klass(), num_methods, CHECK_NULL);
objArrayHandle result (THREAD, r);
int out_idx = 0;
@ -1653,7 +1653,7 @@ JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofC
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass))
|| Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) {
// Return empty array
oop res = oopFactory::new_objArray(SystemDictionary::reflect_constructor_klass(), 0 , CHECK_NULL);
oop res = oopFactory::new_objArray(SystemDictionary::reflect_Constructor_klass(), 0 , CHECK_NULL);
return (jobjectArray) JNIHandles::make_local(env, res);
}
@ -1677,7 +1677,7 @@ JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofC
}
// Allocate result
objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_constructor_klass(), num_constructors, CHECK_NULL);
objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_Constructor_klass(), num_constructors, CHECK_NULL);
objArrayHandle result(THREAD, r);
int out_idx = 0;
@ -1890,7 +1890,7 @@ JVM_ENTRY(jobjectArray, JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject
symbolHandle klass_name (THREAD, cp->klass_name_at(klass_ref));
symbolHandle member_name(THREAD, cp->uncached_name_ref_at(index));
symbolHandle member_sig (THREAD, cp->uncached_signature_ref_at(index));
objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::string_klass(), 3, CHECK_NULL);
objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::String_klass(), 3, CHECK_NULL);
objArrayHandle dest(THREAD, dest_o);
Handle str = java_lang_String::create_from_symbol(klass_name, CHECK_NULL);
dest->obj_at_put(0, str());
@ -2578,7 +2578,7 @@ static void thread_entry(JavaThread* thread, TRAPS) {
JavaValue result(T_VOID);
JavaCalls::call_virtual(&result,
obj,
KlassHandle(THREAD, SystemDictionary::thread_klass()),
KlassHandle(THREAD, SystemDictionary::Thread_klass()),
vmSymbolHandles::run_method_name(),
vmSymbolHandles::void_method_signature(),
THREAD);
@ -2676,7 +2676,7 @@ JVM_ENTRY(void, JVM_StopThread(JNIEnv* env, jobject jthread, jobject throwable))
// Fix for 4314342, 4145910, perhaps others: it now doesn't have
// any effect on the "liveness" of a thread; see
// JVM_IsThreadAlive, below.
if (java_throwable->is_a(SystemDictionary::threaddeath_klass())) {
if (java_throwable->is_a(SystemDictionary::ThreadDeath_klass())) {
java_lang_Thread::set_stillborn(java_thread);
}
THROW_OOP(java_throwable);
@ -3031,7 +3031,7 @@ JVM_ENTRY(jobjectArray, JVM_GetClassContext(JNIEnv *env))
}
// Create result array of type [Ljava/lang/Class;
objArrayOop result = oopFactory::new_objArray(SystemDictionary::class_klass(), depth, CHECK_NULL);
objArrayOop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), depth, CHECK_NULL);
// Fill in mirrors corresponding to method holders
int index = 0;
while (first != NULL) {
@ -4327,7 +4327,7 @@ JVM_ENTRY(jobjectArray, JVM_GetAllThreads(JNIEnv *env, jclass dummy))
JvmtiVMObjectAllocEventCollector oam;
int num_threads = tle.num_threads();
objArrayOop r = oopFactory::new_objArray(SystemDictionary::thread_klass(), num_threads, CHECK_NULL);
objArrayOop r = oopFactory::new_objArray(SystemDictionary::Thread_klass(), num_threads, CHECK_NULL);
objArrayHandle threads_ah(THREAD, r);
for (int i = 0; i < num_threads; i++) {
@ -4361,7 +4361,7 @@ JVM_ENTRY(jobjectArray, JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobject
// check if threads is not an array of objects of Thread class
klassOop k = objArrayKlass::cast(ah->klass())->element_klass();
if (k != SystemDictionary::thread_klass()) {
if (k != SystemDictionary::Thread_klass()) {
THROW_(vmSymbols::java_lang_IllegalArgumentException(), 0);
}
@ -4421,7 +4421,7 @@ JVM_ENTRY(jobjectArray, JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass))
if (encl_method_class_idx == 0) {
return NULL;
}
objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::object_klass(), 3, CHECK_NULL);
objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::Object_klass(), 3, CHECK_NULL);
objArrayHandle dest(THREAD, dest_o);
klassOop enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL);
dest->obj_at_put(0, Klass::cast(enc_k)->java_mirror());
@ -4535,7 +4535,7 @@ JVM_ENTRY(jobjectArray, JVM_GetThreadStateNames(JNIEnv* env,
values_h->int_at(0) == java_lang_Thread::NEW,
"Invalid threadStatus value");
objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(),
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
1, /* only 1 substate */
CHECK_NULL);
names_h = objArrayHandle(THREAD, r);
@ -4548,7 +4548,7 @@ JVM_ENTRY(jobjectArray, JVM_GetThreadStateNames(JNIEnv* env,
values_h->int_at(0) == java_lang_Thread::RUNNABLE,
"Invalid threadStatus value");
objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(),
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
1, /* only 1 substate */
CHECK_NULL);
names_h = objArrayHandle(THREAD, r);
@ -4561,7 +4561,7 @@ JVM_ENTRY(jobjectArray, JVM_GetThreadStateNames(JNIEnv* env,
values_h->int_at(0) == java_lang_Thread::BLOCKED_ON_MONITOR_ENTER,
"Invalid threadStatus value");
objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(),
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
1, /* only 1 substate */
CHECK_NULL);
names_h = objArrayHandle(THREAD, r);
@ -4574,7 +4574,7 @@ JVM_ENTRY(jobjectArray, JVM_GetThreadStateNames(JNIEnv* env,
values_h->int_at(0) == java_lang_Thread::IN_OBJECT_WAIT &&
values_h->int_at(1) == java_lang_Thread::PARKED,
"Invalid threadStatus value");
objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(),
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
2, /* number of substates */
CHECK_NULL);
names_h = objArrayHandle(THREAD, r);
@ -4592,7 +4592,7 @@ JVM_ENTRY(jobjectArray, JVM_GetThreadStateNames(JNIEnv* env,
values_h->int_at(1) == java_lang_Thread::IN_OBJECT_WAIT_TIMED &&
values_h->int_at(2) == java_lang_Thread::PARKED_TIMED,
"Invalid threadStatus value");
objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(),
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
3, /* number of substates */
CHECK_NULL);
names_h = objArrayHandle(THREAD, r);
@ -4611,7 +4611,7 @@ JVM_ENTRY(jobjectArray, JVM_GetThreadStateNames(JNIEnv* env,
assert(values_h->length() == 1 &&
values_h->int_at(0) == java_lang_Thread::TERMINATED,
"Invalid threadStatus value");
objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(),
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
1, /* only 1 substate */
CHECK_NULL);
names_h = objArrayHandle(THREAD, r);
@ -4646,4 +4646,3 @@ JVM_ENTRY(void, JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t i
#endif // KERNEL
}
JVM_END

4
hotspot/src/share/vm/prims/jvmtiEnter.xsl
View File

@ -773,7 +773,7 @@ static jvmtiError JNICALL
</xsl:apply-templates>
<xsl:text>
}
if (!thread_oop-&gt;is_a(SystemDictionary::thread_klass())) {
if (!thread_oop-&gt;is_a(SystemDictionary::Thread_klass())) {
</xsl:text>
<xsl:apply-templates select=".." mode="traceError">
<xsl:with-param name="err">JVMTI_ERROR_INVALID_THREAD</xsl:with-param>
@ -857,7 +857,7 @@ static jvmtiError JNICALL
</xsl:apply-templates>
<xsl:text>
}
if (!k_mirror->is_a(SystemDictionary::class_klass())) {
if (!k_mirror->is_a(SystemDictionary::Class_klass())) {
</xsl:text>
<xsl:apply-templates select=".." mode="traceError">
<xsl:with-param name="err">JVMTI_ERROR_INVALID_CLASS</xsl:with-param>

16
hotspot/src/share/vm/prims/jvmtiEnv.cpp
View File

@ -133,7 +133,7 @@ JvmtiEnv::GetThreadLocalStorage(jthread thread, void** data_ptr) {
if (thread_oop == NULL) {
return JVMTI_ERROR_INVALID_THREAD;
}
if (!thread_oop->is_a(SystemDictionary::thread_klass())) {
if (!thread_oop->is_a(SystemDictionary::Thread_klass())) {
return JVMTI_ERROR_INVALID_THREAD;
}
JavaThread* java_thread = java_lang_Thread::thread(thread_oop);
@ -199,7 +199,7 @@ JvmtiEnv::RetransformClasses(jint class_count, const jclass* classes) {
if (k_mirror == NULL) {
return JVMTI_ERROR_INVALID_CLASS;
}
if (!k_mirror->is_a(SystemDictionary::class_klass())) {
if (!k_mirror->is_a(SystemDictionary::Class_klass())) {
return JVMTI_ERROR_INVALID_CLASS;
}
@ -266,7 +266,7 @@ JvmtiEnv::GetObjectSize(jobject object, jlong* size_ptr) {
oop mirror = JNIHandles::resolve_external_guard(object);
NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT);
if (mirror->klass() == SystemDictionary::class_klass()) {
if (mirror->klass() == SystemDictionary::Class_klass()) {
if (!java_lang_Class::is_primitive(mirror)) {
mirror = java_lang_Class::as_klassOop(mirror);
assert(mirror != NULL, "class for non-primitive mirror must exist");
@ -327,7 +327,7 @@ JvmtiEnv::SetEventNotificationMode(jvmtiEventMode mode, jvmtiEvent event_type, j
if (thread_oop == NULL) {
return JVMTI_ERROR_INVALID_THREAD;
}
if (!thread_oop->is_a(SystemDictionary::thread_klass())) {
if (!thread_oop->is_a(SystemDictionary::Thread_klass())) {
return JVMTI_ERROR_INVALID_THREAD;
}
java_thread = java_lang_Thread::thread(thread_oop);
@ -620,7 +620,7 @@ JvmtiEnv::GetThreadState(jthread thread, jint* thread_state_ptr) {
thread_oop = JNIHandles::resolve_external_guard(thread);
}
if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::thread_klass())) {
if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::Thread_klass())) {
return JVMTI_ERROR_INVALID_THREAD;
}
@ -858,7 +858,7 @@ JvmtiEnv::StopThread(JavaThread* java_thread, jobject exception) {
jvmtiError
JvmtiEnv::InterruptThread(jthread thread) {
oop thread_oop = JNIHandles::resolve_external_guard(thread);
if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::thread_klass()))
if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::Thread_klass()))
return JVMTI_ERROR_INVALID_THREAD;
JavaThread* current_thread = JavaThread::current();
@ -895,7 +895,7 @@ JvmtiEnv::GetThreadInfo(jthread thread, jvmtiThreadInfo* info_ptr) {
} else {
thread_oop = JNIHandles::resolve_external_guard(thread);
}
if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::thread_klass()))
if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::Thread_klass()))
return JVMTI_ERROR_INVALID_THREAD;
Handle thread_obj(current_thread, thread_oop);
@ -1061,7 +1061,7 @@ JvmtiEnv::GetCurrentContendedMonitor(JavaThread* java_thread, jobject* monitor_p
jvmtiError
JvmtiEnv::RunAgentThread(jthread thread, jvmtiStartFunction proc, const void* arg, jint priority) {
oop thread_oop = JNIHandles::resolve_external_guard(thread);
if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::thread_klass())) {
if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::Thread_klass())) {
return JVMTI_ERROR_INVALID_THREAD;
}
if (priority < JVMTI_THREAD_MIN_PRIORITY || priority > JVMTI_THREAD_MAX_PRIORITY) {

4
hotspot/src/share/vm/prims/jvmtiEnvBase.cpp
View File

@ -508,7 +508,7 @@ JvmtiEnvBase::new_jthreadGroupArray(int length, Handle *handles) {
JavaThread *
JvmtiEnvBase::get_JavaThread(jthread jni_thread) {
oop t = JNIHandles::resolve_external_guard(jni_thread);
if (t == NULL || !t->is_a(SystemDictionary::thread_klass())) {
if (t == NULL || !t->is_a(SystemDictionary::Thread_klass())) {
return NULL;
}
// The following returns NULL if the thread has not yet run or is in
@ -1250,7 +1250,7 @@ VM_GetThreadListStackTraces::doit() {
for (int i = 0; i < _thread_count; ++i) {
jthread jt = _thread_list[i];
oop thread_oop = JNIHandles::resolve_external_guard(jt);
if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::thread_klass())) {
if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::Thread_klass())) {
set_result(JVMTI_ERROR_INVALID_THREAD);
return;
}

4
hotspot/src/share/vm/prims/jvmtiExport.cpp
View File

@ -627,7 +627,7 @@ static inline klassOop oop_to_klassOop(oop obj) {
klassOop k = obj->klass();
// if the object is a java.lang.Class then return the java mirror
if (k == SystemDictionary::class_klass()) {
if (k == SystemDictionary::Class_klass()) {
if (!java_lang_Class::is_primitive(obj)) {
k = java_lang_Class::as_klassOop(obj);
assert(k != NULL, "class for non-primitive mirror must exist");
@ -1896,7 +1896,7 @@ void JvmtiExport::record_vm_internal_object_allocation(oop obj) {
if (collector != NULL && collector->is_enabled()) {
// Don't record classes as these will be notified via the ClassLoad
// event.
if (obj->klass() != SystemDictionary::class_klass()) {
if (obj->klass() != SystemDictionary::Class_klass()) {
collector->record_allocation(obj);
}
}

2
hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp
View File

@ -3214,7 +3214,7 @@ void VM_RedefineClasses::redefine_single_class(jclass the_jclass,
// - all instanceKlasses for redefined classes reused & contents updated
the_class->vtable()->initialize_vtable(false, THREAD);
the_class->itable()->initialize_itable(false, THREAD);
assert(!HAS_PENDING_EXCEPTION || (THREAD->pending_exception()->is_a(SystemDictionary::threaddeath_klass())), "redefine exception");
assert(!HAS_PENDING_EXCEPTION || (THREAD->pending_exception()->is_a(SystemDictionary::ThreadDeath_klass())), "redefine exception");
}
// Leave arrays of jmethodIDs and itable index cache unchanged

22
hotspot/src/share/vm/prims/jvmtiTagMap.cpp
View File

@ -579,7 +579,7 @@ static inline jlong tag_for(JvmtiTagMap* tag_map, oop o) {
// If the object is a java.lang.Class then return the klassOop,
// otherwise return the original object
static inline oop klassOop_if_java_lang_Class(oop o) {
if (o->klass() == SystemDictionary::class_klass()) {
if (o->klass() == SystemDictionary::Class_klass()) {
if (!java_lang_Class::is_primitive(o)) {
o = (oop)java_lang_Class::as_klassOop(o);
assert(o != NULL, "class for non-primitive mirror must exist");
@ -644,7 +644,7 @@ class CallbackWrapper : public StackObj {
} else {
// if the object represents a runtime class then use the
// tag for java.lang.Class
_klass = SystemDictionary::class_klass();
_klass = SystemDictionary::Class_klass();
}
_klass_tag = tag_for(tag_map, _klass);
}
@ -747,7 +747,7 @@ class TwoOopCallbackWrapper : public CallbackWrapper {
// get referrer class tag.
klassOop k = (_referrer == referrer) ? // Check if referrer is a class...
_referrer->klass() // No, just get its class
: SystemDictionary::class_klass(); // Yes, its class is Class
: SystemDictionary::Class_klass(); // Yes, its class is Class
_referrer_klass_tag = tag_for(tag_map, k);
}
}
@ -1126,7 +1126,7 @@ static jint invoke_string_value_callback(jvmtiStringPrimitiveValueCallback cb,
oop str,
void* user_data)
{
assert(str->klass() == SystemDictionary::string_klass(), "not a string");
assert(str->klass() == SystemDictionary::String_klass(), "not a string");
// get the string value and length
// (string value may be offset from the base)
@ -1186,7 +1186,7 @@ static jint invoke_primitive_field_callback_for_static_fields
// for static fields only the index will be set
static jvmtiHeapReferenceInfo reference_info = { 0 };
assert(obj->klass() == SystemDictionary::class_klass(), "not a class");
assert(obj->klass() == SystemDictionary::Class_klass(), "not a class");
if (java_lang_Class::is_primitive(obj)) {
return 0;
}
@ -1498,7 +1498,7 @@ void IterateThroughHeapObjectClosure::do_object(oop obj) {
if (callbacks()->primitive_field_callback != NULL && obj->is_instance()) {
jint res;
jvmtiPrimitiveFieldCallback cb = callbacks()->primitive_field_callback;
if (obj->klass() == SystemDictionary::class_klass()) {
if (obj->klass() == SystemDictionary::Class_klass()) {
res = invoke_primitive_field_callback_for_static_fields(&wrapper,
obj,
cb,
@ -1515,7 +1515,7 @@ void IterateThroughHeapObjectClosure::do_object(oop obj) {
// string callback
if (!is_array &&
callbacks()->string_primitive_value_callback != NULL &&
obj->klass() == SystemDictionary::string_klass()) {
obj->klass() == SystemDictionary::String_klass()) {
jint res = invoke_string_value_callback(
callbacks()->string_primitive_value_callback,
&wrapper,
@ -2381,7 +2381,7 @@ inline bool CallbackInvoker::report_primitive_array_values(oop obj) {
// invoke the string value callback
inline bool CallbackInvoker::report_string_value(oop str) {
assert(str->klass() == SystemDictionary::string_klass(), "not a string");
assert(str->klass() == SystemDictionary::String_klass(), "not a string");
AdvancedHeapWalkContext* context = advanced_context();
assert(context->string_primitive_value_callback() != NULL, "no callback");
@ -2928,7 +2928,7 @@ inline bool VM_HeapWalkOperation::iterate_over_class(klassOop k) {
// super (only if something more interesting than java.lang.Object)
klassOop java_super = ik->java_super();
if (java_super != NULL && java_super != SystemDictionary::object_klass()) {
if (java_super != NULL && java_super != SystemDictionary::Object_klass()) {
oop super = Klass::cast(java_super)->java_mirror();
if (!CallbackInvoker::report_superclass_reference(mirror, super)) {
return false;
@ -3070,7 +3070,7 @@ inline bool VM_HeapWalkOperation::iterate_over_object(oop o) {
// if the object is a java.lang.String
if (is_reporting_string_values() &&
o->klass() == SystemDictionary::string_klass()) {
o->klass() == SystemDictionary::String_klass()) {
if (!CallbackInvoker::report_string_value(o)) {
return false;
}
@ -3255,7 +3255,7 @@ bool VM_HeapWalkOperation::visit(oop o) {
// instance
if (o->is_instance()) {
if (o->klass() == SystemDictionary::class_klass()) {
if (o->klass() == SystemDictionary::Class_klass()) {
o = klassOop_if_java_lang_Class(o);
if (o->is_klass()) {
// a java.lang.Class

2
hotspot/src/share/vm/prims/methodHandleWalk.cpp
View File

@ -1045,7 +1045,7 @@ MethodHandleCompiler::make_invoke(methodOop m, vmIntrinsics::ID iid,
case T_DOUBLE: emit_bc(Bytecodes::_dreturn); break;
case T_VOID: emit_bc(Bytecodes::_return); break;
case T_OBJECT:
if (_rklass.not_null() && _rklass() != SystemDictionary::object_klass())
if (_rklass.not_null() && _rklass() != SystemDictionary::Object_klass())
emit_bc(Bytecodes::_checkcast, cpool_klass_put(_rklass()));
emit_bc(Bytecodes::_areturn);
break;

26
hotspot/src/share/vm/prims/methodHandles.cpp
View File

@ -143,7 +143,7 @@ methodOop MethodHandles::decode_vmtarget(oop vmtarget, int vmindex, oop mtype,
return klassItable::method_for_itable_index((klassOop)vmtarget, vmindex);
} else {
if (!tk->oop_is_instance())
tk = instanceKlass::cast(SystemDictionary::object_klass());
tk = instanceKlass::cast(SystemDictionary::Object_klass());
return ((instanceKlass*)tk)->method_at_vtable(vmindex);
}
}
@ -264,14 +264,14 @@ methodOop MethodHandles::decode_method(oop x, klassOop& receiver_limit_result, i
return decode_MemberName(x, receiver_limit_result, decode_flags_result);
} else if (java_dyn_MethodHandle::is_subclass(xk)) {
return decode_MethodHandle(x, receiver_limit_result, decode_flags_result);
} else if (xk == SystemDictionary::reflect_method_klass()) {
} else if (xk == SystemDictionary::reflect_Method_klass()) {
oop clazz = java_lang_reflect_Method::clazz(x);
int slot = java_lang_reflect_Method::slot(x);
klassOop k = java_lang_Class::as_klassOop(clazz);
if (k != NULL && Klass::cast(k)->oop_is_instance())
return decode_methodOop(instanceKlass::cast(k)->method_with_idnum(slot),
decode_flags_result);
} else if (xk == SystemDictionary::reflect_constructor_klass()) {
} else if (xk == SystemDictionary::reflect_Constructor_klass()) {
oop clazz = java_lang_reflect_Constructor::clazz(x);
int slot = java_lang_reflect_Constructor::slot(x);
klassOop k = java_lang_Class::as_klassOop(clazz);
@ -328,7 +328,7 @@ enum {
};
void MethodHandles::init_MemberName(oop mname_oop, oop target_oop) {
if (target_oop->klass() == SystemDictionary::reflect_field_klass()) {
if (target_oop->klass() == SystemDictionary::reflect_Field_klass()) {
oop clazz = java_lang_reflect_Field::clazz(target_oop); // fd.field_holder()
int slot = java_lang_reflect_Field::slot(target_oop); // fd.index()
int mods = java_lang_reflect_Field::modifiers(target_oop);
@ -413,7 +413,7 @@ void MethodHandles::resolve_MemberName(Handle mname, TRAPS) {
if (defc_klassOop == NULL) return; // a primitive; no resolution possible
if (!Klass::cast(defc_klassOop)->oop_is_instance()) {
if (!Klass::cast(defc_klassOop)->oop_is_array()) return;
defc_klassOop = SystemDictionary::object_klass();
defc_klassOop = SystemDictionary::Object_klass();
}
instanceKlassHandle defc(THREAD, defc_klassOop);
defc_klassOop = NULL; // safety
@ -749,7 +749,7 @@ oop MethodHandles::encode_target(Handle mh, int format, TRAPS) {
return NULL; // unformed MH
}
klassOop tklass = target->klass();
if (Klass::cast(tklass)->is_subclass_of(SystemDictionary::object_klass())) {
if (Klass::cast(tklass)->is_subclass_of(SystemDictionary::Object_klass())) {
return target; // target is another MH (or something else?)
}
}
@ -828,19 +828,19 @@ static bool is_always_null_type(klassOop klass) {
}
bool MethodHandles::class_cast_needed(klassOop src, klassOop dst) {
if (src == dst || dst == SystemDictionary::object_klass())
if (src == dst || dst == SystemDictionary::Object_klass())
return false; // quickest checks
Klass* srck = Klass::cast(src);
Klass* dstk = Klass::cast(dst);
if (dstk->is_interface()) {
// interface receivers can safely be viewed as untyped,
// because interface calls always include a dynamic check
//dstk = Klass::cast(SystemDictionary::object_klass());
//dstk = Klass::cast(SystemDictionary::Object_klass());
return false;
}
if (srck->is_interface()) {
// interface arguments must be viewed as untyped
//srck = Klass::cast(SystemDictionary::object_klass());
//srck = Klass::cast(SystemDictionary::Object_klass());
return true;
}
if (is_always_null_type(src)) {
@ -853,7 +853,7 @@ bool MethodHandles::class_cast_needed(klassOop src, klassOop dst) {
}
static oop object_java_mirror() {
return Klass::cast(SystemDictionary::object_klass())->java_mirror();
return Klass::cast(SystemDictionary::Object_klass())->java_mirror();
}
bool MethodHandles::same_basic_type_for_arguments(BasicType src,
@ -1449,7 +1449,7 @@ void MethodHandles::verify_BoundMethodHandle(Handle mh, Handle target, int argnu
break;
}
// check subrange of Integer.value, if necessary
if (argument == NULL || argument->klass() != SystemDictionary::int_klass()) {
if (argument == NULL || argument->klass() != SystemDictionary::Integer_klass()) {
err = "bound integer argument must be of type java.lang.Integer";
break;
}
@ -1472,7 +1472,7 @@ void MethodHandles::verify_BoundMethodHandle(Handle mh, Handle target, int argnu
BasicType argbox = java_lang_boxing_object::basic_type(argument);
if (argbox != ptype) {
err = check_argument_type_change(T_OBJECT, (argument == NULL
? SystemDictionary::object_klass()
? SystemDictionary::Object_klass()
: argument->klass()),
ptype, ptype_klass(), argnum);
assert(err != NULL, "this must be an error");
@ -2175,7 +2175,7 @@ JVM_ENTRY(void, MHI_init_MT(JNIEnv *env, jobject igcls, jobject erased_jh)) {
symbolOop name = vmSymbols::toString_name(), sig = vmSymbols::void_string_signature();
JavaCallArguments args(Handle(THREAD, JNIHandles::resolve_non_null(erased_jh)));
JavaValue result(T_OBJECT);
JavaCalls::call_virtual(&result, SystemDictionary::object_klass(), name, sig,
JavaCalls::call_virtual(&result, SystemDictionary::Object_klass(), name, sig,
&args, CHECK);
Handle str(THREAD, (oop)result.get_jobject());
java_lang_String::print(str, tty);

2
hotspot/src/share/vm/prims/nativeLookup.cpp
View File

@ -137,7 +137,7 @@ address NativeLookup::lookup_style(methodHandle method, char* pure_name, const c
}
// Otherwise call static method findNative in ClassLoader
KlassHandle klass (THREAD, SystemDictionary::classloader_klass());
KlassHandle klass (THREAD, SystemDictionary::ClassLoader_klass());
Handle name_arg = java_lang_String::create_from_str(jni_name, CHECK_NULL);
JavaValue result(T_LONG);

2
hotspot/src/share/vm/runtime/jniHandles.cpp
View File

@ -144,7 +144,7 @@ void JNIHandles::initialize() {
EXCEPTION_MARK;
// We will never reach the CATCH below since Exceptions::_throw will cause
// the VM to exit if an exception is thrown during initialization
klassOop k = SystemDictionary::object_klass();
klassOop k = SystemDictionary::Object_klass();
_deleted_handle = instanceKlass::cast(k)->allocate_permanent_instance(CATCH);
}

2
hotspot/src/share/vm/runtime/os.cpp
View File

@ -280,7 +280,7 @@ void os::signal_init() {
string,
CHECK);
KlassHandle group(THREAD, SystemDictionary::threadGroup_klass());
KlassHandle group(THREAD, SystemDictionary::ThreadGroup_klass());
JavaCalls::call_special(&result,
thread_group,
group,

18
hotspot/src/share/vm/runtime/reflection.cpp
View File

@ -449,7 +449,7 @@ bool Reflection::verify_class_access(klassOop current_class, klassOop new_class,
// sun/reflect/MagicAccessorImpl subclasses to succeed trivially.
if ( JDK_Version::is_gte_jdk14x_version()
&& UseNewReflection
&& Klass::cast(current_class)->is_subclass_of(SystemDictionary::reflect_magic_klass())) {
&& Klass::cast(current_class)->is_subclass_of(SystemDictionary::reflect_MagicAccessorImpl_klass())) {
return true;
}
@ -541,7 +541,7 @@ bool Reflection::verify_field_access(klassOop current_class,
// sun/reflect/MagicAccessorImpl subclasses to succeed trivially.
if ( JDK_Version::is_gte_jdk14x_version()
&& UseNewReflection
&& Klass::cast(current_class)->is_subclass_of(SystemDictionary::reflect_magic_klass())) {
&& Klass::cast(current_class)->is_subclass_of(SystemDictionary::reflect_MagicAccessorImpl_klass())) {
return true;
}
@ -631,7 +631,7 @@ oop get_mirror_from_signature(methodHandle method, SignatureStream* ss, TRAPS) {
objArrayHandle Reflection::get_parameter_types(methodHandle method, int parameter_count, oop* return_type, TRAPS) {
// Allocate array holding parameter types (java.lang.Class instances)
objArrayOop m = oopFactory::new_objArray(SystemDictionary::class_klass(), parameter_count, CHECK_(objArrayHandle()));
objArrayOop m = oopFactory::new_objArray(SystemDictionary::Class_klass(), parameter_count, CHECK_(objArrayHandle()));
objArrayHandle mirrors (THREAD, m);
int index = 0;
// Collect parameter types
@ -1308,7 +1308,7 @@ oop Reflection::reflect_method(oop mirror, symbolHandle method_name, objArrayHan
if (Klass::cast(klass)->oop_is_array() && which == MEMBER_DECLARED) return NULL;
if (Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) {
klass = SystemDictionary::object_klass();
klass = SystemDictionary::Object_klass();
}
instanceKlassHandle h_k(THREAD, klass);
@ -1375,13 +1375,13 @@ objArrayOop Reflection::reflect_methods(oop mirror, jint which, TRAPS) {
// Exclude primitive types
if (java_lang_Class::is_primitive(mirror) ||
(Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array() && (which == MEMBER_DECLARED))) {
klassOop klass = SystemDictionary::reflect_method_klass();
klassOop klass = SystemDictionary::reflect_Method_klass();
return oopFactory::new_objArray(klass, 0, CHECK_NULL); // Return empty array
}
klassOop klass = java_lang_Class::as_klassOop(mirror);
if (Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) {
klass = SystemDictionary::object_klass();
klass = SystemDictionary::Object_klass();
}
instanceKlassHandle h_k(THREAD, klass);
@ -1411,7 +1411,7 @@ objArrayOop Reflection::reflect_methods(oop mirror, jint which, TRAPS) {
}
// Allocate result
klassOop klass = SystemDictionary::reflect_method_klass();
klassOop klass = SystemDictionary::reflect_Method_klass();
objArrayOop r = oopFactory::new_objArray(klass, count, CHECK_NULL);
objArrayHandle h_result (THREAD, r);
@ -1462,7 +1462,7 @@ objArrayOop Reflection::reflect_methods(oop mirror, jint which, TRAPS) {
}
}
// Allocate result
klassOop klass = SystemDictionary::reflect_method_klass();
klassOop klass = SystemDictionary::reflect_Method_klass();
objArrayOop r = oopFactory::new_objArray(klass, count, CHECK_NULL);
objArrayHandle h_result (THREAD, r);
@ -1523,7 +1523,7 @@ objArrayOop Reflection::reflect_constructors(oop mirror, jint which, TRAPS) {
bool prim = java_lang_Class::is_primitive(mirror);
Klass* k = prim ? NULL : Klass::cast(java_lang_Class::as_klassOop(mirror));
if (prim || k->is_interface() || k->oop_is_array()) {
return oopFactory::new_objArray(SystemDictionary::reflect_constructor_klass(), 0, CHECK_NULL); // Return empty array
return oopFactory::new_objArray(SystemDictionary::reflect_Constructor_klass(), 0, CHECK_NULL); // Return empty array
}
// Must be instanceKlass at this point

6
hotspot/src/share/vm/runtime/reflectionUtils.cpp
View File

@ -63,15 +63,15 @@ GrowableArray<FilteredField*> *FilteredFieldsMap::_filtered_fields =
void FilteredFieldsMap::initialize() {
int offset;
offset = java_lang_Throwable::get_backtrace_offset();
_filtered_fields->append(new FilteredField(SystemDictionary::throwable_klass(), offset));
_filtered_fields->append(new FilteredField(SystemDictionary::Throwable_klass(), offset));
// The latest version of vm may be used with old jdk.
if (JDK_Version::is_gte_jdk16x_version()) {
// The following class fields do not exist in
// previous version of jdk.
offset = sun_reflect_ConstantPool::cp_oop_offset();
_filtered_fields->append(new FilteredField(SystemDictionary::reflect_constant_pool_klass(), offset));
_filtered_fields->append(new FilteredField(SystemDictionary::reflect_ConstantPool_klass(), offset));
offset = sun_reflect_UnsafeStaticFieldAccessorImpl::base_offset();
_filtered_fields->append(new FilteredField(SystemDictionary::reflect_unsafe_static_field_accessor_impl_klass(), offset));
_filtered_fields->append(new FilteredField(SystemDictionary::reflect_UnsafeStaticFieldAccessorImpl_klass(), offset));
}
}

4
hotspot/src/share/vm/runtime/sharedRuntime.cpp
View File

@ -860,7 +860,7 @@ methodHandle SharedRuntime::resolve_helper(JavaThread *thread,
if (JvmtiExport::can_hotswap_or_post_breakpoint()) {
int retry_count = 0;
while (!HAS_PENDING_EXCEPTION && callee_method->is_old() &&
callee_method->method_holder() != SystemDictionary::object_klass()) {
callee_method->method_holder() != SystemDictionary::Object_klass()) {
// If has a pending exception then there is no need to re-try to
// resolve this method.
// If the method has been redefined, we need to try again.
@ -1538,7 +1538,7 @@ char* SharedRuntime::generate_wrong_method_type_message(JavaThread* thread,
oop SharedRuntime::wrong_method_type_is_for_single_argument(JavaThread* thr,
oopDesc* required) {
if (required == NULL) return NULL;
if (required->klass() == SystemDictionary::class_klass())
if (required->klass() == SystemDictionary::Class_klass())
return required;
if (required->is_klass())
return Klass::cast(klassOop(required))->java_mirror();

2
hotspot/src/share/vm/runtime/statSampler.cpp
View File

@ -177,7 +177,7 @@ const char* StatSampler::get_system_property(const char* name, TRAPS) {
// public static String getProperty(String key, String def);
JavaCalls::call_static(&result,
KlassHandle(THREAD, SystemDictionary::system_klass()),
KlassHandle(THREAD, SystemDictionary::System_klass()),
vmSymbolHandles::getProperty_name(),
vmSymbolHandles::string_string_signature(),
key_str,

14
hotspot/src/share/vm/runtime/thread.cpp
View File

@ -957,7 +957,7 @@ void JavaThread::allocate_threadObj(Handle thread_group, char* thread_name, bool
return;
}
KlassHandle group(this, SystemDictionary::threadGroup_klass());
KlassHandle group(this, SystemDictionary::ThreadGroup_klass());
Handle threadObj(this, this->threadObj());
JavaCalls::call_special(&result,
@ -1451,7 +1451,7 @@ void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
// so call ThreadGroup.uncaughtException()
KlassHandle recvrKlass(THREAD, threadObj->klass());
CallInfo callinfo;
KlassHandle thread_klass(THREAD, SystemDictionary::thread_klass());
KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass());
LinkResolver::resolve_virtual_call(callinfo, threadObj, recvrKlass, thread_klass,
vmSymbolHandles::dispatchUncaughtException_name(),
vmSymbolHandles::throwable_void_signature(),
@ -1467,7 +1467,7 @@ void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
uncaught_exception,
THREAD);
} else {
KlassHandle thread_group(THREAD, SystemDictionary::threadGroup_klass());
KlassHandle thread_group(THREAD, SystemDictionary::ThreadGroup_klass());
JavaValue result(T_VOID);
JavaCalls::call_virtual(&result,
group, thread_group,
@ -1488,7 +1488,7 @@ void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
while (java_lang_Thread::threadGroup(threadObj()) != NULL && (count-- > 0)) {
EXCEPTION_MARK;
JavaValue result(T_VOID);
KlassHandle thread_klass(THREAD, SystemDictionary::thread_klass());
KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass());
JavaCalls::call_virtual(&result,
threadObj, thread_klass,
vmSymbolHandles::exit_method_name(),
@ -1726,7 +1726,7 @@ void JavaThread::check_and_handle_async_exceptions(bool check_unsafe_error) {
// Check for pending async. exception
if (_pending_async_exception != NULL) {
// Only overwrite an already pending exception, if it is not a threadDeath.
if (!has_pending_exception() || !pending_exception()->is_a(SystemDictionary::threaddeath_klass())) {
if (!has_pending_exception() || !pending_exception()->is_a(SystemDictionary::ThreadDeath_klass())) {
// We cannot call Exceptions::_throw(...) here because we cannot block
set_pending_exception(_pending_async_exception, __FILE__, __LINE__);
@ -1835,14 +1835,14 @@ void JavaThread::send_thread_stop(oop java_throwable) {
if (is_Compiler_thread()) return;
// This is a change from JDK 1.1, but JDK 1.2 will also do it:
if (java_throwable->is_a(SystemDictionary::threaddeath_klass())) {
if (java_throwable->is_a(SystemDictionary::ThreadDeath_klass())) {
java_lang_Thread::set_stillborn(threadObj());
}
{
// Actually throw the Throwable against the target Thread - however
// only if there is no thread death exception installed already.
if (_pending_async_exception == NULL || !_pending_async_exception->is_a(SystemDictionary::threaddeath_klass())) {
if (_pending_async_exception == NULL || !_pending_async_exception->is_a(SystemDictionary::ThreadDeath_klass())) {
// If the topmost frame is a runtime stub, then we are calling into
// OptoRuntime from compiled code. Some runtime stubs (new, monitor_exit..)
// must deoptimize the caller before continuing, as the compiled exception handler table

8
hotspot/src/share/vm/runtime/vframe.cpp
View File

@ -124,7 +124,7 @@ GrowableArray<MonitorInfo*>* javaVFrame::locked_monitors() {
static void print_locked_object_class_name(outputStream* st, Handle obj, const char* lock_state) {
if (obj.not_null()) {
st->print("\t- %s <" INTPTR_FORMAT "> ", lock_state, (address)obj());
if (obj->klass() == SystemDictionary::class_klass()) {
if (obj->klass() == SystemDictionary::Class_klass()) {
klassOop target_klass = java_lang_Class::as_klassOop(obj());
st->print_cr("(a java.lang.Class for %s)", instanceKlass::cast(target_klass)->external_name());
} else {
@ -430,7 +430,7 @@ void vframeStreamCommon::security_get_caller_frame(int depth) {
// This is Method.invoke() -- skip it
} else if (use_new_reflection &&
Klass::cast(method()->method_holder())
->is_subclass_of(SystemDictionary::reflect_method_accessor_klass())) {
->is_subclass_of(SystemDictionary::reflect_MethodAccessorImpl_klass())) {
// This is an auxilary frame -- skip it
} else {
// This is non-excluded frame, we need to count it against the depth
@ -490,8 +490,8 @@ void vframeStreamCommon::skip_prefixed_method_and_wrappers() {
void vframeStreamCommon::skip_reflection_related_frames() {
while (!at_end() &&
(JDK_Version::is_gte_jdk14x_version() && UseNewReflection &&
(Klass::cast(method()->method_holder())->is_subclass_of(SystemDictionary::reflect_method_accessor_klass()) ||
Klass::cast(method()->method_holder())->is_subclass_of(SystemDictionary::reflect_constructor_accessor_klass())))) {
(Klass::cast(method()->method_holder())->is_subclass_of(SystemDictionary::reflect_MethodAccessorImpl_klass()) ||
Klass::cast(method()->method_holder())->is_subclass_of(SystemDictionary::reflect_ConstructorAccessorImpl_klass())))) {
next();
}
}

56
hotspot/src/share/vm/runtime/vmStructs.cpp
View File

@ -455,40 +455,38 @@ static inline uint64_t cast_uint64_t(size_t x)
static_field(SystemDictionary, _shared_dictionary, Dictionary*) \
static_field(SystemDictionary, _system_loader_lock_obj, oop) \
static_field(SystemDictionary, _loader_constraints, LoaderConstraintTable*) \
static_field(SystemDictionary, WK_KLASS(object_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(string_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(class_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(cloneable_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(classloader_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(serializable_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(system_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(throwable_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(threaddeath_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(error_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(exception_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(runtime_exception_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(classNotFoundException_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(noClassDefFoundError_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(linkageError_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(Object_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(String_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(Class_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(Cloneable_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(ClassLoader_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(Serializable_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(System_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(Throwable_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(ThreadDeath_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(Error_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(Exception_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(RuntimeException_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(ClassNotFoundException_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(NoClassDefFoundError_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(LinkageError_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(ClassCastException_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(ArrayStoreException_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(virtualMachineError_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(VirtualMachineError_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(OutOfMemoryError_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(StackOverflowError_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(protectionDomain_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(ProtectionDomain_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(AccessControlContext_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(reference_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(soft_reference_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(weak_reference_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(final_reference_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(phantom_reference_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(finalizer_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(thread_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(threadGroup_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(properties_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(stringBuffer_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(vector_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(hashtable_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(Reference_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(SoftReference_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(WeakReference_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(FinalReference_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(PhantomReference_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(Finalizer_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(Thread_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(ThreadGroup_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(Properties_klass), klassOop) \
static_field(SystemDictionary, WK_KLASS(StringBuffer_klass), klassOop) \
static_field(SystemDictionary, _box_klasses[0], klassOop) \
static_field(SystemDictionary, _java_system_loader, oop) \
\

2
hotspot/src/share/vm/services/attachListener.cpp
View File

@ -437,7 +437,7 @@ void AttachListener::init() {
string,
CHECK);
KlassHandle group(THREAD, SystemDictionary::threadGroup_klass());
KlassHandle group(THREAD, SystemDictionary::ThreadGroup_klass());
JavaCalls::call_special(&result,
thread_group,
group,

2
hotspot/src/share/vm/services/heapDumper.cpp
View File

@ -1274,7 +1274,7 @@ void HeapObjectDumper::do_object(oop o) {
if (o->is_klass()) return;
// skip classes as these emitted as HPROF_GC_CLASS_DUMP records
if (o->klass() == SystemDictionary::class_klass()) {
if (o->klass() == SystemDictionary::Class_klass()) {
if (!java_lang_Class::is_primitive(o)) {
return;
}

2
hotspot/src/share/vm/services/lowMemoryDetector.cpp
View File

@ -32,7 +32,7 @@ volatile jint LowMemoryDetector::_disabled_count = 0;
void LowMemoryDetector::initialize() {
EXCEPTION_MARK;
instanceKlassHandle klass (THREAD, SystemDictionary::thread_klass());
instanceKlassHandle klass (THREAD, SystemDictionary::Thread_klass());
instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
const char thread_name[] = "Low Memory Detector";

14
hotspot/src/share/vm/services/management.cpp
View File

@ -491,7 +491,7 @@ JVM_ENTRY(jobjectArray, jmm_GetInputArgumentArray(JNIEnv *env))
int num_flags = Arguments::num_jvm_flags();
int num_args = Arguments::num_jvm_args();
instanceKlassHandle ik (THREAD, SystemDictionary::string_klass());
instanceKlassHandle ik (THREAD, SystemDictionary::String_klass());
objArrayOop r = oopFactory::new_objArray(ik(), num_args + num_flags, CHECK_NULL);
objArrayHandle result_h(THREAD, r);
@ -1321,7 +1321,7 @@ JVM_ENTRY(jobjectArray, jmm_GetLoadedClasses(JNIEnv *env))
LoadedClassesEnumerator lce(THREAD); // Pass current Thread as parameter
int num_classes = lce.num_loaded_classes();
objArrayOop r = oopFactory::new_objArray(SystemDictionary::class_klass(), num_classes, CHECK_0);
objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), num_classes, CHECK_0);
objArrayHandle classes_ah(THREAD, r);
for (int i = 0; i < num_classes; i++) {
@ -1481,7 +1481,7 @@ JVM_ENTRY(jobjectArray, jmm_GetVMGlobalNames(JNIEnv *env))
// last flag entry is always NULL, so subtract 1
int nFlags = (int) Flag::numFlags - 1;
// allocate a temp array
objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(),
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
nFlags, CHECK_0);
objArrayHandle flags_ah(THREAD, r);
int num_entries = 0;
@ -1497,7 +1497,7 @@ JVM_ENTRY(jobjectArray, jmm_GetVMGlobalNames(JNIEnv *env))
if (num_entries < nFlags) {
// Return array of right length
objArrayOop res = oopFactory::new_objArray(SystemDictionary::string_klass(), num_entries, CHECK_0);
objArrayOop res = oopFactory::new_objArray(SystemDictionary::String_klass(), num_entries, CHECK_0);
for(int i = 0; i < num_entries; i++) {
res->obj_at_put(i, flags_ah->obj_at(i));
}
@ -1593,7 +1593,7 @@ JVM_ENTRY(jint, jmm_GetVMGlobals(JNIEnv *env,
objArrayHandle names_ah(THREAD, ta);
// Make sure we have a String array
klassOop element_klass = objArrayKlass::cast(names_ah->klass())->element_klass();
if (element_klass != SystemDictionary::string_klass()) {
if (element_klass != SystemDictionary::String_klass()) {
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
"Array element type is not String class", 0);
}
@ -1747,7 +1747,7 @@ JVM_ENTRY(jint, jmm_GetInternalThreadTimes(JNIEnv *env,
// Make sure we have a String array
klassOop element_klass = objArrayKlass::cast(names_ah->klass())->element_klass();
if (element_klass != SystemDictionary::string_klass()) {
if (element_klass != SystemDictionary::String_klass()) {
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
"Array element type is not String class", 0);
}
@ -1782,7 +1782,7 @@ static Handle find_deadlocks(bool object_monitors_only, TRAPS) {
num_threads += cycle->num_threads();
}
objArrayOop r = oopFactory::new_objArray(SystemDictionary::thread_klass(), num_threads, CHECK_NH);
objArrayOop r = oopFactory::new_objArray(SystemDictionary::Thread_klass(), num_threads, CHECK_NH);
objArrayHandle threads_ah(THREAD, r);
int index = 0;

2
hotspot/src/share/vm/services/serviceUtil.hpp
View File

@ -45,7 +45,7 @@ class ServiceUtil : public AllStatic {
// instance
if (o->is_instance()) {
// instance objects are visible
if (o->klass() != SystemDictionary::class_klass()) {
if (o->klass() != SystemDictionary::Class_klass()) {
return true;
}
if (java_lang_Class::is_primitive(o)) {

2
hotspot/src/share/vm/services/threadService.cpp
View File

@ -540,7 +540,7 @@ bool ThreadStackTrace::is_owned_monitor_on_stack(oop object) {
}
Handle ThreadStackTrace::allocate_fill_stack_trace_element_array(TRAPS) {
klassOop k = SystemDictionary::stackTraceElement_klass();
klassOop k = SystemDictionary::StackTraceElement_klass();
assert(k != NULL, "must be loaded in 1.4+");
instanceKlassHandle ik(THREAD, k);

4
hotspot/src/share/vm/utilities/exceptions.cpp
View File

@ -122,7 +122,7 @@ void Exceptions::_throw(Thread* thread, const char* file, int line, Handle h_exc
// Check for special boot-strapping/vm-thread handling
if (special_exception(thread, file, line, h_exception)) return;
assert(h_exception->is_a(SystemDictionary::throwable_klass()), "exception is not a subclass of java/lang/Throwable");
assert(h_exception->is_a(SystemDictionary::Throwable_klass()), "exception is not a subclass of java/lang/Throwable");
// set the pending exception
thread->set_pending_exception(h_exception(), file, line);
@ -255,7 +255,7 @@ Handle Exceptions::new_exception(Thread *thread, symbolHandle h_name,
// Future: object initializer should take a cause argument
if (h_cause() != NULL) {
assert(h_cause->is_a(SystemDictionary::throwable_klass()),
assert(h_cause->is_a(SystemDictionary::Throwable_klass()),
"exception cause is not a subclass of java/lang/Throwable");
JavaValue result1(T_OBJECT);
JavaCallArguments args1;