1 /* 2 * Copyright (c) 2011, 2016, 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 "oops/generateOopMap.hpp" 31 #include "oops/fieldStreams.hpp" 32 #include "oops/oop.inline.hpp" 33 #include "oops/objArrayOop.inline.hpp" 34 #include "runtime/fieldDescriptor.hpp" 35 #include "runtime/javaCalls.hpp" 36 #include "jvmci/jvmciRuntime.hpp" 37 #include "compiler/abstractCompiler.hpp" 38 #include "compiler/compileBroker.hpp" 39 #include "compiler/compilerOracle.hpp" 40 #include "compiler/disassembler.hpp" 41 #include "compiler/oopMap.hpp" 42 #include "jvmci/jvmciCompilerToVM.hpp" 43 #include "jvmci/jvmciCompiler.hpp" 44 #include "jvmci/jvmciEnv.hpp" 45 #include "jvmci/jvmciJavaClasses.hpp" 46 #include "jvmci/jvmciCodeInstaller.hpp" 47 #include "gc/g1/heapRegion.hpp" 48 #include "runtime/javaCalls.hpp" 49 #include "runtime/deoptimization.hpp" 50 #include "runtime/vframe.hpp" 51 #include "runtime/vframe_hp.hpp" 52 #include "runtime/vmStructs.hpp" 53 54 55 // Entry to native method implementation that transitions current thread to '_thread_in_vm'. 56 #define C2V_VMENTRY(result_type, name, signature) \ 57 JNIEXPORT result_type JNICALL c2v_ ## name signature { \ 58 TRACE_jvmci_1("CompilerToVM::" #name); \ 59 TRACE_CALL(result_type, jvmci_ ## name signature) \ 60 JVMCI_VM_ENTRY_MARK; \ 61 62 #define C2V_END } 63 64 oop CompilerToVM::get_jvmci_method(const methodHandle& method, TRAPS) { 65 if (method() != NULL) { 66 JavaValue result(T_OBJECT); 67 JavaCallArguments args; 68 args.push_long((jlong) (address) method()); 69 JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedJavaMethodImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::method_fromMetaspace_signature(), &args, CHECK_NULL); 70 71 return (oop)result.get_jobject(); 72 } 73 return NULL; 74 } 75 76 oop CompilerToVM::get_jvmci_type(KlassHandle klass, TRAPS) { 77 if (klass() != NULL) { 78 JavaValue result(T_OBJECT); 79 JavaCallArguments args; 80 args.push_oop(klass->java_mirror()); 81 JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedObjectTypeImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::klass_fromMetaspace_signature(), &args, CHECK_NULL); 82 83 return (oop)result.get_jobject(); 84 } 85 return NULL; 86 } 87 88 void CompilerToVM::invalidate_installed_code(Handle installedCode, TRAPS) { 89 if (installedCode() == NULL) { 90 THROW(vmSymbols::java_lang_NullPointerException()); 91 } 92 jlong nativeMethod = InstalledCode::address(installedCode); 93 nmethod* nm = (nmethod*)nativeMethod; 94 assert(nm == NULL || nm->jvmci_installed_code() == installedCode(), "sanity check"); 95 if (nm != NULL && nm->is_alive()) { 96 // The nmethod state machinery maintains the link between the 97 // HotSpotInstalledCode and nmethod* so as long as the nmethod appears to be 98 // alive assume there is work to do and deoptimize the nmethod. 99 nm->mark_for_deoptimization(); 100 VM_Deoptimize op; 101 VMThread::execute(&op); 102 } 103 InstalledCode::set_address(installedCode, 0); 104 } 105 106 extern "C" { 107 extern VMStructEntry* gHotSpotVMStructs; 108 extern uint64_t gHotSpotVMStructEntryTypeNameOffset; 109 extern uint64_t gHotSpotVMStructEntryFieldNameOffset; 110 extern uint64_t gHotSpotVMStructEntryTypeStringOffset; 111 extern uint64_t gHotSpotVMStructEntryIsStaticOffset; 112 extern uint64_t gHotSpotVMStructEntryOffsetOffset; 113 extern uint64_t gHotSpotVMStructEntryAddressOffset; 114 extern uint64_t gHotSpotVMStructEntryArrayStride; 115 116 extern VMTypeEntry* gHotSpotVMTypes; 117 extern uint64_t gHotSpotVMTypeEntryTypeNameOffset; 118 extern uint64_t gHotSpotVMTypeEntrySuperclassNameOffset; 119 extern uint64_t gHotSpotVMTypeEntryIsOopTypeOffset; 120 extern uint64_t gHotSpotVMTypeEntryIsIntegerTypeOffset; 121 extern uint64_t gHotSpotVMTypeEntryIsUnsignedOffset; 122 extern uint64_t gHotSpotVMTypeEntrySizeOffset; 123 extern uint64_t gHotSpotVMTypeEntryArrayStride; 124 125 extern VMIntConstantEntry* gHotSpotVMIntConstants; 126 extern uint64_t gHotSpotVMIntConstantEntryNameOffset; 127 extern uint64_t gHotSpotVMIntConstantEntryValueOffset; 128 extern uint64_t gHotSpotVMIntConstantEntryArrayStride; 129 130 extern VMLongConstantEntry* gHotSpotVMLongConstants; 131 extern uint64_t gHotSpotVMLongConstantEntryNameOffset; 132 extern uint64_t gHotSpotVMLongConstantEntryValueOffset; 133 extern uint64_t gHotSpotVMLongConstantEntryArrayStride; 134 135 extern VMAddressEntry* gHotSpotVMAddresses; 136 extern uint64_t gHotSpotVMAddressEntryNameOffset; 137 extern uint64_t gHotSpotVMAddressEntryValueOffset; 138 extern uint64_t gHotSpotVMAddressEntryArrayStride; 139 } 140 141 // FIXME This is only temporary until the GC code is changed. 142 bool CompilerToVM::_supports_inline_contig_alloc; 143 HeapWord** CompilerToVM::_heap_end_addr; 144 HeapWord** CompilerToVM::_heap_top_addr; 145 146 /** 147 * We put all gHotSpotVM values in an array so we can read them easily from Java. 148 */ 149 static uintptr_t ciHotSpotVMData[28]; 150 151 C2V_VMENTRY(jlong, initializeConfiguration, (JNIEnv *env, jobject)) 152 ciHotSpotVMData[0] = (uintptr_t) gHotSpotVMStructs; 153 ciHotSpotVMData[1] = gHotSpotVMStructEntryTypeNameOffset; 154 ciHotSpotVMData[2] = gHotSpotVMStructEntryFieldNameOffset; 155 ciHotSpotVMData[3] = gHotSpotVMStructEntryTypeStringOffset; 156 ciHotSpotVMData[4] = gHotSpotVMStructEntryIsStaticOffset; 157 ciHotSpotVMData[5] = gHotSpotVMStructEntryOffsetOffset; 158 ciHotSpotVMData[6] = gHotSpotVMStructEntryAddressOffset; 159 ciHotSpotVMData[7] = gHotSpotVMStructEntryArrayStride; 160 161 ciHotSpotVMData[8] = (uintptr_t) gHotSpotVMTypes; 162 ciHotSpotVMData[9] = gHotSpotVMTypeEntryTypeNameOffset; 163 ciHotSpotVMData[10] = gHotSpotVMTypeEntrySuperclassNameOffset; 164 ciHotSpotVMData[11] = gHotSpotVMTypeEntryIsOopTypeOffset; 165 ciHotSpotVMData[12] = gHotSpotVMTypeEntryIsIntegerTypeOffset; 166 ciHotSpotVMData[13] = gHotSpotVMTypeEntryIsUnsignedOffset; 167 ciHotSpotVMData[14] = gHotSpotVMTypeEntrySizeOffset; 168 ciHotSpotVMData[15] = gHotSpotVMTypeEntryArrayStride; 169 170 ciHotSpotVMData[16] = (uintptr_t) gHotSpotVMIntConstants; 171 ciHotSpotVMData[17] = gHotSpotVMIntConstantEntryNameOffset; 172 ciHotSpotVMData[18] = gHotSpotVMIntConstantEntryValueOffset; 173 ciHotSpotVMData[19] = gHotSpotVMIntConstantEntryArrayStride; 174 175 ciHotSpotVMData[20] = (uintptr_t) gHotSpotVMLongConstants; 176 ciHotSpotVMData[21] = gHotSpotVMLongConstantEntryNameOffset; 177 ciHotSpotVMData[22] = gHotSpotVMLongConstantEntryValueOffset; 178 ciHotSpotVMData[23] = gHotSpotVMLongConstantEntryArrayStride; 179 180 ciHotSpotVMData[24] = (uintptr_t) gHotSpotVMAddresses; 181 ciHotSpotVMData[25] = gHotSpotVMAddressEntryNameOffset; 182 ciHotSpotVMData[26] = gHotSpotVMAddressEntryValueOffset; 183 ciHotSpotVMData[27] = gHotSpotVMAddressEntryArrayStride; 184 185 // FIXME This is only temporary until the GC code is changed. 186 CompilerToVM::_supports_inline_contig_alloc = Universe::heap()->supports_inline_contig_alloc(); 187 CompilerToVM::_heap_end_addr = CompilerToVM::_supports_inline_contig_alloc ? Universe::heap()->end_addr() : (HeapWord**) -1; 188 CompilerToVM::_heap_top_addr = CompilerToVM::_supports_inline_contig_alloc ? Universe::heap()->top_addr() : (HeapWord**) -1; 189 190 return (jlong) (address) &ciHotSpotVMData; 191 C2V_END 192 193 C2V_VMENTRY(jbyteArray, getBytecode, (JNIEnv *, jobject, jobject jvmci_method)) 194 methodHandle method = CompilerToVM::asMethod(jvmci_method); 195 ResourceMark rm; 196 197 int code_size = method->code_size(); 198 typeArrayOop reconstituted_code = oopFactory::new_byteArray(code_size, CHECK_NULL); 199 200 guarantee(method->method_holder()->is_rewritten(), "Method's holder should be rewritten"); 201 // iterate over all bytecodes and replace non-Java bytecodes 202 203 for (BytecodeStream s(method); s.next() != Bytecodes::_illegal; ) { 204 Bytecodes::Code code = s.code(); 205 Bytecodes::Code raw_code = s.raw_code(); 206 int bci = s.bci(); 207 int len = s.instruction_size(); 208 209 // Restore original byte code. 210 reconstituted_code->byte_at_put(bci, (jbyte) (s.is_wide()? Bytecodes::_wide : code)); 211 if (len > 1) { 212 memcpy(reconstituted_code->byte_at_addr(bci + 1), s.bcp()+1, len-1); 213 } 214 215 if (len > 1) { 216 // Restore the big-endian constant pool indexes. 217 // Cf. Rewriter::scan_method 218 switch (code) { 219 case Bytecodes::_getstatic: 220 case Bytecodes::_putstatic: 221 case Bytecodes::_getfield: 222 case Bytecodes::_putfield: 223 case Bytecodes::_invokevirtual: 224 case Bytecodes::_invokespecial: 225 case Bytecodes::_invokestatic: 226 case Bytecodes::_invokeinterface: 227 case Bytecodes::_invokehandle: { 228 int cp_index = Bytes::get_native_u2((address) reconstituted_code->byte_at_addr(bci + 1)); 229 Bytes::put_Java_u2((address) reconstituted_code->byte_at_addr(bci + 1), (u2) cp_index); 230 break; 231 } 232 233 case Bytecodes::_invokedynamic: 234 int cp_index = Bytes::get_native_u4((address) reconstituted_code->byte_at_addr(bci + 1)); 235 Bytes::put_Java_u4((address) reconstituted_code->byte_at_addr(bci + 1), (u4) cp_index); 236 break; 237 } 238 239 // Not all ldc byte code are rewritten. 240 switch (raw_code) { 241 case Bytecodes::_fast_aldc: { 242 int cpc_index = reconstituted_code->byte_at(bci + 1) & 0xff; 243 int cp_index = method->constants()->object_to_cp_index(cpc_index); 244 assert(cp_index < method->constants()->length(), "sanity check"); 245 reconstituted_code->byte_at_put(bci + 1, (jbyte) cp_index); 246 break; 247 } 248 249 case Bytecodes::_fast_aldc_w: { 250 int cpc_index = Bytes::get_native_u2((address) reconstituted_code->byte_at_addr(bci + 1)); 251 int cp_index = method->constants()->object_to_cp_index(cpc_index); 252 assert(cp_index < method->constants()->length(), "sanity check"); 253 Bytes::put_Java_u2((address) reconstituted_code->byte_at_addr(bci + 1), (u2) cp_index); 254 break; 255 } 256 } 257 } 258 } 259 260 return (jbyteArray) JNIHandles::make_local(THREAD, reconstituted_code); 261 C2V_END 262 263 C2V_VMENTRY(jint, getExceptionTableLength, (JNIEnv *, jobject, jobject jvmci_method)) 264 ResourceMark rm; 265 methodHandle method = CompilerToVM::asMethod(jvmci_method); 266 return method->exception_table_length(); 267 C2V_END 268 269 C2V_VMENTRY(jlong, getExceptionTableStart, (JNIEnv *, jobject, jobject jvmci_method)) 270 ResourceMark rm; 271 methodHandle method = CompilerToVM::asMethod(jvmci_method); 272 if (method->exception_table_length() == 0) { 273 return 0L; 274 } 275 return (jlong) (address) method->exception_table_start(); 276 C2V_END 277 278 C2V_VMENTRY(jobject, getResolvedJavaMethodAtSlot, (JNIEnv *, jobject, jclass holder_handle, jint slot)) 279 oop java_class = JNIHandles::resolve(holder_handle); 280 Klass* holder = java_lang_Class::as_Klass(java_class); 281 methodHandle method = InstanceKlass::cast(holder)->method_with_idnum(slot); 282 oop result = CompilerToVM::get_jvmci_method(method, CHECK_NULL); 283 return JNIHandles::make_local(THREAD, result); 284 } 285 286 C2V_VMENTRY(jobject, getResolvedJavaMethod, (JNIEnv *, jobject, jobject base, jlong offset)) 287 methodHandle method; 288 oop base_object = JNIHandles::resolve(base); 289 if (base_object == NULL) { 290 method = *((Method**)(offset)); 291 } else if (base_object->is_a(SystemDictionary::MemberName_klass())) { 292 method = (Method*) (intptr_t) base_object->long_field(offset); 293 } else if (base_object->is_a(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass())) { 294 method = *((Method**)(HotSpotResolvedJavaMethodImpl::metaspaceMethod(base_object) + offset)); 295 } else { 296 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 297 err_msg("Unexpected type: %s", base_object->klass()->external_name())); 298 } 299 assert (method.is_null() || method->is_method(), "invalid read"); 300 oop result = CompilerToVM::get_jvmci_method(method, CHECK_NULL); 301 return JNIHandles::make_local(THREAD, result); 302 } 303 304 C2V_VMENTRY(jobject, getConstantPool, (JNIEnv *, jobject, jobject base, jlong offset)) 305 constantPoolHandle cp; 306 oop base_object = JNIHandles::resolve(base); 307 jlong base_address = 0; 308 if (base_object != NULL) { 309 if (base_object->is_a(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass())) { 310 base_address = HotSpotResolvedJavaMethodImpl::metaspaceMethod(base_object); 311 } else if (base_object->is_a(SystemDictionary::HotSpotConstantPool_klass())) { 312 base_address = HotSpotConstantPool::metaspaceConstantPool(base_object); 313 } else if (base_object->is_a(SystemDictionary::HotSpotResolvedObjectTypeImpl_klass())) { 314 base_address = (jlong) CompilerToVM::asKlass(base_object); 315 } else { 316 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 317 err_msg("Unexpected type: %s", base_object->klass()->external_name())); 318 } 319 } 320 cp = *((ConstantPool**) (intptr_t) (base_address + offset)); 321 if (!cp.is_null()) { 322 JavaValue method_result(T_OBJECT); 323 JavaCallArguments args; 324 args.push_long((jlong) (address) cp()); 325 JavaCalls::call_static(&method_result, SystemDictionary::HotSpotConstantPool_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::constantPool_fromMetaspace_signature(), &args, CHECK_NULL); 326 return JNIHandles::make_local(THREAD, (oop)method_result.get_jobject()); 327 } 328 return NULL; 329 } 330 331 C2V_VMENTRY(jobject, getResolvedJavaType, (JNIEnv *, jobject, jobject base, jlong offset, jboolean compressed)) 332 KlassHandle klass; 333 oop base_object = JNIHandles::resolve(base); 334 jlong base_address = 0; 335 if (base_object != NULL && offset == oopDesc::klass_offset_in_bytes()) { 336 klass = base_object->klass(); 337 } else if (!compressed) { 338 if (base_object != NULL) { 339 if (base_object->is_a(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass())) { 340 base_address = HotSpotResolvedJavaMethodImpl::metaspaceMethod(base_object); 341 } else if (base_object->is_a(SystemDictionary::HotSpotConstantPool_klass())) { 342 base_address = HotSpotConstantPool::metaspaceConstantPool(base_object); 343 } else if (base_object->is_a(SystemDictionary::HotSpotResolvedObjectTypeImpl_klass())) { 344 base_address = (jlong) CompilerToVM::asKlass(base_object); 345 } else if (base_object->is_a(SystemDictionary::Class_klass())) { 346 base_address = (jlong) (address) base_object; 347 } else { 348 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 349 err_msg("Unexpected arguments: %s " JLONG_FORMAT " %s", base_object->klass()->external_name(), offset, compressed ? "true" : "false")); 350 } 351 } 352 klass = *((Klass**) (intptr_t) (base_address + offset)); 353 } else { 354 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 355 err_msg("Unexpected arguments: %s " JLONG_FORMAT " %s", base_object->klass()->external_name(), offset, compressed ? "true" : "false")); 356 } 357 assert (klass.is_null() || klass->is_klass(), "invalid read"); 358 oop result = CompilerToVM::get_jvmci_type(klass, CHECK_NULL); 359 return JNIHandles::make_local(THREAD, result); 360 } 361 362 C2V_VMENTRY(jobject, findUniqueConcreteMethod, (JNIEnv *, jobject, jobject jvmci_type, jobject jvmci_method)) 363 ResourceMark rm; 364 methodHandle method = CompilerToVM::asMethod(jvmci_method); 365 KlassHandle holder = CompilerToVM::asKlass(jvmci_type); 366 if (holder->is_interface()) { 367 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Interface %s should be handled in Java code", holder->external_name())); 368 } 369 370 methodHandle ucm; 371 { 372 MutexLocker locker(Compile_lock); 373 ucm = Dependencies::find_unique_concrete_method(holder(), method()); 374 } 375 oop result = CompilerToVM::get_jvmci_method(ucm, CHECK_NULL); 376 return JNIHandles::make_local(THREAD, result); 377 C2V_END 378 379 C2V_VMENTRY(jobject, getImplementor, (JNIEnv *, jobject, jobject jvmci_type)) 380 InstanceKlass* klass = (InstanceKlass*) CompilerToVM::asKlass(jvmci_type); 381 oop implementor = CompilerToVM::get_jvmci_type(klass->implementor(), CHECK_NULL); 382 return JNIHandles::make_local(THREAD, implementor); 383 C2V_END 384 385 C2V_VMENTRY(jboolean, methodIsIgnoredBySecurityStackWalk,(JNIEnv *, jobject, jobject jvmci_method)) 386 methodHandle method = CompilerToVM::asMethod(jvmci_method); 387 return method->is_ignored_by_security_stack_walk(); 388 C2V_END 389 390 C2V_VMENTRY(jboolean, canInlineMethod,(JNIEnv *, jobject, jobject jvmci_method)) 391 methodHandle method = CompilerToVM::asMethod(jvmci_method); 392 return !method->is_not_compilable() && !CompilerOracle::should_not_inline(method) && !method->dont_inline(); 393 C2V_END 394 395 C2V_VMENTRY(jboolean, shouldInlineMethod,(JNIEnv *, jobject, jobject jvmci_method)) 396 methodHandle method = CompilerToVM::asMethod(jvmci_method); 397 return CompilerOracle::should_inline(method) || method->force_inline(); 398 C2V_END 399 400 C2V_VMENTRY(jobject, lookupType, (JNIEnv*, jobject, jstring jname, jclass accessing_class, jboolean resolve)) 401 ResourceMark rm; 402 Handle name = JNIHandles::resolve(jname); 403 Symbol* class_name = java_lang_String::as_symbol(name, CHECK_0); 404 if (java_lang_String::length(name()) <= 1) { 405 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Primitive type %s should be handled in Java code", class_name->as_C_string())); 406 } 407 408 Klass* resolved_klass = NULL; 409 Handle class_loader; 410 Handle protection_domain; 411 if (JNIHandles::resolve(accessing_class) == NULL) { 412 THROW_0(vmSymbols::java_lang_NullPointerException()); 413 } 414 Klass* accessing_klass = java_lang_Class::as_Klass(JNIHandles::resolve(accessing_class)); 415 class_loader = accessing_klass->class_loader(); 416 protection_domain = accessing_klass->protection_domain(); 417 418 if (resolve) { 419 resolved_klass = SystemDictionary::resolve_or_null(class_name, class_loader, protection_domain, CHECK_0); 420 } else { 421 if (class_name->byte_at(0) == 'L' && 422 class_name->byte_at(class_name->utf8_length()-1) == ';') { 423 // This is a name from a signature. Strip off the trimmings. 424 // Call recursive to keep scope of strippedsym. 425 TempNewSymbol strippedsym = SymbolTable::new_symbol(class_name->as_utf8()+1, 426 class_name->utf8_length()-2, 427 CHECK_0); 428 resolved_klass = SystemDictionary::find(strippedsym, class_loader, protection_domain, CHECK_0); 429 } else if (FieldType::is_array(class_name)) { 430 FieldArrayInfo fd; 431 // dimension and object_key in FieldArrayInfo are assigned as a side-effect 432 // of this call 433 BasicType t = FieldType::get_array_info(class_name, fd, CHECK_0); 434 if (t == T_OBJECT) { 435 TempNewSymbol strippedsym = SymbolTable::new_symbol(class_name->as_utf8()+1+fd.dimension(), 436 class_name->utf8_length()-2-fd.dimension(), 437 CHECK_0); 438 // naked oop "k" is OK here -- we assign back into it 439 resolved_klass = SystemDictionary::find(strippedsym, 440 class_loader, 441 protection_domain, 442 CHECK_0); 443 if (resolved_klass != NULL) { 444 resolved_klass = resolved_klass->array_klass(fd.dimension(), CHECK_0); 445 } 446 } else { 447 resolved_klass = Universe::typeArrayKlassObj(t); 448 resolved_klass = TypeArrayKlass::cast(resolved_klass)->array_klass(fd.dimension(), CHECK_0); 449 } 450 } 451 } 452 Handle result = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL); 453 return JNIHandles::make_local(THREAD, result()); 454 C2V_END 455 456 C2V_VMENTRY(jobject, resolveConstantInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 457 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 458 oop result = cp->resolve_constant_at(index, CHECK_NULL); 459 return JNIHandles::make_local(THREAD, result); 460 C2V_END 461 462 C2V_VMENTRY(jobject, resolvePossiblyCachedConstantInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 463 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 464 oop result = cp->resolve_possibly_cached_constant_at(index, CHECK_NULL); 465 return JNIHandles::make_local(THREAD, result); 466 C2V_END 467 468 C2V_VMENTRY(jint, lookupNameAndTypeRefIndexInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 469 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 470 return cp->name_and_type_ref_index_at(index); 471 C2V_END 472 473 C2V_VMENTRY(jobject, lookupNameInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint which)) 474 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 475 Handle sym = java_lang_String::create_from_symbol(cp->name_ref_at(which), CHECK_NULL); 476 return JNIHandles::make_local(THREAD, sym()); 477 C2V_END 478 479 C2V_VMENTRY(jobject, lookupSignatureInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint which)) 480 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 481 Handle sym = java_lang_String::create_from_symbol(cp->signature_ref_at(which), CHECK_NULL); 482 return JNIHandles::make_local(THREAD, sym()); 483 C2V_END 484 485 C2V_VMENTRY(jint, lookupKlassRefIndexInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 486 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 487 return cp->klass_ref_index_at(index); 488 C2V_END 489 490 C2V_VMENTRY(jobject, resolveTypeInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 491 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 492 Klass* resolved_klass = cp->klass_at(index, CHECK_NULL); 493 Handle klass = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL); 494 return JNIHandles::make_local(THREAD, klass()); 495 C2V_END 496 497 C2V_VMENTRY(jobject, lookupKlassInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode)) 498 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 499 KlassHandle loading_klass(cp->pool_holder()); 500 bool is_accessible = false; 501 KlassHandle klass = JVMCIEnv::get_klass_by_index(cp, index, is_accessible, loading_klass); 502 Symbol* symbol = NULL; 503 if (klass.is_null()) { 504 symbol = cp->klass_name_at(index); 505 } 506 Handle result; 507 if (!klass.is_null()) { 508 result = CompilerToVM::get_jvmci_type(klass, CHECK_NULL); 509 } else { 510 result = java_lang_String::create_from_symbol(symbol, CHECK_NULL); 511 } 512 return JNIHandles::make_local(THREAD, result()); 513 C2V_END 514 515 C2V_VMENTRY(jobject, lookupAppendixInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 516 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 517 oop appendix_oop = ConstantPool::appendix_at_if_loaded(cp, index); 518 return JNIHandles::make_local(THREAD, appendix_oop); 519 C2V_END 520 521 C2V_VMENTRY(jobject, lookupMethodInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode)) 522 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 523 instanceKlassHandle pool_holder(cp->pool_holder()); 524 Bytecodes::Code bc = (Bytecodes::Code) (((int) opcode) & 0xFF); 525 methodHandle method = JVMCIEnv::get_method_by_index(cp, index, bc, pool_holder); 526 oop result = CompilerToVM::get_jvmci_method(method, CHECK_NULL); 527 return JNIHandles::make_local(THREAD, result); 528 C2V_END 529 530 C2V_VMENTRY(jint, constantPoolRemapInstructionOperandFromCache, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 531 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 532 return cp->remap_instruction_operand_from_cache(index); 533 C2V_END 534 535 C2V_VMENTRY(jobject, resolveFieldInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode, jlongArray info_handle)) 536 ResourceMark rm; 537 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 538 Bytecodes::Code code = (Bytecodes::Code)(((int) opcode) & 0xFF); 539 fieldDescriptor fd; 540 LinkInfo link_info(cp, index, CHECK_0); 541 LinkResolver::resolve_field(fd, link_info, Bytecodes::java_code(code), false, CHECK_0); 542 typeArrayOop info = (typeArrayOop) JNIHandles::resolve(info_handle); 543 assert(info != NULL && info->length() == 2, "must be"); 544 info->long_at_put(0, (jlong) fd.access_flags().as_int()); 545 info->long_at_put(1, (jlong) fd.offset()); 546 oop field_holder = CompilerToVM::get_jvmci_type(fd.field_holder(), CHECK_NULL); 547 return JNIHandles::make_local(THREAD, field_holder); 548 C2V_END 549 550 C2V_VMENTRY(jint, getVtableIndexForInterfaceMethod, (JNIEnv *, jobject, jobject jvmci_type, jobject jvmci_method)) 551 ResourceMark rm; 552 Klass* klass = CompilerToVM::asKlass(jvmci_type); 553 Method* method = CompilerToVM::asMethod(jvmci_method); 554 if (klass->is_interface()) { 555 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Interface %s should be handled in Java code", klass->external_name())); 556 } 557 if (!method->method_holder()->is_interface()) { 558 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())); 559 } 560 if (!InstanceKlass::cast(klass)->is_linked()) { 561 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Class %s must be linked", klass->external_name())); 562 } 563 return LinkResolver::vtable_index_of_interface_method(klass, method); 564 C2V_END 565 566 C2V_VMENTRY(jobject, resolveMethod, (JNIEnv *, jobject, jobject receiver_jvmci_type, jobject jvmci_method, jobject caller_jvmci_type)) 567 Klass* recv_klass = CompilerToVM::asKlass(receiver_jvmci_type); 568 Klass* caller_klass = CompilerToVM::asKlass(caller_jvmci_type); 569 Method* method = CompilerToVM::asMethod(jvmci_method); 570 571 if (recv_klass->is_array_klass() || (InstanceKlass::cast(recv_klass)->is_linked())) { 572 Klass* holder_klass = method->method_holder(); 573 Symbol* method_name = method->name(); 574 Symbol* method_signature = method->signature(); 575 576 if (holder_klass->is_interface()) { 577 // do link-time resolution to check all access rules. 578 LinkInfo link_info(holder_klass, method_name, method_signature, caller_klass, true); 579 methodHandle resolved_method = LinkResolver::linktime_resolve_interface_method_or_null(link_info); 580 if (resolved_method.is_null() || resolved_method->is_private()) { 581 return NULL; 582 } 583 assert(recv_klass->is_subtype_of(holder_klass), ""); 584 // do actual lookup 585 methodHandle sel_method = LinkResolver::lookup_instance_method_in_klasses(recv_klass, resolved_method->name(), resolved_method->signature(), CHECK_AND_CLEAR_0); 586 oop result = CompilerToVM::get_jvmci_method(sel_method, CHECK_NULL); 587 return JNIHandles::make_local(THREAD, result); 588 } else { 589 // do link-time resolution to check all access rules. 590 LinkInfo link_info(holder_klass, method_name, method_signature, caller_klass, true); 591 methodHandle resolved_method = LinkResolver::linktime_resolve_virtual_method_or_null(link_info); 592 if (resolved_method.is_null()) { 593 return NULL; 594 } 595 // do actual lookup (see LinkResolver::runtime_resolve_virtual_method) 596 int vtable_index = Method::invalid_vtable_index; 597 Method* selected_method; 598 599 if (resolved_method->method_holder()->is_interface()) { // miranda method 600 vtable_index = LinkResolver::vtable_index_of_interface_method(holder_klass, resolved_method); 601 assert(vtable_index >= 0 , "we should have valid vtable index at this point"); 602 603 InstanceKlass* inst = InstanceKlass::cast(recv_klass); 604 selected_method = inst->method_at_vtable(vtable_index); 605 } else { 606 // at this point we are sure that resolved_method is virtual and not 607 // a miranda method; therefore, it must have a valid vtable index. 608 assert(!resolved_method->has_itable_index(), ""); 609 vtable_index = resolved_method->vtable_index(); 610 // We could get a negative vtable_index for final methods, 611 // because as an optimization they are they are never put in the vtable, 612 // unless they override an existing method. 613 // If we do get a negative, it means the resolved method is the the selected 614 // method, and it can never be changed by an override. 615 if (vtable_index == Method::nonvirtual_vtable_index) { 616 assert(resolved_method->can_be_statically_bound(), "cannot override this method"); 617 selected_method = resolved_method(); 618 } else { 619 // recv_klass might be an arrayKlassOop but all vtables start at 620 // the same place. The cast is to avoid virtual call and assertion. 621 InstanceKlass* inst = (InstanceKlass*)recv_klass; 622 selected_method = inst->method_at_vtable(vtable_index); 623 } 624 } 625 oop result = CompilerToVM::get_jvmci_method(selected_method, CHECK_NULL); 626 return JNIHandles::make_local(THREAD, result); 627 } 628 } 629 return NULL; 630 C2V_END 631 632 C2V_VMENTRY(jboolean, hasFinalizableSubclass,(JNIEnv *, jobject, jobject jvmci_type)) 633 Klass* klass = CompilerToVM::asKlass(jvmci_type); 634 assert(klass != NULL, "method must not be called for primitive types"); 635 return Dependencies::find_finalizable_subclass(klass) != NULL; 636 C2V_END 637 638 C2V_VMENTRY(jobject, getClassInitializer, (JNIEnv *, jobject, jobject jvmci_type)) 639 InstanceKlass* klass = (InstanceKlass*) CompilerToVM::asKlass(jvmci_type); 640 oop result = CompilerToVM::get_jvmci_method(klass->class_initializer(), CHECK_NULL); 641 return JNIHandles::make_local(THREAD, result); 642 C2V_END 643 644 C2V_VMENTRY(jlong, getMaxCallTargetOffset, (JNIEnv*, jobject, jlong addr)) 645 address target_addr = (address) addr; 646 if (target_addr != 0x0) { 647 int64_t off_low = (int64_t)target_addr - ((int64_t)CodeCache::low_bound() + sizeof(int)); 648 int64_t off_high = (int64_t)target_addr - ((int64_t)CodeCache::high_bound() + sizeof(int)); 649 return MAX2(ABS(off_low), ABS(off_high)); 650 } 651 return -1; 652 C2V_END 653 654 C2V_VMENTRY(void, doNotInlineOrCompile,(JNIEnv *, jobject, jobject jvmci_method)) 655 methodHandle method = CompilerToVM::asMethod(jvmci_method); 656 method->set_not_c1_compilable(); 657 method->set_not_c2_compilable(); 658 method->set_dont_inline(true); 659 C2V_END 660 661 C2V_VMENTRY(jint, installCode, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject installed_code, jobject speculation_log)) 662 ResourceMark rm; 663 HandleMark hm; 664 Handle target_handle = JNIHandles::resolve(target); 665 Handle compiled_code_handle = JNIHandles::resolve(compiled_code); 666 CodeBlob* cb = NULL; 667 Handle installed_code_handle = JNIHandles::resolve(installed_code); 668 Handle speculation_log_handle = JNIHandles::resolve(speculation_log); 669 670 JVMCICompiler* compiler = JVMCICompiler::instance(CHECK_JNI_ERR); 671 672 TraceTime install_time("installCode", JVMCICompiler::codeInstallTimer()); 673 CodeInstaller installer; 674 JVMCIEnv::CodeInstallResult result = installer.install(compiler, target_handle, compiled_code_handle, cb, installed_code_handle, speculation_log_handle, CHECK_0); 675 676 if (PrintCodeCacheOnCompilation) { 677 stringStream s; 678 // Dump code cache into a buffer before locking the tty, 679 { 680 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 681 CodeCache::print_summary(&s, false); 682 } 683 ttyLocker ttyl; 684 tty->print_raw_cr(s.as_string()); 685 } 686 687 if (result != JVMCIEnv::ok) { 688 assert(cb == NULL, "should be"); 689 } else { 690 if (!installed_code_handle.is_null()) { 691 assert(installed_code_handle->is_a(InstalledCode::klass()), "wrong type"); 692 CompilerToVM::invalidate_installed_code(installed_code_handle, CHECK_0); 693 InstalledCode::set_address(installed_code_handle, (jlong) cb); 694 InstalledCode::set_version(installed_code_handle, InstalledCode::version(installed_code_handle) + 1); 695 if (cb->is_nmethod()) { 696 InstalledCode::set_entryPoint(installed_code_handle, (jlong) cb->as_nmethod_or_null()->verified_entry_point()); 697 } else { 698 InstalledCode::set_entryPoint(installed_code_handle, (jlong) cb->code_begin()); 699 } 700 if (installed_code_handle->is_a(HotSpotInstalledCode::klass())) { 701 HotSpotInstalledCode::set_size(installed_code_handle, cb->size()); 702 HotSpotInstalledCode::set_codeStart(installed_code_handle, (jlong) cb->code_begin()); 703 HotSpotInstalledCode::set_codeSize(installed_code_handle, cb->code_size()); 704 } 705 nmethod* nm = cb->as_nmethod_or_null(); 706 if (nm != NULL && installed_code_handle->is_scavengable()) { 707 assert(nm->detect_scavenge_root_oops(), "nm should be scavengable if installed_code is scavengable"); 708 if (!UseG1GC) { 709 assert(nm->on_scavenge_root_list(), "nm should be on scavengable list"); 710 } 711 } 712 } 713 } 714 return result; 715 C2V_END 716 717 C2V_VMENTRY(jint, getMetadata, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject metadata)) 718 ResourceMark rm; 719 HandleMark hm; 720 721 Handle target_handle = JNIHandles::resolve(target); 722 Handle compiled_code_handle = JNIHandles::resolve(compiled_code); 723 Handle metadata_handle = JNIHandles::resolve(metadata); 724 725 HotSpotOopMap::klass()->initialize(thread); 726 727 CodeMetadata code_metadata; 728 CodeBlob *cb = NULL; 729 CodeInstaller installer; 730 731 JVMCIEnv::CodeInstallResult result = installer.gather_metadata(target_handle, compiled_code_handle, code_metadata, CHECK_0); //cb, pc_descs, nr_pc_descs, scopes_descs, scopes_size, reloc_buffer); 732 if (result != JVMCIEnv::ok) { 733 return result; 734 } 735 736 if (code_metadata.get_nr_pc_desc() > 0) { 737 typeArrayHandle pcArrayOop = oopFactory::new_byteArray(sizeof(PcDesc) * code_metadata.get_nr_pc_desc(), CHECK_(JVMCIEnv::cache_full)); 738 memcpy(pcArrayOop->byte_at_addr(0), code_metadata.get_pc_desc(), sizeof(PcDesc) * code_metadata.get_nr_pc_desc()); 739 HotSpotMetaData::set_pcDescBytes(metadata_handle, pcArrayOop()); 740 } 741 742 if (code_metadata.get_scopes_size() > 0) { 743 typeArrayHandle scopesArrayOop = oopFactory::new_byteArray(code_metadata.get_scopes_size(), CHECK_(JVMCIEnv::cache_full)); 744 memcpy(scopesArrayOop->byte_at_addr(0), code_metadata.get_scopes_desc(), code_metadata.get_scopes_size()); 745 HotSpotMetaData::set_scopesDescBytes(metadata_handle, scopesArrayOop()); 746 } 747 748 RelocBuffer* reloc_buffer = code_metadata.get_reloc_buffer(); 749 typeArrayHandle relocArrayOop = oopFactory::new_byteArray((int) reloc_buffer->size(), CHECK_(JVMCIEnv::cache_full)); 750 if (reloc_buffer->size() > 0) { 751 memcpy(relocArrayOop->byte_at_addr(0), reloc_buffer->begin(), reloc_buffer->size()); 752 } 753 HotSpotMetaData::set_relocBytes(metadata_handle, relocArrayOop()); 754 755 const OopMapSet* oopMapSet = installer.oopMapSet(); 756 { 757 ResourceMark mark; 758 ImmutableOopMapBuilder builder(oopMapSet); 759 int oopmap_size = builder.heap_size(); 760 typeArrayHandle oopMapArrayHandle = oopFactory::new_byteArray(oopmap_size, CHECK_(JVMCIEnv::cache_full)); 761 builder.generate_into((address) oopMapArrayHandle->byte_at_addr(0)); 762 HotSpotMetaData::set_oopMaps(metadata_handle, oopMapArrayHandle()); 763 } 764 765 HotSpotMetaData::set_metadata(metadata_handle, NULL); 766 767 ExceptionHandlerTable* handler = code_metadata.get_exception_table(); 768 int table_size = handler->size_in_bytes(); 769 typeArrayHandle exceptionArrayOop = oopFactory::new_byteArray(table_size, CHECK_(JVMCIEnv::cache_full)); 770 771 if (table_size > 0) { 772 handler->copy_bytes_to((address) exceptionArrayOop->byte_at_addr(0)); 773 } 774 HotSpotMetaData::set_exceptionBytes(metadata_handle, exceptionArrayOop()); 775 776 return result; 777 C2V_END 778 779 C2V_VMENTRY(void, notifyCompilationStatistics, (JNIEnv *jniEnv, jobject, jint id, jobject hotspot_method, jboolean osr, jint processedBytecodes, jlong time, jlong timeUnitsPerSecond, jobject installed_code)) 780 JVMCICompiler* compiler = JVMCICompiler::instance(CHECK); 781 CompilerStatistics* stats = compiler->stats(); 782 783 elapsedTimer timer = elapsedTimer(time, timeUnitsPerSecond); 784 if (osr) { 785 stats->_osr.update(timer, processedBytecodes); 786 } else { 787 stats->_standard.update(timer, processedBytecodes); 788 } 789 Handle installed_code_handle = JNIHandles::resolve(installed_code); 790 if (installed_code_handle->is_a(HotSpotInstalledCode::klass())) { 791 stats->_nmethods_size += HotSpotInstalledCode::size(installed_code_handle); 792 stats->_nmethods_code_size += HotSpotInstalledCode::codeSize(installed_code_handle); 793 } 794 795 if (CITimeEach) { 796 methodHandle method = CompilerToVM::asMethod(hotspot_method); 797 float bytes_per_sec = 1.0 * processedBytecodes / timer.seconds(); 798 tty->print_cr("%3d seconds: %f bytes/sec: %f (bytes %d)", 799 id, timer.seconds(), bytes_per_sec, processedBytecodes); 800 } 801 C2V_END 802 803 C2V_VMENTRY(void, resetCompilationStatistics, (JNIEnv *jniEnv, jobject)) 804 JVMCICompiler* compiler = JVMCICompiler::instance(CHECK); 805 CompilerStatistics* stats = compiler->stats(); 806 stats->_standard.reset(); 807 stats->_osr.reset(); 808 C2V_END 809 810 C2V_VMENTRY(jobject, disassembleCodeBlob, (JNIEnv *jniEnv, jobject, jobject installedCode)) 811 ResourceMark rm; 812 HandleMark hm; 813 814 if (installedCode == NULL) { 815 THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(), "installedCode is null"); 816 } 817 818 jlong codeBlob = InstalledCode::address(installedCode); 819 if (codeBlob == 0L) { 820 return NULL; 821 } 822 823 CodeBlob* cb = (CodeBlob*) (address) codeBlob; 824 if (cb == NULL) { 825 return NULL; 826 } 827 828 // We don't want the stringStream buffer to resize during disassembly as it 829 // uses scoped resource memory. If a nested function called during disassembly uses 830 // a ResourceMark and the buffer expands within the scope of the mark, 831 // the buffer becomes garbage when that scope is exited. Experience shows that 832 // the disassembled code is typically about 10x the code size so a fixed buffer 833 // sized to 20x code size plus a fixed amount for header info should be sufficient. 834 int bufferSize = cb->code_size() * 20 + 1024; 835 char* buffer = NEW_RESOURCE_ARRAY(char, bufferSize); 836 stringStream st(buffer, bufferSize); 837 if (cb->is_nmethod()) { 838 nmethod* nm = (nmethod*) cb; 839 if (!nm->is_alive()) { 840 return NULL; 841 } 842 Disassembler::decode(nm, &st); 843 } else { 844 Disassembler::decode(cb, &st); 845 } 846 if (st.size() <= 0) { 847 return NULL; 848 } 849 850 Handle result = java_lang_String::create_from_platform_dependent_str(st.as_string(), CHECK_NULL); 851 return JNIHandles::make_local(THREAD, result()); 852 C2V_END 853 854 C2V_VMENTRY(jobject, getStackTraceElement, (JNIEnv*, jobject, jobject jvmci_method, int bci)) 855 ResourceMark rm; 856 HandleMark hm; 857 858 methodHandle method = CompilerToVM::asMethod(jvmci_method); 859 oop element = java_lang_StackTraceElement::create(method, bci, CHECK_NULL); 860 return JNIHandles::make_local(THREAD, element); 861 C2V_END 862 863 C2V_VMENTRY(jobject, executeInstalledCode, (JNIEnv*, jobject, jobject args, jobject hotspotInstalledCode)) 864 ResourceMark rm; 865 HandleMark hm; 866 867 jlong nmethodValue = InstalledCode::address(hotspotInstalledCode); 868 if (nmethodValue == 0L) { 869 THROW_NULL(vmSymbols::jdk_vm_ci_code_InvalidInstalledCodeException()); 870 } 871 nmethod* nm = (nmethod*) (address) nmethodValue; 872 methodHandle mh = nm->method(); 873 Symbol* signature = mh->signature(); 874 JavaCallArguments jca(mh->size_of_parameters()); 875 876 JavaArgumentUnboxer jap(signature, &jca, (arrayOop) JNIHandles::resolve(args), mh->is_static()); 877 JavaValue result(jap.get_ret_type()); 878 jca.set_alternative_target(nm); 879 JavaCalls::call(&result, mh, &jca, CHECK_NULL); 880 881 if (jap.get_ret_type() == T_VOID) { 882 return NULL; 883 } else if (jap.get_ret_type() == T_OBJECT || jap.get_ret_type() == T_ARRAY) { 884 return JNIHandles::make_local(THREAD, (oop) result.get_jobject()); 885 } else { 886 jvalue *value = (jvalue *) result.get_value_addr(); 887 // Narrow the value down if required (Important on big endian machines) 888 switch (jap.get_ret_type()) { 889 case T_BOOLEAN: 890 value->z = (jboolean) value->i; 891 break; 892 case T_BYTE: 893 value->b = (jbyte) value->i; 894 break; 895 case T_CHAR: 896 value->c = (jchar) value->i; 897 break; 898 case T_SHORT: 899 value->s = (jshort) value->i; 900 break; 901 } 902 oop o = java_lang_boxing_object::create(jap.get_ret_type(), value, CHECK_NULL); 903 return JNIHandles::make_local(THREAD, o); 904 } 905 C2V_END 906 907 C2V_VMENTRY(jlongArray, getLineNumberTable, (JNIEnv *, jobject, jobject jvmci_method)) 908 Method* method = CompilerToVM::asMethod(jvmci_method); 909 if (!method->has_linenumber_table()) { 910 return NULL; 911 } 912 u2 num_entries = 0; 913 CompressedLineNumberReadStream streamForSize(method->compressed_linenumber_table()); 914 while (streamForSize.read_pair()) { 915 num_entries++; 916 } 917 918 CompressedLineNumberReadStream stream(method->compressed_linenumber_table()); 919 typeArrayOop result = oopFactory::new_longArray(2 * num_entries, CHECK_NULL); 920 921 int i = 0; 922 jlong value; 923 while (stream.read_pair()) { 924 value = ((long) stream.bci()); 925 result->long_at_put(i, value); 926 value = ((long) stream.line()); 927 result->long_at_put(i + 1, value); 928 i += 2; 929 } 930 931 return (jlongArray) JNIHandles::make_local(THREAD, result); 932 C2V_END 933 934 C2V_VMENTRY(jlong, getLocalVariableTableStart, (JNIEnv *, jobject, jobject jvmci_method)) 935 ResourceMark rm; 936 Method* method = CompilerToVM::asMethod(jvmci_method); 937 if (!method->has_localvariable_table()) { 938 return 0; 939 } 940 return (jlong) (address) method->localvariable_table_start(); 941 C2V_END 942 943 C2V_VMENTRY(jint, getLocalVariableTableLength, (JNIEnv *, jobject, jobject jvmci_method)) 944 ResourceMark rm; 945 Method* method = CompilerToVM::asMethod(jvmci_method); 946 return method->localvariable_table_length(); 947 C2V_END 948 949 C2V_VMENTRY(void, reprofile, (JNIEnv*, jobject, jobject jvmci_method)) 950 Method* method = CompilerToVM::asMethod(jvmci_method); 951 MethodCounters* mcs = method->method_counters(); 952 if (mcs != NULL) { 953 mcs->clear_counters(); 954 } 955 NOT_PRODUCT(method->set_compiled_invocation_count(0)); 956 957 nmethod* code = method->code(); 958 if (code != NULL) { 959 code->make_not_entrant(); 960 } 961 962 MethodData* method_data = method->method_data(); 963 if (method_data == NULL) { 964 ClassLoaderData* loader_data = method->method_holder()->class_loader_data(); 965 method_data = MethodData::allocate(loader_data, method, CHECK); 966 method->set_method_data(method_data); 967 } else { 968 method_data->initialize(); 969 } 970 C2V_END 971 972 973 C2V_VMENTRY(void, invalidateInstalledCode, (JNIEnv*, jobject, jobject installed_code)) 974 Handle installed_code_handle = JNIHandles::resolve(installed_code); 975 CompilerToVM::invalidate_installed_code(installed_code_handle, CHECK); 976 C2V_END 977 978 C2V_VMENTRY(jobject, readUncompressedOop, (JNIEnv*, jobject, jlong addr)) 979 oop ret = oopDesc::load_decode_heap_oop((oop*)(address)addr); 980 return JNIHandles::make_local(THREAD, ret); 981 C2V_END 982 983 C2V_VMENTRY(jlongArray, collectCounters, (JNIEnv*, jobject)) 984 typeArrayOop arrayOop = oopFactory::new_longArray(JVMCICounterSize, CHECK_NULL); 985 JavaThread::collect_counters(arrayOop); 986 return (jlongArray) JNIHandles::make_local(THREAD, arrayOop); 987 C2V_END 988 989 C2V_VMENTRY(int, allocateCompileId, (JNIEnv*, jobject, jobject jvmci_method, int entry_bci)) 990 HandleMark hm; 991 ResourceMark rm; 992 if (JNIHandles::resolve(jvmci_method) == NULL) { 993 THROW_0(vmSymbols::java_lang_NullPointerException()); 994 } 995 Method* method = CompilerToVM::asMethod(jvmci_method); 996 if (entry_bci >= method->code_size() || entry_bci < -1) { 997 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), err_msg("Unexpected bci %d", entry_bci)); 998 } 999 return CompileBroker::assign_compile_id_unlocked(THREAD, method, entry_bci); 1000 C2V_END 1001 1002 1003 C2V_VMENTRY(jboolean, isMature, (JNIEnv*, jobject, jlong metaspace_method_data)) 1004 MethodData* mdo = CompilerToVM::asMethodData(metaspace_method_data); 1005 return mdo != NULL && mdo->is_mature(); 1006 C2V_END 1007 1008 C2V_VMENTRY(jboolean, hasCompiledCodeForOSR, (JNIEnv*, jobject, jobject jvmci_method, int entry_bci, int comp_level)) 1009 Method* method = CompilerToVM::asMethod(jvmci_method); 1010 return method->lookup_osr_nmethod_for(entry_bci, comp_level, true) != NULL; 1011 C2V_END 1012 1013 C2V_VMENTRY(jobject, getSymbol, (JNIEnv*, jobject, jlong symbol)) 1014 Handle sym = java_lang_String::create_from_symbol((Symbol*)(address)symbol, CHECK_NULL); 1015 return JNIHandles::make_local(THREAD, sym()); 1016 C2V_END 1017 1018 bool matches(jobjectArray methods, Method* method) { 1019 objArrayOop methods_oop = (objArrayOop) JNIHandles::resolve(methods); 1020 1021 for (int i = 0; i < methods_oop->length(); i++) { 1022 oop resolved = methods_oop->obj_at(i); 1023 if (resolved->is_a(HotSpotResolvedJavaMethodImpl::klass()) && CompilerToVM::asMethod(resolved) == method) { 1024 return true; 1025 } 1026 } 1027 return false; 1028 } 1029 1030 C2V_VMENTRY(jobject, getNextStackFrame, (JNIEnv*, jobject compilerToVM, jobject hs_frame, jobjectArray methods, jint initialSkip)) 1031 ResourceMark rm; 1032 1033 if (!thread->has_last_Java_frame()) return NULL; 1034 Handle result = HotSpotStackFrameReference::klass()->allocate_instance(thread); 1035 HotSpotStackFrameReference::klass()->initialize(thread); 1036 1037 StackFrameStream fst(thread); 1038 if (hs_frame != NULL) { 1039 // look for the correct stack frame if one is given 1040 intptr_t* stack_pointer = (intptr_t*) HotSpotStackFrameReference::stackPointer(hs_frame); 1041 while (fst.current()->sp() != stack_pointer && !fst.is_done()) { 1042 fst.next(); 1043 } 1044 if (fst.current()->sp() != stack_pointer) { 1045 THROW_MSG_NULL(vmSymbols::java_lang_IllegalStateException(), "stack frame not found") 1046 } 1047 } 1048 1049 int frame_number = 0; 1050 vframe* vf = vframe::new_vframe(fst.current(), fst.register_map(), thread); 1051 if (hs_frame != NULL) { 1052 // look for the correct vframe within the stack frame if one is given 1053 int last_frame_number = HotSpotStackFrameReference::frameNumber(hs_frame); 1054 while (frame_number < last_frame_number) { 1055 if (vf->is_top()) { 1056 THROW_MSG_NULL(vmSymbols::java_lang_IllegalStateException(), "invalid frame number") 1057 } 1058 vf = vf->sender(); 1059 frame_number ++; 1060 } 1061 // move one frame forward 1062 if (vf->is_top()) { 1063 if (fst.is_done()) { 1064 return NULL; 1065 } 1066 fst.next(); 1067 vf = vframe::new_vframe(fst.current(), fst.register_map(), thread); 1068 frame_number = 0; 1069 } else { 1070 vf = vf->sender(); 1071 frame_number++; 1072 } 1073 } 1074 1075 while (true) { 1076 // look for the given method 1077 while (true) { 1078 StackValueCollection* locals = NULL; 1079 if (vf->is_compiled_frame()) { 1080 // compiled method frame 1081 compiledVFrame* cvf = compiledVFrame::cast(vf); 1082 if (methods == NULL || matches(methods, cvf->method())) { 1083 if (initialSkip > 0) { 1084 initialSkip --; 1085 } else { 1086 ScopeDesc* scope = cvf->scope(); 1087 // native wrapper do not have a scope 1088 if (scope != NULL && scope->objects() != NULL) { 1089 bool realloc_failures = Deoptimization::realloc_objects(thread, fst.current(), scope->objects(), THREAD); 1090 Deoptimization::reassign_fields(fst.current(), fst.register_map(), scope->objects(), realloc_failures, false); 1091 1092 GrowableArray<ScopeValue*>* local_values = scope->locals(); 1093 typeArrayHandle array = oopFactory::new_boolArray(local_values->length(), thread); 1094 for (int i = 0; i < local_values->length(); i++) { 1095 ScopeValue* value = local_values->at(i); 1096 if (value->is_object()) { 1097 array->bool_at_put(i, true); 1098 } 1099 } 1100 HotSpotStackFrameReference::set_localIsVirtual(result, array()); 1101 } else { 1102 HotSpotStackFrameReference::set_localIsVirtual(result, NULL); 1103 } 1104 1105 locals = cvf->locals(); 1106 HotSpotStackFrameReference::set_bci(result, cvf->bci()); 1107 oop method = CompilerToVM::get_jvmci_method(cvf->method(), CHECK_NULL); 1108 HotSpotStackFrameReference::set_method(result, method); 1109 } 1110 } 1111 } else if (vf->is_interpreted_frame()) { 1112 // interpreted method frame 1113 interpretedVFrame* ivf = interpretedVFrame::cast(vf); 1114 if (methods == NULL || matches(methods, ivf->method())) { 1115 if (initialSkip > 0) { 1116 initialSkip --; 1117 } else { 1118 locals = ivf->locals(); 1119 HotSpotStackFrameReference::set_bci(result, ivf->bci()); 1120 oop method = CompilerToVM::get_jvmci_method(ivf->method(), CHECK_NULL); 1121 HotSpotStackFrameReference::set_method(result, method); 1122 HotSpotStackFrameReference::set_localIsVirtual(result, NULL); 1123 } 1124 } 1125 } 1126 1127 // locals != NULL means that we found a matching frame and result is already partially initialized 1128 if (locals != NULL) { 1129 HotSpotStackFrameReference::set_compilerToVM(result, JNIHandles::resolve(compilerToVM)); 1130 HotSpotStackFrameReference::set_stackPointer(result, (jlong) fst.current()->sp()); 1131 HotSpotStackFrameReference::set_frameNumber(result, frame_number); 1132 1133 // initialize the locals array 1134 objArrayHandle array = oopFactory::new_objectArray(locals->size(), thread); 1135 for (int i = 0; i < locals->size(); i++) { 1136 StackValue* var = locals->at(i); 1137 if (var->type() == T_OBJECT) { 1138 array->obj_at_put(i, locals->at(i)->get_obj()()); 1139 } 1140 } 1141 HotSpotStackFrameReference::set_locals(result, array()); 1142 1143 return JNIHandles::make_local(thread, result()); 1144 } 1145 1146 if (vf->is_top()) { 1147 break; 1148 } 1149 frame_number++; 1150 vf = vf->sender(); 1151 } // end of vframe loop 1152 1153 if (fst.is_done()) { 1154 break; 1155 } 1156 fst.next(); 1157 vf = vframe::new_vframe(fst.current(), fst.register_map(), thread); 1158 frame_number = 0; 1159 } // end of frame loop 1160 1161 // the end was reached without finding a matching method 1162 return NULL; 1163 C2V_END 1164 1165 C2V_VMENTRY(void, resolveInvokeDynamicInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 1166 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 1167 CallInfo callInfo; 1168 LinkResolver::resolve_invoke(callInfo, Handle(), cp, index, Bytecodes::_invokedynamic, CHECK); 1169 ConstantPoolCacheEntry* cp_cache_entry = cp->invokedynamic_cp_cache_entry_at(index); 1170 cp_cache_entry->set_dynamic_call(cp, callInfo); 1171 C2V_END 1172 1173 C2V_VMENTRY(void, resolveInvokeHandleInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index)) 1174 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool); 1175 CallInfo callInfo; 1176 LinkResolver::resolve_invoke(callInfo, Handle(), cp, index, Bytecodes::_invokehandle, CHECK); 1177 ConstantPoolCacheEntry* cp_cache_entry = cp_cache_entry = cp->cache()->entry_at(cp->decode_cpcache_index(index)); 1178 cp_cache_entry->set_method_handle(cp, callInfo); 1179 C2V_END 1180 1181 C2V_VMENTRY(jboolean, shouldDebugNonSafepoints, (JNIEnv*, jobject)) 1182 //see compute_recording_non_safepoints in debugInfroRec.cpp 1183 if (JvmtiExport::should_post_compiled_method_load() && FLAG_IS_DEFAULT(DebugNonSafepoints)) { 1184 return true; 1185 } 1186 return DebugNonSafepoints; 1187 C2V_END 1188 1189 // public native void materializeVirtualObjects(HotSpotStackFrameReference stackFrame, boolean invalidate); 1190 C2V_VMENTRY(void, materializeVirtualObjects, (JNIEnv*, jobject, jobject hs_frame, bool invalidate)) 1191 ResourceMark rm; 1192 1193 if (hs_frame == NULL) { 1194 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "stack frame is null") 1195 } 1196 1197 HotSpotStackFrameReference::klass()->initialize(thread); 1198 1199 // look for the given stack frame 1200 StackFrameStream fst(thread); 1201 intptr_t* stack_pointer = (intptr_t*) HotSpotStackFrameReference::stackPointer(hs_frame); 1202 while (fst.current()->sp() != stack_pointer && !fst.is_done()) { 1203 fst.next(); 1204 } 1205 if (fst.current()->sp() != stack_pointer) { 1206 THROW_MSG(vmSymbols::java_lang_IllegalStateException(), "stack frame not found") 1207 } 1208 1209 if (invalidate) { 1210 if (!fst.current()->is_compiled_frame()) { 1211 THROW_MSG(vmSymbols::java_lang_IllegalStateException(), "compiled stack frame expected") 1212 } 1213 assert(fst.current()->cb()->is_nmethod(), "nmethod expected"); 1214 ((nmethod*) fst.current()->cb())->make_not_entrant(); 1215 } 1216 Deoptimization::deoptimize(thread, *fst.current(), fst.register_map(), Deoptimization::Reason_none); 1217 // look for the frame again as it has been updated by deopt (pc, deopt state...) 1218 StackFrameStream fstAfterDeopt(thread); 1219 while (fstAfterDeopt.current()->sp() != stack_pointer && !fstAfterDeopt.is_done()) { 1220 fstAfterDeopt.next(); 1221 } 1222 if (fstAfterDeopt.current()->sp() != stack_pointer) { 1223 THROW_MSG(vmSymbols::java_lang_IllegalStateException(), "stack frame not found after deopt") 1224 } 1225 1226 vframe* vf = vframe::new_vframe(fstAfterDeopt.current(), fstAfterDeopt.register_map(), thread); 1227 if (!vf->is_compiled_frame()) { 1228 THROW_MSG(vmSymbols::java_lang_IllegalStateException(), "compiled stack frame expected") 1229 } 1230 1231 GrowableArray<compiledVFrame*>* virtualFrames = new GrowableArray<compiledVFrame*>(10); 1232 while (true) { 1233 assert(vf->is_compiled_frame(), "Wrong frame type"); 1234 virtualFrames->push(compiledVFrame::cast(vf)); 1235 if (vf->is_top()) { 1236 break; 1237 } 1238 vf = vf->sender(); 1239 } 1240 1241 int last_frame_number = HotSpotStackFrameReference::frameNumber(hs_frame); 1242 if (last_frame_number >= virtualFrames->length()) { 1243 THROW_MSG(vmSymbols::java_lang_IllegalStateException(), "invalid frame number") 1244 } 1245 1246 // Reallocate the non-escaping objects and restore their fields. 1247 assert (virtualFrames->at(last_frame_number)->scope() != NULL,"invalid scope"); 1248 GrowableArray<ScopeValue*>* objects = virtualFrames->at(last_frame_number)->scope()->objects(); 1249 1250 if (objects == NULL) { 1251 // no objects to materialize 1252 return; 1253 } 1254 1255 bool realloc_failures = Deoptimization::realloc_objects(thread, fstAfterDeopt.current(), objects, THREAD); 1256 Deoptimization::reassign_fields(fstAfterDeopt.current(), fstAfterDeopt.register_map(), objects, realloc_failures, false); 1257 1258 for (int frame_index = 0; frame_index < virtualFrames->length(); frame_index++) { 1259 compiledVFrame* cvf = virtualFrames->at(frame_index); 1260 1261 GrowableArray<ScopeValue*>* scopeLocals = cvf->scope()->locals(); 1262 StackValueCollection* locals = cvf->locals(); 1263 1264 if (locals != NULL) { 1265 for (int i2 = 0; i2 < locals->size(); i2++) { 1266 StackValue* var = locals->at(i2); 1267 if (var->type() == T_OBJECT && scopeLocals->at(i2)->is_object()) { 1268 jvalue val; 1269 val.l = (jobject) locals->at(i2)->get_obj()(); 1270 cvf->update_local(T_OBJECT, i2, val); 1271 } 1272 } 1273 } 1274 } 1275 1276 // all locals are materialized by now 1277 HotSpotStackFrameReference::set_localIsVirtual(hs_frame, NULL); 1278 1279 // update the locals array 1280 objArrayHandle array = HotSpotStackFrameReference::locals(hs_frame); 1281 StackValueCollection* locals = virtualFrames->at(last_frame_number)->locals(); 1282 for (int i = 0; i < locals->size(); i++) { 1283 StackValue* var = locals->at(i); 1284 if (var->type() == T_OBJECT) { 1285 array->obj_at_put(i, locals->at(i)->get_obj()()); 1286 } 1287 } 1288 C2V_END 1289 1290 C2V_VMENTRY(void, writeDebugOutput, (JNIEnv*, jobject, jbyteArray bytes, jint offset, jint length)) 1291 if (bytes == NULL) { 1292 THROW(vmSymbols::java_lang_NullPointerException()); 1293 } 1294 typeArrayOop array = (typeArrayOop) JNIHandles::resolve(bytes); 1295 1296 // Check if offset and length are non negative. 1297 if (offset < 0 || length < 0) { 1298 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); 1299 } 1300 // Check if the range is valid. 1301 if ((((unsigned int) length + (unsigned int) offset) > (unsigned int) array->length())) { 1302 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); 1303 } 1304 while (length > 0) { 1305 jbyte* start = array->byte_at_addr(offset); 1306 tty->write((char*) start, MIN2(length, O_BUFLEN)); 1307 length -= O_BUFLEN; 1308 offset += O_BUFLEN; 1309 } 1310 C2V_END 1311 1312 C2V_VMENTRY(void, flushDebugOutput, (JNIEnv*, jobject)) 1313 tty->flush(); 1314 C2V_END 1315 1316 C2V_VMENTRY(int, methodDataProfileDataSize, (JNIEnv*, jobject, jlong metaspace_method_data, jint position)) 1317 ResourceMark rm; 1318 MethodData* mdo = CompilerToVM::asMethodData(metaspace_method_data); 1319 ProfileData* profile_data = mdo->data_at(position); 1320 if (mdo->is_valid(profile_data)) { 1321 return profile_data->size_in_bytes(); 1322 } 1323 DataLayout* data = mdo->extra_data_base(); 1324 DataLayout* end = mdo->extra_data_limit(); 1325 for (;; data = mdo->next_extra(data)) { 1326 assert(data < end, "moved past end of extra data"); 1327 profile_data = data->data_in(); 1328 if (mdo->dp_to_di(profile_data->dp()) == position) { 1329 return profile_data->size_in_bytes(); 1330 } 1331 } 1332 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), err_msg("Invalid profile data position %d", position)); 1333 C2V_END 1334 1335 1336 #define CC (char*) /*cast a literal from (const char*)*/ 1337 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &(c2v_ ## f)) 1338 1339 #define STRING "Ljava/lang/String;" 1340 #define OBJECT "Ljava/lang/Object;" 1341 #define CLASS "Ljava/lang/Class;" 1342 #define STACK_TRACE_ELEMENT "Ljava/lang/StackTraceElement;" 1343 #define INSTALLED_CODE "Ljdk/vm/ci/code/InstalledCode;" 1344 #define TARGET_DESCRIPTION "Ljdk/vm/ci/code/TargetDescription;" 1345 #define RESOLVED_METHOD "Ljdk/vm/ci/meta/ResolvedJavaMethod;" 1346 #define HS_RESOLVED_METHOD "Ljdk/vm/ci/hotspot/HotSpotResolvedJavaMethodImpl;" 1347 #define HS_RESOLVED_KLASS "Ljdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl;" 1348 #define HS_CONSTANT_POOL "Ljdk/vm/ci/hotspot/HotSpotConstantPool;" 1349 #define HS_COMPILED_CODE "Ljdk/vm/ci/hotspot/HotSpotCompiledCode;" 1350 #define HS_CONFIG "Ljdk/vm/ci/hotspot/HotSpotVMConfig;" 1351 #define HS_METADATA "Ljdk/vm/ci/hotspot/HotSpotMetaData;" 1352 #define HS_STACK_FRAME_REF "Ljdk/vm/ci/hotspot/HotSpotStackFrameReference;" 1353 #define HS_SPECULATION_LOG "Ljdk/vm/ci/hotspot/HotSpotSpeculationLog;" 1354 #define METASPACE_METHOD_DATA "J" 1355 1356 JNINativeMethod CompilerToVM::methods[] = { 1357 {CC"getBytecode", CC"("HS_RESOLVED_METHOD")[B", FN_PTR(getBytecode)}, 1358 {CC"getExceptionTableStart", CC"("HS_RESOLVED_METHOD")J", FN_PTR(getExceptionTableStart)}, 1359 {CC"getExceptionTableLength", CC"("HS_RESOLVED_METHOD")I", FN_PTR(getExceptionTableLength)}, 1360 {CC"findUniqueConcreteMethod", CC"("HS_RESOLVED_KLASS HS_RESOLVED_METHOD")"HS_RESOLVED_METHOD, FN_PTR(findUniqueConcreteMethod)}, 1361 {CC"getImplementor", CC"("HS_RESOLVED_KLASS")"HS_RESOLVED_KLASS, FN_PTR(getImplementor)}, 1362 {CC"getStackTraceElement", CC"("HS_RESOLVED_METHOD"I)"STACK_TRACE_ELEMENT, FN_PTR(getStackTraceElement)}, 1363 {CC"methodIsIgnoredBySecurityStackWalk", CC"("HS_RESOLVED_METHOD")Z", FN_PTR(methodIsIgnoredBySecurityStackWalk)}, 1364 {CC"doNotInlineOrCompile", CC"("HS_RESOLVED_METHOD")V", FN_PTR(doNotInlineOrCompile)}, 1365 {CC"canInlineMethod", CC"("HS_RESOLVED_METHOD")Z", FN_PTR(canInlineMethod)}, 1366 {CC"shouldInlineMethod", CC"("HS_RESOLVED_METHOD")Z", FN_PTR(shouldInlineMethod)}, 1367 {CC"lookupType", CC"("STRING CLASS"Z)"HS_RESOLVED_KLASS, FN_PTR(lookupType)}, 1368 {CC"lookupNameInPool", CC"("HS_CONSTANT_POOL"I)"STRING, FN_PTR(lookupNameInPool)}, 1369 {CC"lookupNameAndTypeRefIndexInPool", CC"("HS_CONSTANT_POOL"I)I", FN_PTR(lookupNameAndTypeRefIndexInPool)}, 1370 {CC"lookupSignatureInPool", CC"("HS_CONSTANT_POOL"I)"STRING, FN_PTR(lookupSignatureInPool)}, 1371 {CC"lookupKlassRefIndexInPool", CC"("HS_CONSTANT_POOL"I)I", FN_PTR(lookupKlassRefIndexInPool)}, 1372 {CC"lookupKlassInPool", CC"("HS_CONSTANT_POOL"I)Ljava/lang/Object;", FN_PTR(lookupKlassInPool)}, 1373 {CC"lookupAppendixInPool", CC"("HS_CONSTANT_POOL"I)"OBJECT, FN_PTR(lookupAppendixInPool)}, 1374 {CC"lookupMethodInPool", CC"("HS_CONSTANT_POOL"IB)"HS_RESOLVED_METHOD, FN_PTR(lookupMethodInPool)}, 1375 {CC"constantPoolRemapInstructionOperandFromCache", CC"("HS_CONSTANT_POOL"I)I", FN_PTR(constantPoolRemapInstructionOperandFromCache)}, 1376 {CC"resolveConstantInPool", CC"("HS_CONSTANT_POOL"I)"OBJECT, FN_PTR(resolveConstantInPool)}, 1377 {CC"resolvePossiblyCachedConstantInPool", CC"("HS_CONSTANT_POOL"I)"OBJECT, FN_PTR(resolvePossiblyCachedConstantInPool)}, 1378 {CC"resolveTypeInPool", CC"("HS_CONSTANT_POOL"I)"HS_RESOLVED_KLASS, FN_PTR(resolveTypeInPool)}, 1379 {CC"resolveFieldInPool", CC"("HS_CONSTANT_POOL"IB[J)"HS_RESOLVED_KLASS, FN_PTR(resolveFieldInPool)}, 1380 {CC"resolveInvokeDynamicInPool", CC"("HS_CONSTANT_POOL"I)V", FN_PTR(resolveInvokeDynamicInPool)}, 1381 {CC"resolveInvokeHandleInPool", CC"("HS_CONSTANT_POOL"I)V", FN_PTR(resolveInvokeHandleInPool)}, 1382 {CC"resolveMethod", CC"("HS_RESOLVED_KLASS HS_RESOLVED_METHOD HS_RESOLVED_KLASS")"HS_RESOLVED_METHOD, FN_PTR(resolveMethod)}, 1383 {CC"getVtableIndexForInterfaceMethod", CC"("HS_RESOLVED_KLASS HS_RESOLVED_METHOD")I", FN_PTR(getVtableIndexForInterfaceMethod)}, 1384 {CC"getClassInitializer", CC"("HS_RESOLVED_KLASS")"HS_RESOLVED_METHOD, FN_PTR(getClassInitializer)}, 1385 {CC"hasFinalizableSubclass", CC"("HS_RESOLVED_KLASS")Z", FN_PTR(hasFinalizableSubclass)}, 1386 {CC"getMaxCallTargetOffset", CC"(J)J", FN_PTR(getMaxCallTargetOffset)}, 1387 {CC"getResolvedJavaMethodAtSlot", CC"("CLASS"I)"HS_RESOLVED_METHOD, FN_PTR(getResolvedJavaMethodAtSlot)}, 1388 {CC"getResolvedJavaMethod", CC"(Ljava/lang/Object;J)"HS_RESOLVED_METHOD, FN_PTR(getResolvedJavaMethod)}, 1389 {CC"getConstantPool", CC"(Ljava/lang/Object;J)"HS_CONSTANT_POOL, FN_PTR(getConstantPool)}, 1390 {CC"getResolvedJavaType", CC"(Ljava/lang/Object;JZ)"HS_RESOLVED_KLASS, FN_PTR(getResolvedJavaType)}, 1391 {CC"initializeConfiguration", CC"("HS_CONFIG")J", FN_PTR(initializeConfiguration)}, 1392 {CC"installCode", CC"("TARGET_DESCRIPTION HS_COMPILED_CODE INSTALLED_CODE HS_SPECULATION_LOG")I", FN_PTR(installCode)}, 1393 {CC"getMetadata", CC"("TARGET_DESCRIPTION HS_COMPILED_CODE HS_METADATA")I", FN_PTR(getMetadata)}, 1394 {CC"notifyCompilationStatistics", CC"(I"HS_RESOLVED_METHOD"ZIJJ"INSTALLED_CODE")V", FN_PTR(notifyCompilationStatistics)}, 1395 {CC"resetCompilationStatistics", CC"()V", FN_PTR(resetCompilationStatistics)}, 1396 {CC"disassembleCodeBlob", CC"("INSTALLED_CODE")"STRING, FN_PTR(disassembleCodeBlob)}, 1397 {CC"executeInstalledCode", CC"(["OBJECT INSTALLED_CODE")"OBJECT, FN_PTR(executeInstalledCode)}, 1398 {CC"getLineNumberTable", CC"("HS_RESOLVED_METHOD")[J", FN_PTR(getLineNumberTable)}, 1399 {CC"getLocalVariableTableStart", CC"("HS_RESOLVED_METHOD")J", FN_PTR(getLocalVariableTableStart)}, 1400 {CC"getLocalVariableTableLength", CC"("HS_RESOLVED_METHOD")I", FN_PTR(getLocalVariableTableLength)}, 1401 {CC"reprofile", CC"("HS_RESOLVED_METHOD")V", FN_PTR(reprofile)}, 1402 {CC"invalidateInstalledCode", CC"("INSTALLED_CODE")V", FN_PTR(invalidateInstalledCode)}, 1403 {CC"readUncompressedOop", CC"(J)"OBJECT, FN_PTR(readUncompressedOop)}, 1404 {CC"collectCounters", CC"()[J", FN_PTR(collectCounters)}, 1405 {CC"allocateCompileId", CC"("HS_RESOLVED_METHOD"I)I", FN_PTR(allocateCompileId)}, 1406 {CC"isMature", CC"("METASPACE_METHOD_DATA")Z", FN_PTR(isMature)}, 1407 {CC"hasCompiledCodeForOSR", CC"("HS_RESOLVED_METHOD"II)Z", FN_PTR(hasCompiledCodeForOSR)}, 1408 {CC"getSymbol", CC"(J)"STRING, FN_PTR(getSymbol)}, 1409 {CC"getNextStackFrame", CC"("HS_STACK_FRAME_REF "["RESOLVED_METHOD"I)"HS_STACK_FRAME_REF, FN_PTR(getNextStackFrame)}, 1410 {CC"materializeVirtualObjects", CC"("HS_STACK_FRAME_REF"Z)V", FN_PTR(materializeVirtualObjects)}, 1411 {CC"shouldDebugNonSafepoints", CC"()Z", FN_PTR(shouldDebugNonSafepoints)}, 1412 {CC"writeDebugOutput", CC"([BII)V", FN_PTR(writeDebugOutput)}, 1413 {CC"flushDebugOutput", CC"()V", FN_PTR(flushDebugOutput)}, 1414 {CC"methodDataProfileDataSize", CC"(JI)I", FN_PTR(methodDataProfileDataSize)}, 1415 }; 1416 1417 int CompilerToVM::methods_count() { 1418 return sizeof(methods) / sizeof(JNINativeMethod); 1419 } 1420