diff -r caf5eb7dd4a7 -r 882756847a04 hotspot/src/share/vm/interpreter/linkResolver.cpp --- a/hotspot/src/share/vm/interpreter/linkResolver.cpp Fri Aug 31 16:39:35 2012 -0700 +++ b/hotspot/src/share/vm/interpreter/linkResolver.cpp Sat Sep 01 13:25:18 2012 -0400 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -75,7 +75,7 @@ void CallInfo::set_static(KlassHandle resolved_klass, methodHandle resolved_method, TRAPS) { - int vtable_index = methodOopDesc::nonvirtual_vtable_index; + int vtable_index = Method::nonvirtual_vtable_index; set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, vtable_index, CHECK); } @@ -85,7 +85,7 @@ // comes from java/lang/Object, it can be the subject of a virtual call, so // 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; + int vtable_index = Method::invalid_vtable_index; 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(); @@ -94,7 +94,7 @@ } void CallInfo::set_virtual(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int vtable_index, TRAPS) { - assert(vtable_index >= 0 || vtable_index == methodOopDesc::nonvirtual_vtable_index, "valid index"); + assert(vtable_index >= 0 || vtable_index == Method::nonvirtual_vtable_index, "valid index"); set_common(resolved_klass, selected_klass, resolved_method, selected_method, vtable_index, CHECK); assert(!resolved_method->is_compiled_lambda_form(), "these must be handled via an invokehandle call"); } @@ -103,11 +103,11 @@ if (resolved_method.is_null()) { THROW_MSG(vmSymbols::java_lang_InternalError(), "resolved method is null"); } - KlassHandle resolved_klass = SystemDictionaryHandles::MethodHandle_klass(); + KlassHandle resolved_klass = SystemDictionary::MethodHandle_klass(); assert(resolved_method->intrinsic_id() == vmIntrinsics::_invokeBasic || resolved_method->is_compiled_lambda_form(), "linkMethod must return one of these"); - int vtable_index = methodOopDesc::nonvirtual_vtable_index; + int vtable_index = Method::nonvirtual_vtable_index; assert(resolved_method->vtable_index() == vtable_index, ""); set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, vtable_index, CHECK); _resolved_appendix = resolved_appendix; @@ -131,7 +131,7 @@ // don't force compilation, resolve was on behalf of compiler return; } - if (instanceKlass::cast(selected_method->method_holder())->is_not_initialized()) { + if (InstanceKlass::cast(selected_method->method_holder())->is_not_initialized()) { // 'is_not_initialized' means not only '!is_initialized', but also that // initialization has not been started yet ('!being_initialized') // Do not force compilation of methods in uninitialized classes. @@ -152,8 +152,8 @@ // Klass resolution void LinkResolver::check_klass_accessability(KlassHandle ref_klass, KlassHandle sel_klass, TRAPS) { - if (!Reflection::verify_class_access(ref_klass->as_klassOop(), - sel_klass->as_klassOop(), + if (!Reflection::verify_class_access(ref_klass(), + sel_klass(), true)) { ResourceMark rm(THREAD); Exceptions::fthrow( @@ -168,13 +168,13 @@ } void LinkResolver::resolve_klass(KlassHandle& result, constantPoolHandle pool, int index, TRAPS) { - klassOop result_oop = pool->klass_ref_at(index, CHECK); + Klass* result_oop = pool->klass_ref_at(index, CHECK); result = KlassHandle(THREAD, result_oop); } void LinkResolver::resolve_klass_no_update(KlassHandle& result, constantPoolHandle pool, int index, TRAPS) { - klassOop result_oop = - constantPoolOopDesc::klass_ref_at_if_loaded_check(pool, index, CHECK); + Klass* result_oop = + ConstantPool::klass_ref_at_if_loaded_check(pool, index, CHECK); result = KlassHandle(THREAD, result_oop); } @@ -185,7 +185,7 @@ // According to JVM spec. $5.4.3c & $5.4.3d void LinkResolver::lookup_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { - methodOop result_oop = klass->uncached_lookup_method(name, signature); + Method* result_oop = klass->uncached_lookup_method(name, signature); if (EnableInvokeDynamic && result_oop != NULL) { vmIntrinsics::ID iid = result_oop->intrinsic_id(); if (MethodHandles::is_signature_polymorphic(iid)) { @@ -198,7 +198,7 @@ // returns first instance method void LinkResolver::lookup_instance_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { - methodOop result_oop = klass->uncached_lookup_method(name, signature); + Method* result_oop = klass->uncached_lookup_method(name, signature); result = methodHandle(THREAD, result_oop); while (!result.is_null() && result->is_static()) { klass = KlassHandle(THREAD, Klass::cast(result->method_holder())->super()); @@ -209,12 +209,12 @@ int LinkResolver::vtable_index_of_miranda_method(KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { ResourceMark rm(THREAD); - klassVtable *vt = instanceKlass::cast(klass())->vtable(); + klassVtable *vt = InstanceKlass::cast(klass())->vtable(); return vt->index_of_miranda(name, signature); } void LinkResolver::lookup_method_in_interfaces(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { - instanceKlass *ik = instanceKlass::cast(klass()); + InstanceKlass *ik = InstanceKlass::cast(klass()); result = methodHandle(THREAD, ik->lookup_method_in_all_interfaces(name, signature)); } @@ -264,8 +264,8 @@ // We will ask Java code to spin an adapter method for it. if (!MethodHandles::enabled()) { // Make sure the Java part of the runtime has been booted up. - klassOop natives = SystemDictionary::MethodHandleNatives_klass(); - if (natives == NULL || instanceKlass::cast(natives)->is_not_initialized()) { + Klass* natives = SystemDictionary::MethodHandleNatives_klass(); + if (natives == NULL || InstanceKlass::cast(natives)->is_not_initialized()) { SystemDictionary::resolve_or_fail(vmSymbols::java_lang_invoke_MethodHandleNatives(), Handle(), Handle(), @@ -340,9 +340,9 @@ } // assert(extra_arg_result_or_null != NULL, "must be able to return extra argument"); - if (!Reflection::verify_field_access(ref_klass->as_klassOop(), - resolved_klass->as_klassOop(), - sel_klass->as_klassOop(), + if (!Reflection::verify_field_access(ref_klass(), + resolved_klass(), + sel_klass(), flags, true)) { ResourceMark rm(THREAD); @@ -364,7 +364,7 @@ // resolve klass if (code == Bytecodes::_invokedynamic) { - resolved_klass = SystemDictionaryHandles::MethodHandle_klass(); + resolved_klass = SystemDictionary::MethodHandle_klass(); Symbol* method_name = vmSymbols::invoke_name(); Symbol* method_signature = pool->signature_ref_at(index); KlassHandle current_klass(THREAD, pool->pool_holder()); @@ -381,7 +381,7 @@ if (pool->has_preresolution() || (resolved_klass() == SystemDictionary::MethodHandle_klass() && MethodHandles::is_signature_polymorphic_name(resolved_klass(), method_name))) { - methodOop result_oop = constantPoolOopDesc::method_at_if_loaded(pool, index); + Method* result_oop = ConstantPool::method_at_if_loaded(pool, index); if (result_oop != NULL) { resolved_method = methodHandle(THREAD, result_oop); return; @@ -430,7 +430,7 @@ // 4. method lookup failed ResourceMark rm(THREAD); THROW_MSG_CAUSE(vmSymbols::java_lang_NoSuchMethodError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), + Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), method_name, method_signature), nested_exception); @@ -441,7 +441,7 @@ if (resolved_method->is_abstract() && !resolved_klass->is_abstract()) { ResourceMark rm(THREAD); THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), + Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), method_name, method_signature)); } @@ -458,8 +458,8 @@ CHECK); // check loader constraints - Handle loader (THREAD, instanceKlass::cast(current_klass())->class_loader()); - Handle class_loader (THREAD, instanceKlass::cast(resolved_method->method_holder())->class_loader()); + Handle loader (THREAD, InstanceKlass::cast(current_klass())->class_loader()); + Handle class_loader (THREAD, InstanceKlass::cast(resolved_method->method_holder())->class_loader()); { ResourceMark rm(THREAD); char* failed_type_name = @@ -470,11 +470,11 @@ " \"%s\" the class loader (instance of %s) of the current class, %s," " and the class loader (instance of %s) for resolved class, %s, have" " different Class objects for the type %s used in the signature"; - char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature); + char* sig = Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature); const char* loader1 = SystemDictionary::loader_name(loader()); - char* current = instanceKlass::cast(current_klass())->name()->as_C_string(); + char* current = InstanceKlass::cast(current_klass())->name()->as_C_string(); const char* loader2 = SystemDictionary::loader_name(class_loader()); - char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string(); + char* resolved = InstanceKlass::cast(resolved_klass())->name()->as_C_string(); size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + strlen(current) + strlen(loader2) + strlen(resolved) + strlen(failed_type_name); @@ -512,7 +512,7 @@ // no method found ResourceMark rm(THREAD); THROW_MSG(vmSymbols::java_lang_NoSuchMethodError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), + Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), method_name, method_signature)); } @@ -520,8 +520,8 @@ if (check_access) { HandleMark hm(THREAD); - Handle loader (THREAD, instanceKlass::cast(current_klass())->class_loader()); - Handle class_loader (THREAD, instanceKlass::cast(resolved_method->method_holder())->class_loader()); + Handle loader (THREAD, InstanceKlass::cast(current_klass())->class_loader()); + Handle class_loader (THREAD, InstanceKlass::cast(resolved_method->method_holder())->class_loader()); { ResourceMark rm(THREAD); char* failed_type_name = @@ -533,11 +533,11 @@ "current class, %s, and the class loader (instance of %s) for " "resolved class, %s, have different Class objects for the type %s " "used in the signature"; - char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature); + char* sig = Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature); const char* loader1 = SystemDictionary::loader_name(loader()); - char* current = instanceKlass::cast(current_klass())->name()->as_C_string(); + char* current = InstanceKlass::cast(current_klass())->name()->as_C_string(); const char* loader2 = SystemDictionary::loader_name(class_loader()); - char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string(); + char* resolved = InstanceKlass::cast(resolved_klass())->name()->as_C_string(); size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + strlen(current) + strlen(loader2) + strlen(resolved) + strlen(failed_type_name); @@ -558,9 +558,9 @@ KlassHandle sel_klass, fieldDescriptor& fd, TRAPS) { - if (!Reflection::verify_field_access(ref_klass->as_klassOop(), - resolved_klass->as_klassOop(), - sel_klass->as_klassOop(), + if (!Reflection::verify_field_access(ref_klass(), + resolved_klass(), + sel_klass(), fd.access_flags(), true)) { ResourceMark rm(THREAD); @@ -605,7 +605,7 @@ // Resolve instance field fieldDescriptor fd; // find_field initializes fd if found - KlassHandle sel_klass(THREAD, instanceKlass::cast(resolved_klass())->find_field(field, sig, &fd)); + KlassHandle sel_klass(THREAD, InstanceKlass::cast(resolved_klass())->find_field(field, sig, &fd)); // check if field exists; i.e., if a klass containing the field def has been selected if (sel_klass.is_null()){ ResourceMark rm(THREAD); @@ -641,8 +641,8 @@ { HandleMark hm(THREAD); - Handle ref_loader (THREAD, instanceKlass::cast(ref_klass())->class_loader()); - Handle sel_loader (THREAD, instanceKlass::cast(sel_klass())->class_loader()); + Handle ref_loader (THREAD, InstanceKlass::cast(ref_klass())->class_loader()); + Handle sel_loader (THREAD, InstanceKlass::cast(sel_klass())->class_loader()); Symbol* signature_ref = pool->signature_ref_at(index); { ResourceMark rm(THREAD); @@ -658,7 +658,7 @@ "type, %s, have different Class objects for that type"; char* field_name = field->as_C_string(); const char* loader1 = SystemDictionary::loader_name(ref_loader()); - char* sel = instanceKlass::cast(sel_klass())->name()->as_C_string(); + char* sel = InstanceKlass::cast(sel_klass())->name()->as_C_string(); const char* loader2 = SystemDictionary::loader_name(sel_loader()); size_t buflen = strlen(msg) + strlen(field_name) + strlen(loader1) + strlen(sel) + strlen(loader2) + strlen(failed_type_name); @@ -718,7 +718,7 @@ if (!resolved_method->is_static()) { ResourceMark rm(THREAD); char buf[200]; - jio_snprintf(buf, sizeof(buf), "Expected static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), + jio_snprintf(buf, sizeof(buf), "Expected static method %s", Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), resolved_method->name(), resolved_method->signature())); THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); @@ -761,7 +761,7 @@ char buf[200]; jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", - methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), + Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), resolved_method->name(), resolved_method->signature())); THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); @@ -795,7 +795,7 @@ if (sel_method.is_null()) { ResourceMark rm(THREAD); THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), + Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), resolved_method->name(), resolved_method->signature())); } @@ -806,7 +806,7 @@ if (sel_method->is_static()) { ResourceMark rm(THREAD); char buf[200]; - jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), + jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), resolved_method->name(), resolved_method->signature())); THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); @@ -816,7 +816,7 @@ if (sel_method->is_abstract()) { ResourceMark rm(THREAD); THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), + Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), sel_method->name(), sel_method->signature())); } @@ -847,7 +847,7 @@ if (resolved_method->is_static()) { ResourceMark rm(THREAD); char buf[200]; - jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), + jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), resolved_method->name(), resolved_method->signature())); THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); @@ -864,7 +864,7 @@ TRAPS) { // setup default return values - int vtable_index = methodOopDesc::invalid_vtable_index; + int vtable_index = Method::invalid_vtable_index; methodHandle selected_method; assert(recv.is_null() || recv->is_oop(), "receiver is not an oop"); @@ -874,23 +874,23 @@ THROW(vmSymbols::java_lang_NullPointerException()); } - // Virtual methods cannot be resolved before its klass has been linked, for otherwise the methodOop's + // Virtual methods cannot be resolved before its klass has been linked, for otherwise the Method*'s // has not been rewritten, and the vtable initialized. - assert(instanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked"); + assert(InstanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked"); - // Virtual methods cannot be resolved before its klass has been linked, for otherwise the methodOop's + // Virtual methods cannot be resolved before its klass has been linked, for otherwise the Method*'s // has not been rewritten, and the vtable initialized. Make sure to do this after the nullcheck, since // a missing receiver might result in a bogus lookup. - assert(instanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked"); + assert(InstanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked"); // do lookup based on receiver klass using the vtable index - if (resolved_method->method_holder()->klass_part()->is_interface()) { // miranda method + if (resolved_method->method_holder()->is_interface()) { // miranda method vtable_index = vtable_index_of_miranda_method(resolved_klass, resolved_method->name(), resolved_method->signature(), CHECK); assert(vtable_index >= 0 , "we should have valid vtable index at this point"); - instanceKlass* inst = instanceKlass::cast(recv_klass()); + InstanceKlass* inst = InstanceKlass::cast(recv_klass()); selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index)); } else { // at this point we are sure that resolved_method is virtual and not @@ -901,13 +901,13 @@ // unless they override an existing method. // If we do get a negative, it means the resolved method is the the selected // method, and it can never be changed by an override. - if (vtable_index == methodOopDesc::nonvirtual_vtable_index) { + if (vtable_index == Method::nonvirtual_vtable_index) { assert(resolved_method->can_be_statically_bound(), "cannot override this method"); selected_method = resolved_method; } else { // recv_klass might be an arrayKlassOop but all vtables start at // the same place. The cast is to avoid virtual call and assertion. - instanceKlass* inst = (instanceKlass*)recv_klass()->klass_part(); + InstanceKlass* inst = (InstanceKlass*)recv_klass(); selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index)); } } @@ -916,7 +916,7 @@ if (selected_method.is_null()) { ResourceMark rm(THREAD); THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), + Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), resolved_method->name(), resolved_method->signature())); } @@ -925,7 +925,7 @@ if (check_null_and_abstract && selected_method->is_abstract()) { ResourceMark rm(THREAD); THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), + Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), selected_method->name(), selected_method->signature())); } @@ -978,7 +978,7 @@ if (sel_method.is_null()) { ResourceMark rm(THREAD); THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()), + Method::name_and_sig_as_C_string(Klass::cast(recv_klass()), resolved_method->name(), resolved_method->signature())); } @@ -986,7 +986,7 @@ if (!sel_method->is_public()) { ResourceMark rm(THREAD); THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()), + Method::name_and_sig_as_C_string(Klass::cast(recv_klass()), sel_method->name(), sel_method->signature())); } @@ -994,7 +994,7 @@ if (check_null_and_abstract && sel_method->is_abstract()) { ResourceMark rm(THREAD); THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()), + Method::name_and_sig_as_C_string(Klass::cast(recv_klass()), sel_method->name(), sel_method->signature())); } @@ -1080,7 +1080,7 @@ resolve_virtual_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); if (HAS_PENDING_EXCEPTION) { CLEAR_PENDING_EXCEPTION; - return methodOopDesc::invalid_vtable_index; + return Method::invalid_vtable_index; } return info.vtable_index(); } @@ -1170,7 +1170,7 @@ Symbol* method_signature = NULL; KlassHandle current_klass; resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); - KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass()); + KlassHandle recvrKlass (THREAD, recv.is_null() ? (Klass*)NULL : recv->klass()); resolve_virtual_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); } @@ -1181,7 +1181,7 @@ Symbol* method_signature = NULL; KlassHandle current_klass; resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); - KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass()); + KlassHandle recvrKlass (THREAD, recv.is_null() ? (Klass*)NULL : recv->klass()); resolve_interface_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); } @@ -1227,24 +1227,24 @@ // Resolve the bootstrap specifier (BSM + optional arguments). Handle bootstrap_specifier; // Check if CallSite has been bound already: - ConstantPoolCacheEntry* cpce = pool->cache()->secondary_entry_at(index); + ConstantPoolCacheEntry* cpce = pool->invokedynamic_cp_cache_entry_at(index); if (cpce->is_f1_null()) { - int pool_index = pool->cache()->main_entry_at(index)->constant_pool_index(); + int pool_index = cpce->constant_pool_index(); oop bsm_info = pool->resolve_bootstrap_specifier_at(pool_index, CHECK); assert(bsm_info != NULL, ""); // FIXME: Cache this once per BootstrapMethods entry, not once per CONSTANT_InvokeDynamic. bootstrap_specifier = Handle(THREAD, bsm_info); } if (!cpce->is_f1_null()) { - methodHandle method(THREAD, cpce->f2_as_vfinal_method()); - Handle appendix(THREAD, cpce->has_appendix() ? cpce->f1_appendix() : (oop)NULL); + methodHandle method(THREAD, cpce->f1_as_method()); + Handle appendix(THREAD, cpce->appendix_if_resolved(pool)); result.set_handle(method, appendix, CHECK); return; } if (TraceMethodHandles) { tty->print_cr("resolve_invokedynamic #%d %s %s", - constantPoolCacheOopDesc::decode_secondary_index(index), + ConstantPool::decode_invokedynamic_index(index), method_name->as_C_string(), method_signature->as_C_string()); tty->print(" BSM info: "); bootstrap_specifier->print(); } @@ -1265,7 +1265,7 @@ bootstrap_specifier, method_name, method_signature, &resolved_appendix, - THREAD); + CHECK); if (HAS_PENDING_EXCEPTION) { if (TraceMethodHandles) { tty->print_cr("invokedynamic throws BSME for "INTPTR_FORMAT, PENDING_EXCEPTION); @@ -1282,7 +1282,8 @@ // See the "Linking Exceptions" section for the invokedynamic instruction in the JVMS. Handle nested_exception(THREAD, PENDING_EXCEPTION); CLEAR_PENDING_EXCEPTION; - THROW_CAUSE(vmSymbols::java_lang_BootstrapMethodError(), nested_exception) + THROW_MSG_CAUSE(vmSymbols::java_lang_BootstrapMethodError(), + "BootstrapMethodError", nested_exception) } result.set_handle(resolved_method, resolved_appendix, CHECK); }