infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-01-28 12:09:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

8367142: Avoid InstanceKlass::cast when converting java mirror to InstanceKlass

Browse Source 
Reviewed-by: dholmes, coleenp
This commit is contained in:
Ioi Lam 2025-09-16 01:04:48 +00:00
parent 64155dfac0
commit 2425584849
15 changed files with 80 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/hotspot/share/cds/aotMetaspace.cpp
View File

@ -785,7 +785,7 @@ void AOTMetaspace::link_all_loaded_classes(JavaThread* current) {
const GrowableArray<OopHandle>* mirrors = collect_classes.mirrors();
for (int i = 0; i < mirrors->length(); i++) {
OopHandle mirror = mirrors->at(i);
InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(mirror.resolve()));
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror.resolve());
if (may_be_eagerly_linked(ik)) {
has_linked |= try_link_class(current, ik);
}
@ -812,7 +812,7 @@ void AOTMetaspace::link_shared_classes(TRAPS) {
const GrowableArray<OopHandle>* mirrors = collect_classes.mirrors();
for (int i = 0; i < mirrors->length(); i++) {
OopHandle mirror = mirrors->at(i);
InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(mirror.resolve()));
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror.resolve());
AOTConstantPoolResolver::preresolve_string_cp_entries(ik, CHECK);
}
}

2
src/hotspot/share/cds/unregisteredClasses.cpp
View File

@ -94,7 +94,7 @@ InstanceKlass* UnregisteredClasses::load_class(Symbol* name, const char* path, T
CHECK_NULL);
assert(result.get_type() == T_OBJECT, "just checking");
return InstanceKlass::cast(java_lang_Class::as_Klass(result.get_oop()));
return java_lang_Class::as_InstanceKlass(result.get_oop());
}
bool UnregisteredClasses::check_for_exclusion(const InstanceKlass* k) {

27
src/hotspot/share/classfile/javaClasses.cpp
View File

@ -990,7 +990,7 @@ void java_lang_Class::fixup_mirror(Klass* k, TRAPS) {
create_mirror(k, Handle(), Handle(), Handle(), Handle(), CHECK);
}
void java_lang_Class::initialize_mirror_fields(Klass* k,
void java_lang_Class::initialize_mirror_fields(InstanceKlass* ik,
Handle mirror,
Handle protection_domain,
Handle classData,
@ -1005,7 +1005,7 @@ void java_lang_Class::initialize_mirror_fields(Klass* k,
set_protection_domain(mirror(), protection_domain());
// Initialize static fields
InstanceKlass::cast(k)->do_local_static_fields(&initialize_static_field, mirror, CHECK);
ik->do_local_static_fields(&initialize_static_field, mirror, CHECK);
// Set classData
set_class_data(mirror(), classData());
@ -1111,8 +1111,7 @@ void java_lang_Class::allocate_mirror(Klass* k, bool is_scratch, Handle protecti
// and java_mirror in this klass.
} else {
assert(k->is_instance_klass(), "Must be");
initialize_mirror_fields(k, mirror, protection_domain, classData, THREAD);
initialize_mirror_fields(InstanceKlass::cast(k), mirror, protection_domain, classData, THREAD);
if (HAS_PENDING_EXCEPTION) {
// If any of the fields throws an exception like OOM remove the klass field
// from the mirror so GC doesn't follow it after the klass has been deallocated.
@ -2590,7 +2589,7 @@ static void print_stack_element_to_stream(outputStream* st, Handle mirror, int m
ResourceMark rm;
stringStream ss;
InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
InstanceKlass* holder = java_lang_Class::as_InstanceKlass(mirror());
const char* klass_name = holder->external_name();
char* method_name = name->as_C_string();
ss.print("\tat %s.%s(", klass_name, method_name);
@ -2969,7 +2968,7 @@ void java_lang_Throwable::get_stack_trace_elements(int depth, Handle backtrace,
THROW(vmSymbols::java_lang_NullPointerException());
}
InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(bte._mirror()));
InstanceKlass* holder = java_lang_Class::as_InstanceKlass(bte._mirror());
methodHandle method (THREAD, holder->method_with_orig_idnum(bte._method_id, bte._version));
java_lang_StackTraceElement::fill_in(stack_trace_element, holder,
@ -3055,7 +3054,7 @@ bool java_lang_Throwable::get_top_method_and_bci(oop throwable, Method** method,
// Get first backtrace element.
BacktraceElement bte = iter.next(current);
InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(bte._mirror()));
InstanceKlass* holder = java_lang_Class::as_InstanceKlass(bte._mirror());
assert(holder != nullptr, "first element should be non-null");
Method* m = holder->method_with_orig_idnum(bte._method_id, bte._version);
@ -3441,11 +3440,11 @@ void java_lang_reflect_Method::serialize_offsets(SerializeClosure* f) {
Handle java_lang_reflect_Method::create(TRAPS) {
assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
Klass* klass = vmClasses::reflect_Method_klass();
InstanceKlass* klass = vmClasses::reflect_Method_klass();
// This class is eagerly initialized during VM initialization, since we keep a reference
// to one of the methods
assert(InstanceKlass::cast(klass)->is_initialized(), "must be initialized");
return InstanceKlass::cast(klass)->allocate_instance_handle(THREAD);
assert(klass->is_initialized(), "must be initialized");
return klass->allocate_instance_handle(THREAD);
}
oop java_lang_reflect_Method::clazz(oop reflect) {
@ -3914,17 +3913,15 @@ void reflect_ConstantPool::set_cp(oop reflect, ConstantPool* value) {
}
ConstantPool* reflect_ConstantPool::get_cp(oop reflect) {
oop mirror = reflect->obj_field(_oop_offset);
Klass* k = java_lang_Class::as_Klass(mirror);
assert(k->is_instance_klass(), "Must be");
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror);
// Get the constant pool back from the klass. Since class redefinition
// merges the new constant pool into the old, this is essentially the
// same constant pool as the original. If constant pool merging is
// no longer done in the future, this will have to change to save
// the original.
return InstanceKlass::cast(k)->constants();
return ik->constants();
}
@ -5531,7 +5528,7 @@ void JavaClasses::check_offsets() {
#endif // PRODUCT
int InjectedField::compute_offset() {
InstanceKlass* ik = InstanceKlass::cast(klass());
InstanceKlass* ik = klass();
for (AllFieldStream fs(ik); !fs.done(); fs.next()) {
if (!may_be_java && !fs.field_flags().is_injected()) {
// Only look at injected fields

12
src/hotspot/share/classfile/javaClasses.hpp
View File

@ -269,7 +269,7 @@ class java_lang_Class : AllStatic {
static void set_protection_domain(oop java_class, oop protection_domain);
static void set_class_loader(oop java_class, oop class_loader);
static void set_component_mirror(oop java_class, oop comp_mirror);
static void initialize_mirror_fields(Klass* k, Handle mirror, Handle protection_domain,
static void initialize_mirror_fields(InstanceKlass* ik, Handle mirror, Handle protection_domain,
Handle classData, TRAPS);
static void set_mirror_module_field(JavaThread* current, Klass* K, Handle mirror, Handle module);
public:
@ -293,8 +293,10 @@ class java_lang_Class : AllStatic {
static void fixup_module_field(Klass* k, Handle module);
// Conversion
// Conversion -- java_class must not be null. The return value is null only if java_class is a primitive type.
static Klass* as_Klass(oop java_class);
static InstanceKlass* as_InstanceKlass(oop java_class);
static void set_klass(oop java_class, Klass* klass);
static BasicType as_BasicType(oop java_class, Klass** reference_klass = nullptr);
static Symbol* as_signature(oop java_class, bool intern_if_not_found);
@ -1895,11 +1897,11 @@ class InjectedField {
const vmClassID klass_id;
const vmSymbolID name_index;
const vmSymbolID signature_index;
const bool may_be_java;
const bool may_be_java;
Klass* klass() const { return vmClasses::klass_at(klass_id); }
Symbol* name() const { return lookup_symbol(name_index); }
InstanceKlass* klass() const { return vmClasses::klass_at(klass_id); }
Symbol* name() const { return lookup_symbol(name_index); }
Symbol* signature() const { return lookup_symbol(signature_index); }
int compute_offset();

6
src/hotspot/share/classfile/javaClasses.inline.hpp
View File

@ -291,6 +291,12 @@ inline Klass* java_lang_Class::as_Klass(oop java_class) {
return k;
}
inline InstanceKlass* java_lang_Class::as_InstanceKlass(oop java_class) {
Klass* k = as_Klass(java_class);
assert(k == nullptr || k->is_instance_klass(), "type check");
return static_cast<InstanceKlass*>(k);
}
inline bool java_lang_Class::is_primitive(oop java_class) {
// should assert:
// assert(java_lang_Class::is_instance(java_class), "must be a Class object");

4
src/hotspot/share/classfile/systemDictionary.cpp
View File

@ -1277,10 +1277,10 @@ InstanceKlass* SystemDictionary::load_instance_class_impl(Symbol* class_name, Ha
assert(result.get_type() == T_OBJECT, "just checking");
oop obj = result.get_oop();
// Primitive classes return null since forName() can not be
// Primitive classes return null since forName() cannot be
// used to obtain any of the Class objects representing primitives or void
if ((obj != nullptr) && !(java_lang_Class::is_primitive(obj))) {
InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(obj));
InstanceKlass* k = java_lang_Class::as_InstanceKlass(obj);
// For user defined Java class loaders, check that the name returned is
// the same as that requested. This check is done for the bootstrap
// loader when parsing the class file.

2
src/hotspot/share/jfr/leakprofiler/chains/edgeUtils.cpp
View File

@ -65,7 +65,7 @@ const Symbol* EdgeUtils::field_name(const Edge& edge, jshort* modifiers) {
if (is_static_field(ref_owner, ik, offset)) {
assert(ik->is_mirror_instance_klass(), "invariant");
assert(java_lang_Class::as_Klass(ref_owner)->is_instance_klass(), "invariant");
ik = InstanceKlass::cast(java_lang_Class::as_Klass(ref_owner));
ik = java_lang_Class::as_InstanceKlass(ref_owner);
}
while (ik != nullptr) {
JavaFieldStream jfs(ik);

2
src/hotspot/share/jvmci/jvmciRuntime.cpp
View File

@ -187,7 +187,7 @@ JRT_ENTRY(void, JVMCIRuntime::dynamic_new_array_or_null(JavaThread* current, oop
JRT_END
JRT_ENTRY(void, JVMCIRuntime::dynamic_new_instance_or_null(JavaThread* current, oopDesc* type_mirror))
InstanceKlass* klass = InstanceKlass::cast(java_lang_Class::as_Klass(type_mirror));
InstanceKlass* klass = java_lang_Class::as_InstanceKlass(type_mirror);
if (klass == nullptr) {
ResourceMark rm(current);

2
src/hotspot/share/prims/jni.cpp
View File

@ -526,7 +526,7 @@ JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message))
jint ret = JNI_OK;
DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret);
InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
InstanceKlass* k = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(clazz));
Symbol* name = k->name();
Handle class_loader (THREAD, k->class_loader());
THROW_MSG_LOADER_(name, (char *)message, class_loader, JNI_OK);

82
src/hotspot/share/prims/jvm.cpp
View File

@ -840,14 +840,9 @@ JVM_ENTRY(jclass, JVM_FindClassFromClass(JNIEnv *env, const char *name,
if (log_is_enabled(Debug, class, resolve) && result != nullptr) {
// this function is generally only used for class loading during verification.
ResourceMark rm;
oop from_mirror = JNIHandles::resolve_non_null(from);
Klass* from_class = java_lang_Class::as_Klass(from_mirror);
const char * from_name = from_class->external_name();
oop mirror = JNIHandles::resolve_non_null(result);
Klass* to_class = java_lang_Class::as_Klass(mirror);
const char * to = to_class->external_name();
log_debug(class, resolve)("%s %s (verification)", from_name, to);
const char* from_name = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(from))->external_name();
const char* to_name = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result))->external_name();
log_debug(class, resolve)("%s %s (verification)", from_name, to_name);
}
#if INCLUDE_CDS
@ -918,12 +913,12 @@ static jclass jvm_lookup_define_class(jclass lookup, const char *name,
jboolean init, int flags, jobject classData, TRAPS) {
ResourceMark rm(THREAD);
Klass* lookup_k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(lookup));
// Lookup class must be a non-null instance
InstanceKlass* lookup_k = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(lookup));
// Lookup class must not be a primitive class (whose mirror has a null Klass*)
if (lookup_k == nullptr) {
// The error message is wrong. We come here only if lookup is a primitive class
THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Lookup class is null");
}
assert(lookup_k->is_instance_klass(), "Lookup class must be an instance klass");
Handle class_loader (THREAD, lookup_k->class_loader());
@ -934,7 +929,7 @@ static jclass jvm_lookup_define_class(jclass lookup, const char *name,
InstanceKlass* host_class = nullptr;
if (is_nestmate) {
host_class = InstanceKlass::cast(lookup_k)->nest_host(CHECK_NULL);
host_class = lookup_k->nest_host(CHECK_NULL);
}
log_info(class, nestmates)("LookupDefineClass: %s - %s%s, %s, %s, %s",
@ -1265,7 +1260,7 @@ JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass))
return (jobjectArray)JNIHandles::make_local(THREAD, result);
}
InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(ofMirror));
InstanceKlass* k = java_lang_Class::as_InstanceKlass(ofMirror);
InnerClassesIterator iter(k);
if (iter.length() == 0) {
@ -1404,11 +1399,10 @@ static bool jvm_get_field_common(jobject field, fieldDescriptor& fd) {
oop reflected = JNIHandles::resolve_non_null(field);
oop mirror = java_lang_reflect_Field::clazz(reflected);
Klass* k = java_lang_Class::as_Klass(mirror);
int slot = java_lang_reflect_Field::slot(reflected);
int modifiers = java_lang_reflect_Field::modifiers(reflected);
InstanceKlass* ik = InstanceKlass::cast(k);
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror);
int offset = ik->field_offset(slot);
if (modifiers & JVM_ACC_STATIC) {
@ -1444,9 +1438,9 @@ static Method* jvm_get_method_common(jobject method) {
mirror = java_lang_reflect_Method::clazz(reflected);
slot = java_lang_reflect_Method::slot(reflected);
}
Klass* k = java_lang_Class::as_Klass(mirror);
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror);
Method* m = InstanceKlass::cast(k)->method_with_idnum(slot);
Method* m = ik->method_with_idnum(slot);
assert(m != nullptr, "cannot find method");
return m; // caller has to deal with null in product mode
}
@ -1570,7 +1564,7 @@ JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass,
return (jobjectArray) JNIHandles::make_local(THREAD, res);
}
InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(ofMirror));
InstanceKlass* k = java_lang_Class::as_InstanceKlass(ofMirror);
constantPoolHandle cp(THREAD, k->constants());
// Ensure class is linked
@ -1627,9 +1621,7 @@ JVM_END
// even if the class is not a record.
JVM_ENTRY(jobjectArray, JVM_GetRecordComponents(JNIEnv* env, jclass ofClass))
{
Klass* c = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass));
assert(c->is_instance_klass(), "must be");
InstanceKlass* ik = InstanceKlass::cast(c);
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(ofClass));
Array<RecordComponent*>* components = ik->record_components();
if (components != nullptr) {
@ -1671,7 +1663,7 @@ static jobjectArray get_class_declared_methods_helper(
return (jobjectArray) JNIHandles::make_local(THREAD, res);
}
InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(ofMirror));
InstanceKlass* k = java_lang_Class::as_InstanceKlass(ofMirror);
// Ensure class is linked
k->link_class(CHECK_NULL);
@ -1750,23 +1742,17 @@ JVM_END
JVM_ENTRY(jboolean, JVM_AreNestMates(JNIEnv *env, jclass current, jclass member))
{
Klass* c = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(current));
assert(c->is_instance_klass(), "must be");
InstanceKlass* ck = InstanceKlass::cast(c);
Klass* m = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(member));
assert(m->is_instance_klass(), "must be");
InstanceKlass* mk = InstanceKlass::cast(m);
return ck->has_nestmate_access_to(mk, THREAD);
InstanceKlass* c = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(current));
InstanceKlass* m = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(member));
return c->has_nestmate_access_to(m, THREAD);
}
JVM_END
JVM_ENTRY(jclass, JVM_GetNestHost(JNIEnv* env, jclass current))
{
// current is not a primitive or array class
Klass* c = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(current));
assert(c->is_instance_klass(), "must be");
InstanceKlass* ck = InstanceKlass::cast(c);
InstanceKlass* host = ck->nest_host(THREAD);
InstanceKlass* c = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(current));
InstanceKlass* host = c->nest_host(THREAD);
return (jclass) (host == nullptr ? nullptr :
JNIHandles::make_local(THREAD, host->java_mirror()));
}
@ -1776,13 +1762,11 @@ JVM_ENTRY(jobjectArray, JVM_GetNestMembers(JNIEnv* env, jclass current))
{
// current is not a primitive or array class
ResourceMark rm(THREAD);
Klass* c = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(current));
assert(c->is_instance_klass(), "must be");
InstanceKlass* ck = InstanceKlass::cast(c);
InstanceKlass* host = ck->nest_host(THREAD);
InstanceKlass* c = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(current));
InstanceKlass* host = c->nest_host(THREAD);
log_trace(class, nestmates)("Calling GetNestMembers for type %s with nest-host %s",
ck->external_name(), host->external_name());
c->external_name(), host->external_name());
{
JvmtiVMObjectAllocEventCollector oam;
Array<u2>* members = host->nest_members();
@ -1845,7 +1829,7 @@ JVM_ENTRY(jobjectArray, JVM_GetNestMembers(JNIEnv* env, jclass current))
}
}
else {
assert(host == ck || ck->is_hidden(), "must be singleton nest or dynamic nestmate");
assert(host == c || c->is_hidden(), "must be singleton nest or dynamic nestmate");
}
return (jobjectArray)JNIHandles::make_local(THREAD, result());
}
@ -1856,9 +1840,8 @@ JVM_ENTRY(jobjectArray, JVM_GetPermittedSubclasses(JNIEnv* env, jclass current))
{
oop mirror = JNIHandles::resolve_non_null(current);
assert(!java_lang_Class::is_primitive(mirror), "should not be");
Klass* c = java_lang_Class::as_Klass(mirror);
assert(c->is_instance_klass(), "must be");
InstanceKlass* ik = InstanceKlass::cast(c);
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror);
ResourceMark rm(THREAD);
log_trace(class, sealed)("Calling GetPermittedSubclasses for %s type %s",
ik->is_sealed() ? "sealed" : "non-sealed", ik->external_name());
@ -3379,16 +3362,14 @@ JVM_ENTRY(void, JVM_RegisterLambdaProxyClassForArchiving(JNIEnv* env,
return;
}
Klass* caller_k = java_lang_Class::as_Klass(JNIHandles::resolve(caller));
InstanceKlass* caller_ik = InstanceKlass::cast(caller_k);
InstanceKlass* caller_ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(caller));
if (caller_ik->is_hidden()) {
// Hidden classes not of type lambda proxy classes are currently not being archived.
// If the caller_ik is of one of the above types, the corresponding lambda proxy class won't be
// registered for archiving.
return;
}
Klass* lambda_k = java_lang_Class::as_Klass(JNIHandles::resolve(lambdaProxyClass));
InstanceKlass* lambda_ik = InstanceKlass::cast(lambda_k);
InstanceKlass* lambda_ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(lambdaProxyClass));
assert(lambda_ik->is_hidden(), "must be a hidden class");
assert(!lambda_ik->is_non_strong_hidden(), "expected a strong hidden class");
@ -3428,8 +3409,7 @@ JVM_ENTRY(jclass, JVM_LookupLambdaProxyClassFromArchive(JNIEnv* env,
THROW_(vmSymbols::java_lang_NullPointerException(), nullptr);
}
Klass* caller_k = java_lang_Class::as_Klass(JNIHandles::resolve(caller));
InstanceKlass* caller_ik = InstanceKlass::cast(caller_k);
InstanceKlass* caller_ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(caller));
if (!caller_ik->in_aot_cache()) {
// there won't be a shared lambda class if the caller_ik is not in the shared archive.
return nullptr;
@ -3825,11 +3805,7 @@ JVM_ENTRY(jint, JVM_GetClassFileVersion(JNIEnv* env, jclass current))
// return latest major version and minor version of 0.
return JVM_CLASSFILE_MAJOR_VERSION;
}
assert(!java_lang_Class::as_Klass(mirror)->is_array_klass(), "unexpected array class");
Klass* c = java_lang_Class::as_Klass(mirror);
assert(c->is_instance_klass(), "must be");
InstanceKlass* ik = InstanceKlass::cast(c);
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror);
return (ik->minor_version() << 16) | ik->major_version();
JVM_END

2
src/hotspot/share/prims/methodHandles.cpp
View File

@ -902,7 +902,7 @@ void MethodHandles::expand_MemberName(Handle mname, int suppress, TRAPS) {
if (clazz == nullptr) {
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "nothing to expand (as field)");
}
InstanceKlass* defc = InstanceKlass::cast(java_lang_Class::as_Klass(clazz));
InstanceKlass* defc = java_lang_Class::as_InstanceKlass(clazz);
DEBUG_ONLY(clazz = nullptr); // safety
intptr_t vmindex = java_lang_invoke_MemberName::vmindex(mname());
bool is_static = ((flags & JVM_ACC_STATIC) != 0);

2
src/hotspot/share/prims/unsafe.cpp
View File

@ -489,7 +489,7 @@ static jlong find_known_instance_field_offset(jclass clazz, jstring name, TRAPS)
ResourceMark rm(THREAD);
char *utf_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name));
InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
InstanceKlass* k = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(clazz));
jint offset = -1; // Not found
for (JavaFieldStream fs(k); !fs.done(); fs.next()) {

26
src/hotspot/share/prims/whitebox.cpp
View File

@ -1156,7 +1156,7 @@ WB_ENTRY(jboolean, WB_EnqueueMethodForCompilation(JNIEnv* env, jobject o, jobjec
WB_END
WB_ENTRY(jboolean, WB_EnqueueInitializerForCompilation(JNIEnv* env, jobject o, jclass klass, jint comp_level))
InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass));
Method* clinit = ik->class_initializer();
if (clinit == nullptr || clinit->method_holder()->is_not_initialized()) {
return false;
@ -1936,18 +1936,18 @@ WB_ENTRY(void, WB_ForceClassLoaderStatsSafepoint(JNIEnv* env, jobject wb))
WB_END
WB_ENTRY(jlong, WB_GetConstantPool(JNIEnv* env, jobject wb, jclass klass))
InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass));
return (jlong) ik->constants();
WB_END
WB_ENTRY(jobjectArray, WB_GetResolvedReferences(JNIEnv* env, jobject wb, jclass klass))
InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass));
objArrayOop resolved_refs= ik->constants()->resolved_references();
return (jobjectArray)JNIHandles::make_local(THREAD, resolved_refs);
WB_END
WB_ENTRY(jint, WB_getFieldEntriesLength(JNIEnv* env, jobject wb, jclass klass))
InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass));
ConstantPool* cp = ik->constants();
if (cp->cache() == nullptr) {
return -1;
@ -1956,7 +1956,7 @@ WB_ENTRY(jint, WB_getFieldEntriesLength(JNIEnv* env, jobject wb, jclass klass))
WB_END
WB_ENTRY(jint, WB_getFieldCPIndex(JNIEnv* env, jobject wb, jclass klass, jint index))
InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass));
ConstantPool* cp = ik->constants();
if (cp->cache() == nullptr) {
return -1;
@ -1965,7 +1965,7 @@ WB_ENTRY(jint, WB_getFieldCPIndex(JNIEnv* env, jobject wb, jclass klass, jint in
WB_END
WB_ENTRY(jint, WB_getMethodEntriesLength(JNIEnv* env, jobject wb, jclass klass))
InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass));
ConstantPool* cp = ik->constants();
if (cp->cache() == nullptr) {
return -1;
@ -1974,7 +1974,7 @@ WB_ENTRY(jint, WB_getMethodEntriesLength(JNIEnv* env, jobject wb, jclass klass))
WB_END
WB_ENTRY(jint, WB_getMethodCPIndex(JNIEnv* env, jobject wb, jclass klass, jint index))
InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass));
ConstantPool* cp = ik->constants();
if (cp->cache() == nullptr) {
return -1;
@ -1983,7 +1983,7 @@ WB_ENTRY(jint, WB_getMethodCPIndex(JNIEnv* env, jobject wb, jclass klass, jint i
WB_END
WB_ENTRY(jint, WB_getIndyInfoLength(JNIEnv* env, jobject wb, jclass klass))
InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass));
ConstantPool* cp = ik->constants();
if (cp->cache() == nullptr) {
return -1;
@ -1992,7 +1992,7 @@ WB_ENTRY(jint, WB_getIndyInfoLength(JNIEnv* env, jobject wb, jclass klass))
WB_END
WB_ENTRY(jint, WB_getIndyCPIndex(JNIEnv* env, jobject wb, jclass klass, jint index))
InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass));
ConstantPool* cp = ik->constants();
if (cp->cache() == nullptr) {
return -1;
@ -2386,10 +2386,8 @@ int WhiteBox::offset_for_field(const char* field_name, oop object,
Symbol* signature_symbol) {
assert(field_name != nullptr && strlen(field_name) > 0, "Field name not valid");
//Get the class of our object
Klass* arg_klass = object->klass();
//Turn it into an instance-klass
InstanceKlass* ik = InstanceKlass::cast(arg_klass);
//Only non-array oops have fields. Don't call this function on arrays!
InstanceKlass* ik = InstanceKlass::cast(object->klass());
//Create symbols to look for in the class
TempNewSymbol name_symbol = SymbolTable::new_symbol(field_name);
@ -3065,7 +3063,7 @@ JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass))
{
if (WhiteBoxAPI) {
// Make sure that wbclass is loaded by the null classloader
InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(wbclass)));
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(wbclass));
Handle loader(THREAD, ik->class_loader());
if (loader.is_null()) {
WhiteBox::register_methods(env, wbclass, thread, methods, sizeof(methods) / sizeof(methods[0]));

4
src/hotspot/share/runtime/reflection.cpp
View File

@ -1136,7 +1136,7 @@ oop Reflection::invoke_method(oop method_mirror, Handle receiver, objArrayHandle
rtype = T_OBJECT;
}
InstanceKlass* klass = InstanceKlass::cast(java_lang_Class::as_Klass(mirror));
InstanceKlass* klass = java_lang_Class::as_InstanceKlass(mirror);
Method* m = klass->method_with_idnum(slot);
if (m == nullptr) {
THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "invoke");
@ -1153,7 +1153,7 @@ oop Reflection::invoke_constructor(oop constructor_mirror, objArrayHandle args,
bool override = java_lang_reflect_Constructor::override(constructor_mirror) != 0;
objArrayHandle ptypes(THREAD, objArrayOop(java_lang_reflect_Constructor::parameter_types(constructor_mirror)));
InstanceKlass* klass = InstanceKlass::cast(java_lang_Class::as_Klass(mirror));
InstanceKlass* klass = java_lang_Class::as_InstanceKlass(mirror);
Method* m = klass->method_with_idnum(slot);
if (m == nullptr) {
THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "invoke");

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

@ -881,8 +881,8 @@ void SharedRuntime::throw_StackOverflowError_common(JavaThread* current, bool de
// We avoid using the normal exception construction in this case because
// it performs an upcall to Java, and we're already out of stack space.
JavaThread* THREAD = current; // For exception macros.
Klass* k = vmClasses::StackOverflowError_klass();
oop exception_oop = InstanceKlass::cast(k)->allocate_instance(CHECK);
InstanceKlass* k = vmClasses::StackOverflowError_klass();
oop exception_oop = k->allocate_instance(CHECK);
if (delayed) {
java_lang_Throwable::set_message(exception_oop,
Universe::delayed_stack_overflow_error_message());