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