1 /* 2 * Copyright (c) 2011, 2017, 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 #include "precompiled.hpp" 25 #include "classfile/javaClasses.inline.hpp" 26 #include "code/codeCache.hpp" 27 #include "code/scopeDesc.hpp" 28 #include "interpreter/linkResolver.hpp" 29 #include "memory/oopFactory.hpp" 30 #include "memory/resourceArea.hpp" 31 #include "oops/generateOopMap.hpp" 32 #include "oops/fieldStreams.hpp" 33 #include "oops/oop.inline.hpp" 34 #include "oops/objArrayOop.inline.hpp" 35 #include "runtime/fieldDescriptor.hpp" 36 #include "runtime/javaCalls.hpp" 37 #include "jvmci/jvmciRuntime.hpp" 38 #include "compiler/abstractCompiler.hpp" 39 #include "compiler/compileBroker.hpp" 40 #include "compiler/compilerOracle.hpp" 41 #include "compiler/disassembler.hpp" 42 #include "compiler/oopMap.hpp" 43 #include "jvmci/jvmciCompilerToVM.hpp" 44 #include "jvmci/jvmciCompiler.hpp" 45 #include "jvmci/jvmciEnv.hpp" 46 #include "jvmci/jvmciJavaClasses.hpp" 47 #include "jvmci/jvmciCodeInstaller.hpp" 48 #include "jvmci/vmStructs_jvmci.hpp" 49 #include "gc/g1/heapRegion.hpp" 50 #include "runtime/javaCalls.hpp" 51 #include "runtime/deoptimization.hpp" 52 #include "runtime/timerTrace.hpp" 53 #include "runtime/vframe.hpp" 54 #include "runtime/vframe_hp.hpp" 55 #include "runtime/vmStructs.hpp" 56 #include "utilities/resourceHash.hpp" 57 58 59 void JNIHandleMark::push_jni_handle_block() { 60 JavaThread* thread = JavaThread::current(); 61 if (thread != NULL) { 62 // Allocate a new block for JNI handles. 63 // Inlined code from jni_PushLocalFrame() 64 JNIHandleBlock* java_handles = ((JavaThread*)thread)->active_handles(); 65 JNIHandleBlock* compile_handles = JNIHandleBlock::allocate_block(thread); 66 assert(compile_handles != NULL && java_handles != NULL, "should not be NULL"); 67 compile_handles->set_pop_frame_link(java_handles); 68 thread->set_active_handles(compile_handles); 69 } 70 } 71 72 void JNIHandleMark::pop_jni_handle_block() { 73 JavaThread* thread = JavaThread::current(); 74 if (thread != NULL) { 75 // Release our JNI handle block 76 JNIHandleBlock* compile_handles = thread->active_handles(); 77 JNIHandleBlock* java_handles = compile_handles->pop_frame_link(); 78 thread->set_active_handles(java_handles); 79 compile_handles->set_pop_frame_link(NULL); 80 JNIHandleBlock::release_block(compile_handles, thread); // may block 81 } 82 } 83 84 // Entry to native method implementation that transitions current thread to '_thread_in_vm'. 85 #define C2V_VMENTRY(result_type, name, signature) \ 86 JNIEXPORT result_type JNICALL c2v_ ## name signature { \ 87 TRACE_jvmci_1("CompilerToVM::" #name); \ 88 TRACE_CALL(result_type, jvmci_ ## name signature) \ 89 JVMCI_VM_ENTRY_MARK; \ 90 91 #define C2V_END } 92 93 oop CompilerToVM::get_jvmci_method(const methodHandle& method, TRAPS) { 94 if (method() != NULL) { 95 JavaValue result(T_OBJECT); 96 JavaCallArguments args; 97 args.push_long((jlong) (address) method()); 98 JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedJavaMethodImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::method_fromMetaspace_signature(), &args, CHECK_NULL); 99 100 return (oop)result.get_jobject(); 101 } 102 return NULL; 103 } 104 105 oop CompilerToVM::get_jvmci_type(Klass* klass, TRAPS) { 106 if (klass != NULL) { 107 JavaValue result(T_OBJECT); 108 JavaCallArguments args; 109 args.push_oop(Handle(THREAD, klass->java_mirror())); 110 JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedObjectTypeImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::klass_fromMetaspace_signature(), &args, CHECK_NULL); 111 112 return (oop)result.get_jobject(); 113 } 114 return NULL; 115 } 116 117 118 int CompilerToVM::Data::Klass_vtable_start_offset; 119 int CompilerToVM::Data::Klass_vtable_length_offset; 120 121 int CompilerToVM::Data::Method_extra_stack_entries; 122 123 address CompilerToVM::Data::SharedRuntime_ic_miss_stub; 124 address CompilerToVM::Data::SharedRuntime_handle_wrong_method_stub; 125 address CompilerToVM::Data::SharedRuntime_deopt_blob_unpack; 126 address CompilerToVM::Data::SharedRuntime_deopt_blob_uncommon_trap; 127 128 size_t CompilerToVM::Data::ThreadLocalAllocBuffer_alignment_reserve; 129 130 CollectedHeap* CompilerToVM::Data::Universe_collectedHeap; 131 int CompilerToVM::Data::Universe_base_vtable_size; 132 address CompilerToVM::Data::Universe_narrow_oop_base; 133 int CompilerToVM::Data::Universe_narrow_oop_shift; 134 address CompilerToVM::Data::Universe_narrow_klass_base; 135 int CompilerToVM::Data::Universe_narrow_klass_shift; 136 void* CompilerToVM::Data::Universe_non_oop_bits; 137 uintptr_t CompilerToVM::Data::Universe_verify_oop_mask; 138 uintptr_t CompilerToVM::Data::Universe_verify_oop_bits; 139 140 bool CompilerToVM::Data::_supports_inline_contig_alloc; 141 HeapWord** CompilerToVM::Data::_heap_end_addr; 142 HeapWord* volatile* CompilerToVM::Data::_heap_top_addr; 143 int CompilerToVM::Data::_max_oop_map_stack_offset; 144 145 jbyte* CompilerToVM::Data::cardtable_start_address; 146 int CompilerToVM::Data::cardtable_shift; 147 148 int CompilerToVM::Data::vm_page_size; 149 150 int CompilerToVM::Data::sizeof_vtableEntry = sizeof(vtableEntry); 151 int CompilerToVM::Data::sizeof_ExceptionTableElement = sizeof(ExceptionTableElement); 152 int CompilerToVM::Data::sizeof_LocalVariableTableElement = sizeof(LocalVariableTableElement); 153 int CompilerToVM::Data::sizeof_ConstantPool = sizeof(ConstantPool); 154 int CompilerToVM::Data::sizeof_SymbolPointer = sizeof(Symbol*); 155 int CompilerToVM::Data::sizeof_narrowKlass = sizeof(narrowKlass); 156 int CompilerToVM::Data::sizeof_arrayOopDesc = sizeof(arrayOopDesc); 157 int CompilerToVM::Data::sizeof_BasicLock = sizeof(BasicLock); 158 159 address CompilerToVM::Data::dsin; 160 address CompilerToVM::Data::dcos; 161 address CompilerToVM::Data::dtan; 162 address CompilerToVM::Data::dexp; 163 address CompilerToVM::Data::dlog; 164 address CompilerToVM::Data::dlog10; 165 address CompilerToVM::Data::dpow; 166 167 address CompilerToVM::Data::symbol_init; 168 address CompilerToVM::Data::symbol_clinit; 169 170 void CompilerToVM::Data::initialize(TRAPS) { 171 Klass_vtable_start_offset = in_bytes(Klass::vtable_start_offset()); 172 Klass_vtable_length_offset = in_bytes(Klass::vtable_length_offset()); 173 174 Method_extra_stack_entries = Method::extra_stack_entries(); 175 176 SharedRuntime_ic_miss_stub = SharedRuntime::get_ic_miss_stub(); 177 SharedRuntime_handle_wrong_method_stub = SharedRuntime::get_handle_wrong_method_stub(); 178 SharedRuntime_deopt_blob_unpack = SharedRuntime::deopt_blob()->unpack(); 179 SharedRuntime_deopt_blob_uncommon_trap = SharedRuntime::deopt_blob()->uncommon_trap(); 180 181 ThreadLocalAllocBuffer_alignment_reserve = ThreadLocalAllocBuffer::alignment_reserve(); 182 183 Universe_collectedHeap = Universe::heap(); 184 Universe_base_vtable_size = Universe::base_vtable_size(); 185 Universe_narrow_oop_base = Universe::narrow_oop_base(); 186 Universe_narrow_oop_shift = Universe::narrow_oop_shift(); 187 Universe_narrow_klass_base = Universe::narrow_klass_base(); 188 Universe_narrow_klass_shift = Universe::narrow_klass_shift(); 189 Universe_non_oop_bits = Universe::non_oop_word(); 190 Universe_verify_oop_mask = Universe::verify_oop_mask(); 191 Universe_verify_oop_bits = Universe::verify_oop_bits(); 192 193 _supports_inline_contig_alloc = Universe::heap()->supports_inline_contig_alloc(); 194 _heap_end_addr = _supports_inline_contig_alloc ? Universe::heap()->end_addr() : (HeapWord**) -1; 195 _heap_top_addr = _supports_inline_contig_alloc ? Universe::heap()->top_addr() : (HeapWord* volatile*) -1; 196 197 _max_oop_map_stack_offset = (OopMapValue::register_mask - VMRegImpl::stack2reg(0)->value()) * VMRegImpl::stack_slot_size; 198 int max_oop_map_stack_index = _max_oop_map_stack_offset / VMRegImpl::stack_slot_size; 199 assert(OopMapValue::legal_vm_reg_name(VMRegImpl::stack2reg(max_oop_map_stack_index)), "should be valid"); 200 assert(!OopMapValue::legal_vm_reg_name(VMRegImpl::stack2reg(max_oop_map_stack_index + 1)), "should be invalid"); 201 202 symbol_init = (address) vmSymbols::object_initializer_name(); 203 symbol_clinit = (address) vmSymbols::class_initializer_name(); 204 205 BarrierSet* bs = Universe::heap()->barrier_set(); 206 switch (bs->kind()) { 207 case BarrierSet::CardTableModRef: 208 case BarrierSet::CardTableForRS: 209 case BarrierSet::CardTableExtension: 210 case BarrierSet::G1SATBCT: 211 case BarrierSet::G1SATBCTLogging: { 212 jbyte* base = barrier_set_cast<CardTableModRefBS>(bs)->byte_map_base; 213 assert(base != 0, "unexpected byte_map_base"); 214 cardtable_start_address = base; 215 cardtable_shift = CardTableModRefBS::card_shift; 216 break; 217 } 218 case BarrierSet::ModRef: 219 cardtable_start_address = 0; 220 cardtable_shift = 0; 221 // No post barriers 222 break; 223 default: 224 JVMCI_ERROR("Unsupported BarrierSet kind %d", bs->kind()); 225 break; 226 } 227 228 vm_page_size = os::vm_page_size(); 229 230 #define SET_TRIGFUNC(name) \ 231 if (StubRoutines::name() != NULL) { \ 232 name = StubRoutines::name(); \ 233 } else { \ 234 name = CAST_FROM_FN_PTR(address, SharedRuntime::name); \ 235 } 236 237 SET_TRIGFUNC(dsin); 238 SET_TRIGFUNC(dcos); 239 SET_TRIGFUNC(dtan); 240 SET_TRIGFUNC(dexp); 241 SET_TRIGFUNC(dlog10); 242 SET_TRIGFUNC(dlog); 243 SET_TRIGFUNC(dpow); 244 245 #undef SET_TRIGFUNC 246 } 247 248 objArrayHandle CompilerToVM::initialize_intrinsics(TRAPS) { 249 objArrayHandle vmIntrinsics = oopFactory::new_objArray_handle(VMIntrinsicMethod::klass(), (vmIntrinsics::ID_LIMIT - 1), CHECK_(objArrayHandle())); 250 int index = 0; 251 // The intrinsics for a class are usually adjacent to each other. 252 // When they are, the string for the class name can be reused. 253 vmSymbols::SID kls_sid = vmSymbols::NO_SID; 254 Handle kls_str; 255 #define SID_ENUM(n) vmSymbols::VM_SYMBOL_ENUM_NAME(n) 256 #define VM_SYMBOL_TO_STRING(s) \ 257 java_lang_String::create_from_symbol(vmSymbols::symbol_at(SID_ENUM(s)), CHECK_(objArrayHandle())) 258 #define VM_INTRINSIC_INFO(id, kls, name, sig, ignore_fcode) { \ 259 instanceHandle vmIntrinsicMethod = InstanceKlass::cast(VMIntrinsicMethod::klass())->allocate_instance_handle(CHECK_(objArrayHandle())); \ 260 if (kls_sid != SID_ENUM(kls)) { \ 261 kls_str = VM_SYMBOL_TO_STRING(kls); \ 262 kls_sid = SID_ENUM(kls); \ 263 } \ 264 Handle name_str = VM_SYMBOL_TO_STRING(name); \ 265 Handle sig_str = VM_SYMBOL_TO_STRING(sig); \ 266 VMIntrinsicMethod::set_declaringClass(vmIntrinsicMethod, kls_str()); \ 267 VMIntrinsicMethod::set_name(vmIntrinsicMethod, name_str()); \ 268 VMIntrinsicMethod::set_descriptor(vmIntrinsicMethod, sig_str()); \ 269 VMIntrinsicMethod::set_id(vmIntrinsicMethod, vmIntrinsics::id); \ 270 vmIntrinsics->obj_at_put(index++, vmIntrinsicMethod()); \ 271 } 272 273 VM_INTRINSICS_DO(VM_INTRINSIC_INFO, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE) 274 #undef SID_ENUM 275 #undef VM_SYMBOL_TO_STRING 276 #undef VM_INTRINSIC_INFO 277 assert(index == vmIntrinsics::ID_LIMIT - 1, "must be"); 278 279 return vmIntrinsics; 280 } 281 282 /** 283 * The set of VM flags known to be used. 284 */ 285 #define PREDEFINED_CONFIG_FLAGS(do_bool_flag, do_intx_flag, do_uintx_flag) \ 286 do_intx_flag(AllocateInstancePrefetchLines) \ 287 do_intx_flag(AllocatePrefetchDistance) \ 288 do_intx_flag(AllocatePrefetchInstr) \ 289 do_intx_flag(AllocatePrefetchLines) \ 290 do_intx_flag(AllocatePrefetchStepSize) \ 291 do_intx_flag(AllocatePrefetchStyle) \ 292 do_intx_flag(BciProfileWidth) \ 293 do_bool_flag(BootstrapJVMCI) \ 294 do_bool_flag(CITime) \ 295 do_bool_flag(CITimeEach) \ 296 do_uintx_flag(CodeCacheSegmentSize) \ 297 do_intx_flag(CodeEntryAlignment) \ 298 do_bool_flag(CompactFields) \ 299 NOT_PRODUCT(do_intx_flag(CompileTheWorldStartAt)) \ 300 NOT_PRODUCT(do_intx_flag(CompileTheWorldStopAt)) \ 301 do_intx_flag(ContendedPaddingWidth) \ 302 do_bool_flag(DontCompileHugeMethods) \ 303 do_bool_flag(EnableContended) \ 304 do_intx_flag(FieldsAllocationStyle) \ 305 do_bool_flag(FoldStableValues) \ 306 do_bool_flag(ForceUnreachable) \ 307 do_intx_flag(HugeMethodLimit) \ 308 do_bool_flag(Inline) \ 309 do_intx_flag(JVMCICounterSize) \ 310 do_bool_flag(JVMCIPrintProperties) \ 311 do_bool_flag(JVMCIUseFastLocking) \ 312 do_intx_flag(MethodProfileWidth) \ 313 do_intx_flag(ObjectAlignmentInBytes) \ 314 do_bool_flag(PrintInlining) \ 315 do_bool_flag(ReduceInitialCardMarks) \ 316 do_bool_flag(RestrictContended) \ 317 do_intx_flag(StackReservedPages) \ 318 do_intx_flag(StackShadowPages) \ 319 do_bool_flag(TLABStats) \ 320 do_uintx_flag(TLABWasteIncrement) \ 321 do_intx_flag(TypeProfileWidth) \ 322 do_bool_flag(UseAESIntrinsics) \ 323 X86_ONLY(do_intx_flag(UseAVX)) \ 324 do_bool_flag(UseBiasedLocking) \ 325 do_bool_flag(UseCRC32Intrinsics) \ 326 do_bool_flag(UseCompressedClassPointers) \ 327 do_bool_flag(UseCompressedOops) \ 328 do_bool_flag(UseConcMarkSweepGC) \ 329 X86_ONLY(do_bool_flag(UseCountLeadingZerosInstruction)) \ 330 X86_ONLY(do_bool_flag(UseCountTrailingZerosInstruction)) \ 331 do_bool_flag(UseG1GC) \ 332 COMPILER2_PRESENT(do_bool_flag(UseMontgomeryMultiplyIntrinsic)) \ 333 COMPILER2_PRESENT(do_bool_flag(UseMontgomerySquareIntrinsic)) \ 334 COMPILER2_PRESENT(do_bool_flag(UseMulAddIntrinsic)) \ 335 COMPILER2_PRESENT(do_bool_flag(UseMultiplyToLenIntrinsic)) \ 336 do_bool_flag(UsePopCountInstruction) \ 337 do_bool_flag(UseSHA1Intrinsics) \ 338 do_bool_flag(UseSHA256Intrinsics) \ 339 do_bool_flag(UseSHA512Intrinsics) \ 340 do_intx_flag(UseSSE) \ 341 COMPILER2_PRESENT(do_bool_flag(UseSquareToLenIntrinsic)) \ 342 do_bool_flag(UseStackBanging) \ 343 do_bool_flag(UseTLAB) \ 344 do_bool_flag(VerifyOops) \ 345 346 #define BOXED_BOOLEAN(name, value) oop name = ((jboolean)(value) ? boxedTrue() : boxedFalse()) 347 #define BOXED_DOUBLE(name, value) oop name; do { jvalue p; p.d = (jdouble) (value); name = java_lang_boxing_object::create(T_DOUBLE, &p, CHECK_NULL);} while(0) 348 #define BOXED_LONG(name, value) \ 349 oop name; \ 350 do { \ 351 jvalue p; p.j = (jlong) (value); \ 352 Handle* e = longs.get(p.j); \ 353 if (e == NULL) { \ 354 oop o = java_lang_boxing_object::create(T_LONG, &p, CHECK_NULL); \ 355 Handle h(THREAD, o); \ 356 longs.put(p.j, h); \ 357 name = h(); \ 358 } else { \ 359 name = (*e)(); \ 360 } \ 361 } while (0) 362 363 #define CSTRING_TO_JSTRING(name, value) \ 364 Handle name; \ 365 do { \ 366 if (value != NULL) { \ 367 Handle* e = strings.get(value); \ 368 if (e == NULL) { \ 369 Handle h = java_lang_String::create_from_str(value, CHECK_NULL); \ 370 strings.put(value, h); \ 371 name = h; \ 372 } else { \ 373 name = (*e); \ 374 } \ 375 } \ 376 } while (0) 377 378 C2V_VMENTRY(jobjectArray, readConfiguration, (JNIEnv *env)) 379 ResourceMark rm; 380 HandleMark hm; 381 382 // Used to canonicalize Long and String values. 383 ResourceHashtable<jlong, Handle> longs; 384 ResourceHashtable<const char*, Handle, &CompilerToVM::cstring_hash, &CompilerToVM::cstring_equals> strings; 385 386 jvalue prim; 387 prim.z = true; oop boxedTrueOop = java_lang_boxing_object::create(T_BOOLEAN, &prim, CHECK_NULL); 388 Handle boxedTrue(THREAD, boxedTrueOop); 389 prim.z = false; oop boxedFalseOop = java_lang_boxing_object::create(T_BOOLEAN, &prim, CHECK_NULL); 390 Handle boxedFalse(THREAD, boxedFalseOop); 391 392 CompilerToVM::Data::initialize(CHECK_NULL); 393 394 VMField::klass()->initialize(CHECK_NULL); 395 VMFlag::klass()->initialize(CHECK_NULL); 396 VMIntrinsicMethod::klass()->initialize(CHECK_NULL); 397 398 int len = JVMCIVMStructs::localHotSpotVMStructs_count(); 399 objArrayHandle vmFields = oopFactory::new_objArray_handle(VMField::klass(), len, CHECK_NULL); 400 for (int i = 0; i < len ; i++) { 401 VMStructEntry vmField = JVMCIVMStructs::localHotSpotVMStructs[i]; 402 instanceHandle vmFieldObj = InstanceKlass::cast(VMField::klass())->allocate_instance_handle(CHECK_NULL); 403 size_t name_buf_len = strlen(vmField.typeName) + strlen(vmField.fieldName) + 2 /* "::" */; 404 char* name_buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, name_buf_len + 1); 405 sprintf(name_buf, "%s::%s", vmField.typeName, vmField.fieldName); 406 CSTRING_TO_JSTRING(name, name_buf); 407 CSTRING_TO_JSTRING(type, vmField.typeString); 408 VMField::set_name(vmFieldObj, name()); 409 VMField::set_type(vmFieldObj, type()); 410 VMField::set_offset(vmFieldObj, vmField.offset); 411 VMField::set_address(vmFieldObj, (jlong) vmField.address); 412 if (vmField.isStatic && vmField.typeString != NULL) { 413 if (strcmp(vmField.typeString, "bool") == 0) { 414 BOXED_BOOLEAN(box, *(jbyte*) vmField.address); 415 VMField::set_value(vmFieldObj, box); 416 } else if (strcmp(vmField.typeString, "int") == 0 || 417 strcmp(vmField.typeString, "jint") == 0) { 418 BOXED_LONG(box, *(jint*) vmField.address); 419 VMField::set_value(vmFieldObj, box); 420 } else if (strcmp(vmField.typeString, "uint64_t") == 0) { 421 BOXED_LONG(box, *(uint64_t*) vmField.address); 422 VMField::set_value(vmFieldObj, box); 423 } else if (strcmp(vmField.typeString, "address") == 0 || 424 strcmp(vmField.typeString, "intptr_t") == 0 || 425 strcmp(vmField.typeString, "uintptr_t") == 0 || 426 strcmp(vmField.typeString, "size_t") == 0 || 427 // All foo* types are addresses. 428 vmField.typeString[strlen(vmField.typeString) - 1] == '*') { 429 BOXED_LONG(box, *((address*) vmField.address)); 430 VMField::set_value(vmFieldObj, box); 431 } else { 432 JVMCI_ERROR_NULL("VM field %s has unsupported type %s", name_buf, vmField.typeString); 433 } 434 } 435 vmFields->obj_at_put(i, vmFieldObj()); 436 } 437 438 int ints_len = JVMCIVMStructs::localHotSpotVMIntConstants_count(); 439 int longs_len = JVMCIVMStructs::localHotSpotVMLongConstants_count(); 440 len = ints_len + longs_len; 441 objArrayHandle vmConstants = oopFactory::new_objArray_handle(SystemDictionary::Object_klass(), len * 2, CHECK_NULL); 442 int insert = 0; 443 for (int i = 0; i < ints_len ; i++) { 444 VMIntConstantEntry c = JVMCIVMStructs::localHotSpotVMIntConstants[i]; 445 CSTRING_TO_JSTRING(name, c.name); 446 BOXED_LONG(value, c.value); 447 vmConstants->obj_at_put(insert++, name()); 448 vmConstants->obj_at_put(insert++, value); 449 } 450 for (int i = 0; i < longs_len ; i++) { 451 VMLongConstantEntry c = JVMCIVMStructs::localHotSpotVMLongConstants[i]; 452 CSTRING_TO_JSTRING(name, c.name); 453 BOXED_LONG(value, c.value); 454 vmConstants->obj_at_put(insert++, name()); 455 vmConstants->obj_at_put(insert++, value); 456 } 457 assert(insert == len * 2, "must be"); 458 459 len = JVMCIVMStructs::localHotSpotVMAddresses_count(); 460 objArrayHandle vmAddresses = oopFactory::new_objArray_handle(SystemDictionary::Object_klass(), len * 2, CHECK_NULL); 461 for (int i = 0; i < len ; i++) { 462 VMAddressEntry a = JVMCIVMStructs::localHotSpotVMAddresses[i]; 463 CSTRING_TO_JSTRING(name, a.name); 464 BOXED_LONG(value, a.value); 465 vmAddresses->obj_at_put(i * 2, name()); 466 vmAddresses->obj_at_put(i * 2 + 1, value); 467 } 468 469 #define COUNT_FLAG(ignore) +1 470 #ifdef ASSERT 471 #define CHECK_FLAG(type, name) { \ 472 Flag* flag = Flag::find_flag(#name, strlen(#name), /*allow_locked*/ true, /* return_flag */ true); \ 473 assert(flag != NULL, "No such flag named " #name); \ 474 assert(flag->is_##type(), "Flag " #name " is not of type " #type); \ 475 } 476 #else 477 #define CHECK_FLAG(type, name) 478 #endif 479 480 #define ADD_FLAG(type, name, convert) { \ 481 CHECK_FLAG(type, name) \ 482 instanceHandle vmFlagObj = InstanceKlass::cast(VMFlag::klass())->allocate_instance_handle(CHECK_NULL); \ 483 CSTRING_TO_JSTRING(fname, #name); \ 484 CSTRING_TO_JSTRING(ftype, #type); \ 485 VMFlag::set_name(vmFlagObj, fname()); \ 486 VMFlag::set_type(vmFlagObj, ftype()); \ 487 convert(value, name); \ 488 VMFlag::set_value(vmFlagObj, value); \ 489 vmFlags->obj_at_put(i++, vmFlagObj()); \ 490 } 491 #define ADD_BOOL_FLAG(name) ADD_FLAG(bool, name, BOXED_BOOLEAN) 492 #define ADD_INTX_FLAG(name) ADD_FLAG(intx, name, BOXED_LONG) 493 #define ADD_UINTX_FLAG(name) ADD_FLAG(uintx, name, BOXED_LONG) 494 495 len = 0 + PREDEFINED_CONFIG_FLAGS(COUNT_FLAG, COUNT_FLAG, COUNT_FLAG); 496 objArrayHandle vmFlags = oopFactory::new_objArray_handle(VMFlag::klass(), len, CHECK_NULL); 497 int i = 0; 498 PREDEFINED_CONFIG_FLAGS(ADD_BOOL_FLAG, ADD_INTX_FLAG, ADD_UINTX_FLAG) 499 500 objArrayHandle vmIntrinsics = CompilerToVM::initialize_intrinsics(CHECK_NULL); 501 502 objArrayOop data = oopFactory::new_objArray(SystemDictionary::Object_klass(), 5, CHECK_NULL); 503 data->obj_at_put(0, vmFields()); 504 data->obj_at_put(1, vmConstants()); 505 data->obj_at_put(2, vmAddresses()); 506 data->obj_at_put(3, vmFlags()); 507 data->obj_at_put(4, vmIntrinsics()); 508 509 return (jobjectArray) JNIHandles::make_local(THREAD, data); 510 #undef COUNT_FLAG 511 #undef ADD_FLAG 512 #undef ADD_BOOL_FLAG 513 #undef ADD_INTX_FLAG 514 #undef ADD_UINTX_FLAG 515 #undef CHECK_FLAG 516 C2V_END 517 518 C2V_VMENTRY(jobject, getFlagValue, (JNIEnv *, jobject c2vm, jobject name_handle)) 519 #define RETURN_BOXED_LONG(value) oop box; jvalue p; p.j = (jlong) (value); box = java_lang_boxing_object::create(T_LONG, &p, CHECK_NULL); return JNIHandles::make_local(THREAD, box); 520 #define RETURN_BOXED_DOUBLE(value) oop box; jvalue p; p.d = (jdouble) (value); box = java_lang_boxing_object::create(T_DOUBLE, &p, CHECK_NULL); return JNIHandles::make_local(THREAD, box); 521 Handle name(THREAD, JNIHandles::resolve(name_handle)); 522 if (name.is_null()) { 523 THROW_0(vmSymbols::java_lang_NullPointerException()); 524 } 525 ResourceMark rm; 526 const char* cstring = java_lang_String::as_utf8_string(name()); 527 Flag* flag = Flag::find_flag(cstring, strlen(cstring), /* allow_locked */ true, /* return_flag */ true); 528 if (flag == NULL) { 529 return c2vm; 530 } 531 if (flag->is_bool()) { 532 jvalue prim; 533 prim.z = flag->get_bool(); 534 oop box = java_lang_boxing_object::create(T_BOOLEAN, &prim, CHECK_NULL); 535 return JNIHandles::make_local(THREAD, box); 536 } else if (flag->is_ccstr()) { 537 Handle value = java_lang_String::create_from_str(flag->get_ccstr(), CHECK_NULL); 538 return JNIHandles::make_local(THREAD, value()); 539 } else if (flag->is_intx()) { 540 RETURN_BOXED_LONG(flag->get_intx()); 541 } else if (flag->is_int()) { 542 RETURN_BOXED_LONG(flag->get_int()); 543 } else if (flag->is_uint()) { 544 RETURN_BOXED_LONG(flag->get_uint()); 545 } else if (flag->is_uint64_t()) { 546 RETURN_BOXED_LONG(flag->get_uint64_t()); 547 } else if (flag->is_size_t()) { 548 RETURN_BOXED_LONG(flag->get_size_t()); 549 } else if (flag->is_uintx()) { 550 RETURN_BOXED_LONG(flag->get_uintx()); 551 } else if (flag->is_double()) { 552 RETURN_BOXED_DOUBLE(flag->get_double()); 553 } else { 554 JVMCI_ERROR_NULL("VM flag %s has unsupported type %s", flag->_name, flag->_type); 555 } 556 C2V_END 557 558 #undef BOXED_LONG 559 #undef BOXED_DOUBLE 560 #undef CSTRING_TO_JSTRING 561 562 C2V_VMENTRY(jbyteArray, getBytecode, (JNIEnv *, jobject, jobject jvmci_method)) 563 methodHandle method = CompilerToVM::asMethod(jvmci_method); 564 ResourceMark rm; 565 566 int code_size = method->code_size(); 567 typeArrayOop reconstituted_code = oopFactory::new_byteArray(code_size, CHECK_NULL); 568 569 guarantee(method->method_holder()->is_rewritten(), "Method's holder should be rewritten"); 570 // iterate over all bytecodes and replace non-Java bytecodes 571 572 for (BytecodeStream s(method); s.next() != Bytecodes::_illegal; ) { 573 Bytecodes::Code code = s.code(); 574 Bytecodes::Code raw_code = s.raw_code(); 575 int bci = s.bci(); 576 int len = s.instruction_size(); 577 578 // Restore original byte code. 579 reconstituted_code->byte_at_put(bci, (jbyte) (s.is_wide()? Bytecodes::_wide : code)); 580 if (len > 1) { 581 memcpy(reconstituted_code->byte_at_addr(bci + 1), s.bcp()+1, len-1); 582 } 583 584 if (len > 1) { 585 // Restore the big-endian constant pool indexes. 586 // Cf. Rewriter::scan_method 587 switch (code) { 588 case Bytecodes::_getstatic: 589 case Bytecodes::_putstatic: 590 case Bytecodes::_getfield: 591 case Bytecodes::_putfield: 592 case Bytecodes::_invokevirtual: 593 case Bytecodes::_invokespecial: 594 case Bytecodes::_invokestatic: 595 case Bytecodes::_invokeinterface: 596 case Bytecodes::_invokehandle: { 597 int cp_index = Bytes::get_native_u2((address) reconstituted_code->byte_at_addr(bci + 1)); 598 Bytes::put_Java_u2((address) reconstituted_code->byte_at_addr(bci + 1), (u2) cp_index); 599 break; 600 } 601 602 case Bytecodes::_invokedynamic: { 603 int cp_index = Bytes::get_native_u4((address) reconstituted_code->byte_at_addr(bci + 1)); 604 Bytes::put_Java_u4((address) reconstituted_code->byte_at_addr(bci + 1), (u4) cp_index); 605 break; 606 } 607 608 default: 609 break; 610 } 611 612 // Not all ldc byte code are rewritten. 613 switch (raw_code) { 614 case Bytecodes::_fast_aldc: { 615 int cpc_index = reconstituted_code->byte_at(bci + 1) & 0xff; 616 int cp_index = method->constants()->object_to_cp_index(cpc_index); 617 assert(cp_index < method->constants()->length(), "sanity check"); 618 reconstituted_code->byte_at_put(bci + 1, (jbyte) cp_index); 619 break; 620 } 621 622 case Bytecodes::_fast_aldc_w: { 623 int cpc_index = Bytes::get_native_u2((address) reconstituted_code->byte_at_addr(bci + 1)); 624 int cp_index = method->constants()->object_to_cp_index(cpc_index); 625 assert(cp_index < method->constants()->length(), "sanity check"); 626 Bytes::put_Java_u2((address) reconstituted_code->byte_at_addr(bci + 1), (u2) cp_index); 627 break; 628 } 629 630 default: 631 break; 632 } 633 } 634 } 635 636 return (jbyteArray) JNIHandles::make_local(THREAD, reconstituted_code); 637 C2V_END 638 639 C2V_VMENTRY(jint, getExceptionTableLength, (JNIEnv *, jobject, jobject jvmci_method)) 640 ResourceMark rm; 641 methodHandle method = CompilerToVM::asMethod(jvmci_method); 642 return method->exception_table_length(); 643 C2V_END 644 645 C2V_VMENTRY(jlong, getExceptionTableStart, (JNIEnv *, jobject, jobject jvmci_method)) 646 ResourceMark rm; 647 methodHandle method = CompilerToVM::asMethod(jvmci_method); 648 if (method->exception_table_length() == 0) { 649 return 0L; 650 } 651 return (jlong) (address) method->exception_table_start(); 652 C2V_END 653 654 C2V_VMENTRY(jobject, asResolvedJavaMethod, (JNIEnv *, jobject, jobject executable_handle)) 655 oop executable = JNIHandles::resolve(executable_handle); 656 oop mirror = NULL; 657 int slot = 0; 658 659 if (executable->klass() == SystemDictionary::reflect_Constructor_klass()) { 660 mirror = java_lang_reflect_Constructor::clazz(executable); 661 slot = java_lang_reflect_Constructor::slot(executable); 662 } else { 663 assert(executable->klass() == SystemDictionary::reflect_Method_klass(), "wrong type"); 664 mirror = java_lang_reflect_Method::clazz(executable); 665 slot = java_lang_reflect_Method::slot(executable); 666 } 667 Klass* holder = java_lang_Class::as_Klass(mirror); 668 methodHandle method = InstanceKlass::cast(holder)->method_with_idnum(slot); 669 oop result = CompilerToVM::get_jvmci_method(method, CHECK_NULL); 670 return JNIHandles::make_local(THREAD, result); 671 } 672 673 C2V_VMENTRY(jobject, getResolvedJavaMethod, (JNIEnv *, jobject, jobject base, jlong offset)) 674 methodHandle method; 675 oop base_object = JNIHandles::resolve(base); 676 if (base_object == NULL) { 677 method = *((Method**)(offset)); 678 } else if (base_object->is_a(SystemDictionary::ResolvedMethodName_klass())) { 679 method = (Method*) (intptr_t) base_object->long_field(offset); 680 } else if (base_object->is_a(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass())) { 681 method = *((Method**)(HotSpotResolvedJavaMethodImpl::metaspaceMethod(base_object) + offset)); 682 } else { 683 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 684 err_msg("Unexpected type: %s", base_object->klass()->external_name())); 685 } 686 assert (method.is_null() || method->is_method(), "invalid read"); 687 oop result = CompilerToVM::get_jvmci_method(method, CHECK_NULL); 688 return JNIHandles::make_local(THREAD, result); 689 } 690 691 C2V_VMENTRY(jobject, getConstantPool, (JNIEnv *, jobject, jobject object_handle)) 692 constantPoolHandle cp; 693 oop object = JNIHandles::resolve(object_handle); 694 if (object == NULL) { 695 THROW_0(vmSymbols::java_lang_NullPointerException()); 696 } 697 if (object->is_a(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass())) { 698 cp = CompilerToVM::asMethod(object)->constMethod()->constants(); 699 } else if (object->is_a(SystemDictionary::HotSpotResolvedObjectTypeImpl_klass())) { 700 cp = InstanceKlass::cast(CompilerToVM::asKlass(object))->constants(); 701 } else { 702 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 703 err_msg("Unexpected type: %s", object->klass()->external_name())); 704 } 705 assert(!cp.is_null(), "npe"); 706 JavaValue method_result(T_OBJECT); 707 JavaCallArguments args; 708 args.push_long((jlong) (address) cp()); 709 JavaCalls::call_static(&method_result, SystemDictionary::HotSpotConstantPool_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::constantPool_fromMetaspace_signature(), &args, CHECK_NULL); 710 return JNIHandles::make_local(THREAD, (oop)method_result.get_jobject()); 711 } 712 713 C2V_VMENTRY(jobject, getResolvedJavaType, (JNIEnv *, jobject, jobject base, jlong offset, jboolean compressed)) 714 Klass* klass = NULL; 715 oop base_object = JNIHandles::resolve(base); 716 jlong base_address = 0; 717 if (base_object != NULL && offset == oopDesc::klass_offset_in_bytes()) { 718 klass = base_object->klass(); 719 } else if (!compressed) { 720 if (base_object != NULL) { 721 if (base_object->is_a(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass())) { 722 base_address = HotSpotResolvedJavaMethodImpl::metaspaceMethod(base_object); 723 } else if (base_object->is_a(SystemDictionary::HotSpotConstantPool_klass())) { 724 base_address = HotSpotConstantPool::metaspaceConstantPool(base_object); 725 } else if (base_object->is_a(SystemDictionary::HotSpotResolvedObjectTypeImpl_klass())) { 726 base_address = (jlong) CompilerToVM::asKlass(base_object); 727 } else if (base_object->is_a(SystemDictionary::Class_klass())) { 728 base_address = (jlong) (address) base_object; 729 } else { 730 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 731 err_msg("Unexpected arguments: %s " JLONG_FORMAT " %s", base_object->klass()->external_name(), offset, compressed ? "true" : "false")); 732 } 733 } 734 klass = *((Klass**) (intptr_t) (base_address + offset)); 735 } else { 736 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 737 err_msg("Unexpected arguments: %s " JLONG_FORMAT " %s", base_object->klass()->external_name(), offset, compressed ? "true" : "false")); 738 } 739 assert (klass == NULL || klass->is_klass(), "invalid read"); 740 oop result = CompilerToVM::get_jvmci_type(klass, CHECK_NULL); 741 return JNIHandles::make_local(THREAD, result); 742 } 743 744 C2V_VMENTRY(jobject, findUniqueConcreteMethod, (JNIEnv *, jobject, jobject jvmci_type, jobject jvmci_method)) 745 ResourceMark rm; 746 methodHandle method = CompilerToVM::asMethod(jvmci_method); 747 Klass* holder = CompilerToVM::asKlass(jvmci_type); 748 if (holder->is_interface()) { 749 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Interface %s should be handled in Java code", holder->external_name())); 750 } 751 752 methodHandle ucm; 753 { 754 MutexLocker locker(Compile_lock); 755 ucm = Dependencies::find_unique_concrete_method(holder, method()); 756 } 757 oop result = CompilerToVM::get_jvmci_method(ucm, CHECK_NULL); 758 return JNIHandles::make_local(THREAD, result); 759 C2V_END 760 761 C2V_VMENTRY(jobject, getImplementor, (JNIEnv *, jobject, jobject jvmci_type)) 762 InstanceKlass* klass = (InstanceKlass*) CompilerToVM::asKlass(jvmci_type); 763 oop implementor = CompilerToVM::get_jvmci_type(klass->implementor(), CHECK_NULL); 764 return JNIHandles::make_local(THREAD, implementor); 765 C2V_END 766 767 C2V_VMENTRY(jboolean, methodIsIgnoredBySecurityStackWalk,(JNIEnv *, jobject, jobject jvmci_method)) 768 methodHandle method = CompilerToVM::asMethod(jvmci_method); 769 return method->is_ignored_by_security_stack_walk(); 770 C2V_END 771 772 C2V_VMENTRY(jboolean, isCompilable,(JNIEnv *, jobject, jobject jvmci_method)) 773 methodHandle method = CompilerToVM::asMethod(jvmci_method); 774 return !method->is_not_compilable(CompLevel_full_optimization); 775 C2V_END 776 777 C2V_VMENTRY(jboolean, hasNeverInlineDirective,(JNIEnv *, jobject, jobject jvmci_method)) 778 methodHandle method = CompilerToVM::asMethod(jvmci_method); 779 return CompilerOracle::should_not_inline(method) || method->dont_inline(); 780 C2V_END 781 782 C2V_VMENTRY(jboolean, shouldInlineMethod,(JNIEnv *, jobject, jobject jvmci_method)) 783 methodHandle method = CompilerToVM::asMethod(jvmci_method); 784 return CompilerOracle::should_inline(method) || method->force_inline(); 785 C2V_END 786 787 C2V_VMENTRY(jobject, lookupType, (JNIEnv*, jobject, jstring jname, jclass accessing_class, jboolean resolve)) 788 ResourceMark rm; 789 Handle name(THREAD, JNIHandles::resolve(jname)); 790 Symbol* class_name = java_lang_String::as_symbol(name(), CHECK_0); 791 if (java_lang_String::length(name()) <= 1) { 792 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Primitive type %s should be handled in Java code", class_name->as_C_string())); 793 } 794 795 Klass* resolved_klass = NULL; 796 if (JNIHandles::resolve(accessing_class) == NULL) { 797 THROW_0(vmSymbols::java_lang_NullPointerException()); 798 } 799 Klass* accessing_klass = java_lang_Class::as_Klass(JNIHandles::resolve(accessing_class)); 800 Handle class_loader(THREAD, accessing_klass->class_loader()); 801 Handle protection_domain(THREAD, accessing_klass->protection_domain()); 802 803 if (resolve) { 804 resolved_klass = SystemDictionary::resolve_or_null(class_name, class_loader, protection_domain, CHECK_0); 805 } else { 806 if (class_name->byte_at(0) == 'L' && 807 class_name->byte_at(class_name->utf8_length()-1) == ';') { 808 // This is a name from a signature. Strip off the trimmings. 809 // Call recursive to keep scope of strippedsym. 810 TempNewSymbol strippedsym = SymbolTable::new_symbol(class_name->as_utf8()+1, 811 class_name->utf8_length()-2, 812 CHECK_0); 813 resolved_klass = SystemDictionary::find(strippedsym, class_loader, protection_domain, CHECK_0); 814 } else if (FieldType::is_array(class_name)) { 815 FieldArrayInfo fd; 816 // dimension and object_key in FieldArrayInfo are assigned as a side-effect 817 // of this call 818 BasicType t = FieldType::get_array_info(class_name, fd, CHECK_0); 819 if (t == T_OBJECT) { 820 TempNewSymbol strippedsym = SymbolTable::new_symbol(class_name->as_utf8()+1+fd.dimension(), 821 class_name->utf8_length()-2-fd.dimension(), 822 CHECK_0); 823 // naked oop "k" is OK here -- we assign back into it 824 resolved_klass = SystemDictionary::find(strippedsym, 825 class_loader, 826 protection_domain, 827 CHECK_0); 828 if (resolved_klass != NULL) { 829 resolved_klass = resolved_klass->array_klass(fd.dimension(), CHECK_0); 830 } 831 } else { 832 resolved_klass = Universe::typeArrayKlassObj(t); 833 resolved_klass = TypeArrayKlass::cast(resolved_klass)->array_klass(fd.dimension(), CHECK_0); 834 } 835 } 836 } 837 oop result = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL); 838 return JNIHandles::make_local(THREAD, result); 839 C2V_END 840 841 C2V_VMENTRY(jobject, resolveConstantInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 842 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 843 oop result = cp->resolve_constant_at(index, CHECK_NULL); 844 return JNIHandles::make_local(THREAD, result); 845 C2V_END 846 847 C2V_VMENTRY(jobject, resolvePossiblyCachedConstantInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 848 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 849 oop result = cp->resolve_possibly_cached_constant_at(index, CHECK_NULL); 850 return JNIHandles::make_local(THREAD, result); 851 C2V_END 852 853 C2V_VMENTRY(jint, lookupNameAndTypeRefIndexInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 854 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 855 return cp->name_and_type_ref_index_at(index); 856 C2V_END 857 858 C2V_VMENTRY(jobject, lookupNameInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint which)) 859 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 860 Handle sym = java_lang_String::create_from_symbol(cp->name_ref_at(which), CHECK_NULL); 861 return JNIHandles::make_local(THREAD, sym()); 862 C2V_END 863 864 C2V_VMENTRY(jobject, lookupSignatureInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint which)) 865 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 866 Handle sym = java_lang_String::create_from_symbol(cp->signature_ref_at(which), CHECK_NULL); 867 return JNIHandles::make_local(THREAD, sym()); 868 C2V_END 869 870 C2V_VMENTRY(jint, lookupKlassRefIndexInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 871 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 872 return cp->klass_ref_index_at(index); 873 C2V_END 874 875 C2V_VMENTRY(jobject, resolveTypeInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 876 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 877 Klass* resolved_klass = cp->klass_at(index, CHECK_NULL); 878 oop klass = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL); 879 return JNIHandles::make_local(THREAD, klass); 880 C2V_END 881 882 C2V_VMENTRY(jobject, lookupKlassInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode)) 883 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 884 Klass* loading_klass = cp->pool_holder(); 885 bool is_accessible = false; 886 Klass* klass = JVMCIEnv::get_klass_by_index(cp, index, is_accessible, loading_klass); 887 Symbol* symbol = NULL; 888 if (klass == NULL) { 889 symbol = cp->klass_name_at(index); 890 } 891 oop result_oop; 892 if (klass != NULL) { 893 result_oop = CompilerToVM::get_jvmci_type(klass, CHECK_NULL); 894 } else { 895 Handle result = java_lang_String::create_from_symbol(symbol, CHECK_NULL); 896 result_oop = result(); 897 } 898 return JNIHandles::make_local(THREAD, result_oop); 899 C2V_END 900 901 C2V_VMENTRY(jobject, lookupAppendixInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 902 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 903 oop appendix_oop = ConstantPool::appendix_at_if_loaded(cp, index); 904 return JNIHandles::make_local(THREAD, appendix_oop); 905 C2V_END 906 907 C2V_VMENTRY(jobject, lookupMethodInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode)) 908 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 909 InstanceKlass* pool_holder = cp->pool_holder(); 910 Bytecodes::Code bc = (Bytecodes::Code) (((int) opcode) & 0xFF); 911 methodHandle method = JVMCIEnv::get_method_by_index(cp, index, bc, pool_holder); 912 oop result = CompilerToVM::get_jvmci_method(method, CHECK_NULL); 913 return JNIHandles::make_local(THREAD, result); 914 C2V_END 915 916 C2V_VMENTRY(jint, constantPoolRemapInstructionOperandFromCache, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 917 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 918 return cp->remap_instruction_operand_from_cache(index); 919 C2V_END 920 921 C2V_VMENTRY(jobject, resolveFieldInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jobject jvmci_method, jbyte opcode, jintArray info_handle)) 922 ResourceMark rm; 923 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 924 Bytecodes::Code code = (Bytecodes::Code)(((int) opcode) & 0xFF); 925 fieldDescriptor fd; 926 LinkInfo link_info(cp, index, (jvmci_method != NULL) ? CompilerToVM::asMethod(jvmci_method) : NULL, CHECK_0); 927 LinkResolver::resolve_field(fd, link_info, Bytecodes::java_code(code), false, CHECK_0); 928 typeArrayOop info = (typeArrayOop) JNIHandles::resolve(info_handle); 929 if (info == NULL || info->length() != 3) { 930 JVMCI_ERROR_NULL("info must not be null and have a length of 3"); 931 } 932 info->int_at_put(0, fd.access_flags().as_int()); 933 info->int_at_put(1, fd.offset()); 934 info->int_at_put(2, fd.index()); 935 oop field_holder = CompilerToVM::get_jvmci_type(fd.field_holder(), CHECK_NULL); 936 return JNIHandles::make_local(THREAD, field_holder); 937 C2V_END 938 939 C2V_VMENTRY(jint, getVtableIndexForInterfaceMethod, (JNIEnv *, jobject, jobject jvmci_type, jobject jvmci_method)) 940 ResourceMark rm; 941 Klass* klass = CompilerToVM::asKlass(jvmci_type); 942 Method* method = CompilerToVM::asMethod(jvmci_method); 943 if (klass->is_interface()) { 944 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Interface %s should be handled in Java code", klass->external_name())); 945 } 946 if (!method->method_holder()->is_interface()) { 947 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Method %s is not held by an interface, this case should be handled in Java code", method->name_and_sig_as_C_string())); 948 } 949 if (!InstanceKlass::cast(klass)->is_linked()) { 950 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Class %s must be linked", klass->external_name())); 951 } 952 return LinkResolver::vtable_index_of_interface_method(klass, method); 953 C2V_END 954 955 C2V_VMENTRY(jobject, resolveMethod, (JNIEnv *, jobject, jobject receiver_jvmci_type, jobject jvmci_method, jobject caller_jvmci_type)) 956 Klass* recv_klass = CompilerToVM::asKlass(receiver_jvmci_type); 957 Klass* caller_klass = CompilerToVM::asKlass(caller_jvmci_type); 958 methodHandle method = CompilerToVM::asMethod(jvmci_method); 959 960 Klass* resolved = method->method_holder(); 961 Symbol* h_name = method->name(); 962 Symbol* h_signature = method->signature(); 963 964 if (MethodHandles::is_signature_polymorphic_method(method())) { 965 // Signature polymorphic methods are already resolved, JVMCI just returns NULL in this case. 966 return NULL; 967 } 968 969 LinkInfo link_info(resolved, h_name, h_signature, caller_klass); 970 methodHandle m; 971 // Only do exact lookup if receiver klass has been linked. Otherwise, 972 // the vtable has not been setup, and the LinkResolver will fail. 973 if (recv_klass->is_array_klass() || 974 (InstanceKlass::cast(recv_klass)->is_linked() && !recv_klass->is_interface())) { 975 if (resolved->is_interface()) { 976 m = LinkResolver::resolve_interface_call_or_null(recv_klass, link_info); 977 } else { 978 m = LinkResolver::resolve_virtual_call_or_null(recv_klass, link_info); 979 } 980 } 981 982 if (m.is_null()) { 983 // Return NULL if there was a problem with lookup (uninitialized class, etc.) 984 return NULL; 985 } 986 987 oop result = CompilerToVM::get_jvmci_method(m, CHECK_NULL); 988 return JNIHandles::make_local(THREAD, result); 989 C2V_END 990 991 C2V_VMENTRY(jboolean, hasFinalizableSubclass,(JNIEnv *, jobject, jobject jvmci_type)) 992 Klass* klass = CompilerToVM::asKlass(jvmci_type); 993 assert(klass != NULL, "method must not be called for primitive types"); 994 return Dependencies::find_finalizable_subclass(klass) != NULL; 995 C2V_END 996 997 C2V_VMENTRY(jobject, getClassInitializer, (JNIEnv *, jobject, jobject jvmci_type)) 998 InstanceKlass* klass = (InstanceKlass*) CompilerToVM::asKlass(jvmci_type); 999 oop result = CompilerToVM::get_jvmci_method(klass->class_initializer(), CHECK_NULL); 1000 return JNIHandles::make_local(THREAD, result); 1001 C2V_END 1002 1003 C2V_VMENTRY(jlong, getMaxCallTargetOffset, (JNIEnv*, jobject, jlong addr)) 1004 address target_addr = (address) addr; 1005 if (target_addr != 0x0) { 1006 int64_t off_low = (int64_t)target_addr - ((int64_t)CodeCache::low_bound() + sizeof(int)); 1007 int64_t off_high = (int64_t)target_addr - ((int64_t)CodeCache::high_bound() + sizeof(int)); 1008 return MAX2(ABS(off_low), ABS(off_high)); 1009 } 1010 return -1; 1011 C2V_END 1012 1013 C2V_VMENTRY(void, setNotInlineableOrCompileable,(JNIEnv *, jobject, jobject jvmci_method)) 1014 methodHandle method = CompilerToVM::asMethod(jvmci_method); 1015 method->set_not_c1_compilable(); 1016 method->set_not_c2_compilable(); 1017 method->set_dont_inline(true); 1018 C2V_END 1019 1020 C2V_VMENTRY(jint, installCode, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject installed_code, jobject speculation_log)) 1021 ResourceMark rm; 1022 HandleMark hm; 1023 JNIHandleMark jni_hm; 1024 1025 Handle target_handle(THREAD, JNIHandles::resolve(target)); 1026 Handle compiled_code_handle(THREAD, JNIHandles::resolve(compiled_code)); 1027 CodeBlob* cb = NULL; 1028 Handle installed_code_handle(THREAD, JNIHandles::resolve(installed_code)); 1029 Handle speculation_log_handle(THREAD, JNIHandles::resolve(speculation_log)); 1030 1031 JVMCICompiler* compiler = JVMCICompiler::instance(CHECK_JNI_ERR); 1032 1033 TraceTime install_time("installCode", JVMCICompiler::codeInstallTimer()); 1034 bool is_immutable_PIC = HotSpotCompiledCode::isImmutablePIC(compiled_code_handle) > 0; 1035 CodeInstaller installer(is_immutable_PIC); 1036 JVMCIEnv::CodeInstallResult result = installer.install(compiler, target_handle, compiled_code_handle, cb, installed_code_handle, speculation_log_handle, CHECK_0); 1037 1038 if (PrintCodeCacheOnCompilation) { 1039 stringStream s; 1040 // Dump code cache into a buffer before locking the tty, 1041 { 1042 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 1043 CodeCache::print_summary(&s, false); 1044 } 1045 ttyLocker ttyl; 1046 tty->print_raw_cr(s.as_string()); 1047 } 1048 1049 if (result != JVMCIEnv::ok) { 1050 assert(cb == NULL, "should be"); 1051 } else { 1052 if (!installed_code_handle.is_null()) { 1053 assert(installed_code_handle->is_a(InstalledCode::klass()), "wrong type"); 1054 nmethod::invalidate_installed_code(installed_code_handle, CHECK_0); 1055 { 1056 // Ensure that all updates to the InstalledCode fields are consistent. 1057 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag); 1058 InstalledCode::set_address(installed_code_handle, (jlong) cb); 1059 InstalledCode::set_version(installed_code_handle, InstalledCode::version(installed_code_handle) + 1); 1060 if (cb->is_nmethod()) { 1061 InstalledCode::set_entryPoint(installed_code_handle, (jlong) cb->as_nmethod_or_null()->verified_entry_point()); 1062 } else { 1063 InstalledCode::set_entryPoint(installed_code_handle, (jlong) cb->code_begin()); 1064 } 1065 if (installed_code_handle->is_a(HotSpotInstalledCode::klass())) { 1066 HotSpotInstalledCode::set_size(installed_code_handle, cb->size()); 1067 HotSpotInstalledCode::set_codeStart(installed_code_handle, (jlong) cb->code_begin()); 1068 HotSpotInstalledCode::set_codeSize(installed_code_handle, cb->code_size()); 1069 } 1070 } 1071 nmethod* nm = cb->as_nmethod_or_null(); 1072 if (nm != NULL && installed_code_handle->is_scavengable()) { 1073 assert(nm->detect_scavenge_root_oops(), "nm should be scavengable if installed_code is scavengable"); 1074 if (!UseG1GC) { 1075 assert(nm->on_scavenge_root_list(), "nm should be on scavengable list"); 1076 } 1077 } 1078 } 1079 } 1080 return result; 1081 C2V_END 1082 1083 C2V_VMENTRY(jint, getMetadata, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject metadata)) 1084 ResourceMark rm; 1085 HandleMark hm; 1086 1087 Handle target_handle(THREAD, JNIHandles::resolve(target)); 1088 Handle compiled_code_handle(THREAD, JNIHandles::resolve(compiled_code)); 1089 Handle metadata_handle(THREAD, JNIHandles::resolve(metadata)); 1090 1091 CodeMetadata code_metadata; 1092 CodeBlob *cb = NULL; 1093 CodeInstaller installer(true /* immutable PIC compilation */); 1094 1095 JVMCIEnv::CodeInstallResult result = installer.gather_metadata(target_handle, compiled_code_handle, code_metadata, CHECK_0); 1096 if (result != JVMCIEnv::ok) { 1097 return result; 1098 } 1099 1100 if (code_metadata.get_nr_pc_desc() > 0) { 1101 typeArrayHandle pcArrayOop = oopFactory::new_byteArray_handle(sizeof(PcDesc) * code_metadata.get_nr_pc_desc(), CHECK_(JVMCIEnv::cache_full)); 1102 memcpy(pcArrayOop->byte_at_addr(0), code_metadata.get_pc_desc(), sizeof(PcDesc) * code_metadata.get_nr_pc_desc()); 1103 HotSpotMetaData::set_pcDescBytes(metadata_handle, pcArrayOop()); 1104 } 1105 1106 if (code_metadata.get_scopes_size() > 0) { 1107 typeArrayHandle scopesArrayOop = oopFactory::new_byteArray_handle(code_metadata.get_scopes_size(), CHECK_(JVMCIEnv::cache_full)); 1108 memcpy(scopesArrayOop->byte_at_addr(0), code_metadata.get_scopes_desc(), code_metadata.get_scopes_size()); 1109 HotSpotMetaData::set_scopesDescBytes(metadata_handle, scopesArrayOop()); 1110 } 1111 1112 RelocBuffer* reloc_buffer = code_metadata.get_reloc_buffer(); 1113 typeArrayHandle relocArrayOop = oopFactory::new_byteArray_handle((int) reloc_buffer->size(), CHECK_(JVMCIEnv::cache_full)); 1114 if (reloc_buffer->size() > 0) { 1115 memcpy(relocArrayOop->byte_at_addr(0), reloc_buffer->begin(), reloc_buffer->size()); 1116 } 1117 HotSpotMetaData::set_relocBytes(metadata_handle, relocArrayOop()); 1118 1119 const OopMapSet* oopMapSet = installer.oopMapSet(); 1120 { 1121 ResourceMark mark; 1122 ImmutableOopMapBuilder builder(oopMapSet); 1123 int oopmap_size = builder.heap_size(); 1124 typeArrayHandle oopMapArrayHandle = oopFactory::new_byteArray_handle(oopmap_size, CHECK_(JVMCIEnv::cache_full)); 1125 builder.generate_into((address) oopMapArrayHandle->byte_at_addr(0)); 1126 HotSpotMetaData::set_oopMaps(metadata_handle, oopMapArrayHandle()); 1127 } 1128 1129 AOTOopRecorder* recorder = code_metadata.get_oop_recorder(); 1130 1131 int nr_meta_strings = recorder->nr_meta_strings(); 1132 objArrayOop metadataArray = oopFactory::new_objectArray(nr_meta_strings, CHECK_(JVMCIEnv::cache_full)); 1133 objArrayHandle metadataArrayHandle(THREAD, metadataArray); 1134 for (int i = 0; i < nr_meta_strings; ++i) { 1135 const char* element = recorder->meta_element(i); 1136 Handle java_string = java_lang_String::create_from_str(element, CHECK_(JVMCIEnv::cache_full)); 1137 metadataArrayHandle->obj_at_put(i, java_string()); 1138 } 1139 HotSpotMetaData::set_metadata(metadata_handle, metadataArrayHandle()); 1140 1141 ExceptionHandlerTable* handler = code_metadata.get_exception_table(); 1142 int table_size = handler->size_in_bytes(); 1143 typeArrayHandle exceptionArrayOop = oopFactory::new_byteArray_handle(table_size, CHECK_(JVMCIEnv::cache_full)); 1144 1145 if (table_size > 0) { 1146 handler->copy_bytes_to((address) exceptionArrayOop->byte_at_addr(0)); 1147 } 1148 HotSpotMetaData::set_exceptionBytes(metadata_handle, exceptionArrayOop()); 1149 1150 return result; 1151 C2V_END 1152 1153 C2V_VMENTRY(void, resetCompilationStatistics, (JNIEnv *jniEnv, jobject)) 1154 JVMCICompiler* compiler = JVMCICompiler::instance(CHECK); 1155 CompilerStatistics* stats = compiler->stats(); 1156 stats->_standard.reset(); 1157 stats->_osr.reset(); 1158 C2V_END 1159 1160 C2V_VMENTRY(jobject, disassembleCodeBlob, (JNIEnv *jniEnv, jobject, jobject installedCode)) 1161 ResourceMark rm; 1162 HandleMark hm; 1163 1164 if (installedCode == NULL) { 1165 THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(), "installedCode is null"); 1166 } 1167 1168 jlong codeBlob = InstalledCode::address(installedCode); 1169 if (codeBlob == 0L) { 1170 return NULL; 1171 } 1172 1173 CodeBlob* cb = (CodeBlob*) (address) codeBlob; 1174 if (cb == NULL) { 1175 return NULL; 1176 } 1177 1178 // We don't want the stringStream buffer to resize during disassembly as it 1179 // uses scoped resource memory. If a nested function called during disassembly uses 1180 // a ResourceMark and the buffer expands within the scope of the mark, 1181 // the buffer becomes garbage when that scope is exited. Experience shows that 1182 // the disassembled code is typically about 10x the code size so a fixed buffer 1183 // sized to 20x code size plus a fixed amount for header info should be sufficient. 1184 int bufferSize = cb->code_size() * 20 + 1024; 1185 char* buffer = NEW_RESOURCE_ARRAY(char, bufferSize); 1186 stringStream st(buffer, bufferSize); 1187 if (cb->is_nmethod()) { 1188 nmethod* nm = (nmethod*) cb; 1189 if (!nm->is_alive()) { 1190 return NULL; 1191 } 1192 } 1193 Disassembler::decode(cb, &st); 1194 if (st.size() <= 0) { 1195 return NULL; 1196 } 1197 1198 Handle result = java_lang_String::create_from_platform_dependent_str(st.as_string(), CHECK_NULL); 1199 return JNIHandles::make_local(THREAD, result()); 1200 C2V_END 1201 1202 C2V_VMENTRY(jobject, getStackTraceElement, (JNIEnv*, jobject, jobject jvmci_method, int bci)) 1203 ResourceMark rm; 1204 HandleMark hm; 1205 1206 methodHandle method = CompilerToVM::asMethod(jvmci_method); 1207 oop element = java_lang_StackTraceElement::create(method, bci, CHECK_NULL); 1208 return JNIHandles::make_local(THREAD, element); 1209 C2V_END 1210 1211 C2V_VMENTRY(jobject, executeInstalledCode, (JNIEnv*, jobject, jobject args, jobject hotspotInstalledCode)) 1212 ResourceMark rm; 1213 HandleMark hm; 1214 1215 jlong nmethodValue = InstalledCode::address(hotspotInstalledCode); 1216 if (nmethodValue == 0L) { 1217 THROW_NULL(vmSymbols::jdk_vm_ci_code_InvalidInstalledCodeException()); 1218 } 1219 nmethod* nm = (nmethod*) (address) nmethodValue; 1220 methodHandle mh = nm->method(); 1221 Symbol* signature = mh->signature(); 1222 JavaCallArguments jca(mh->size_of_parameters()); 1223 1224 JavaArgumentUnboxer jap(signature, &jca, (arrayOop) JNIHandles::resolve(args), mh->is_static()); 1225 JavaValue result(jap.get_ret_type()); 1226 jca.set_alternative_target(nm); 1227 JavaCalls::call(&result, mh, &jca, CHECK_NULL); 1228 1229 if (jap.get_ret_type() == T_VOID) { 1230 return NULL; 1231 } else if (jap.get_ret_type() == T_OBJECT || jap.get_ret_type() == T_ARRAY) { 1232 return JNIHandles::make_local(THREAD, (oop) result.get_jobject()); 1233 } else { 1234 jvalue *value = (jvalue *) result.get_value_addr(); 1235 // Narrow the value down if required (Important on big endian machines) 1236 switch (jap.get_ret_type()) { 1237 case T_BOOLEAN: 1238 value->z = (jboolean) value->i; 1239 break; 1240 case T_BYTE: 1241 value->b = (jbyte) value->i; 1242 break; 1243 case T_CHAR: 1244 value->c = (jchar) value->i; 1245 break; 1246 case T_SHORT: 1247 value->s = (jshort) value->i; 1248 break; 1249 default: 1250 break; 1251 } 1252 oop o = java_lang_boxing_object::create(jap.get_ret_type(), value, CHECK_NULL); 1253 return JNIHandles::make_local(THREAD, o); 1254 } 1255 C2V_END 1256 1257 C2V_VMENTRY(jlongArray, getLineNumberTable, (JNIEnv *, jobject, jobject jvmci_method)) 1258 Method* method = CompilerToVM::asMethod(jvmci_method); 1259 if (!method->has_linenumber_table()) { 1260 return NULL; 1261 } 1262 u2 num_entries = 0; 1263 CompressedLineNumberReadStream streamForSize(method->compressed_linenumber_table()); 1264 while (streamForSize.read_pair()) { 1265 num_entries++; 1266 } 1267 1268 CompressedLineNumberReadStream stream(method->compressed_linenumber_table()); 1269 typeArrayOop result = oopFactory::new_longArray(2 * num_entries, CHECK_NULL); 1270 1271 int i = 0; 1272 jlong value; 1273 while (stream.read_pair()) { 1274 value = ((long) stream.bci()); 1275 result->long_at_put(i, value); 1276 value = ((long) stream.line()); 1277 result->long_at_put(i + 1, value); 1278 i += 2; 1279 } 1280 1281 return (jlongArray) JNIHandles::make_local(THREAD, result); 1282 C2V_END 1283 1284 C2V_VMENTRY(jlong, getLocalVariableTableStart, (JNIEnv *, jobject, jobject jvmci_method)) 1285 ResourceMark rm; 1286 Method* method = CompilerToVM::asMethod(jvmci_method); 1287 if (!method->has_localvariable_table()) { 1288 return 0; 1289 } 1290 return (jlong) (address) method->localvariable_table_start(); 1291 C2V_END 1292 1293 C2V_VMENTRY(jint, getLocalVariableTableLength, (JNIEnv *, jobject, jobject jvmci_method)) 1294 ResourceMark rm; 1295 Method* method = CompilerToVM::asMethod(jvmci_method); 1296 return method->localvariable_table_length(); 1297 C2V_END 1298 1299 C2V_VMENTRY(void, reprofile, (JNIEnv*, jobject, jobject jvmci_method)) 1300 Method* method = CompilerToVM::asMethod(jvmci_method); 1301 MethodCounters* mcs = method->method_counters(); 1302 if (mcs != NULL) { 1303 mcs->clear_counters(); 1304 } 1305 NOT_PRODUCT(method->set_compiled_invocation_count(0)); 1306 1307 CompiledMethod* code = method->code(); 1308 if (code != NULL) { 1309 code->make_not_entrant(); 1310 } 1311 1312 MethodData* method_data = method->method_data(); 1313 if (method_data == NULL) { 1314 ClassLoaderData* loader_data = method->method_holder()->class_loader_data(); 1315 method_data = MethodData::allocate(loader_data, method, CHECK); 1316 method->set_method_data(method_data); 1317 } else { 1318 method_data->initialize(); 1319 } 1320 C2V_END 1321 1322 1323 C2V_VMENTRY(void, invalidateInstalledCode, (JNIEnv*, jobject, jobject installed_code)) 1324 Handle installed_code_handle(THREAD, JNIHandles::resolve(installed_code)); 1325 nmethod::invalidate_installed_code(installed_code_handle, CHECK); 1326 C2V_END 1327 1328 C2V_VMENTRY(jlongArray, collectCounters, (JNIEnv*, jobject)) 1329 typeArrayOop arrayOop = oopFactory::new_longArray(JVMCICounterSize, CHECK_NULL); 1330 JavaThread::collect_counters(arrayOop); 1331 return (jlongArray) JNIHandles::make_local(THREAD, arrayOop); 1332 C2V_END 1333 1334 C2V_VMENTRY(int, allocateCompileId, (JNIEnv*, jobject, jobject jvmci_method, int entry_bci)) 1335 HandleMark hm; 1336 ResourceMark rm; 1337 if (JNIHandles::resolve(jvmci_method) == NULL) { 1338 THROW_0(vmSymbols::java_lang_NullPointerException()); 1339 } 1340 Method* method = CompilerToVM::asMethod(jvmci_method); 1341 if (entry_bci >= method->code_size() || entry_bci < -1) { 1342 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), err_msg("Unexpected bci %d", entry_bci)); 1343 } 1344 return CompileBroker::assign_compile_id_unlocked(THREAD, method, entry_bci); 1345 C2V_END 1346 1347 1348 C2V_VMENTRY(jboolean, isMature, (JNIEnv*, jobject, jlong metaspace_method_data)) 1349 MethodData* mdo = CompilerToVM::asMethodData(metaspace_method_data); 1350 return mdo != NULL && mdo->is_mature(); 1351 C2V_END 1352 1353 C2V_VMENTRY(jboolean, hasCompiledCodeForOSR, (JNIEnv*, jobject, jobject jvmci_method, int entry_bci, int comp_level)) 1354 Method* method = CompilerToVM::asMethod(jvmci_method); 1355 return method->lookup_osr_nmethod_for(entry_bci, comp_level, true) != NULL; 1356 C2V_END 1357 1358 C2V_VMENTRY(jobject, getSymbol, (JNIEnv*, jobject, jlong symbol)) 1359 Handle sym = java_lang_String::create_from_symbol((Symbol*)(address)symbol, CHECK_NULL); 1360 return JNIHandles::make_local(THREAD, sym()); 1361 C2V_END 1362 1363 bool matches(jobjectArray methods, Method* method) { 1364 objArrayOop methods_oop = (objArrayOop) JNIHandles::resolve(methods); 1365 1366 for (int i = 0; i < methods_oop->length(); i++) { 1367 oop resolved = methods_oop->obj_at(i); 1368 if (resolved->is_a(HotSpotResolvedJavaMethodImpl::klass()) && CompilerToVM::asMethod(resolved) == method) { 1369 return true; 1370 } 1371 } 1372 return false; 1373 } 1374 1375 C2V_VMENTRY(jobject, getNextStackFrame, (JNIEnv*, jobject compilerToVM, jobject hs_frame, jobjectArray methods, jint initialSkip)) 1376 ResourceMark rm; 1377 1378 if (!thread->has_last_Java_frame()) return NULL; 1379 Handle result = HotSpotStackFrameReference::klass()->allocate_instance_handle(thread); 1380 HotSpotStackFrameReference::klass()->initialize(thread); 1381 1382 StackFrameStream fst(thread); 1383 if (hs_frame != NULL) { 1384 // look for the correct stack frame if one is given 1385 intptr_t* stack_pointer = (intptr_t*) HotSpotStackFrameReference::stackPointer(hs_frame); 1386 while (fst.current()->sp() != stack_pointer && !fst.is_done()) { 1387 fst.next(); 1388 } 1389 if (fst.current()->sp() != stack_pointer) { 1390 THROW_MSG_NULL(vmSymbols::java_lang_IllegalStateException(), "stack frame not found") 1391 } 1392 } 1393 1394 int frame_number = 0; 1395 vframe* vf = vframe::new_vframe(fst.current(), fst.register_map(), thread); 1396 if (hs_frame != NULL) { 1397 // look for the correct vframe within the stack frame if one is given 1398 int last_frame_number = HotSpotStackFrameReference::frameNumber(hs_frame); 1399 while (frame_number < last_frame_number) { 1400 if (vf->is_top()) { 1401 THROW_MSG_NULL(vmSymbols::java_lang_IllegalStateException(), "invalid frame number") 1402 } 1403 vf = vf->sender(); 1404 frame_number ++; 1405 } 1406 // move one frame forward 1407 if (vf->is_top()) { 1408 if (fst.is_done()) { 1409 return NULL; 1410 } 1411 fst.next(); 1412 vf = vframe::new_vframe(fst.current(), fst.register_map(), thread); 1413 frame_number = 0; 1414 } else { 1415 vf = vf->sender(); 1416 frame_number++; 1417 } 1418 } 1419 1420 while (true) { 1421 // look for the given method 1422 while (true) { 1423 StackValueCollection* locals = NULL; 1424 if (vf->is_compiled_frame()) { 1425 // compiled method frame 1426 compiledVFrame* cvf = compiledVFrame::cast(vf); 1427 if (methods == NULL || matches(methods, cvf->method())) { 1428 if (initialSkip > 0) { 1429 initialSkip --; 1430 } else { 1431 ScopeDesc* scope = cvf->scope(); 1432 // native wrapper do not have a scope 1433 if (scope != NULL && scope->objects() != NULL) { 1434 bool realloc_failures = Deoptimization::realloc_objects(thread, fst.current(), scope->objects(), THREAD); 1435 Deoptimization::reassign_fields(fst.current(), fst.register_map(), scope->objects(), realloc_failures, false); 1436 1437 GrowableArray<ScopeValue*>* local_values = scope->locals(); 1438 typeArrayOop array_oop = oopFactory::new_boolArray(local_values->length(), thread); 1439 typeArrayHandle array(THREAD, array_oop); 1440 for (int i = 0; i < local_values->length(); i++) { 1441 ScopeValue* value = local_values->at(i); 1442 if (value->is_object()) { 1443 array->bool_at_put(i, true); 1444 } 1445 } 1446 HotSpotStackFrameReference::set_localIsVirtual(result, array()); 1447 } else { 1448 HotSpotStackFrameReference::set_localIsVirtual(result, NULL); 1449 } 1450 1451 locals = cvf->locals(); 1452 HotSpotStackFrameReference::set_bci(result, cvf->bci()); 1453 oop method = CompilerToVM::get_jvmci_method(cvf->method(), CHECK_NULL); 1454 HotSpotStackFrameReference::set_method(result, method); 1455 } 1456 } 1457 } else if (vf->is_interpreted_frame()) { 1458 // interpreted method frame 1459 interpretedVFrame* ivf = interpretedVFrame::cast(vf); 1460 if (methods == NULL || matches(methods, ivf->method())) { 1461 if (initialSkip > 0) { 1462 initialSkip --; 1463 } else { 1464 locals = ivf->locals(); 1465 HotSpotStackFrameReference::set_bci(result, ivf->bci()); 1466 oop method = CompilerToVM::get_jvmci_method(ivf->method(), CHECK_NULL); 1467 HotSpotStackFrameReference::set_method(result, method); 1468 HotSpotStackFrameReference::set_localIsVirtual(result, NULL); 1469 } 1470 } 1471 } 1472 1473 // locals != NULL means that we found a matching frame and result is already partially initialized 1474 if (locals != NULL) { 1475 HotSpotStackFrameReference::set_compilerToVM(result, JNIHandles::resolve(compilerToVM)); 1476 HotSpotStackFrameReference::set_stackPointer(result, (jlong) fst.current()->sp()); 1477 HotSpotStackFrameReference::set_frameNumber(result, frame_number); 1478 1479 // initialize the locals array 1480 objArrayOop array_oop = oopFactory::new_objectArray(locals->size(), CHECK_NULL); 1481 objArrayHandle array(THREAD, array_oop); 1482 for (int i = 0; i < locals->size(); i++) { 1483 StackValue* var = locals->at(i); 1484 if (var->type() == T_OBJECT) { 1485 array->obj_at_put(i, locals->at(i)->get_obj()()); 1486 } 1487 } 1488 HotSpotStackFrameReference::set_locals(result, array()); 1489 1490 return JNIHandles::make_local(thread, result()); 1491 } 1492 1493 if (vf->is_top()) { 1494 break; 1495 } 1496 frame_number++; 1497 vf = vf->sender(); 1498 } // end of vframe loop 1499 1500 if (fst.is_done()) { 1501 break; 1502 } 1503 fst.next(); 1504 vf = vframe::new_vframe(fst.current(), fst.register_map(), thread); 1505 frame_number = 0; 1506 } // end of frame loop 1507 1508 // the end was reached without finding a matching method 1509 return NULL; 1510 C2V_END 1511 1512 C2V_VMENTRY(void, resolveInvokeDynamicInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 1513 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 1514 CallInfo callInfo; 1515 LinkResolver::resolve_invoke(callInfo, Handle(), cp, index, Bytecodes::_invokedynamic, CHECK); 1516 ConstantPoolCacheEntry* cp_cache_entry = cp->invokedynamic_cp_cache_entry_at(index); 1517 cp_cache_entry->set_dynamic_call(cp, callInfo); 1518 C2V_END 1519 1520 C2V_VMENTRY(void, resolveInvokeHandleInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 1521 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 1522 Klass* holder = cp->klass_ref_at(index, CHECK); 1523 Symbol* name = cp->name_ref_at(index); 1524 if (MethodHandles::is_signature_polymorphic_name(holder, name)) { 1525 CallInfo callInfo; 1526 LinkResolver::resolve_invoke(callInfo, Handle(), cp, index, Bytecodes::_invokehandle, CHECK); 1527 ConstantPoolCacheEntry* cp_cache_entry = cp->cache()->entry_at(cp->decode_cpcache_index(index)); 1528 cp_cache_entry->set_method_handle(cp, callInfo); 1529 } 1530 C2V_END 1531 1532 C2V_VMENTRY(jobject, getSignaturePolymorphicHolders, (JNIEnv*, jobject)) 1533 objArrayHandle holders = oopFactory::new_objArray_handle(SystemDictionary::String_klass(), 2, CHECK_NULL); 1534 Handle mh = java_lang_String::create_from_str("Ljava/lang/invoke/MethodHandle;", CHECK_NULL); 1535 Handle vh = java_lang_String::create_from_str("Ljava/lang/invoke/VarHandle;", CHECK_NULL); 1536 holders->obj_at_put(0, mh()); 1537 holders->obj_at_put(1, vh()); 1538 return JNIHandles::make_local(THREAD, holders()); 1539 C2V_END 1540 1541 C2V_VMENTRY(jboolean, shouldDebugNonSafepoints, (JNIEnv*, jobject)) 1542 //see compute_recording_non_safepoints in debugInfroRec.cpp 1543 if (JvmtiExport::should_post_compiled_method_load() && FLAG_IS_DEFAULT(DebugNonSafepoints)) { 1544 return true; 1545 } 1546 return DebugNonSafepoints; 1547 C2V_END 1548 1549 // public native void materializeVirtualObjects(HotSpotStackFrameReference stackFrame, boolean invalidate); 1550 C2V_VMENTRY(void, materializeVirtualObjects, (JNIEnv*, jobject, jobject hs_frame, bool invalidate)) 1551 ResourceMark rm; 1552 1553 if (hs_frame == NULL) { 1554 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "stack frame is null") 1555 } 1556 1557 HotSpotStackFrameReference::klass()->initialize(thread); 1558 1559 // look for the given stack frame 1560 StackFrameStream fst(thread); 1561 intptr_t* stack_pointer = (intptr_t*) HotSpotStackFrameReference::stackPointer(hs_frame); 1562 while (fst.current()->sp() != stack_pointer && !fst.is_done()) { 1563 fst.next(); 1564 } 1565 if (fst.current()->sp() != stack_pointer) { 1566 THROW_MSG(vmSymbols::java_lang_IllegalStateException(), "stack frame not found") 1567 } 1568 1569 if (invalidate) { 1570 if (!fst.current()->is_compiled_frame()) { 1571 THROW_MSG(vmSymbols::java_lang_IllegalStateException(), "compiled stack frame expected") 1572 } 1573 assert(fst.current()->cb()->is_nmethod(), "nmethod expected"); 1574 ((nmethod*) fst.current()->cb())->make_not_entrant(); 1575 } 1576 Deoptimization::deoptimize(thread, *fst.current(), fst.register_map(), Deoptimization::Reason_none); 1577 // look for the frame again as it has been updated by deopt (pc, deopt state...) 1578 StackFrameStream fstAfterDeopt(thread); 1579 while (fstAfterDeopt.current()->sp() != stack_pointer && !fstAfterDeopt.is_done()) { 1580 fstAfterDeopt.next(); 1581 } 1582 if (fstAfterDeopt.current()->sp() != stack_pointer) { 1583 THROW_MSG(vmSymbols::java_lang_IllegalStateException(), "stack frame not found after deopt") 1584 } 1585 1586 vframe* vf = vframe::new_vframe(fstAfterDeopt.current(), fstAfterDeopt.register_map(), thread); 1587 if (!vf->is_compiled_frame()) { 1588 THROW_MSG(vmSymbols::java_lang_IllegalStateException(), "compiled stack frame expected") 1589 } 1590 1591 GrowableArray<compiledVFrame*>* virtualFrames = new GrowableArray<compiledVFrame*>(10); 1592 while (true) { 1593 assert(vf->is_compiled_frame(), "Wrong frame type"); 1594 virtualFrames->push(compiledVFrame::cast(vf)); 1595 if (vf->is_top()) { 1596 break; 1597 } 1598 vf = vf->sender(); 1599 } 1600 1601 int last_frame_number = HotSpotStackFrameReference::frameNumber(hs_frame); 1602 if (last_frame_number >= virtualFrames->length()) { 1603 THROW_MSG(vmSymbols::java_lang_IllegalStateException(), "invalid frame number") 1604 } 1605 1606 // Reallocate the non-escaping objects and restore their fields. 1607 assert (virtualFrames->at(last_frame_number)->scope() != NULL,"invalid scope"); 1608 GrowableArray<ScopeValue*>* objects = virtualFrames->at(last_frame_number)->scope()->objects(); 1609 1610 if (objects == NULL) { 1611 // no objects to materialize 1612 return; 1613 } 1614 1615 bool realloc_failures = Deoptimization::realloc_objects(thread, fstAfterDeopt.current(), objects, THREAD); 1616 Deoptimization::reassign_fields(fstAfterDeopt.current(), fstAfterDeopt.register_map(), objects, realloc_failures, false); 1617 1618 for (int frame_index = 0; frame_index < virtualFrames->length(); frame_index++) { 1619 compiledVFrame* cvf = virtualFrames->at(frame_index); 1620 1621 GrowableArray<ScopeValue*>* scopeLocals = cvf->scope()->locals(); 1622 StackValueCollection* locals = cvf->locals(); 1623 1624 if (locals != NULL) { 1625 for (int i2 = 0; i2 < locals->size(); i2++) { 1626 StackValue* var = locals->at(i2); 1627 if (var->type() == T_OBJECT && scopeLocals->at(i2)->is_object()) { 1628 jvalue val; 1629 val.l = (jobject) locals->at(i2)->get_obj()(); 1630 cvf->update_local(T_OBJECT, i2, val); 1631 } 1632 } 1633 } 1634 } 1635 1636 // all locals are materialized by now 1637 HotSpotStackFrameReference::set_localIsVirtual(hs_frame, NULL); 1638 1639 // update the locals array 1640 objArrayHandle array(THREAD, HotSpotStackFrameReference::locals(hs_frame)); 1641 StackValueCollection* locals = virtualFrames->at(last_frame_number)->locals(); 1642 for (int i = 0; i < locals->size(); i++) { 1643 StackValue* var = locals->at(i); 1644 if (var->type() == T_OBJECT) { 1645 array->obj_at_put(i, locals->at(i)->get_obj()()); 1646 } 1647 } 1648 C2V_END 1649 1650 C2V_VMENTRY(void, writeDebugOutput, (JNIEnv*, jobject, jbyteArray bytes, jint offset, jint length)) 1651 if (bytes == NULL) { 1652 THROW(vmSymbols::java_lang_NullPointerException()); 1653 } 1654 typeArrayOop array = (typeArrayOop) JNIHandles::resolve(bytes); 1655 1656 // Check if offset and length are non negative. 1657 if (offset < 0 || length < 0) { 1658 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); 1659 } 1660 // Check if the range is valid. 1661 if ((((unsigned int) length + (unsigned int) offset) > (unsigned int) array->length())) { 1662 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); 1663 } 1664 while (length > 0) { 1665 jbyte* start = array->byte_at_addr(offset); 1666 tty->write((char*) start, MIN2(length, O_BUFLEN)); 1667 length -= O_BUFLEN; 1668 offset += O_BUFLEN; 1669 } 1670 C2V_END 1671 1672 C2V_VMENTRY(void, flushDebugOutput, (JNIEnv*, jobject)) 1673 tty->flush(); 1674 C2V_END 1675 1676 C2V_VMENTRY(int, methodDataProfileDataSize, (JNIEnv*, jobject, jlong metaspace_method_data, jint position)) 1677 ResourceMark rm; 1678 MethodData* mdo = CompilerToVM::asMethodData(metaspace_method_data); 1679 ProfileData* profile_data = mdo->data_at(position); 1680 if (mdo->is_valid(profile_data)) { 1681 return profile_data->size_in_bytes(); 1682 } 1683 DataLayout* data = mdo->extra_data_base(); 1684 DataLayout* end = mdo->extra_data_limit(); 1685 for (;; data = mdo->next_extra(data)) { 1686 assert(data < end, "moved past end of extra data"); 1687 profile_data = data->data_in(); 1688 if (mdo->dp_to_di(profile_data->dp()) == position) { 1689 return profile_data->size_in_bytes(); 1690 } 1691 } 1692 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), err_msg("Invalid profile data position %d", position)); 1693 C2V_END 1694 1695 C2V_VMENTRY(jlong, getFingerprint, (JNIEnv*, jobject, jlong metaspace_klass)) 1696 Klass *k = CompilerToVM::asKlass(metaspace_klass); 1697 if (k->is_instance_klass()) { 1698 return InstanceKlass::cast(k)->get_stored_fingerprint(); 1699 } else { 1700 return 0; 1701 } 1702 C2V_END 1703 1704 C2V_VMENTRY(int, interpreterFrameSize, (JNIEnv*, jobject, jobject bytecode_frame_handle)) 1705 if (bytecode_frame_handle == NULL) { 1706 THROW_0(vmSymbols::java_lang_NullPointerException()); 1707 } 1708 1709 oop top_bytecode_frame = JNIHandles::resolve_non_null(bytecode_frame_handle); 1710 oop bytecode_frame = top_bytecode_frame; 1711 int size = 0; 1712 int callee_parameters = 0; 1713 int callee_locals = 0; 1714 Method* method = getMethodFromHotSpotMethod(BytecodePosition::method(bytecode_frame)); 1715 int extra_args = method->max_stack() - BytecodeFrame::numStack(bytecode_frame); 1716 1717 while (bytecode_frame != NULL) { 1718 int locks = BytecodeFrame::numLocks(bytecode_frame); 1719 int temps = BytecodeFrame::numStack(bytecode_frame); 1720 bool is_top_frame = (bytecode_frame == top_bytecode_frame); 1721 Method* method = getMethodFromHotSpotMethod(BytecodePosition::method(bytecode_frame)); 1722 1723 int frame_size = BytesPerWord * Interpreter::size_activation(method->max_stack(), 1724 temps + callee_parameters, 1725 extra_args, 1726 locks, 1727 callee_parameters, 1728 callee_locals, 1729 is_top_frame); 1730 size += frame_size; 1731 1732 callee_parameters = method->size_of_parameters(); 1733 callee_locals = method->max_locals(); 1734 extra_args = 0; 1735 bytecode_frame = BytecodePosition::caller(bytecode_frame); 1736 } 1737 return size + Deoptimization::last_frame_adjust(0, callee_locals) * BytesPerWord; 1738 C2V_END 1739 1740 C2V_VMENTRY(void, compileToBytecode, (JNIEnv*, jobject, jobject lambda_form_handle)) 1741 Handle lambda_form(THREAD, JNIHandles::resolve_non_null(lambda_form_handle)); 1742 if (lambda_form->is_a(SystemDictionary::LambdaForm_klass())) { 1743 TempNewSymbol compileToBytecode = SymbolTable::new_symbol("compileToBytecode", CHECK); 1744 JavaValue result(T_VOID); 1745 JavaCalls::call_special(&result, lambda_form, SystemDictionary::LambdaForm_klass(), compileToBytecode, vmSymbols::void_method_signature(), CHECK); 1746 } else { 1747 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 1748 err_msg("Unexpected type: %s", lambda_form->klass()->external_name())); 1749 } 1750 C2V_END 1751 1752 #define CC (char*) /*cast a literal from (const char*)*/ 1753 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &(c2v_ ## f)) 1754 1755 #define STRING "Ljava/lang/String;" 1756 #define OBJECT "Ljava/lang/Object;" 1757 #define CLASS "Ljava/lang/Class;" 1758 #define EXECUTABLE "Ljava/lang/reflect/Executable;" 1759 #define STACK_TRACE_ELEMENT "Ljava/lang/StackTraceElement;" 1760 #define INSTALLED_CODE "Ljdk/vm/ci/code/InstalledCode;" 1761 #define TARGET_DESCRIPTION "Ljdk/vm/ci/code/TargetDescription;" 1762 #define BYTECODE_FRAME "Ljdk/vm/ci/code/BytecodeFrame;" 1763 #define RESOLVED_METHOD "Ljdk/vm/ci/meta/ResolvedJavaMethod;" 1764 #define HS_RESOLVED_METHOD "Ljdk/vm/ci/hotspot/HotSpotResolvedJavaMethodImpl;" 1765 #define HS_RESOLVED_KLASS "Ljdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl;" 1766 #define HS_CONSTANT_POOL "Ljdk/vm/ci/hotspot/HotSpotConstantPool;" 1767 #define HS_COMPILED_CODE "Ljdk/vm/ci/hotspot/HotSpotCompiledCode;" 1768 #define HS_CONFIG "Ljdk/vm/ci/hotspot/HotSpotVMConfig;" 1769 #define HS_METADATA "Ljdk/vm/ci/hotspot/HotSpotMetaData;" 1770 #define HS_STACK_FRAME_REF "Ljdk/vm/ci/hotspot/HotSpotStackFrameReference;" 1771 #define HS_SPECULATION_LOG "Ljdk/vm/ci/hotspot/HotSpotSpeculationLog;" 1772 #define METASPACE_METHOD_DATA "J" 1773 1774 JNINativeMethod CompilerToVM::methods[] = { 1775 {CC "getBytecode", CC "(" HS_RESOLVED_METHOD ")[B", FN_PTR(getBytecode)}, 1776 {CC "getExceptionTableStart", CC "(" HS_RESOLVED_METHOD ")J", FN_PTR(getExceptionTableStart)}, 1777 {CC "getExceptionTableLength", CC "(" HS_RESOLVED_METHOD ")I", FN_PTR(getExceptionTableLength)}, 1778 {CC "findUniqueConcreteMethod", CC "(" HS_RESOLVED_KLASS HS_RESOLVED_METHOD ")" HS_RESOLVED_METHOD, FN_PTR(findUniqueConcreteMethod)}, 1779 {CC "getImplementor", CC "(" HS_RESOLVED_KLASS ")" HS_RESOLVED_KLASS, FN_PTR(getImplementor)}, 1780 {CC "getStackTraceElement", CC "(" HS_RESOLVED_METHOD "I)" STACK_TRACE_ELEMENT, FN_PTR(getStackTraceElement)}, 1781 {CC "methodIsIgnoredBySecurityStackWalk", CC "(" HS_RESOLVED_METHOD ")Z", FN_PTR(methodIsIgnoredBySecurityStackWalk)}, 1782 {CC "setNotInlineableOrCompileable", CC "(" HS_RESOLVED_METHOD ")V", FN_PTR(setNotInlineableOrCompileable)}, 1783 {CC "isCompilable", CC "(" HS_RESOLVED_METHOD ")Z", FN_PTR(isCompilable)}, 1784 {CC "hasNeverInlineDirective", CC "(" HS_RESOLVED_METHOD ")Z", FN_PTR(hasNeverInlineDirective)}, 1785 {CC "shouldInlineMethod", CC "(" HS_RESOLVED_METHOD ")Z", FN_PTR(shouldInlineMethod)}, 1786 {CC "lookupType", CC "(" STRING CLASS "Z)" HS_RESOLVED_KLASS, FN_PTR(lookupType)}, 1787 {CC "lookupNameInPool", CC "(" HS_CONSTANT_POOL "I)" STRING, FN_PTR(lookupNameInPool)}, 1788 {CC "lookupNameAndTypeRefIndexInPool", CC "(" HS_CONSTANT_POOL "I)I", FN_PTR(lookupNameAndTypeRefIndexInPool)}, 1789 {CC "lookupSignatureInPool", CC "(" HS_CONSTANT_POOL "I)" STRING, FN_PTR(lookupSignatureInPool)}, 1790 {CC "lookupKlassRefIndexInPool", CC "(" HS_CONSTANT_POOL "I)I", FN_PTR(lookupKlassRefIndexInPool)}, 1791 {CC "lookupKlassInPool", CC "(" HS_CONSTANT_POOL "I)Ljava/lang/Object;", FN_PTR(lookupKlassInPool)}, 1792 {CC "lookupAppendixInPool", CC "(" HS_CONSTANT_POOL "I)" OBJECT, FN_PTR(lookupAppendixInPool)}, 1793 {CC "lookupMethodInPool", CC "(" HS_CONSTANT_POOL "IB)" HS_RESOLVED_METHOD, FN_PTR(lookupMethodInPool)}, 1794 {CC "constantPoolRemapInstructionOperandFromCache", CC "(" HS_CONSTANT_POOL "I)I", FN_PTR(constantPoolRemapInstructionOperandFromCache)}, 1795 {CC "resolveConstantInPool", CC "(" HS_CONSTANT_POOL "I)" OBJECT, FN_PTR(resolveConstantInPool)}, 1796 {CC "resolvePossiblyCachedConstantInPool", CC "(" HS_CONSTANT_POOL "I)" OBJECT, FN_PTR(resolvePossiblyCachedConstantInPool)}, 1797 {CC "resolveTypeInPool", CC "(" HS_CONSTANT_POOL "I)" HS_RESOLVED_KLASS, FN_PTR(resolveTypeInPool)}, 1798 {CC "resolveFieldInPool", CC "(" HS_CONSTANT_POOL "I" HS_RESOLVED_METHOD "B[I)" HS_RESOLVED_KLASS, FN_PTR(resolveFieldInPool)}, 1799 {CC "resolveInvokeDynamicInPool", CC "(" HS_CONSTANT_POOL "I)V", FN_PTR(resolveInvokeDynamicInPool)}, 1800 {CC "resolveInvokeHandleInPool", CC "(" HS_CONSTANT_POOL "I)V", FN_PTR(resolveInvokeHandleInPool)}, 1801 {CC "resolveMethod", CC "(" HS_RESOLVED_KLASS HS_RESOLVED_METHOD HS_RESOLVED_KLASS ")" HS_RESOLVED_METHOD, FN_PTR(resolveMethod)}, 1802 {CC "getSignaturePolymorphicHolders", CC "()[" STRING, FN_PTR(getSignaturePolymorphicHolders)}, 1803 {CC "getVtableIndexForInterfaceMethod", CC "(" HS_RESOLVED_KLASS HS_RESOLVED_METHOD ")I", FN_PTR(getVtableIndexForInterfaceMethod)}, 1804 {CC "getClassInitializer", CC "(" HS_RESOLVED_KLASS ")" HS_RESOLVED_METHOD, FN_PTR(getClassInitializer)}, 1805 {CC "hasFinalizableSubclass", CC "(" HS_RESOLVED_KLASS ")Z", FN_PTR(hasFinalizableSubclass)}, 1806 {CC "getMaxCallTargetOffset", CC "(J)J", FN_PTR(getMaxCallTargetOffset)}, 1807 {CC "asResolvedJavaMethod", CC "(" EXECUTABLE ")" HS_RESOLVED_METHOD, FN_PTR(asResolvedJavaMethod)}, 1808 {CC "getResolvedJavaMethod", CC "(Ljava/lang/Object;J)" HS_RESOLVED_METHOD, FN_PTR(getResolvedJavaMethod)}, 1809 {CC "getConstantPool", CC "(Ljava/lang/Object;)" HS_CONSTANT_POOL, FN_PTR(getConstantPool)}, 1810 {CC "getResolvedJavaType", CC "(Ljava/lang/Object;JZ)" HS_RESOLVED_KLASS, FN_PTR(getResolvedJavaType)}, 1811 {CC "readConfiguration", CC "()[" OBJECT, FN_PTR(readConfiguration)}, 1812 {CC "installCode", CC "(" TARGET_DESCRIPTION HS_COMPILED_CODE INSTALLED_CODE HS_SPECULATION_LOG ")I", FN_PTR(installCode)}, 1813 {CC "getMetadata", CC "(" TARGET_DESCRIPTION HS_COMPILED_CODE HS_METADATA ")I", FN_PTR(getMetadata)}, 1814 {CC "resetCompilationStatistics", CC "()V", FN_PTR(resetCompilationStatistics)}, 1815 {CC "disassembleCodeBlob", CC "(" INSTALLED_CODE ")" STRING, FN_PTR(disassembleCodeBlob)}, 1816 {CC "executeInstalledCode", CC "([" OBJECT INSTALLED_CODE ")" OBJECT, FN_PTR(executeInstalledCode)}, 1817 {CC "getLineNumberTable", CC "(" HS_RESOLVED_METHOD ")[J", FN_PTR(getLineNumberTable)}, 1818 {CC "getLocalVariableTableStart", CC "(" HS_RESOLVED_METHOD ")J", FN_PTR(getLocalVariableTableStart)}, 1819 {CC "getLocalVariableTableLength", CC "(" HS_RESOLVED_METHOD ")I", FN_PTR(getLocalVariableTableLength)}, 1820 {CC "reprofile", CC "(" HS_RESOLVED_METHOD ")V", FN_PTR(reprofile)}, 1821 {CC "invalidateInstalledCode", CC "(" INSTALLED_CODE ")V", FN_PTR(invalidateInstalledCode)}, 1822 {CC "collectCounters", CC "()[J", FN_PTR(collectCounters)}, 1823 {CC "allocateCompileId", CC "(" HS_RESOLVED_METHOD "I)I", FN_PTR(allocateCompileId)}, 1824 {CC "isMature", CC "(" METASPACE_METHOD_DATA ")Z", FN_PTR(isMature)}, 1825 {CC "hasCompiledCodeForOSR", CC "(" HS_RESOLVED_METHOD "II)Z", FN_PTR(hasCompiledCodeForOSR)}, 1826 {CC "getSymbol", CC "(J)" STRING, FN_PTR(getSymbol)}, 1827 {CC "getNextStackFrame", CC "(" HS_STACK_FRAME_REF "[" RESOLVED_METHOD "I)" HS_STACK_FRAME_REF, FN_PTR(getNextStackFrame)}, 1828 {CC "materializeVirtualObjects", CC "(" HS_STACK_FRAME_REF "Z)V", FN_PTR(materializeVirtualObjects)}, 1829 {CC "shouldDebugNonSafepoints", CC "()Z", FN_PTR(shouldDebugNonSafepoints)}, 1830 {CC "writeDebugOutput", CC "([BII)V", FN_PTR(writeDebugOutput)}, 1831 {CC "flushDebugOutput", CC "()V", FN_PTR(flushDebugOutput)}, 1832 {CC "methodDataProfileDataSize", CC "(JI)I", FN_PTR(methodDataProfileDataSize)}, 1833 {CC "getFingerprint", CC "(J)J", FN_PTR(getFingerprint)}, 1834 {CC "interpreterFrameSize", CC "(" BYTECODE_FRAME ")I", FN_PTR(interpreterFrameSize)}, 1835 {CC "compileToBytecode", CC "(" OBJECT ")V", FN_PTR(compileToBytecode)}, 1836 {CC "getFlagValue", CC "(" STRING ")" OBJECT, FN_PTR(getFlagValue)}, 1837 }; 1838 1839 int CompilerToVM::methods_count() { 1840 return sizeof(methods) / sizeof(JNINativeMethod); 1841 }