Skip to content

Commit cc65836

Browse files
iklamiklam
committed
8367719: Refactor JNI code that uses class_to_verify_considering_redefinition()
Reviewed-by: coleenp, dholmes, sspitsyn
1 parent d21e73d commit cc65836

File tree

3 files changed

+93
-110
lines changed

3 files changed

+93
-110
lines changed

‎src/hotspot/share/prims/jvm.cpp‎

Lines changed: 80 additions & 98 deletions
Original file line numberDiff line numberDiff line change
@@ -2253,39 +2253,51 @@ JVM_END
22532253
// Reflection for the verifier /////////////////////////////////////////////////////////////////
22542254

22552255
// RedefineClasses support: bug 6214132 caused verification to fail.
2256-
// All functions from this section should call the jvmtiThreadSate function:
2257-
// Klass* class_to_verify_considering_redefinition(Klass* klass).
2258-
// The function returns a Klass* of the _scratch_class if the verifier
2259-
// was invoked in the middle of the class redefinition.
2260-
// Otherwise it returns its argument value which is the _the_class Klass*.
2261-
// Please, refer to the description in the jvmtiThreadState.hpp.
2256+
// All functions from this section, unless noted otherwise, should call the functions
2257+
// get_klass_considering_redefinition(), or
2258+
// get_instance_klass_considering_redefinition()
2259+
// These functions return JvmtiThreadState::_scratch_class if the verifier
2260+
// was invoked in the middle of the redefinition of cls.
2261+
// See jvmtiThreadState.hpp for details.
2262+
2263+
inline Klass* get_klass_considering_redefinition(jclass cls, JavaThread* thread) {
2264+
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2265+
if (k->is_instance_klass()) {
2266+
return JvmtiThreadState::class_to_verify_considering_redefinition(InstanceKlass::cast(k), thread);
2267+
} else {
2268+
return k;
2269+
}
2270+
}
2271+
2272+
inline InstanceKlass* get_instance_klass_considering_redefinition(jclass cls, JavaThread* thread) {
2273+
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(cls));
2274+
return JvmtiThreadState::class_to_verify_considering_redefinition(ik, thread);
2275+
}
22622276

22632277
JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
22642278
oop mirror = JNIHandles::resolve_non_null(cls);
22652279
if (java_lang_Class::is_primitive(mirror)) {
22662280
return JNI_FALSE;
22672281
}
22682282
Klass* k = java_lang_Class::as_Klass(mirror);
2269-
// This isn't necessary since answer is the same since redefinition
2283+
// This isn't necessary since answer is the same because redefinition
22702284
// has already checked this matches for the scratch class.
2271-
// k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2285+
// k = get_klass_considering_redefinition(cls, thread)
22722286
jboolean result = k->is_interface();
22732287
assert(!result || k->is_instance_klass(),
22742288
"all interfaces are instance types");
22752289
return result;
22762290
JVM_END
22772291

2278-
22792292
JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls))
2293+
// No need to call get_klass_considering_redefinition() as redefinition cannot change a class's name.
22802294
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2281-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
22822295
return k->name()->as_utf8();
22832296
JVM_END
22842297

22852298

22862299
JVM_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))
2287-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2288-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2300+
Klass* k = get_klass_considering_redefinition(cls, thread);
22892301
// types will have length zero if this is not an InstanceKlass
22902302
// (length is determined by call to JVM_GetClassCPEntriesCount)
22912303
if (k->is_instance_klass()) {
@@ -2299,22 +2311,19 @@ JVM_END
22992311

23002312

23012313
JVM_ENTRY(jint, JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls))
2302-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2303-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2314+
Klass* k = get_klass_considering_redefinition(cls, thread);
23042315
return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->constants()->length();
23052316
JVM_END
23062317

23072318

23082319
JVM_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv *env, jclass cls))
2309-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2310-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2320+
Klass* k = get_klass_considering_redefinition(cls, thread);
23112321
return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->java_fields_count();
23122322
JVM_END
23132323

23142324

23152325
JVM_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv *env, jclass cls))
2316-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2317-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2326+
Klass* k = get_klass_considering_redefinition(cls, thread);
23182327
return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->methods()->length();
23192328
JVM_END
23202329

@@ -2325,9 +2334,8 @@ JVM_END
23252334
// by the results of JVM_GetClass{Fields,Methods}Count, which return
23262335
// zero for arrays.
23272336
JVM_ENTRY(void, JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions))
2328-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2329-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2330-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2337+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2338+
Method* method = ik->methods()->at(method_index);
23312339
int length = method->checked_exceptions_length();
23322340
if (length > 0) {
23332341
CheckedExceptionElement* table= method->checked_exceptions_start();
@@ -2339,33 +2347,29 @@ JVM_END
23392347

23402348

23412349
JVM_ENTRY(jint, JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index))
2342-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2343-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2344-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2350+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2351+
Method* method = ik->methods()->at(method_index);
23452352
return method->checked_exceptions_length();
23462353
JVM_END
23472354

23482355

23492356
JVM_ENTRY(void, JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code))
2350-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2351-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2352-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2357+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2358+
Method* method = ik->methods()->at(method_index);
23532359
memcpy(code, method->code_base(), method->code_size());
23542360
JVM_END
23552361

23562362

23572363
JVM_ENTRY(jint, JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index))
2358-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2359-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2360-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2364+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2365+
Method* method = ik->methods()->at(method_index);
23612366
return method->code_size();
23622367
JVM_END
23632368

23642369

23652370
JVM_ENTRY(void, JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry))
2366-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2367-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2368-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2371+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2372+
Method* method = ik->methods()->at(method_index);
23692373
ExceptionTable extable(method);
23702374
entry->start_pc = extable.start_pc(entry_index);
23712375
entry->end_pc = extable.end_pc(entry_index);
@@ -2375,81 +2379,71 @@ JVM_END
23752379

23762380

23772381
JVM_ENTRY(jint, JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index))
2378-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2379-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2380-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2382+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2383+
Method* method = ik->methods()->at(method_index);
23812384
return method->exception_table_length();
23822385
JVM_END
23832386

23842387

23852388
JVM_ENTRY(jint, JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index))
2386-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2387-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2388-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2389+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2390+
Method* method = ik->methods()->at(method_index);
23892391
return method->access_flags().as_method_flags();
23902392
JVM_END
23912393

23922394

23932395
JVM_ENTRY(jint, JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index))
2394-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2395-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2396-
return InstanceKlass::cast(k)->field_access_flags(field_index);
2396+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2397+
return ik->field_access_flags(field_index);
23972398
JVM_END
23982399

23992400

24002401
JVM_ENTRY(jint, JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index))
2401-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2402-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2403-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2402+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2403+
Method* method = ik->methods()->at(method_index);
24042404
return method->max_locals();
24052405
JVM_END
24062406

24072407

24082408
JVM_ENTRY(jint, JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index))
2409-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2410-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2411-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2409+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2410+
Method* method = ik->methods()->at(method_index);
24122411
return method->size_of_parameters();
24132412
JVM_END
24142413

24152414

24162415
JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2417-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2418-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2419-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2416+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2417+
Method* method = ik->methods()->at(method_index);
24202418
return method->verifier_max_stack();
24212419
JVM_END
24222420

24232421

24242422
JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
24252423
ResourceMark rm(THREAD);
2426-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2427-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2428-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2424+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2425+
Method* method = ik->methods()->at(method_index);
24292426
return method->name() == vmSymbols::object_initializer_name();
24302427
JVM_END
24312428

24322429

24332430
JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
24342431
ResourceMark rm(THREAD);
2435-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2436-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2437-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2432+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2433+
Method* method = ik->methods()->at(method_index);
24382434
return method->is_overpass();
24392435
JVM_END
24402436

24412437
JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2442-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2443-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2444-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2438+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2439+
Method* method = ik->methods()->at(method_index);
24452440
return method->name()->as_utf8();
24462441
JVM_END
24472442

24482443

24492444
JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
2450-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2451-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2452-
Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2445+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2446+
Method* method = ik->methods()->at(method_index);
24532447
return method->signature()->as_utf8();
24542448
JVM_END
24552449

@@ -2462,9 +2456,8 @@ JVM_END
24622456
* constant pool, so we must use cp->uncached_x methods when appropriate.
24632457
*/
24642458
JVM_ENTRY(const char*, JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2465-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2466-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2467-
ConstantPool* cp = InstanceKlass::cast(k)->constants();
2459+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2460+
ConstantPool* cp = ik->constants();
24682461
switch (cp->tag_at(cp_index).value()) {
24692462
case JVM_CONSTANT_Fieldref:
24702463
return cp->uncached_name_ref_at(cp_index)->as_utf8();
@@ -2477,9 +2470,8 @@ JVM_END
24772470

24782471

24792472
JVM_ENTRY(const char*, JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2480-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2481-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2482-
ConstantPool* cp = InstanceKlass::cast(k)->constants();
2473+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2474+
ConstantPool* cp = ik->constants();
24832475
switch (cp->tag_at(cp_index).value()) {
24842476
case JVM_CONSTANT_InterfaceMethodref:
24852477
case JVM_CONSTANT_Methodref:
@@ -2493,9 +2485,8 @@ JVM_END
24932485

24942486

24952487
JVM_ENTRY(const char*, JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index))
2496-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2497-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2498-
ConstantPool* cp = InstanceKlass::cast(k)->constants();
2488+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2489+
ConstantPool* cp = ik->constants();
24992490
switch (cp->tag_at(cp_index).value()) {
25002491
case JVM_CONSTANT_InterfaceMethodref:
25012492
case JVM_CONSTANT_Methodref:
@@ -2509,9 +2500,8 @@ JVM_END
25092500

25102501

25112502
JVM_ENTRY(const char*, JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index))
2512-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2513-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2514-
ConstantPool* cp = InstanceKlass::cast(k)->constants();
2503+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2504+
ConstantPool* cp = ik->constants();
25152505
switch (cp->tag_at(cp_index).value()) {
25162506
case JVM_CONSTANT_Fieldref:
25172507
return cp->uncached_signature_ref_at(cp_index)->as_utf8();
@@ -2524,18 +2514,16 @@ JVM_END
25242514

25252515

25262516
JVM_ENTRY(const char*, JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2527-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2528-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2529-
ConstantPool* cp = InstanceKlass::cast(k)->constants();
2517+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2518+
ConstantPool* cp = ik->constants();
25302519
Symbol* classname = cp->klass_name_at(cp_index);
25312520
return classname->as_utf8();
25322521
JVM_END
25332522

25342523

25352524
JVM_ENTRY(const char*, JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2536-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2537-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2538-
ConstantPool* cp = InstanceKlass::cast(k)->constants();
2525+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2526+
ConstantPool* cp = ik->constants();
25392527
switch (cp->tag_at(cp_index).value()) {
25402528
case JVM_CONSTANT_Fieldref: {
25412529
int class_index = cp->uncached_klass_ref_index_at(cp_index);
@@ -2551,9 +2539,8 @@ JVM_END
25512539

25522540

25532541
JVM_ENTRY(const char*, JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2554-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2555-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2556-
ConstantPool* cp = InstanceKlass::cast(k)->constants();
2542+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2543+
ConstantPool* cp = ik->constants();
25572544
switch (cp->tag_at(cp_index).value()) {
25582545
case JVM_CONSTANT_Methodref:
25592546
case JVM_CONSTANT_InterfaceMethodref: {
@@ -2570,18 +2557,15 @@ JVM_END
25702557

25712558

25722559
JVM_ENTRY(jint, JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls))
2573-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2574-
Klass* k_called = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(called_cls));
2575-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2576-
k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread);
2577-
ConstantPool* cp = InstanceKlass::cast(k)->constants();
2578-
ConstantPool* cp_called = InstanceKlass::cast(k_called)->constants();
2560+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2561+
InstanceKlass* ik_called = get_instance_klass_considering_redefinition(called_cls, thread);
2562+
ConstantPool* cp = ik->constants();
2563+
ConstantPool* cp_called = ik_called->constants();
25792564
switch (cp->tag_at(cp_index).value()) {
25802565
case JVM_CONSTANT_Fieldref: {
25812566
Symbol* name = cp->uncached_name_ref_at(cp_index);
25822567
Symbol* signature = cp->uncached_signature_ref_at(cp_index);
2583-
InstanceKlass* ik = InstanceKlass::cast(k_called);
2584-
for (JavaFieldStream fs(ik); !fs.done(); fs.next()) {
2568+
for (JavaFieldStream fs(ik_called); !fs.done(); fs.next()) {
25852569
if (fs.name() == name && fs.signature() == signature) {
25862570
return fs.access_flags().as_field_flags();
25872571
}
@@ -2597,17 +2581,15 @@ JVM_END
25972581

25982582

25992583
JVM_ENTRY(jint, JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls))
2600-
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2601-
Klass* k_called = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(called_cls));
2602-
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2603-
k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread);
2604-
ConstantPool* cp = InstanceKlass::cast(k)->constants();
2584+
InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2585+
InstanceKlass* ik_called = get_instance_klass_considering_redefinition(called_cls, thread);
2586+
ConstantPool* cp = ik->constants();
26052587
switch (cp->tag_at(cp_index).value()) {
26062588
case JVM_CONSTANT_Methodref:
26072589
case JVM_CONSTANT_InterfaceMethodref: {
26082590
Symbol* name = cp->uncached_name_ref_at(cp_index);
26092591
Symbol* signature = cp->uncached_signature_ref_at(cp_index);
2610-
Array<Method*>* methods = InstanceKlass::cast(k_called)->methods();
2592+
Array<Method*>* methods = ik_called->methods();
26112593
int methods_count = methods->length();
26122594
for (int i = 0; i < methods_count; i++) {
26132595
Method* method = methods->at(i);

‎src/hotspot/share/prims/jvmtiRedefineClasses.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -99,7 +99,7 @@ VM_RedefineClasses::VM_RedefineClasses(jint class_count,
9999

100100
static inline InstanceKlass* get_ik(jclass def) {
101101
oop mirror = JNIHandles::resolve_non_null(def);
102-
return InstanceKlass::cast(java_lang_Class::as_Klass(mirror));
102+
return java_lang_Class::as_InstanceKlass(mirror);
103103
}
104104

105105
// If any of the classes are being redefined, wait
@@ -1310,12 +1310,12 @@ int VM_RedefineClasses::find_new_operand_index(int old_index) {
13101310
class RedefineVerifyMark : public StackObj {
13111311
private:
13121312
JvmtiThreadState* _state;
1313-
Klass* _scratch_class;
1313+
InstanceKlass* _scratch_class;
13141314
OopHandle _scratch_mirror;
13151315

13161316
public:
13171317

1318-
RedefineVerifyMark(Klass* the_class, Klass* scratch_class,
1318+
RedefineVerifyMark(InstanceKlass* the_class, InstanceKlass* scratch_class,
13191319
JvmtiThreadState* state) : _state(state), _scratch_class(scratch_class)
13201320
{
13211321
_state->set_class_versions_map(the_class, scratch_class);

0 commit comments

Comments
 (0)