1 /* 2 * Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "classfile/symbolTable.hpp" 27 #include "compiler/compileBroker.hpp" 28 #include "interpreter/interpreter.hpp" 29 #include "interpreter/oopMapCache.hpp" 30 #include "memory/allocation.inline.hpp" 31 #include "memory/oopFactory.hpp" 32 #include "prims/jvmtiRedefineClassesTrace.hpp" 33 #include "prims/methodHandles.hpp" 34 #include "runtime/compilationPolicy.hpp" 35 #include "runtime/javaCalls.hpp" 36 #include "runtime/reflection.hpp" 37 #include "runtime/signature.hpp" 38 #include "runtime/stubRoutines.hpp" 39 40 41 /* 42 * JSR 292 reference implementation: method handles 43 * The JDK 7 reference implementation represented method handle 44 * combinations as chains. Each link in the chain had a "vmentry" 45 * field which pointed at a bit of assembly code which performed 46 * one transformation before dispatching to the next link in the chain. 47 * 48 * The current reference implementation pushes almost all code generation 49 * responsibility to (trusted) Java code. A method handle contains a 50 * pointer to its "LambdaForm", which embodies all details of the method 51 * handle's behavior. The LambdaForm is a normal Java object, managed 52 * by a runtime coded in Java. 53 */ 54 55 bool MethodHandles::_enabled = false; // set true after successful native linkage 56 MethodHandlesAdapterBlob* MethodHandles::_adapter_code = NULL; 57 58 //------------------------------------------------------------------------------ 59 // MethodHandles::generate_adapters 60 // 61 void MethodHandles::generate_adapters() { 62 if (!EnableInvokeDynamic || SystemDictionary::MethodHandle_klass() == NULL) return; 63 64 assert(_adapter_code == NULL, "generate only once"); 65 66 ResourceMark rm; 67 TraceTime timer("MethodHandles adapters generation", TraceStartupTime); 68 _adapter_code = MethodHandlesAdapterBlob::create(adapter_code_size); 69 if (_adapter_code == NULL) 70 vm_exit_out_of_memory(adapter_code_size, OOM_MALLOC_ERROR, 71 "CodeCache: no room for MethodHandles adapters"); 72 { 73 CodeBuffer code(_adapter_code); 74 MethodHandlesAdapterGenerator g(&code); 75 g.generate(); 76 code.log_section_sizes("MethodHandlesAdapterBlob"); 77 } 78 } 79 80 //------------------------------------------------------------------------------ 81 // MethodHandlesAdapterGenerator::generate 82 // 83 void MethodHandlesAdapterGenerator::generate() { 84 // Generate generic method handle adapters. 85 // Generate interpreter entries 86 for (Interpreter::MethodKind mk = Interpreter::method_handle_invoke_FIRST; 87 mk <= Interpreter::method_handle_invoke_LAST; 88 mk = Interpreter::MethodKind(1 + (int)mk)) { 89 vmIntrinsics::ID iid = Interpreter::method_handle_intrinsic(mk); 90 StubCodeMark mark(this, "MethodHandle::interpreter_entry", vmIntrinsics::name_at(iid)); 91 address entry = MethodHandles::generate_method_handle_interpreter_entry(_masm, iid); 92 if (entry != NULL) { 93 Interpreter::set_entry_for_kind(mk, entry); 94 } 95 // If the entry is not set, it will throw AbstractMethodError. 96 } 97 } 98 99 void MethodHandles::set_enabled(bool z) { 100 if (_enabled != z) { 101 guarantee(z && EnableInvokeDynamic, "can only enable once, and only if -XX:+EnableInvokeDynamic"); 102 _enabled = z; 103 } 104 } 105 106 // MemberName support 107 108 // import java_lang_invoke_MemberName.* 109 enum { 110 IS_METHOD = java_lang_invoke_MemberName::MN_IS_METHOD, 111 IS_CONSTRUCTOR = java_lang_invoke_MemberName::MN_IS_CONSTRUCTOR, 112 IS_FIELD = java_lang_invoke_MemberName::MN_IS_FIELD, 113 IS_TYPE = java_lang_invoke_MemberName::MN_IS_TYPE, 114 CALLER_SENSITIVE = java_lang_invoke_MemberName::MN_CALLER_SENSITIVE, 115 REFERENCE_KIND_SHIFT = java_lang_invoke_MemberName::MN_REFERENCE_KIND_SHIFT, 116 REFERENCE_KIND_MASK = java_lang_invoke_MemberName::MN_REFERENCE_KIND_MASK, 117 SEARCH_SUPERCLASSES = java_lang_invoke_MemberName::MN_SEARCH_SUPERCLASSES, 118 SEARCH_INTERFACES = java_lang_invoke_MemberName::MN_SEARCH_INTERFACES, 119 ALL_KINDS = IS_METHOD | IS_CONSTRUCTOR | IS_FIELD | IS_TYPE 120 }; 121 122 Handle MethodHandles::new_MemberName(TRAPS) { 123 Handle empty; 124 instanceKlassHandle k(THREAD, SystemDictionary::MemberName_klass()); 125 if (!k->is_initialized()) k->initialize(CHECK_(empty)); 126 return Handle(THREAD, k->allocate_instance(THREAD)); 127 } 128 129 oop MethodHandles::init_MemberName(Handle mname, Handle target) { 130 // This method is used from java.lang.invoke.MemberName constructors. 131 // It fills in the new MemberName from a java.lang.reflect.Member. 132 Thread* thread = Thread::current(); 133 oop target_oop = target(); 134 Klass* target_klass = target_oop->klass(); 135 if (target_klass == SystemDictionary::reflect_Field_klass()) { 136 oop clazz = java_lang_reflect_Field::clazz(target_oop); // fd.field_holder() 137 int slot = java_lang_reflect_Field::slot(target_oop); // fd.index() 138 KlassHandle k(thread, java_lang_Class::as_Klass(clazz)); 139 if (!k.is_null() && k->oop_is_instance()) { 140 fieldDescriptor fd(InstanceKlass::cast(k()), slot); 141 oop mname2 = init_field_MemberName(mname, fd); 142 if (mname2 != NULL) { 143 // Since we have the reified name and type handy, add them to the result. 144 if (java_lang_invoke_MemberName::name(mname2) == NULL) 145 java_lang_invoke_MemberName::set_name(mname2, java_lang_reflect_Field::name(target_oop)); 146 if (java_lang_invoke_MemberName::type(mname2) == NULL) 147 java_lang_invoke_MemberName::set_type(mname2, java_lang_reflect_Field::type(target_oop)); 148 } 149 return mname2; 150 } 151 } else if (target_klass == SystemDictionary::reflect_Method_klass()) { 152 oop clazz = java_lang_reflect_Method::clazz(target_oop); 153 int slot = java_lang_reflect_Method::slot(target_oop); 154 KlassHandle k(thread, java_lang_Class::as_Klass(clazz)); 155 if (!k.is_null() && k->oop_is_instance()) { 156 Method* m = InstanceKlass::cast(k())->method_with_idnum(slot); 157 if (m == NULL || is_signature_polymorphic(m->intrinsic_id())) 158 return NULL; // do not resolve unless there is a concrete signature 159 CallInfo info(m, k()); 160 return init_method_MemberName(mname, info); 161 } 162 } else if (target_klass == SystemDictionary::reflect_Constructor_klass()) { 163 oop clazz = java_lang_reflect_Constructor::clazz(target_oop); 164 int slot = java_lang_reflect_Constructor::slot(target_oop); 165 KlassHandle k(thread, java_lang_Class::as_Klass(clazz)); 166 if (!k.is_null() && k->oop_is_instance()) { 167 Method* m = InstanceKlass::cast(k())->method_with_idnum(slot); 168 if (m == NULL) return NULL; 169 CallInfo info(m, k()); 170 return init_method_MemberName(mname, info); 171 } 172 } 173 return NULL; 174 } 175 176 oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) { 177 assert(info.resolved_appendix().is_null(), "only normal methods here"); 178 KlassHandle receiver_limit = info.resolved_klass(); 179 methodHandle m = info.resolved_method(); 180 int flags = (jushort)( m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS ); 181 int vmindex = Method::invalid_vtable_index; 182 183 switch (info.call_kind()) { 184 case CallInfo::itable_call: 185 vmindex = info.itable_index(); 186 // More importantly, the itable index only works with the method holder. 187 receiver_limit = m->method_holder(); 188 assert(receiver_limit->verify_itable_index(vmindex), ""); 189 flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT); 190 break; 191 192 case CallInfo::vtable_call: 193 vmindex = info.vtable_index(); 194 flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT); 195 assert(receiver_limit->is_subtype_of(m->method_holder()), "virtual call must be type-safe"); 196 break; 197 198 case CallInfo::direct_call: 199 vmindex = Method::nonvirtual_vtable_index; 200 if (m->is_static()) { 201 flags |= IS_METHOD | (JVM_REF_invokeStatic << REFERENCE_KIND_SHIFT); 202 } else if (m->is_initializer()) { 203 flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT); 204 assert(receiver_limit == m->method_holder(), "constructor call must be exactly typed"); 205 } else { 206 flags |= IS_METHOD | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT); 207 assert(receiver_limit->is_subtype_of(m->method_holder()), "special call must be type-safe"); 208 } 209 break; 210 211 default: assert(false, "bad CallInfo"); return NULL; 212 } 213 214 // @CallerSensitive annotation detected 215 if (m->caller_sensitive()) { 216 flags |= CALLER_SENSITIVE; 217 } 218 219 oop mname_oop = mname(); 220 java_lang_invoke_MemberName::set_flags( mname_oop, flags); 221 java_lang_invoke_MemberName::set_vmtarget(mname_oop, m()); 222 java_lang_invoke_MemberName::set_vmindex( mname_oop, vmindex); // vtable/itable index 223 java_lang_invoke_MemberName::set_clazz( mname_oop, receiver_limit->java_mirror()); 224 // Note: name and type can be lazily computed by resolve_MemberName, 225 // if Java code needs them as resolved String and MethodType objects. 226 // The clazz must be eagerly stored, because it provides a GC 227 // root to help keep alive the Method*. 228 // If relevant, the vtable or itable value is stored as vmindex. 229 // This is done eagerly, since it is readily available without 230 // constructing any new objects. 231 // TO DO: maybe intern mname_oop 232 m->method_holder()->add_member_name(m->method_idnum(), mname); 233 234 return mname(); 235 } 236 237 oop MethodHandles::init_field_MemberName(Handle mname, fieldDescriptor& fd, bool is_setter) { 238 int flags = (jushort)( fd.access_flags().as_short() & JVM_RECOGNIZED_FIELD_MODIFIERS ); 239 flags |= IS_FIELD | ((fd.is_static() ? JVM_REF_getStatic : JVM_REF_getField) << REFERENCE_KIND_SHIFT); 240 if (is_setter) flags += ((JVM_REF_putField - JVM_REF_getField) << REFERENCE_KIND_SHIFT); 241 Metadata* vmtarget = fd.field_holder(); 242 int vmindex = fd.offset(); // determines the field uniquely when combined with static bit 243 oop mname_oop = mname(); 244 java_lang_invoke_MemberName::set_flags(mname_oop, flags); 245 java_lang_invoke_MemberName::set_vmtarget(mname_oop, vmtarget); 246 java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex); 247 java_lang_invoke_MemberName::set_clazz(mname_oop, fd.field_holder()->java_mirror()); 248 oop type = field_signature_type_or_null(fd.signature()); 249 oop name = field_name_or_null(fd.name()); 250 if (name != NULL) 251 java_lang_invoke_MemberName::set_name(mname_oop, name); 252 if (type != NULL) 253 java_lang_invoke_MemberName::set_type(mname_oop, type); 254 // Note: name and type can be lazily computed by resolve_MemberName, 255 // if Java code needs them as resolved String and Class objects. 256 // Note that the incoming type oop might be pre-resolved (non-null). 257 // The base clazz and field offset (vmindex) must be eagerly stored, 258 // because they unambiguously identify the field. 259 // Although the fieldDescriptor::_index would also identify the field, 260 // we do not use it, because it is harder to decode. 261 // TO DO: maybe intern mname_oop 262 return mname(); 263 } 264 265 // JVM 2.9 Special Methods: 266 // A method is signature polymorphic if and only if all of the following conditions hold : 267 // * It is declared in the java.lang.invoke.MethodHandle class. 268 // * It has a single formal parameter of type Object[]. 269 // * It has a return type of Object. 270 // * It has the ACC_VARARGS and ACC_NATIVE flags set. 271 bool MethodHandles::is_method_handle_invoke_name(Klass* klass, Symbol* name) { 272 if (klass == NULL) 273 return false; 274 // The following test will fail spuriously during bootstrap of MethodHandle itself: 275 // if (klass != SystemDictionary::MethodHandle_klass()) 276 // Test the name instead: 277 if (klass->name() != vmSymbols::java_lang_invoke_MethodHandle()) 278 return false; 279 Symbol* poly_sig = vmSymbols::object_array_object_signature(); 280 Method* m = InstanceKlass::cast(klass)->find_method(name, poly_sig); 281 if (m == NULL) return false; 282 int required = JVM_ACC_NATIVE | JVM_ACC_VARARGS; 283 int flags = m->access_flags().as_int(); 284 return (flags & required) == required; 285 } 286 287 288 Symbol* MethodHandles::signature_polymorphic_intrinsic_name(vmIntrinsics::ID iid) { 289 assert(is_signature_polymorphic_intrinsic(iid), err_msg("iid=%d", iid)); 290 switch (iid) { 291 case vmIntrinsics::_invokeBasic: return vmSymbols::invokeBasic_name(); 292 case vmIntrinsics::_linkToVirtual: return vmSymbols::linkToVirtual_name(); 293 case vmIntrinsics::_linkToStatic: return vmSymbols::linkToStatic_name(); 294 case vmIntrinsics::_linkToSpecial: return vmSymbols::linkToSpecial_name(); 295 case vmIntrinsics::_linkToInterface: return vmSymbols::linkToInterface_name(); 296 } 297 assert(false, ""); 298 return 0; 299 } 300 301 int MethodHandles::signature_polymorphic_intrinsic_ref_kind(vmIntrinsics::ID iid) { 302 switch (iid) { 303 case vmIntrinsics::_invokeBasic: return 0; 304 case vmIntrinsics::_linkToVirtual: return JVM_REF_invokeVirtual; 305 case vmIntrinsics::_linkToStatic: return JVM_REF_invokeStatic; 306 case vmIntrinsics::_linkToSpecial: return JVM_REF_invokeSpecial; 307 case vmIntrinsics::_linkToInterface: return JVM_REF_invokeInterface; 308 } 309 assert(false, err_msg("iid=%d", iid)); 310 return 0; 311 } 312 313 vmIntrinsics::ID MethodHandles::signature_polymorphic_name_id(Symbol* name) { 314 vmSymbols::SID name_id = vmSymbols::find_sid(name); 315 switch (name_id) { 316 // The ID _invokeGeneric stands for all non-static signature-polymorphic methods, except built-ins. 317 case vmSymbols::VM_SYMBOL_ENUM_NAME(invoke_name): return vmIntrinsics::_invokeGeneric; 318 // The only built-in non-static signature-polymorphic method is MethodHandle.invokeBasic: 319 case vmSymbols::VM_SYMBOL_ENUM_NAME(invokeBasic_name): return vmIntrinsics::_invokeBasic; 320 321 // There is one static signature-polymorphic method for each JVM invocation mode. 322 case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToVirtual_name): return vmIntrinsics::_linkToVirtual; 323 case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToStatic_name): return vmIntrinsics::_linkToStatic; 324 case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToSpecial_name): return vmIntrinsics::_linkToSpecial; 325 case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToInterface_name): return vmIntrinsics::_linkToInterface; 326 } 327 328 // Cover the case of invokeExact and any future variants of invokeFoo. 329 Klass* mh_klass = SystemDictionary::well_known_klass( 330 SystemDictionary::WK_KLASS_ENUM_NAME(MethodHandle_klass) ); 331 if (mh_klass != NULL && is_method_handle_invoke_name(mh_klass, name)) 332 return vmIntrinsics::_invokeGeneric; 333 334 // Note: The pseudo-intrinsic _compiledLambdaForm is never linked against. 335 // Instead it is used to mark lambda forms bound to invokehandle or invokedynamic. 336 return vmIntrinsics::_none; 337 } 338 339 vmIntrinsics::ID MethodHandles::signature_polymorphic_name_id(Klass* klass, Symbol* name) { 340 if (klass != NULL && 341 klass->name() == vmSymbols::java_lang_invoke_MethodHandle()) { 342 vmIntrinsics::ID iid = signature_polymorphic_name_id(name); 343 if (iid != vmIntrinsics::_none) 344 return iid; 345 if (is_method_handle_invoke_name(klass, name)) 346 return vmIntrinsics::_invokeGeneric; 347 } 348 return vmIntrinsics::_none; 349 } 350 351 352 // convert the external string or reflective type to an internal signature 353 Symbol* MethodHandles::lookup_signature(oop type_str, bool intern_if_not_found, TRAPS) { 354 if (java_lang_invoke_MethodType::is_instance(type_str)) { 355 return java_lang_invoke_MethodType::as_signature(type_str, intern_if_not_found, CHECK_NULL); 356 } else if (java_lang_Class::is_instance(type_str)) { 357 return java_lang_Class::as_signature(type_str, false, CHECK_NULL); 358 } else if (java_lang_String::is_instance(type_str)) { 359 if (intern_if_not_found) { 360 return java_lang_String::as_symbol(type_str, CHECK_NULL); 361 } else { 362 return java_lang_String::as_symbol_or_null(type_str); 363 } 364 } else { 365 THROW_MSG_(vmSymbols::java_lang_InternalError(), "unrecognized type", NULL); 366 } 367 } 368 369 static const char OBJ_SIG[] = "Ljava/lang/Object;"; 370 enum { OBJ_SIG_LEN = 18 }; 371 372 bool MethodHandles::is_basic_type_signature(Symbol* sig) { 373 assert(vmSymbols::object_signature()->utf8_length() == (int)OBJ_SIG_LEN, ""); 374 assert(vmSymbols::object_signature()->equals(OBJ_SIG), ""); 375 const int len = sig->utf8_length(); 376 for (int i = 0; i < len; i++) { 377 switch (sig->byte_at(i)) { 378 case 'L': 379 // only java/lang/Object is valid here 380 if (sig->index_of_at(i, OBJ_SIG, OBJ_SIG_LEN) != i) 381 return false; 382 i += OBJ_SIG_LEN-1; //-1 because of i++ in loop 383 continue; 384 case '(': case ')': case 'V': 385 case 'I': case 'J': case 'F': case 'D': 386 continue; 387 //case '[': 388 //case 'Z': case 'B': case 'C': case 'S': 389 default: 390 return false; 391 } 392 } 393 return true; 394 } 395 396 Symbol* MethodHandles::lookup_basic_type_signature(Symbol* sig, bool keep_last_arg, TRAPS) { 397 Symbol* bsig = NULL; 398 if (sig == NULL) { 399 return sig; 400 } else if (is_basic_type_signature(sig)) { 401 sig->increment_refcount(); 402 return sig; // that was easy 403 } else if (sig->byte_at(0) != '(') { 404 BasicType bt = char2type(sig->byte_at(0)); 405 if (is_subword_type(bt)) { 406 bsig = vmSymbols::int_signature(); 407 } else { 408 assert(bt == T_OBJECT || bt == T_ARRAY, "is_basic_type_signature was false"); 409 bsig = vmSymbols::object_signature(); 410 } 411 } else { 412 ResourceMark rm; 413 stringStream buffer(128); 414 buffer.put('('); 415 int arg_pos = 0, keep_arg_pos = -1; 416 if (keep_last_arg) 417 keep_arg_pos = ArgumentCount(sig).size() - 1; 418 for (SignatureStream ss(sig); !ss.is_done(); ss.next()) { 419 BasicType bt = ss.type(); 420 size_t this_arg_pos = buffer.size(); 421 if (ss.at_return_type()) { 422 buffer.put(')'); 423 } 424 if (arg_pos == keep_arg_pos) { 425 buffer.write((char*) ss.raw_bytes(), 426 (int) ss.raw_length()); 427 } else if (bt == T_OBJECT || bt == T_ARRAY) { 428 buffer.write(OBJ_SIG, OBJ_SIG_LEN); 429 } else { 430 if (is_subword_type(bt)) 431 bt = T_INT; 432 buffer.put(type2char(bt)); 433 } 434 arg_pos++; 435 } 436 const char* sigstr = buffer.base(); 437 int siglen = (int) buffer.size(); 438 bsig = SymbolTable::new_symbol(sigstr, siglen, THREAD); 439 } 440 assert(is_basic_type_signature(bsig) || 441 // detune assert in case the injected argument is not a basic type: 442 keep_last_arg, ""); 443 return bsig; 444 } 445 446 void MethodHandles::print_as_basic_type_signature_on(outputStream* st, 447 Symbol* sig, 448 bool keep_arrays, 449 bool keep_basic_names) { 450 st = st ? st : tty; 451 int len = sig->utf8_length(); 452 int array = 0; 453 bool prev_type = false; 454 for (int i = 0; i < len; i++) { 455 char ch = sig->byte_at(i); 456 switch (ch) { 457 case '(': case ')': 458 prev_type = false; 459 st->put(ch); 460 continue; 461 case '[': 462 if (!keep_basic_names && keep_arrays) 463 st->put(ch); 464 array++; 465 continue; 466 case 'L': 467 { 468 if (prev_type) st->put(','); 469 int start = i+1, slash = start; 470 while (++i < len && (ch = sig->byte_at(i)) != ';') { 471 if (ch == '/' || ch == '.' || ch == '$') slash = i+1; 472 } 473 if (slash < i) start = slash; 474 if (!keep_basic_names) { 475 st->put('L'); 476 } else { 477 for (int j = start; j < i; j++) 478 st->put(sig->byte_at(j)); 479 prev_type = true; 480 } 481 break; 482 } 483 default: 484 { 485 if (array && char2type(ch) != T_ILLEGAL && !keep_arrays) { 486 ch = '['; 487 array = 0; 488 } 489 if (prev_type) st->put(','); 490 const char* n = NULL; 491 if (keep_basic_names) 492 n = type2name(char2type(ch)); 493 if (n == NULL) { 494 // unknown letter, or we don't want to know its name 495 st->put(ch); 496 } else { 497 st->print(n); 498 prev_type = true; 499 } 500 break; 501 } 502 } 503 // Switch break goes here to take care of array suffix: 504 if (prev_type) { 505 while (array > 0) { 506 st->print("[]"); 507 --array; 508 } 509 } 510 array = 0; 511 } 512 } 513 514 515 516 static oop object_java_mirror() { 517 return SystemDictionary::Object_klass()->java_mirror(); 518 } 519 520 oop MethodHandles::field_name_or_null(Symbol* s) { 521 if (s == NULL) return NULL; 522 return StringTable::lookup(s); 523 } 524 525 oop MethodHandles::field_signature_type_or_null(Symbol* s) { 526 if (s == NULL) return NULL; 527 BasicType bt = FieldType::basic_type(s); 528 if (is_java_primitive(bt)) { 529 assert(s->utf8_length() == 1, ""); 530 return java_lang_Class::primitive_mirror(bt); 531 } 532 // Here are some more short cuts for common types. 533 // They are optional, since reference types can be resolved lazily. 534 if (bt == T_OBJECT) { 535 if (s == vmSymbols::object_signature()) { 536 return object_java_mirror(); 537 } else if (s == vmSymbols::class_signature()) { 538 return SystemDictionary::Class_klass()->java_mirror(); 539 } else if (s == vmSymbols::string_signature()) { 540 return SystemDictionary::String_klass()->java_mirror(); 541 } 542 } 543 return NULL; 544 } 545 546 547 // An unresolved member name is a mere symbolic reference. 548 // Resolving it plants a vmtarget/vmindex in it, 549 // which refers directly to JVM internals. 550 Handle MethodHandles::resolve_MemberName(Handle mname, TRAPS) { 551 Handle empty; 552 assert(java_lang_invoke_MemberName::is_instance(mname()), ""); 553 554 if (java_lang_invoke_MemberName::vmtarget(mname()) != NULL) { 555 // Already resolved. 556 DEBUG_ONLY(int vmindex = java_lang_invoke_MemberName::vmindex(mname())); 557 assert(vmindex >= Method::nonvirtual_vtable_index, ""); 558 return mname; 559 } 560 561 Handle defc_oop(THREAD, java_lang_invoke_MemberName::clazz(mname())); 562 Handle name_str(THREAD, java_lang_invoke_MemberName::name( mname())); 563 Handle type_str(THREAD, java_lang_invoke_MemberName::type( mname())); 564 int flags = java_lang_invoke_MemberName::flags(mname()); 565 int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK; 566 if (!ref_kind_is_valid(ref_kind)) { 567 THROW_MSG_(vmSymbols::java_lang_InternalError(), "obsolete MemberName format", empty); 568 } 569 570 DEBUG_ONLY(int old_vmindex); 571 assert((old_vmindex = java_lang_invoke_MemberName::vmindex(mname())) == 0, "clean input"); 572 573 if (defc_oop.is_null() || name_str.is_null() || type_str.is_null()) { 574 THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "nothing to resolve", empty); 575 } 576 577 instanceKlassHandle defc; 578 { 579 Klass* defc_klass = java_lang_Class::as_Klass(defc_oop()); 580 if (defc_klass == NULL) return empty; // a primitive; no resolution possible 581 if (!defc_klass->oop_is_instance()) { 582 if (!defc_klass->oop_is_array()) return empty; 583 defc_klass = SystemDictionary::Object_klass(); 584 } 585 defc = instanceKlassHandle(THREAD, defc_klass); 586 } 587 if (defc.is_null()) { 588 THROW_MSG_(vmSymbols::java_lang_InternalError(), "primitive class", empty); 589 } 590 defc->link_class(CHECK_(empty)); // possible safepoint 591 592 // convert the external string name to an internal symbol 593 TempNewSymbol name = java_lang_String::as_symbol_or_null(name_str()); 594 if (name == NULL) return empty; // no such name 595 if (name == vmSymbols::class_initializer_name()) 596 return empty; // illegal name 597 598 vmIntrinsics::ID mh_invoke_id = vmIntrinsics::_none; 599 if ((flags & ALL_KINDS) == IS_METHOD && 600 (defc() == SystemDictionary::MethodHandle_klass()) && 601 (ref_kind == JVM_REF_invokeVirtual || 602 ref_kind == JVM_REF_invokeSpecial || 603 // static invocation mode is required for _linkToVirtual, etc.: 604 ref_kind == JVM_REF_invokeStatic)) { 605 vmIntrinsics::ID iid = signature_polymorphic_name_id(name); 606 if (iid != vmIntrinsics::_none && 607 ((ref_kind == JVM_REF_invokeStatic) == is_signature_polymorphic_static(iid))) { 608 // Virtual methods invoke and invokeExact, plus internal invokers like _invokeBasic. 609 // For a static reference it could an internal linkage routine like _linkToVirtual, etc. 610 mh_invoke_id = iid; 611 } 612 } 613 614 // convert the external string or reflective type to an internal signature 615 TempNewSymbol type = lookup_signature(type_str(), (mh_invoke_id != vmIntrinsics::_none), CHECK_(empty)); 616 if (type == NULL) return empty; // no such signature exists in the VM 617 618 // Time to do the lookup. 619 switch (flags & ALL_KINDS) { 620 case IS_METHOD: 621 { 622 CallInfo result; 623 { 624 assert(!HAS_PENDING_EXCEPTION, ""); 625 if (ref_kind == JVM_REF_invokeStatic) { 626 LinkResolver::resolve_static_call(result, 627 defc, name, type, KlassHandle(), false, false, THREAD); 628 } else if (ref_kind == JVM_REF_invokeInterface) { 629 LinkResolver::resolve_interface_call(result, Handle(), defc, 630 defc, name, type, KlassHandle(), false, false, THREAD); 631 } else if (mh_invoke_id != vmIntrinsics::_none) { 632 assert(!is_signature_polymorphic_static(mh_invoke_id), ""); 633 LinkResolver::resolve_handle_call(result, 634 defc, name, type, KlassHandle(), THREAD); 635 } else if (ref_kind == JVM_REF_invokeSpecial) { 636 LinkResolver::resolve_special_call(result, 637 defc, name, type, KlassHandle(), false, THREAD); 638 } else if (ref_kind == JVM_REF_invokeVirtual) { 639 LinkResolver::resolve_virtual_call(result, Handle(), defc, 640 defc, name, type, KlassHandle(), false, false, THREAD); 641 } else { 642 assert(false, err_msg("ref_kind=%d", ref_kind)); 643 } 644 if (HAS_PENDING_EXCEPTION) { 645 return empty; 646 } 647 } 648 if (result.resolved_appendix().not_null()) { 649 // The resolved MemberName must not be accompanied by an appendix argument, 650 // since there is no way to bind this value into the MemberName. 651 // Caller is responsible to prevent this from happening. 652 THROW_MSG_(vmSymbols::java_lang_InternalError(), "appendix", empty); 653 } 654 oop mname2 = init_method_MemberName(mname, result); 655 return Handle(THREAD, mname2); 656 } 657 case IS_CONSTRUCTOR: 658 { 659 CallInfo result; 660 { 661 assert(!HAS_PENDING_EXCEPTION, ""); 662 if (name == vmSymbols::object_initializer_name()) { 663 LinkResolver::resolve_special_call(result, 664 defc, name, type, KlassHandle(), false, THREAD); 665 } else { 666 break; // will throw after end of switch 667 } 668 if (HAS_PENDING_EXCEPTION) { 669 return empty; 670 } 671 } 672 assert(result.is_statically_bound(), ""); 673 oop mname2 = init_method_MemberName(mname, result); 674 return Handle(THREAD, mname2); 675 } 676 case IS_FIELD: 677 { 678 fieldDescriptor result; // find_field initializes fd if found 679 { 680 assert(!HAS_PENDING_EXCEPTION, ""); 681 LinkResolver::resolve_field(result, defc, name, type, KlassHandle(), Bytecodes::_nop, false, false, THREAD); 682 if (HAS_PENDING_EXCEPTION) { 683 return empty; 684 } 685 } 686 oop mname2 = init_field_MemberName(mname, result, ref_kind_is_setter(ref_kind)); 687 return Handle(THREAD, mname2); 688 } 689 default: 690 THROW_MSG_(vmSymbols::java_lang_InternalError(), "unrecognized MemberName format", empty); 691 } 692 693 return empty; 694 } 695 696 // Conversely, a member name which is only initialized from JVM internals 697 // may have null defc, name, and type fields. 698 // Resolving it plants a vmtarget/vmindex in it, 699 // which refers directly to JVM internals. 700 void MethodHandles::expand_MemberName(Handle mname, int suppress, TRAPS) { 701 assert(java_lang_invoke_MemberName::is_instance(mname()), ""); 702 Metadata* vmtarget = java_lang_invoke_MemberName::vmtarget(mname()); 703 int vmindex = java_lang_invoke_MemberName::vmindex(mname()); 704 if (vmtarget == NULL) { 705 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "nothing to expand"); 706 } 707 708 bool have_defc = (java_lang_invoke_MemberName::clazz(mname()) != NULL); 709 bool have_name = (java_lang_invoke_MemberName::name(mname()) != NULL); 710 bool have_type = (java_lang_invoke_MemberName::type(mname()) != NULL); 711 int flags = java_lang_invoke_MemberName::flags(mname()); 712 713 if (suppress != 0) { 714 if (suppress & _suppress_defc) have_defc = true; 715 if (suppress & _suppress_name) have_name = true; 716 if (suppress & _suppress_type) have_type = true; 717 } 718 719 if (have_defc && have_name && have_type) return; // nothing needed 720 721 switch (flags & ALL_KINDS) { 722 case IS_METHOD: 723 case IS_CONSTRUCTOR: 724 { 725 assert(vmtarget->is_method(), "method or constructor vmtarget is Method*"); 726 methodHandle m(THREAD, (Method*)vmtarget); 727 DEBUG_ONLY(vmtarget = NULL); // safety 728 if (m.is_null()) break; 729 if (!have_defc) { 730 InstanceKlass* defc = m->method_holder(); 731 java_lang_invoke_MemberName::set_clazz(mname(), defc->java_mirror()); 732 } 733 if (!have_name) { 734 //not java_lang_String::create_from_symbol; let's intern member names 735 Handle name = StringTable::intern(m->name(), CHECK); 736 java_lang_invoke_MemberName::set_name(mname(), name()); 737 } 738 if (!have_type) { 739 Handle type = java_lang_String::create_from_symbol(m->signature(), CHECK); 740 java_lang_invoke_MemberName::set_type(mname(), type()); 741 } 742 return; 743 } 744 case IS_FIELD: 745 { 746 assert(vmtarget->is_klass(), "field vmtarget is Klass*"); 747 if (!((Klass*) vmtarget)->oop_is_instance()) break; 748 instanceKlassHandle defc(THREAD, (Klass*) vmtarget); 749 DEBUG_ONLY(vmtarget = NULL); // safety 750 bool is_static = ((flags & JVM_ACC_STATIC) != 0); 751 fieldDescriptor fd; // find_field initializes fd if found 752 if (!defc->find_field_from_offset(vmindex, is_static, &fd)) 753 break; // cannot expand 754 if (!have_defc) { 755 java_lang_invoke_MemberName::set_clazz(mname(), defc->java_mirror()); 756 } 757 if (!have_name) { 758 //not java_lang_String::create_from_symbol; let's intern member names 759 Handle name = StringTable::intern(fd.name(), CHECK); 760 java_lang_invoke_MemberName::set_name(mname(), name()); 761 } 762 if (!have_type) { 763 // If it is a primitive field type, don't mess with short strings like "I". 764 Handle type = field_signature_type_or_null(fd.signature()); 765 if (type.is_null()) { 766 java_lang_String::create_from_symbol(fd.signature(), CHECK); 767 } 768 java_lang_invoke_MemberName::set_type(mname(), type()); 769 } 770 return; 771 } 772 } 773 THROW_MSG(vmSymbols::java_lang_InternalError(), "unrecognized MemberName format"); 774 } 775 776 int MethodHandles::find_MemberNames(KlassHandle k, 777 Symbol* name, Symbol* sig, 778 int mflags, KlassHandle caller, 779 int skip, objArrayHandle results) { 780 // %%% take caller into account! 781 782 Thread* thread = Thread::current(); 783 784 if (k.is_null() || !k->oop_is_instance()) return -1; 785 786 int rfill = 0, rlimit = results->length(), rskip = skip; 787 // overflow measurement: 788 int overflow = 0, overflow_limit = MAX2(1000, rlimit); 789 790 int match_flags = mflags; 791 bool search_superc = ((match_flags & SEARCH_SUPERCLASSES) != 0); 792 bool search_intfc = ((match_flags & SEARCH_INTERFACES) != 0); 793 bool local_only = !(search_superc | search_intfc); 794 bool classes_only = false; 795 796 if (name != NULL) { 797 if (name->utf8_length() == 0) return 0; // a match is not possible 798 } 799 if (sig != NULL) { 800 if (sig->utf8_length() == 0) return 0; // a match is not possible 801 if (sig->byte_at(0) == '(') 802 match_flags &= ~(IS_FIELD | IS_TYPE); 803 else 804 match_flags &= ~(IS_CONSTRUCTOR | IS_METHOD); 805 } 806 807 if ((match_flags & IS_TYPE) != 0) { 808 // NYI, and Core Reflection works quite well for this query 809 } 810 811 if ((match_flags & IS_FIELD) != 0) { 812 for (FieldStream st(k(), local_only, !search_intfc); !st.eos(); st.next()) { 813 if (name != NULL && st.name() != name) 814 continue; 815 if (sig != NULL && st.signature() != sig) 816 continue; 817 // passed the filters 818 if (rskip > 0) { 819 --rskip; 820 } else if (rfill < rlimit) { 821 Handle result(thread, results->obj_at(rfill++)); 822 if (!java_lang_invoke_MemberName::is_instance(result())) 823 return -99; // caller bug! 824 oop saved = MethodHandles::init_field_MemberName(result, st.field_descriptor()); 825 if (saved != result()) 826 results->obj_at_put(rfill-1, saved); // show saved instance to user 827 } else if (++overflow >= overflow_limit) { 828 match_flags = 0; break; // got tired of looking at overflow 829 } 830 } 831 } 832 833 if ((match_flags & (IS_METHOD | IS_CONSTRUCTOR)) != 0) { 834 // watch out for these guys: 835 Symbol* init_name = vmSymbols::object_initializer_name(); 836 Symbol* clinit_name = vmSymbols::class_initializer_name(); 837 if (name == clinit_name) clinit_name = NULL; // hack for exposing <clinit> 838 bool negate_name_test = false; 839 // fix name so that it captures the intention of IS_CONSTRUCTOR 840 if (!(match_flags & IS_METHOD)) { 841 // constructors only 842 if (name == NULL) { 843 name = init_name; 844 } else if (name != init_name) { 845 return 0; // no constructors of this method name 846 } 847 } else if (!(match_flags & IS_CONSTRUCTOR)) { 848 // methods only 849 if (name == NULL) { 850 name = init_name; 851 negate_name_test = true; // if we see the name, we *omit* the entry 852 } else if (name == init_name) { 853 return 0; // no methods of this constructor name 854 } 855 } else { 856 // caller will accept either sort; no need to adjust name 857 } 858 for (MethodStream st(k(), local_only, !search_intfc); !st.eos(); st.next()) { 859 Method* m = st.method(); 860 Symbol* m_name = m->name(); 861 if (m_name == clinit_name) 862 continue; 863 if (name != NULL && ((m_name != name) ^ negate_name_test)) 864 continue; 865 if (sig != NULL && m->signature() != sig) 866 continue; 867 // passed the filters 868 if (rskip > 0) { 869 --rskip; 870 } else if (rfill < rlimit) { 871 Handle result(thread, results->obj_at(rfill++)); 872 if (!java_lang_invoke_MemberName::is_instance(result())) 873 return -99; // caller bug! 874 CallInfo info(m); 875 oop saved = MethodHandles::init_method_MemberName(result, info); 876 if (saved != result()) 877 results->obj_at_put(rfill-1, saved); // show saved instance to user 878 } else if (++overflow >= overflow_limit) { 879 match_flags = 0; break; // got tired of looking at overflow 880 } 881 } 882 } 883 884 // return number of elements we at leasted wanted to initialize 885 return rfill + overflow; 886 } 887 888 //------------------------------------------------------------------------------ 889 // MemberNameTable 890 // 891 892 MemberNameTable::MemberNameTable(int methods_cnt) 893 : GrowableArray<jweak>(methods_cnt, true) { 894 assert_locked_or_safepoint(MemberNameTable_lock); 895 } 896 897 MemberNameTable::~MemberNameTable() { 898 assert_locked_or_safepoint(MemberNameTable_lock); 899 int len = this->length(); 900 901 for (int idx = 0; idx < len; idx++) { 902 jweak ref = this->at(idx); 903 JNIHandles::destroy_weak_global(ref); 904 } 905 } 906 907 void MemberNameTable::add_member_name(int index, jweak mem_name_wref) { 908 assert_locked_or_safepoint(MemberNameTable_lock); 909 this->at_put_grow(index, mem_name_wref); 910 } 911 912 // Return a member name oop or NULL. 913 oop MemberNameTable::get_member_name(int index) { 914 assert_locked_or_safepoint(MemberNameTable_lock); 915 916 jweak ref = this->at(index); 917 oop mem_name = JNIHandles::resolve(ref); 918 return mem_name; 919 } 920 921 #if INCLUDE_JVMTI 922 oop MemberNameTable::find_member_name_by_method(Method* old_method) { 923 assert_locked_or_safepoint(MemberNameTable_lock); 924 oop found = NULL; 925 int len = this->length(); 926 927 for (int idx = 0; idx < len; idx++) { 928 oop mem_name = JNIHandles::resolve(this->at(idx)); 929 if (mem_name == NULL) { 930 continue; 931 } 932 Method* method = (Method*)java_lang_invoke_MemberName::vmtarget(mem_name); 933 if (method == old_method) { 934 found = mem_name; 935 break; 936 } 937 } 938 return found; 939 } 940 941 // It is called at safepoint only 942 void MemberNameTable::adjust_method_entries(Method** old_methods, Method** new_methods, 943 int methods_length, bool *trace_name_printed) { 944 assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint"); 945 // search the MemberNameTable for uses of either obsolete or EMCP methods 946 for (int j = 0; j < methods_length; j++) { 947 Method* old_method = old_methods[j]; 948 Method* new_method = new_methods[j]; 949 oop mem_name = find_member_name_by_method(old_method); 950 if (mem_name != NULL) { 951 java_lang_invoke_MemberName::adjust_vmtarget(mem_name, new_method); 952 953 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) { 954 if (!(*trace_name_printed)) { 955 // RC_TRACE_MESG macro has an embedded ResourceMark 956 RC_TRACE_MESG(("adjust: name=%s", 957 old_method->method_holder()->external_name())); 958 *trace_name_printed = true; 959 } 960 // RC_TRACE macro has an embedded ResourceMark 961 RC_TRACE(0x00400000, ("MemberName method update: %s(%s)", 962 new_method->name()->as_C_string(), 963 new_method->signature()->as_C_string())); 964 } 965 } 966 } 967 } 968 #endif // INCLUDE_JVMTI 969 970 // 971 // Here are the native methods in java.lang.invoke.MethodHandleNatives 972 // They are the private interface between this JVM and the HotSpot-specific 973 // Java code that implements JSR 292 method handles. 974 // 975 // Note: We use a JVM_ENTRY macro to define each of these, for this is the way 976 // that intrinsic (non-JNI) native methods are defined in HotSpot. 977 // 978 979 JVM_ENTRY(jint, MHN_getConstant(JNIEnv *env, jobject igcls, jint which)) { 980 switch (which) { 981 case MethodHandles::GC_COUNT_GWT: 982 #ifdef COMPILER2 983 return true; 984 #else 985 return false; 986 #endif 987 } 988 return 0; 989 } 990 JVM_END 991 992 #ifndef PRODUCT 993 #define EACH_NAMED_CON(template, requirement) \ 994 template(MethodHandles,GC_COUNT_GWT) \ 995 template(java_lang_invoke_MemberName,MN_IS_METHOD) \ 996 template(java_lang_invoke_MemberName,MN_IS_CONSTRUCTOR) \ 997 template(java_lang_invoke_MemberName,MN_IS_FIELD) \ 998 template(java_lang_invoke_MemberName,MN_IS_TYPE) \ 999 template(java_lang_invoke_MemberName,MN_CALLER_SENSITIVE) \ 1000 template(java_lang_invoke_MemberName,MN_SEARCH_SUPERCLASSES) \ 1001 template(java_lang_invoke_MemberName,MN_SEARCH_INTERFACES) \ 1002 template(java_lang_invoke_MemberName,MN_REFERENCE_KIND_SHIFT) \ 1003 template(java_lang_invoke_MemberName,MN_REFERENCE_KIND_MASK) \ 1004 template(MethodHandles,GC_LAMBDA_SUPPORT) \ 1005 /*end*/ 1006 1007 #define IGNORE_REQ(req_expr) /* req_expr */ 1008 #define ONE_PLUS(scope,value) 1+ 1009 static const int con_value_count = EACH_NAMED_CON(ONE_PLUS, IGNORE_REQ) 0; 1010 #define VALUE_COMMA(scope,value) scope::value, 1011 static const int con_values[con_value_count+1] = { EACH_NAMED_CON(VALUE_COMMA, IGNORE_REQ) 0 }; 1012 #define STRING_NULL(scope,value) #value "\0" 1013 static const char con_names[] = { EACH_NAMED_CON(STRING_NULL, IGNORE_REQ) }; 1014 1015 static bool advertise_con_value(int which) { 1016 if (which < 0) return false; 1017 bool ok = true; 1018 int count = 0; 1019 #define INC_COUNT(scope,value) \ 1020 ++count; 1021 #define CHECK_REQ(req_expr) \ 1022 if (which < count) return ok; \ 1023 ok = (req_expr); 1024 EACH_NAMED_CON(INC_COUNT, CHECK_REQ); 1025 #undef INC_COUNT 1026 #undef CHECK_REQ 1027 assert(count == con_value_count, ""); 1028 if (which < count) return ok; 1029 return false; 1030 } 1031 1032 #undef ONE_PLUS 1033 #undef VALUE_COMMA 1034 #undef STRING_NULL 1035 #undef EACH_NAMED_CON 1036 #endif // PRODUCT 1037 1038 JVM_ENTRY(jint, MHN_getNamedCon(JNIEnv *env, jobject igcls, jint which, jobjectArray box_jh)) { 1039 #ifndef PRODUCT 1040 if (advertise_con_value(which)) { 1041 assert(which >= 0 && which < con_value_count, ""); 1042 int con = con_values[which]; 1043 objArrayHandle box(THREAD, (objArrayOop) JNIHandles::resolve(box_jh)); 1044 if (box.not_null() && box->klass() == Universe::objectArrayKlassObj() && box->length() > 0) { 1045 const char* str = &con_names[0]; 1046 for (int i = 0; i < which; i++) 1047 str += strlen(str) + 1; // skip name and null 1048 oop name = java_lang_String::create_oop_from_str(str, CHECK_0); // possible safepoint 1049 box->obj_at_put(0, name); 1050 } 1051 return con; 1052 } 1053 #endif 1054 return 0; 1055 } 1056 JVM_END 1057 1058 // void init(MemberName self, AccessibleObject ref) 1059 JVM_ENTRY(void, MHN_init_Mem(JNIEnv *env, jobject igcls, jobject mname_jh, jobject target_jh)) { 1060 if (mname_jh == NULL) { THROW_MSG(vmSymbols::java_lang_InternalError(), "mname is null"); } 1061 if (target_jh == NULL) { THROW_MSG(vmSymbols::java_lang_InternalError(), "target is null"); } 1062 Handle mname(THREAD, JNIHandles::resolve_non_null(mname_jh)); 1063 Handle target(THREAD, JNIHandles::resolve_non_null(target_jh)); 1064 MethodHandles::init_MemberName(mname, target); 1065 } 1066 JVM_END 1067 1068 // void expand(MemberName self) 1069 JVM_ENTRY(void, MHN_expand_Mem(JNIEnv *env, jobject igcls, jobject mname_jh)) { 1070 if (mname_jh == NULL) { THROW_MSG(vmSymbols::java_lang_InternalError(), "mname is null"); } 1071 Handle mname(THREAD, JNIHandles::resolve_non_null(mname_jh)); 1072 MethodHandles::expand_MemberName(mname, 0, CHECK); 1073 } 1074 JVM_END 1075 1076 // void resolve(MemberName self, Class<?> caller) 1077 JVM_ENTRY(jobject, MHN_resolve_Mem(JNIEnv *env, jobject igcls, jobject mname_jh, jclass caller_jh)) { 1078 if (mname_jh == NULL) { THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "mname is null"); } 1079 Handle mname(THREAD, JNIHandles::resolve_non_null(mname_jh)); 1080 1081 // The trusted Java code that calls this method should already have performed 1082 // access checks on behalf of the given caller. But, we can verify this. 1083 if (VerifyMethodHandles && caller_jh != NULL && 1084 java_lang_invoke_MemberName::clazz(mname()) != NULL) { 1085 Klass* reference_klass = java_lang_Class::as_Klass(java_lang_invoke_MemberName::clazz(mname())); 1086 if (reference_klass != NULL && reference_klass->oop_is_objArray()) { 1087 reference_klass = ObjArrayKlass::cast(reference_klass)->bottom_klass(); 1088 } 1089 1090 // Reflection::verify_class_access can only handle instance classes. 1091 if (reference_klass != NULL && reference_klass->oop_is_instance()) { 1092 // Emulate LinkResolver::check_klass_accessability. 1093 Klass* caller = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh)); 1094 if (!Reflection::verify_class_access(caller, 1095 reference_klass, 1096 true)) { 1097 THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), reference_klass->external_name()); 1098 } 1099 } 1100 } 1101 1102 Handle resolved = MethodHandles::resolve_MemberName(mname, CHECK_NULL); 1103 if (resolved.is_null()) { 1104 int flags = java_lang_invoke_MemberName::flags(mname()); 1105 int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK; 1106 if (!MethodHandles::ref_kind_is_valid(ref_kind)) { 1107 THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "obsolete MemberName format"); 1108 } 1109 if ((flags & ALL_KINDS) == IS_FIELD) { 1110 THROW_MSG_NULL(vmSymbols::java_lang_NoSuchMethodError(), "field resolution failed"); 1111 } else if ((flags & ALL_KINDS) == IS_METHOD || 1112 (flags & ALL_KINDS) == IS_CONSTRUCTOR) { 1113 THROW_MSG_NULL(vmSymbols::java_lang_NoSuchFieldError(), "method resolution failed"); 1114 } else { 1115 THROW_MSG_NULL(vmSymbols::java_lang_LinkageError(), "resolution failed"); 1116 } 1117 } 1118 1119 return JNIHandles::make_local(THREAD, resolved()); 1120 } 1121 JVM_END 1122 1123 static jlong find_member_field_offset(oop mname, bool must_be_static, TRAPS) { 1124 if (mname == NULL || 1125 java_lang_invoke_MemberName::vmtarget(mname) == NULL) { 1126 THROW_MSG_0(vmSymbols::java_lang_InternalError(), "mname not resolved"); 1127 } else { 1128 int flags = java_lang_invoke_MemberName::flags(mname); 1129 if ((flags & IS_FIELD) != 0 && 1130 (must_be_static 1131 ? (flags & JVM_ACC_STATIC) != 0 1132 : (flags & JVM_ACC_STATIC) == 0)) { 1133 int vmindex = java_lang_invoke_MemberName::vmindex(mname); 1134 return (jlong) vmindex; 1135 } 1136 } 1137 const char* msg = (must_be_static ? "static field required" : "non-static field required"); 1138 THROW_MSG_0(vmSymbols::java_lang_InternalError(), msg); 1139 return 0; 1140 } 1141 1142 JVM_ENTRY(jlong, MHN_objectFieldOffset(JNIEnv *env, jobject igcls, jobject mname_jh)) { 1143 return find_member_field_offset(JNIHandles::resolve(mname_jh), false, THREAD); 1144 } 1145 JVM_END 1146 1147 JVM_ENTRY(jlong, MHN_staticFieldOffset(JNIEnv *env, jobject igcls, jobject mname_jh)) { 1148 return find_member_field_offset(JNIHandles::resolve(mname_jh), true, THREAD); 1149 } 1150 JVM_END 1151 1152 JVM_ENTRY(jobject, MHN_staticFieldBase(JNIEnv *env, jobject igcls, jobject mname_jh)) { 1153 // use the other function to perform sanity checks: 1154 jlong ignore = find_member_field_offset(JNIHandles::resolve(mname_jh), true, CHECK_NULL); 1155 oop clazz = java_lang_invoke_MemberName::clazz(JNIHandles::resolve_non_null(mname_jh)); 1156 return JNIHandles::make_local(THREAD, clazz); 1157 } 1158 JVM_END 1159 1160 JVM_ENTRY(jobject, MHN_getMemberVMInfo(JNIEnv *env, jobject igcls, jobject mname_jh)) { 1161 if (mname_jh == NULL) return NULL; 1162 Handle mname(THREAD, JNIHandles::resolve_non_null(mname_jh)); 1163 intptr_t vmindex = java_lang_invoke_MemberName::vmindex(mname()); 1164 Metadata* vmtarget = java_lang_invoke_MemberName::vmtarget(mname()); 1165 objArrayHandle result = oopFactory::new_objArray(SystemDictionary::Object_klass(), 2, CHECK_NULL); 1166 jvalue vmindex_value; vmindex_value.j = (long)vmindex; 1167 oop x = java_lang_boxing_object::create(T_LONG, &vmindex_value, CHECK_NULL); 1168 result->obj_at_put(0, x); 1169 x = NULL; 1170 if (vmtarget == NULL) { 1171 x = NULL; 1172 } else if (vmtarget->is_klass()) { 1173 x = ((Klass*) vmtarget)->java_mirror(); 1174 } else if (vmtarget->is_method()) { 1175 Handle mname2 = MethodHandles::new_MemberName(CHECK_NULL); 1176 CallInfo info((Method*)vmtarget); 1177 x = MethodHandles::init_method_MemberName(mname2, info); 1178 } 1179 result->obj_at_put(1, x); 1180 return JNIHandles::make_local(env, result()); 1181 } 1182 JVM_END 1183 1184 1185 1186 // static native int getMembers(Class<?> defc, String matchName, String matchSig, 1187 // int matchFlags, Class<?> caller, int skip, MemberName[] results); 1188 JVM_ENTRY(jint, MHN_getMembers(JNIEnv *env, jobject igcls, 1189 jclass clazz_jh, jstring name_jh, jstring sig_jh, 1190 int mflags, jclass caller_jh, jint skip, jobjectArray results_jh)) { 1191 if (clazz_jh == NULL || results_jh == NULL) return -1; 1192 KlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz_jh))); 1193 1194 objArrayHandle results(THREAD, (objArrayOop) JNIHandles::resolve(results_jh)); 1195 if (results.is_null() || !results->is_objArray()) return -1; 1196 1197 TempNewSymbol name = NULL; 1198 TempNewSymbol sig = NULL; 1199 if (name_jh != NULL) { 1200 name = java_lang_String::as_symbol_or_null(JNIHandles::resolve_non_null(name_jh)); 1201 if (name == NULL) return 0; // a match is not possible 1202 } 1203 if (sig_jh != NULL) { 1204 sig = java_lang_String::as_symbol_or_null(JNIHandles::resolve_non_null(sig_jh)); 1205 if (sig == NULL) return 0; // a match is not possible 1206 } 1207 1208 KlassHandle caller; 1209 if (caller_jh != NULL) { 1210 oop caller_oop = JNIHandles::resolve_non_null(caller_jh); 1211 if (!java_lang_Class::is_instance(caller_oop)) return -1; 1212 caller = KlassHandle(THREAD, java_lang_Class::as_Klass(caller_oop)); 1213 } 1214 1215 if (name != NULL && sig != NULL && results.not_null()) { 1216 // try a direct resolve 1217 // %%% TO DO 1218 } 1219 1220 int res = MethodHandles::find_MemberNames(k, name, sig, mflags, 1221 caller, skip, results); 1222 // TO DO: expand at least some of the MemberNames, to avoid massive callbacks 1223 return res; 1224 } 1225 JVM_END 1226 1227 JVM_ENTRY(void, MHN_setCallSiteTargetNormal(JNIEnv* env, jobject igcls, jobject call_site_jh, jobject target_jh)) { 1228 Handle call_site(THREAD, JNIHandles::resolve_non_null(call_site_jh)); 1229 Handle target (THREAD, JNIHandles::resolve(target_jh)); 1230 { 1231 // Walk all nmethods depending on this call site. 1232 MutexLocker mu(Compile_lock, thread); 1233 Universe::flush_dependents_on(call_site, target); 1234 java_lang_invoke_CallSite::set_target(call_site(), target()); 1235 } 1236 } 1237 JVM_END 1238 1239 JVM_ENTRY(void, MHN_setCallSiteTargetVolatile(JNIEnv* env, jobject igcls, jobject call_site_jh, jobject target_jh)) { 1240 Handle call_site(THREAD, JNIHandles::resolve_non_null(call_site_jh)); 1241 Handle target (THREAD, JNIHandles::resolve(target_jh)); 1242 { 1243 // Walk all nmethods depending on this call site. 1244 MutexLocker mu(Compile_lock, thread); 1245 Universe::flush_dependents_on(call_site, target); 1246 java_lang_invoke_CallSite::set_target_volatile(call_site(), target()); 1247 } 1248 } 1249 JVM_END 1250 1251 /** 1252 * Throws a java/lang/UnsupportedOperationException unconditionally. 1253 * This is required by the specification of MethodHandle.invoke if 1254 * invoked directly. 1255 */ 1256 JVM_ENTRY(jobject, MH_invoke_UOE(JNIEnv* env, jobject mh, jobjectArray args)) { 1257 THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "MethodHandle.invoke cannot be invoked reflectively"); 1258 return NULL; 1259 } 1260 JVM_END 1261 1262 /** 1263 * Throws a java/lang/UnsupportedOperationException unconditionally. 1264 * This is required by the specification of MethodHandle.invokeExact if 1265 * invoked directly. 1266 */ 1267 JVM_ENTRY(jobject, MH_invokeExact_UOE(JNIEnv* env, jobject mh, jobjectArray args)) { 1268 THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "MethodHandle.invokeExact cannot be invoked reflectively"); 1269 return NULL; 1270 } 1271 JVM_END 1272 1273 /// JVM_RegisterMethodHandleMethods 1274 1275 #undef CS // Solaris builds complain 1276 1277 #define LANG "Ljava/lang/" 1278 #define JLINV "Ljava/lang/invoke/" 1279 1280 #define OBJ LANG"Object;" 1281 #define CLS LANG"Class;" 1282 #define STRG LANG"String;" 1283 #define CS JLINV"CallSite;" 1284 #define MT JLINV"MethodType;" 1285 #define MH JLINV"MethodHandle;" 1286 #define MEM JLINV"MemberName;" 1287 1288 #define CC (char*) /*cast a literal from (const char*)*/ 1289 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f) 1290 1291 // These are the native methods on java.lang.invoke.MethodHandleNatives. 1292 static JNINativeMethod MHN_methods[] = { 1293 {CC"init", CC"("MEM""OBJ")V", FN_PTR(MHN_init_Mem)}, 1294 {CC"expand", CC"("MEM")V", FN_PTR(MHN_expand_Mem)}, 1295 {CC"resolve", CC"("MEM""CLS")"MEM, FN_PTR(MHN_resolve_Mem)}, 1296 {CC"getConstant", CC"(I)I", FN_PTR(MHN_getConstant)}, 1297 // static native int getNamedCon(int which, Object[] name) 1298 {CC"getNamedCon", CC"(I["OBJ")I", FN_PTR(MHN_getNamedCon)}, 1299 // static native int getMembers(Class<?> defc, String matchName, String matchSig, 1300 // int matchFlags, Class<?> caller, int skip, MemberName[] results); 1301 {CC"getMembers", CC"("CLS""STRG""STRG"I"CLS"I["MEM")I", FN_PTR(MHN_getMembers)}, 1302 {CC"objectFieldOffset", CC"("MEM")J", FN_PTR(MHN_objectFieldOffset)}, 1303 {CC"setCallSiteTargetNormal", CC"("CS""MH")V", FN_PTR(MHN_setCallSiteTargetNormal)}, 1304 {CC"setCallSiteTargetVolatile", CC"("CS""MH")V", FN_PTR(MHN_setCallSiteTargetVolatile)}, 1305 {CC"staticFieldOffset", CC"("MEM")J", FN_PTR(MHN_staticFieldOffset)}, 1306 {CC"staticFieldBase", CC"("MEM")"OBJ, FN_PTR(MHN_staticFieldBase)}, 1307 {CC"getMemberVMInfo", CC"("MEM")"OBJ, FN_PTR(MHN_getMemberVMInfo)} 1308 }; 1309 1310 static JNINativeMethod MH_methods[] = { 1311 // UnsupportedOperationException throwers 1312 {CC"invoke", CC"(["OBJ")"OBJ, FN_PTR(MH_invoke_UOE)}, 1313 {CC"invokeExact", CC"(["OBJ")"OBJ, FN_PTR(MH_invokeExact_UOE)} 1314 }; 1315 1316 /** 1317 * Helper method to register native methods. 1318 */ 1319 static bool register_natives(JNIEnv* env, jclass clazz, const JNINativeMethod* methods, jint nMethods) { 1320 int status = env->RegisterNatives(clazz, methods, nMethods); 1321 if (status != JNI_OK || env->ExceptionOccurred()) { 1322 warning("JSR 292 method handle code is mismatched to this JVM. Disabling support."); 1323 env->ExceptionClear(); 1324 return false; 1325 } 1326 return true; 1327 } 1328 1329 /** 1330 * This one function is exported, used by NativeLookup. 1331 */ 1332 JVM_ENTRY(void, JVM_RegisterMethodHandleMethods(JNIEnv *env, jclass MHN_class)) { 1333 if (!EnableInvokeDynamic) { 1334 warning("JSR 292 is disabled in this JVM. Use -XX:+UnlockDiagnosticVMOptions -XX:+EnableInvokeDynamic to enable."); 1335 return; // bind nothing 1336 } 1337 1338 assert(!MethodHandles::enabled(), "must not be enabled"); 1339 bool enable_MH = true; 1340 1341 jclass MH_class = NULL; 1342 if (SystemDictionary::MethodHandle_klass() == NULL) { 1343 enable_MH = false; 1344 } else { 1345 oop mirror = SystemDictionary::MethodHandle_klass()->java_mirror(); 1346 MH_class = (jclass) JNIHandles::make_local(env, mirror); 1347 } 1348 1349 if (enable_MH) { 1350 ThreadToNativeFromVM ttnfv(thread); 1351 1352 if (enable_MH) { 1353 enable_MH = register_natives(env, MHN_class, MHN_methods, sizeof(MHN_methods)/sizeof(JNINativeMethod)); 1354 } 1355 if (enable_MH) { 1356 enable_MH = register_natives(env, MH_class, MH_methods, sizeof(MH_methods)/sizeof(JNINativeMethod)); 1357 } 1358 } 1359 1360 if (TraceInvokeDynamic) { 1361 tty->print_cr("MethodHandle support loaded (using LambdaForms)"); 1362 } 1363 1364 if (enable_MH) { 1365 MethodHandles::generate_adapters(); 1366 MethodHandles::set_enabled(true); 1367 } 1368 } 1369 JVM_END