1 /*
2 * Copyright (c) 2012, 2025, 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 "classfile/javaClasses.inline.hpp"
25 #include "classfile/symbolTable.hpp"
26 #include "classfile/systemDictionary.hpp"
27 #include "classfile/vmClasses.hpp"
28 #include "compiler/compileBroker.hpp"
29 #include "gc/shared/collectedHeap.hpp"
30 #include "gc/shared/memAllocator.hpp"
31 #include "gc/shared/oopStorage.inline.hpp"
32 #include "jvmci/jniAccessMark.inline.hpp"
33 #include "jvmci/jvmciCodeInstaller.hpp"
34 #include "jvmci/jvmciCompilerToVM.hpp"
35 #include "jvmci/jvmciRuntime.hpp"
36 #include "jvmci/metadataHandles.hpp"
37 #include "logging/log.hpp"
38 #include "logging/logStream.hpp"
39 #include "memory/oopFactory.hpp"
40 #include "memory/universe.hpp"
41 #include "oops/constantPool.inline.hpp"
42 #include "oops/klass.inline.hpp"
43 #include "oops/method.inline.hpp"
44 #include "oops/objArrayKlass.hpp"
45 #include "oops/oop.inline.hpp"
46 #include "oops/typeArrayOop.inline.hpp"
47 #include "prims/jvmtiExport.hpp"
48 #include "prims/methodHandles.hpp"
49 #include "runtime/arguments.hpp"
50 #include "runtime/atomic.hpp"
51 #include "runtime/deoptimization.hpp"
52 #include "runtime/fieldDescriptor.inline.hpp"
53 #include "runtime/frame.inline.hpp"
54 #include "runtime/java.hpp"
55 #include "runtime/jniHandles.inline.hpp"
56 #include "runtime/mutex.hpp"
57 #include "runtime/reflection.hpp"
58 #include "runtime/sharedRuntime.hpp"
59 #include "runtime/synchronizer.hpp"
60 #if INCLUDE_G1GC
61 #include "gc/g1/g1BarrierSetRuntime.hpp"
62 #endif // INCLUDE_G1GC
63
64 // Simple helper to see if the caller of a runtime stub which
65 // entered the VM has been deoptimized
66
67 static bool caller_is_deopted() {
68 JavaThread* thread = JavaThread::current();
69 RegisterMap reg_map(thread,
70 RegisterMap::UpdateMap::skip,
71 RegisterMap::ProcessFrames::include,
72 RegisterMap::WalkContinuation::skip);
73 frame runtime_frame = thread->last_frame();
74 frame caller_frame = runtime_frame.sender(®_map);
75 assert(caller_frame.is_compiled_frame(), "must be compiled");
76 return caller_frame.is_deoptimized_frame();
77 }
78
79 // Stress deoptimization
80 static void deopt_caller() {
81 if ( !caller_is_deopted()) {
82 JavaThread* thread = JavaThread::current();
83 RegisterMap reg_map(thread,
84 RegisterMap::UpdateMap::skip,
85 RegisterMap::ProcessFrames::include,
86 RegisterMap::WalkContinuation::skip);
87 frame runtime_frame = thread->last_frame();
88 frame caller_frame = runtime_frame.sender(®_map);
89 Deoptimization::deoptimize_frame(thread, caller_frame.id(), Deoptimization::Reason_constraint);
90 assert(caller_is_deopted(), "Must be deoptimized");
91 }
92 }
93
94 // Manages a scope for a JVMCI runtime call that attempts a heap allocation.
95 // If there is a pending OutOfMemoryError upon closing the scope and the runtime
96 // call is of the variety where allocation failure returns null without an
97 // exception, the following action is taken:
98 // 1. The pending OutOfMemoryError is cleared
99 // 2. null is written to JavaThread::_vm_result_oop
100 class RetryableAllocationMark {
101 private:
102 InternalOOMEMark _iom;
103 public:
104 RetryableAllocationMark(JavaThread* thread) : _iom(thread) {}
105 ~RetryableAllocationMark() {
106 JavaThread* THREAD = _iom.thread(); // For exception macros.
107 if (THREAD != nullptr) {
108 if (HAS_PENDING_EXCEPTION) {
109 oop ex = PENDING_EXCEPTION;
110 THREAD->set_vm_result_oop(nullptr);
111 if (ex->is_a(vmClasses::OutOfMemoryError_klass())) {
112 CLEAR_PENDING_EXCEPTION;
113 }
114 }
115 }
116 }
117 };
118
119 JRT_BLOCK_ENTRY(void, JVMCIRuntime::new_instance_or_null(JavaThread* current, Klass* klass))
120 JRT_BLOCK;
121 assert(klass->is_klass(), "not a class");
122 Handle holder(current, klass->klass_holder()); // keep the klass alive
123 InstanceKlass* h = InstanceKlass::cast(klass);
124 {
125 RetryableAllocationMark ram(current);
126 h->check_valid_for_instantiation(true, CHECK);
127 if (!h->is_initialized()) {
128 // Cannot re-execute class initialization without side effects
129 // so return without attempting the initialization
130 current->set_vm_result_oop(nullptr);
131 return;
132 }
133 // allocate instance and return via TLS
134 oop obj = h->allocate_instance(CHECK);
135 current->set_vm_result_oop(obj);
136 }
137 JRT_BLOCK_END;
138 SharedRuntime::on_slowpath_allocation_exit(current);
139 JRT_END
140
141 JRT_BLOCK_ENTRY(void, JVMCIRuntime::new_array_or_null(JavaThread* current, Klass* array_klass, jint length))
142 JRT_BLOCK;
143 // Note: no handle for klass needed since they are not used
144 // anymore after new_objArray() and no GC can happen before.
145 // (This may have to change if this code changes!)
146 assert(array_klass->is_klass(), "not a class");
147 oop obj;
148 if (array_klass->is_typeArray_klass()) {
149 BasicType elt_type = TypeArrayKlass::cast(array_klass)->element_type();
150 RetryableAllocationMark ram(current);
151 obj = oopFactory::new_typeArray(elt_type, length, CHECK);
152 } else {
153 Handle holder(current, array_klass->klass_holder()); // keep the klass alive
154 Klass* elem_klass = ObjArrayKlass::cast(array_klass)->element_klass();
155 RetryableAllocationMark ram(current);
156 obj = oopFactory::new_objArray(elem_klass, length, CHECK);
157 }
158 // This is pretty rare but this runtime patch is stressful to deoptimization
159 // if we deoptimize here so force a deopt to stress the path.
160 if (DeoptimizeALot) {
161 static int deopts = 0;
162 if (deopts++ % 2 == 0) {
163 // Drop the allocation
164 obj = nullptr;
165 } else {
166 deopt_caller();
167 }
168 }
169 current->set_vm_result_oop(obj);
170 JRT_BLOCK_END;
171 SharedRuntime::on_slowpath_allocation_exit(current);
172 JRT_END
173
174 JRT_ENTRY(void, JVMCIRuntime::new_multi_array_or_null(JavaThread* current, Klass* klass, int rank, jint* dims))
175 assert(klass->is_klass(), "not a class");
176 assert(rank >= 1, "rank must be nonzero");
177 Handle holder(current, klass->klass_holder()); // keep the klass alive
178 RetryableAllocationMark ram(current);
179 oop obj = ArrayKlass::cast(klass)->multi_allocate(rank, dims, CHECK);
180 current->set_vm_result_oop(obj);
181 JRT_END
182
183 JRT_ENTRY(void, JVMCIRuntime::dynamic_new_array_or_null(JavaThread* current, oopDesc* element_mirror, jint length))
184 RetryableAllocationMark ram(current);
185 oop obj = Reflection::reflect_new_array(element_mirror, length, CHECK);
186 current->set_vm_result_oop(obj);
187 JRT_END
188
189 JRT_ENTRY(void, JVMCIRuntime::dynamic_new_instance_or_null(JavaThread* current, oopDesc* type_mirror))
190 InstanceKlass* klass = InstanceKlass::cast(java_lang_Class::as_Klass(type_mirror));
191
192 if (klass == nullptr) {
193 ResourceMark rm(current);
194 THROW(vmSymbols::java_lang_InstantiationException());
195 }
196 RetryableAllocationMark ram(current);
197
198 // Create new instance (the receiver)
199 klass->check_valid_for_instantiation(false, CHECK);
200
201 if (!klass->is_initialized()) {
202 // Cannot re-execute class initialization without side effects
203 // so return without attempting the initialization
204 current->set_vm_result_oop(nullptr);
205 return;
206 }
207
208 oop obj = klass->allocate_instance(CHECK);
209 current->set_vm_result_oop(obj);
210 JRT_END
211
212 extern void vm_exit(int code);
213
214 // Enter this method from compiled code handler below. This is where we transition
215 // to VM mode. This is done as a helper routine so that the method called directly
216 // from compiled code does not have to transition to VM. This allows the entry
217 // method to see if the nmethod that we have just looked up a handler for has
218 // been deoptimized while we were in the vm. This simplifies the assembly code
219 // cpu directories.
220 //
221 // We are entering here from exception stub (via the entry method below)
222 // If there is a compiled exception handler in this method, we will continue there;
223 // otherwise we will unwind the stack and continue at the caller of top frame method
224 // Note: we enter in Java using a special JRT wrapper. This wrapper allows us to
225 // control the area where we can allow a safepoint. After we exit the safepoint area we can
226 // check to see if the handler we are going to return is now in a nmethod that has
227 // been deoptimized. If that is the case we return the deopt blob
228 // unpack_with_exception entry instead. This makes life for the exception blob easier
229 // because making that same check and diverting is painful from assembly language.
230 JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* current, oopDesc* ex, address pc, nmethod*& nm))
231 // Reset method handle flag.
232 current->set_is_method_handle_return(false);
233
234 Handle exception(current, ex);
235
236 // The frame we rethrow the exception to might not have been processed by the GC yet.
237 // The stack watermark barrier takes care of detecting that and ensuring the frame
238 // has updated oops.
239 StackWatermarkSet::after_unwind(current);
240
241 nm = CodeCache::find_nmethod(pc);
242 assert(nm != nullptr, "did not find nmethod");
243 // Adjust the pc as needed/
244 if (nm->is_deopt_pc(pc)) {
245 RegisterMap map(current,
246 RegisterMap::UpdateMap::skip,
247 RegisterMap::ProcessFrames::include,
248 RegisterMap::WalkContinuation::skip);
249 frame exception_frame = current->last_frame().sender(&map);
250 // if the frame isn't deopted then pc must not correspond to the caller of last_frame
251 assert(exception_frame.is_deoptimized_frame(), "must be deopted");
252 pc = exception_frame.pc();
253 }
254 assert(exception.not_null(), "null exceptions should be handled by throw_exception");
255 assert(oopDesc::is_oop(exception()), "just checking");
256 // Check that exception is a subclass of Throwable
257 assert(exception->is_a(vmClasses::Throwable_klass()),
258 "Exception not subclass of Throwable");
259
260 // debugging support
261 // tracing
262 if (log_is_enabled(Info, exceptions)) {
263 ResourceMark rm;
264 stringStream tempst;
265 assert(nm->method() != nullptr, "Unexpected null method()");
266 tempst.print("JVMCI compiled method <%s>\n"
267 " at PC" INTPTR_FORMAT " for thread " INTPTR_FORMAT,
268 nm->method()->print_value_string(), p2i(pc), p2i(current));
269 Exceptions::log_exception(exception, tempst.as_string());
270 }
271 // for AbortVMOnException flag
272 Exceptions::debug_check_abort(exception);
273
274 // Check the stack guard pages and re-enable them if necessary and there is
275 // enough space on the stack to do so. Use fast exceptions only if the guard
276 // pages are enabled.
277 bool guard_pages_enabled = current->stack_overflow_state()->reguard_stack_if_needed();
278
279 if (JvmtiExport::can_post_on_exceptions()) {
280 // To ensure correct notification of exception catches and throws
281 // we have to deoptimize here. If we attempted to notify the
282 // catches and throws during this exception lookup it's possible
283 // we could deoptimize on the way out of the VM and end back in
284 // the interpreter at the throw site. This would result in double
285 // notifications since the interpreter would also notify about
286 // these same catches and throws as it unwound the frame.
287
288 RegisterMap reg_map(current,
289 RegisterMap::UpdateMap::include,
290 RegisterMap::ProcessFrames::include,
291 RegisterMap::WalkContinuation::skip);
292 frame stub_frame = current->last_frame();
293 frame caller_frame = stub_frame.sender(®_map);
294
295 // We don't really want to deoptimize the nmethod itself since we
296 // can actually continue in the exception handler ourselves but I
297 // don't see an easy way to have the desired effect.
298 Deoptimization::deoptimize_frame(current, caller_frame.id(), Deoptimization::Reason_constraint);
299 assert(caller_is_deopted(), "Must be deoptimized");
300
301 return SharedRuntime::deopt_blob()->unpack_with_exception_in_tls();
302 }
303
304 // ExceptionCache is used only for exceptions at call sites and not for implicit exceptions
305 if (guard_pages_enabled) {
306 address fast_continuation = nm->handler_for_exception_and_pc(exception, pc);
307 if (fast_continuation != nullptr) {
308 // Set flag if return address is a method handle call site.
309 current->set_is_method_handle_return(nm->is_method_handle_return(pc));
310 return fast_continuation;
311 }
312 }
313
314 // If the stack guard pages are enabled, check whether there is a handler in
315 // the current method. Otherwise (guard pages disabled), force an unwind and
316 // skip the exception cache update (i.e., just leave continuation==nullptr).
317 address continuation = nullptr;
318 if (guard_pages_enabled) {
319
320 // New exception handling mechanism can support inlined methods
321 // with exception handlers since the mappings are from PC to PC
322
323 // Clear out the exception oop and pc since looking up an
324 // exception handler can cause class loading, which might throw an
325 // exception and those fields are expected to be clear during
326 // normal bytecode execution.
327 current->clear_exception_oop_and_pc();
328
329 bool recursive_exception = false;
330 continuation = SharedRuntime::compute_compiled_exc_handler(nm, pc, exception, false, false, recursive_exception);
331 // If an exception was thrown during exception dispatch, the exception oop may have changed
332 current->set_exception_oop(exception());
333 current->set_exception_pc(pc);
334
335 // The exception cache is used only for non-implicit exceptions
336 // Update the exception cache only when another exception did
337 // occur during the computation of the compiled exception handler
338 // (e.g., when loading the class of the catch type).
339 // Checking for exception oop equality is not
340 // sufficient because some exceptions are pre-allocated and reused.
341 if (continuation != nullptr && !recursive_exception && !SharedRuntime::deopt_blob()->contains(continuation)) {
342 nm->add_handler_for_exception_and_pc(exception, pc, continuation);
343 }
344 }
345
346 // Set flag if return address is a method handle call site.
347 current->set_is_method_handle_return(nm->is_method_handle_return(pc));
348
349 if (log_is_enabled(Info, exceptions)) {
350 ResourceMark rm;
351 log_info(exceptions)("Thread " PTR_FORMAT " continuing at PC " PTR_FORMAT
352 " for exception thrown at PC " PTR_FORMAT,
353 p2i(current), p2i(continuation), p2i(pc));
354 }
355
356 return continuation;
357 JRT_END
358
359 // Enter this method from compiled code only if there is a Java exception handler
360 // in the method handling the exception.
361 // We are entering here from exception stub. We don't do a normal VM transition here.
362 // We do it in a helper. This is so we can check to see if the nmethod we have just
363 // searched for an exception handler has been deoptimized in the meantime.
364 address JVMCIRuntime::exception_handler_for_pc(JavaThread* current) {
365 oop exception = current->exception_oop();
366 address pc = current->exception_pc();
367 // Still in Java mode
368 DEBUG_ONLY(NoHandleMark nhm);
369 nmethod* nm = nullptr;
370 address continuation = nullptr;
371 {
372 // Enter VM mode by calling the helper
373 ResetNoHandleMark rnhm;
374 continuation = exception_handler_for_pc_helper(current, exception, pc, nm);
375 }
376 // Back in JAVA, use no oops DON'T safepoint
377
378 // Now check to see if the compiled method we were called from is now deoptimized.
379 // If so we must return to the deopt blob and deoptimize the nmethod
380 if (nm != nullptr && caller_is_deopted()) {
381 continuation = SharedRuntime::deopt_blob()->unpack_with_exception_in_tls();
382 }
383
384 assert(continuation != nullptr, "no handler found");
385 return continuation;
386 }
387
388 JRT_BLOCK_ENTRY(void, JVMCIRuntime::monitorenter(JavaThread* current, oopDesc* obj, BasicLock* lock))
389 SharedRuntime::monitor_enter_helper(obj, lock, current);
390 JRT_END
391
392 JRT_LEAF(void, JVMCIRuntime::monitorexit(JavaThread* current, oopDesc* obj, BasicLock* lock))
393 assert(current == JavaThread::current(), "pre-condition");
394 assert(current->last_Java_sp(), "last_Java_sp must be set");
395 assert(oopDesc::is_oop(obj), "invalid lock object pointer dected");
396 SharedRuntime::monitor_exit_helper(obj, lock, current);
397 JRT_END
398
399 // Object.notify() fast path, caller does slow path
400 JRT_LEAF(jboolean, JVMCIRuntime::object_notify(JavaThread* current, oopDesc* obj))
401 assert(current == JavaThread::current(), "pre-condition");
402
403 // Very few notify/notifyAll operations find any threads on the waitset, so
404 // the dominant fast-path is to simply return.
405 // Relatedly, it's critical that notify/notifyAll be fast in order to
406 // reduce lock hold times.
407 if (!SafepointSynchronize::is_synchronizing()) {
408 if (ObjectSynchronizer::quick_notify(obj, current, false)) {
409 return true;
410 }
411 }
412 return false; // caller must perform slow path
413
414 JRT_END
415
416 // Object.notifyAll() fast path, caller does slow path
417 JRT_LEAF(jboolean, JVMCIRuntime::object_notifyAll(JavaThread* current, oopDesc* obj))
418 assert(current == JavaThread::current(), "pre-condition");
419
420 if (!SafepointSynchronize::is_synchronizing() ) {
421 if (ObjectSynchronizer::quick_notify(obj, current, true)) {
422 return true;
423 }
424 }
425 return false; // caller must perform slow path
426
427 JRT_END
428
429 JRT_BLOCK_ENTRY(int, JVMCIRuntime::throw_and_post_jvmti_exception(JavaThread* current, const char* exception, const char* message))
430 JRT_BLOCK;
431 TempNewSymbol symbol = SymbolTable::new_symbol(exception);
432 SharedRuntime::throw_and_post_jvmti_exception(current, symbol, message);
433 JRT_BLOCK_END;
434 return caller_is_deopted();
435 JRT_END
436
437 JRT_BLOCK_ENTRY(int, JVMCIRuntime::throw_klass_external_name_exception(JavaThread* current, const char* exception, Klass* klass))
438 JRT_BLOCK;
439 ResourceMark rm(current);
440 TempNewSymbol symbol = SymbolTable::new_symbol(exception);
441 SharedRuntime::throw_and_post_jvmti_exception(current, symbol, klass->external_name());
442 JRT_BLOCK_END;
443 return caller_is_deopted();
444 JRT_END
445
446 JRT_BLOCK_ENTRY(int, JVMCIRuntime::throw_class_cast_exception(JavaThread* current, const char* exception, Klass* caster_klass, Klass* target_klass))
447 JRT_BLOCK;
448 ResourceMark rm(current);
449 const char* message = SharedRuntime::generate_class_cast_message(caster_klass, target_klass);
450 TempNewSymbol symbol = SymbolTable::new_symbol(exception);
451 SharedRuntime::throw_and_post_jvmti_exception(current, symbol, message);
452 JRT_BLOCK_END;
453 return caller_is_deopted();
454 JRT_END
455
456 class ArgumentPusher : public SignatureIterator {
457 protected:
458 JavaCallArguments* _jca;
459 jlong _argument;
460 bool _pushed;
461
462 jlong next_arg() {
463 guarantee(!_pushed, "one argument");
464 _pushed = true;
465 return _argument;
466 }
467
468 float next_float() {
469 guarantee(!_pushed, "one argument");
470 _pushed = true;
471 jvalue v;
472 v.i = (jint) _argument;
473 return v.f;
474 }
475
476 double next_double() {
477 guarantee(!_pushed, "one argument");
478 _pushed = true;
479 jvalue v;
480 v.j = _argument;
481 return v.d;
482 }
483
484 Handle next_object() {
485 guarantee(!_pushed, "one argument");
486 _pushed = true;
487 return Handle(Thread::current(), cast_to_oop(_argument));
488 }
489
490 public:
491 ArgumentPusher(Symbol* signature, JavaCallArguments* jca, jlong argument) : SignatureIterator(signature) {
492 this->_return_type = T_ILLEGAL;
493 _jca = jca;
494 _argument = argument;
495 _pushed = false;
496 do_parameters_on(this);
497 }
498
499 void do_type(BasicType type) {
500 switch (type) {
501 case T_OBJECT:
502 case T_ARRAY: _jca->push_oop(next_object()); break;
503 case T_BOOLEAN: _jca->push_int((jboolean) next_arg()); break;
504 case T_CHAR: _jca->push_int((jchar) next_arg()); break;
505 case T_SHORT: _jca->push_int((jint) next_arg()); break;
506 case T_BYTE: _jca->push_int((jbyte) next_arg()); break;
507 case T_INT: _jca->push_int((jint) next_arg()); break;
508 case T_LONG: _jca->push_long((jlong) next_arg()); break;
509 case T_FLOAT: _jca->push_float(next_float()); break;
510 case T_DOUBLE: _jca->push_double(next_double()); break;
511 default: fatal("Unexpected type %s", type2name(type));
512 }
513 }
514 };
515
516
517 JRT_ENTRY(jlong, JVMCIRuntime::invoke_static_method_one_arg(JavaThread* current, Method* method, jlong argument))
518 ResourceMark rm;
519 HandleMark hm(current);
520
521 methodHandle mh(current, method);
522 if (mh->size_of_parameters() > 1 && !mh->is_static()) {
523 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Invoked method must be static and take at most one argument");
524 }
525
526 Symbol* signature = mh->signature();
527 JavaCallArguments jca(mh->size_of_parameters());
528 ArgumentPusher jap(signature, &jca, argument);
529 BasicType return_type = jap.return_type();
530 JavaValue result(return_type);
531 JavaCalls::call(&result, mh, &jca, CHECK_0);
532
533 if (return_type == T_VOID) {
534 return 0;
535 } else if (return_type == T_OBJECT || return_type == T_ARRAY) {
536 current->set_vm_result_oop(result.get_oop());
537 return 0;
538 } else {
539 jvalue *value = (jvalue *) result.get_value_addr();
540 // Narrow the value down if required (Important on big endian machines)
541 switch (return_type) {
542 case T_BOOLEAN:
543 return (jboolean) value->i;
544 case T_BYTE:
545 return (jbyte) value->i;
546 case T_CHAR:
547 return (jchar) value->i;
548 case T_SHORT:
549 return (jshort) value->i;
550 case T_INT:
551 case T_FLOAT:
552 return value->i;
553 case T_LONG:
554 case T_DOUBLE:
555 return value->j;
556 default:
557 fatal("Unexpected type %s", type2name(return_type));
558 return 0;
559 }
560 }
561 JRT_END
562
563 JRT_LEAF(void, JVMCIRuntime::log_object(JavaThread* thread, oopDesc* obj, bool as_string, bool newline))
564 ttyLocker ttyl;
565
566 if (obj == nullptr) {
567 tty->print("null");
568 } else if (oopDesc::is_oop_or_null(obj, true) && (!as_string || !java_lang_String::is_instance(obj))) {
569 if (oopDesc::is_oop_or_null(obj, true)) {
570 char buf[O_BUFLEN];
571 tty->print("%s@" INTPTR_FORMAT, obj->klass()->name()->as_C_string(buf, O_BUFLEN), p2i(obj));
572 } else {
573 tty->print(INTPTR_FORMAT, p2i(obj));
574 }
575 } else {
576 ResourceMark rm;
577 assert(obj != nullptr && java_lang_String::is_instance(obj), "must be");
578 char *buf = java_lang_String::as_utf8_string(obj);
579 tty->print_raw(buf);
580 }
581 if (newline) {
582 tty->cr();
583 }
584 JRT_END
585
586 #if INCLUDE_G1GC
587
588 void JVMCIRuntime::write_barrier_pre(JavaThread* thread, oopDesc* obj) {
589 G1BarrierSetRuntime::write_ref_field_pre_entry(obj, thread);
590 }
591
592 void JVMCIRuntime::write_barrier_post(JavaThread* thread, volatile CardValue* card_addr) {
593 G1BarrierSetRuntime::write_ref_field_post_entry(card_addr, thread);
594 }
595
596 #endif // INCLUDE_G1GC
597
598 JRT_LEAF(jboolean, JVMCIRuntime::validate_object(JavaThread* thread, oopDesc* parent, oopDesc* child))
599 bool ret = true;
600 if(!Universe::heap()->is_in(parent)) {
601 tty->print_cr("Parent Object " INTPTR_FORMAT " not in heap", p2i(parent));
602 parent->print();
603 ret=false;
604 }
605 if(!Universe::heap()->is_in(child)) {
606 tty->print_cr("Child Object " INTPTR_FORMAT " not in heap", p2i(child));
607 child->print();
608 ret=false;
609 }
610 return (jint)ret;
611 JRT_END
612
613 JRT_ENTRY(void, JVMCIRuntime::vm_error(JavaThread* current, jlong where, jlong format, jlong value))
614 ResourceMark rm(current);
615 const char *error_msg = where == 0L ? "<internal JVMCI error>" : (char*) (address) where;
616 char *detail_msg = nullptr;
617 if (format != 0L) {
618 const char* buf = (char*) (address) format;
619 size_t detail_msg_length = strlen(buf) * 2;
620 detail_msg = (char *) NEW_RESOURCE_ARRAY(u_char, detail_msg_length);
621 jio_snprintf(detail_msg, detail_msg_length, buf, value);
622 }
623 report_vm_error(__FILE__, __LINE__, error_msg, "%s", detail_msg);
624 JRT_END
625
626 JRT_LEAF(oopDesc*, JVMCIRuntime::load_and_clear_exception(JavaThread* thread))
627 oop exception = thread->exception_oop();
628 assert(exception != nullptr, "npe");
629 thread->set_exception_oop(nullptr);
630 thread->set_exception_pc(nullptr);
631 return exception;
632 JRT_END
633
634 PRAGMA_DIAG_PUSH
635 PRAGMA_FORMAT_NONLITERAL_IGNORED
636 JRT_LEAF(void, JVMCIRuntime::log_printf(JavaThread* thread, const char* format, jlong v1, jlong v2, jlong v3))
637 ResourceMark rm;
638 tty->print(format, v1, v2, v3);
639 JRT_END
640 PRAGMA_DIAG_POP
641
642 static void decipher(jlong v, bool ignoreZero) {
643 if (v != 0 || !ignoreZero) {
644 void* p = (void *)(address) v;
645 CodeBlob* cb = CodeCache::find_blob(p);
646 if (cb) {
647 if (cb->is_nmethod()) {
648 char buf[O_BUFLEN];
649 tty->print("%s [" INTPTR_FORMAT "+" JLONG_FORMAT "]", cb->as_nmethod()->method()->name_and_sig_as_C_string(buf, O_BUFLEN), p2i(cb->code_begin()), (jlong)((address)v - cb->code_begin()));
650 return;
651 }
652 cb->print_value_on(tty);
653 return;
654 }
655 if (Universe::heap()->is_in(p)) {
656 oop obj = cast_to_oop(p);
657 obj->print_value_on(tty);
658 return;
659 }
660 tty->print(INTPTR_FORMAT " [long: " JLONG_FORMAT ", double %lf, char %c]",p2i((void *)v), (jlong)v, (jdouble)v, (char)v);
661 }
662 }
663
664 PRAGMA_DIAG_PUSH
665 PRAGMA_FORMAT_NONLITERAL_IGNORED
666 JRT_LEAF(void, JVMCIRuntime::vm_message(jboolean vmError, jlong format, jlong v1, jlong v2, jlong v3))
667 ResourceMark rm;
668 const char *buf = (const char*) (address) format;
669 if (vmError) {
670 if (buf != nullptr) {
671 fatal(buf, v1, v2, v3);
672 } else {
673 fatal("<anonymous error>");
674 }
675 } else if (buf != nullptr) {
676 tty->print(buf, v1, v2, v3);
677 } else {
678 assert(v2 == 0, "v2 != 0");
679 assert(v3 == 0, "v3 != 0");
680 decipher(v1, false);
681 }
682 JRT_END
683 PRAGMA_DIAG_POP
684
685 JRT_LEAF(void, JVMCIRuntime::log_primitive(JavaThread* thread, jchar typeChar, jlong value, jboolean newline))
686 union {
687 jlong l;
688 jdouble d;
689 jfloat f;
690 } uu;
691 uu.l = value;
692 switch (typeChar) {
693 case 'Z': tty->print(value == 0 ? "false" : "true"); break;
694 case 'B': tty->print("%d", (jbyte) value); break;
695 case 'C': tty->print("%c", (jchar) value); break;
696 case 'S': tty->print("%d", (jshort) value); break;
697 case 'I': tty->print("%d", (jint) value); break;
698 case 'F': tty->print("%f", uu.f); break;
699 case 'J': tty->print(JLONG_FORMAT, value); break;
700 case 'D': tty->print("%lf", uu.d); break;
701 default: assert(false, "unknown typeChar"); break;
702 }
703 if (newline) {
704 tty->cr();
705 }
706 JRT_END
707
708 JRT_ENTRY(jint, JVMCIRuntime::identity_hash_code(JavaThread* current, oopDesc* obj))
709 return (jint) obj->identity_hash();
710 JRT_END
711
712 JRT_ENTRY(jint, JVMCIRuntime::test_deoptimize_call_int(JavaThread* current, int value))
713 deopt_caller();
714 return (jint) value;
715 JRT_END
716
717
718 // Implementation of JVMCI.initializeRuntime()
719 // When called from libjvmci, `libjvmciOrHotspotEnv` is a libjvmci env so use JVM_ENTRY_NO_ENV.
720 JVM_ENTRY_NO_ENV(jobject, JVM_GetJVMCIRuntime(JNIEnv *libjvmciOrHotspotEnv, jclass c))
721 JVMCIENV_FROM_JNI(thread, libjvmciOrHotspotEnv);
722 if (!EnableJVMCI) {
723 JVMCI_THROW_MSG_NULL(InternalError, JVMCI_NOT_ENABLED_ERROR_MESSAGE);
724 }
725 JVMCIENV->runtime()->initialize_HotSpotJVMCIRuntime(JVMCI_CHECK_NULL);
726 JVMCIObject runtime = JVMCIENV->runtime()->get_HotSpotJVMCIRuntime(JVMCI_CHECK_NULL);
727 return JVMCIENV->get_jobject(runtime);
728 JVM_END
729
730 // Implementation of Services.readSystemPropertiesInfo(int[] offsets)
731 // When called from libjvmci, `env` is a libjvmci env so use JVM_ENTRY_NO_ENV.
732 JVM_ENTRY_NO_ENV(jlong, JVM_ReadSystemPropertiesInfo(JNIEnv *env, jclass c, jintArray offsets_handle))
733 JVMCIENV_FROM_JNI(thread, env);
734 if (!EnableJVMCI) {
735 JVMCI_THROW_MSG_0(InternalError, JVMCI_NOT_ENABLED_ERROR_MESSAGE);
736 }
737 JVMCIPrimitiveArray offsets = JVMCIENV->wrap(offsets_handle);
738 JVMCIENV->put_int_at(offsets, 0, SystemProperty::next_offset_in_bytes());
739 JVMCIENV->put_int_at(offsets, 1, SystemProperty::key_offset_in_bytes());
740 JVMCIENV->put_int_at(offsets, 2, PathString::value_offset_in_bytes());
741
742 return (jlong) Arguments::system_properties();
743 JVM_END
744
745
746 void JVMCINMethodData::initialize(int nmethod_mirror_index,
747 int nmethod_entry_patch_offset,
748 const char* nmethod_mirror_name,
749 FailedSpeculation** failed_speculations)
750 {
751 _failed_speculations = failed_speculations;
752 _nmethod_mirror_index = nmethod_mirror_index;
753 guarantee(nmethod_entry_patch_offset != -1, "missing entry barrier");
754 _nmethod_entry_patch_offset = nmethod_entry_patch_offset;
755 if (nmethod_mirror_name != nullptr) {
756 _has_name = true;
757 char* dest = (char*) name();
758 strcpy(dest, nmethod_mirror_name);
759 } else {
760 _has_name = false;
761 }
762 }
763
764 void JVMCINMethodData::copy(JVMCINMethodData* data) {
765 initialize(data->_nmethod_mirror_index, data->_nmethod_entry_patch_offset, data->name(), data->_failed_speculations);
766 }
767
768 void JVMCINMethodData::add_failed_speculation(nmethod* nm, jlong speculation) {
769 jlong index = speculation >> JVMCINMethodData::SPECULATION_LENGTH_BITS;
770 guarantee(index >= 0 && index <= max_jint, "Encoded JVMCI speculation index is not a positive Java int: " INTPTR_FORMAT, index);
771 int length = speculation & JVMCINMethodData::SPECULATION_LENGTH_MASK;
772 if (index + length > (uint) nm->speculations_size()) {
773 fatal(INTPTR_FORMAT "[index: " JLONG_FORMAT ", length: %d out of bounds wrt encoded speculations of length %u", speculation, index, length, nm->speculations_size());
774 }
775 address data = nm->speculations_begin() + index;
776 FailedSpeculation::add_failed_speculation(nm, _failed_speculations, data, length);
777 }
778
779 oop JVMCINMethodData::get_nmethod_mirror(nmethod* nm, bool phantom_ref) {
780 if (_nmethod_mirror_index == -1) {
781 return nullptr;
782 }
783 if (phantom_ref) {
784 return nm->oop_at_phantom(_nmethod_mirror_index);
785 } else {
786 return nm->oop_at(_nmethod_mirror_index);
787 }
788 }
789
790 void JVMCINMethodData::set_nmethod_mirror(nmethod* nm, oop new_mirror) {
791 guarantee(_nmethod_mirror_index != -1, "cannot set JVMCI mirror for nmethod");
792 oop* addr = nm->oop_addr_at(_nmethod_mirror_index);
793 guarantee(new_mirror != nullptr, "use clear_nmethod_mirror to clear the mirror");
794 guarantee(*addr == nullptr, "cannot overwrite non-null mirror");
795
796 *addr = new_mirror;
797
798 // Since we've patched some oops in the nmethod,
799 // (re)register it with the heap.
800 MutexLocker ml(CodeCache_lock, Mutex::_no_safepoint_check_flag);
801 Universe::heap()->register_nmethod(nm);
802 }
803
804 void JVMCINMethodData::invalidate_nmethod_mirror(nmethod* nm) {
805 oop nmethod_mirror = get_nmethod_mirror(nm, /* phantom_ref */ false);
806 if (nmethod_mirror == nullptr) {
807 return;
808 }
809
810 // Update the values in the mirror if it still refers to nm.
811 // We cannot use JVMCIObject to wrap the mirror as this is called
812 // during GC, forbidding the creation of JNIHandles.
813 JVMCIEnv* jvmciEnv = nullptr;
814 nmethod* current = (nmethod*) HotSpotJVMCI::InstalledCode::address(jvmciEnv, nmethod_mirror);
815 if (nm == current) {
816 if (nm->is_unloading()) {
817 // Break the link from the mirror to nm such that
818 // future invocations via the mirror will result in
819 // an InvalidInstalledCodeException.
820 HotSpotJVMCI::InstalledCode::set_address(jvmciEnv, nmethod_mirror, 0);
821 HotSpotJVMCI::InstalledCode::set_entryPoint(jvmciEnv, nmethod_mirror, 0);
822 HotSpotJVMCI::HotSpotInstalledCode::set_codeStart(jvmciEnv, nmethod_mirror, 0);
823 } else if (nm->is_not_entrant()) {
824 // Zero the entry point so any new invocation will fail but keep
825 // the address link around that so that existing activations can
826 // be deoptimized via the mirror (i.e. JVMCIEnv::invalidate_installed_code).
827 HotSpotJVMCI::InstalledCode::set_entryPoint(jvmciEnv, nmethod_mirror, 0);
828 HotSpotJVMCI::HotSpotInstalledCode::set_codeStart(jvmciEnv, nmethod_mirror, 0);
829 }
830 }
831
832 if (_nmethod_mirror_index != -1 && nm->is_unloading()) {
833 // Drop the reference to the nmethod mirror object but don't clear the actual oop reference. Otherwise
834 // it would appear that the nmethod didn't need to be unloaded in the first place.
835 _nmethod_mirror_index = -1;
836 }
837 }
838
839 // Handles to objects in the Hotspot heap.
840 static OopStorage* object_handles() {
841 return Universe::vm_global();
842 }
843
844 jlong JVMCIRuntime::make_oop_handle(const Handle& obj) {
845 assert(!Universe::heap()->is_stw_gc_active(), "can't extend the root set during GC pause");
846 assert(oopDesc::is_oop(obj()), "not an oop");
847
848 oop* ptr = OopHandle(object_handles(), obj()).ptr_raw();
849 MutexLocker ml(_lock);
850 _oop_handles.append(ptr);
851 return reinterpret_cast<jlong>(ptr);
852 }
853
854 #ifdef ASSERT
855 bool JVMCIRuntime::is_oop_handle(jlong handle) {
856 const oop* ptr = (oop*) handle;
857 return object_handles()->allocation_status(ptr) == OopStorage::ALLOCATED_ENTRY;
858 }
859 #endif
860
861 int JVMCIRuntime::release_and_clear_oop_handles() {
862 guarantee(_num_attached_threads == cannot_be_attached, "only call during JVMCI runtime shutdown");
863 int released = release_cleared_oop_handles();
864 if (_oop_handles.length() != 0) {
865 for (int i = 0; i < _oop_handles.length(); i++) {
866 oop* oop_ptr = _oop_handles.at(i);
867 guarantee(oop_ptr != nullptr, "release_cleared_oop_handles left null entry in _oop_handles");
868 guarantee(NativeAccess<>::oop_load(oop_ptr) != nullptr, "unexpected cleared handle");
869 // Satisfy OopHandles::release precondition that all
870 // handles being released are null.
871 NativeAccess<>::oop_store(oop_ptr, (oop) nullptr);
872 }
873
874 // Do the bulk release
875 object_handles()->release(_oop_handles.adr_at(0), _oop_handles.length());
876 released += _oop_handles.length();
877 }
878 _oop_handles.clear();
879 return released;
880 }
881
882 static bool is_referent_non_null(oop* handle) {
883 return handle != nullptr && NativeAccess<>::oop_load(handle) != nullptr;
884 }
885
886 // Swaps the elements in `array` at index `a` and index `b`
887 static void swap(GrowableArray<oop*>* array, int a, int b) {
888 oop* tmp = array->at(a);
889 array->at_put(a, array->at(b));
890 array->at_put(b, tmp);
891 }
892
893 int JVMCIRuntime::release_cleared_oop_handles() {
894 // Despite this lock, it's possible for another thread
895 // to clear a handle's referent concurrently (e.g., a thread
896 // executing IndirectHotSpotObjectConstantImpl.clear()).
897 // This is benign - it means there can still be cleared
898 // handles in _oop_handles when this method returns.
899 MutexLocker ml(_lock);
900
901 int next = 0;
902 if (_oop_handles.length() != 0) {
903 // Key for _oop_handles contents in example below:
904 // H: handle with non-null referent
905 // h: handle with clear (i.e., null) referent
906 // -: null entry
907
908 // Shuffle all handles with non-null referents to the front of the list
909 // Example: Before: 0HHh-Hh-
910 // After: HHHh--h-
911 for (int i = 0; i < _oop_handles.length(); i++) {
912 oop* handle = _oop_handles.at(i);
913 if (is_referent_non_null(handle)) {
914 if (i != next && !is_referent_non_null(_oop_handles.at(next))) {
915 // Swap elements at index `next` and `i`
916 swap(&_oop_handles, next, i);
917 }
918 next++;
919 }
920 }
921
922 // `next` is now the index of the first null handle or handle with a null referent
923 int num_alive = next;
924
925 // Shuffle all null handles to the end of the list
926 // Example: Before: HHHh--h-
927 // After: HHHhh---
928 // num_alive: 3
929 for (int i = next; i < _oop_handles.length(); i++) {
930 oop* handle = _oop_handles.at(i);
931 if (handle != nullptr) {
932 if (i != next && _oop_handles.at(next) == nullptr) {
933 // Swap elements at index `next` and `i`
934 swap(&_oop_handles, next, i);
935 }
936 next++;
937 }
938 }
939 if (next != num_alive) {
940 int to_release = next - num_alive;
941
942 // `next` is now the index of the first null handle
943 // Example: to_release: 2
944
945 // Bulk release the handles with a null referent
946 object_handles()->release(_oop_handles.adr_at(num_alive), to_release);
947
948 // Truncate oop handles to only those with a non-null referent
949 JVMCI_event_2("compacted oop handles in JVMCI runtime %d from %d to %d", _id, _oop_handles.length(), num_alive);
950 _oop_handles.trunc_to(num_alive);
951 // Example: HHH
952
953 return to_release;
954 }
955 }
956 return 0;
957 }
958
959 jmetadata JVMCIRuntime::allocate_handle(const methodHandle& handle) {
960 MutexLocker ml(_lock);
961 return _metadata_handles->allocate_handle(handle);
962 }
963
964 jmetadata JVMCIRuntime::allocate_handle(const constantPoolHandle& handle) {
965 MutexLocker ml(_lock);
966 return _metadata_handles->allocate_handle(handle);
967 }
968
969 void JVMCIRuntime::release_handle(jmetadata handle) {
970 MutexLocker ml(_lock);
971 _metadata_handles->chain_free_list(handle);
972 }
973
974 // Function for redirecting shared library JavaVM output to tty
975 static void _log(const char* buf, size_t count) {
976 tty->write((char*) buf, count);
977 }
978
979 // Function for redirecting shared library JavaVM fatal error data to a log file.
980 // The log file is opened on first call to this function.
981 static void _fatal_log(const char* buf, size_t count) {
982 JVMCI::fatal_log(buf, count);
983 }
984
985 // Function for shared library JavaVM to flush tty
986 static void _flush_log() {
987 tty->flush();
988 }
989
990 // Function for shared library JavaVM to exit HotSpot on a fatal error
991 static void _fatal() {
992 Thread* thread = Thread::current_or_null_safe();
993 if (thread != nullptr && thread->is_Java_thread()) {
994 JavaThread* jthread = JavaThread::cast(thread);
995 JVMCIRuntime* runtime = jthread->libjvmci_runtime();
996 if (runtime != nullptr) {
997 int javaVM_id = runtime->get_shared_library_javavm_id();
998 fatal("Fatal error in JVMCI shared library JavaVM[%d] owned by JVMCI runtime %d", javaVM_id, runtime->id());
999 }
1000 }
1001 intx current_thread_id = os::current_thread_id();
1002 fatal("thread %zd: Fatal error in JVMCI shared library", current_thread_id);
1003 }
1004
1005 JVMCIRuntime::JVMCIRuntime(JVMCIRuntime* next, int id, bool for_compile_broker) :
1006 _init_state(uninitialized),
1007 _shared_library_javavm(nullptr),
1008 _shared_library_javavm_id(0),
1009 _id(id),
1010 _next(next),
1011 _metadata_handles(new MetadataHandles()),
1012 _oop_handles(100, mtJVMCI),
1013 _num_attached_threads(0),
1014 _for_compile_broker(for_compile_broker)
1015 {
1016 if (id == -1) {
1017 _lock = JVMCIRuntime_lock;
1018 } else {
1019 stringStream lock_name;
1020 lock_name.print("%s@%d", JVMCIRuntime_lock->name(), id);
1021 Mutex::Rank lock_rank = DEBUG_ONLY(JVMCIRuntime_lock->rank()) NOT_DEBUG(Mutex::safepoint);
1022 _lock = new PaddedMonitor(lock_rank, lock_name.as_string(/*c_heap*/true));
1023 }
1024 JVMCI_event_1("created new %s JVMCI runtime %d (" PTR_FORMAT ")",
1025 id == -1 ? "Java" : for_compile_broker ? "CompileBroker" : "Compiler", id, p2i(this));
1026 }
1027
1028 JVMCIRuntime* JVMCIRuntime::select_runtime_in_shutdown(JavaThread* thread) {
1029 assert(JVMCI_lock->owner() == thread, "must be");
1030 // When shutting down, use the first available runtime.
1031 for (JVMCIRuntime* runtime = JVMCI::_compiler_runtimes; runtime != nullptr; runtime = runtime->_next) {
1032 if (runtime->_num_attached_threads != cannot_be_attached) {
1033 runtime->pre_attach_thread(thread);
1034 JVMCI_event_1("using pre-existing JVMCI runtime %d in shutdown", runtime->id());
1035 return runtime;
1036 }
1037 }
1038 // Lazily initialize JVMCI::_shutdown_compiler_runtime. Safe to
1039 // do here since JVMCI_lock is locked.
1040 if (JVMCI::_shutdown_compiler_runtime == nullptr) {
1041 JVMCI::_shutdown_compiler_runtime = new JVMCIRuntime(nullptr, -2, true);
1042 }
1043 JVMCIRuntime* runtime = JVMCI::_shutdown_compiler_runtime;
1044 JVMCI_event_1("using reserved shutdown JVMCI runtime %d", runtime->id());
1045 return runtime;
1046 }
1047
1048 JVMCIRuntime* JVMCIRuntime::select_runtime(JavaThread* thread, JVMCIRuntime* skip, int* count) {
1049 assert(JVMCI_lock->owner() == thread, "must be");
1050 bool for_compile_broker = thread->is_Compiler_thread();
1051 for (JVMCIRuntime* runtime = JVMCI::_compiler_runtimes; runtime != nullptr; runtime = runtime->_next) {
1052 if (count != nullptr) {
1053 (*count)++;
1054 }
1055 if (for_compile_broker == runtime->_for_compile_broker) {
1056 int count = runtime->_num_attached_threads;
1057 if (count == cannot_be_attached || runtime == skip) {
1058 // Cannot attach to rt
1059 continue;
1060 }
1061 // If selecting for repacking, ignore a runtime without an existing JavaVM
1062 if (skip != nullptr && !runtime->has_shared_library_javavm()) {
1063 continue;
1064 }
1065
1066 // Select first runtime with sufficient capacity
1067 if (count < (int) JVMCIThreadsPerNativeLibraryRuntime) {
1068 runtime->pre_attach_thread(thread);
1069 return runtime;
1070 }
1071 }
1072 }
1073 return nullptr;
1074 }
1075
1076 JVMCIRuntime* JVMCIRuntime::select_or_create_runtime(JavaThread* thread) {
1077 assert(JVMCI_lock->owner() == thread, "must be");
1078 int id = 0;
1079 JVMCIRuntime* runtime;
1080 if (JVMCI::using_singleton_shared_library_runtime()) {
1081 runtime = JVMCI::_compiler_runtimes;
1082 guarantee(runtime != nullptr, "must be");
1083 while (runtime->_num_attached_threads == cannot_be_attached) {
1084 // Since there is only a singleton JVMCIRuntime, we
1085 // need to wait for it to be available for attaching.
1086 JVMCI_lock->wait();
1087 }
1088 runtime->pre_attach_thread(thread);
1089 } else {
1090 runtime = select_runtime(thread, nullptr, &id);
1091 }
1092 if (runtime == nullptr) {
1093 runtime = new JVMCIRuntime(JVMCI::_compiler_runtimes, id, thread->is_Compiler_thread());
1094 JVMCI::_compiler_runtimes = runtime;
1095 runtime->pre_attach_thread(thread);
1096 }
1097 return runtime;
1098 }
1099
1100 JVMCIRuntime* JVMCIRuntime::for_thread(JavaThread* thread) {
1101 assert(thread->libjvmci_runtime() == nullptr, "must be");
1102 // Find the runtime with fewest attached threads
1103 JVMCIRuntime* runtime = nullptr;
1104 {
1105 MutexLocker locker(JVMCI_lock);
1106 runtime = JVMCI::in_shutdown() ? select_runtime_in_shutdown(thread) : select_or_create_runtime(thread);
1107 }
1108 runtime->attach_thread(thread);
1109 return runtime;
1110 }
1111
1112 const char* JVMCIRuntime::attach_shared_library_thread(JavaThread* thread, JavaVM* javaVM) {
1113 MutexLocker locker(JVMCI_lock);
1114 for (JVMCIRuntime* runtime = JVMCI::_compiler_runtimes; runtime != nullptr; runtime = runtime->_next) {
1115 if (runtime->_shared_library_javavm == javaVM) {
1116 if (runtime->_num_attached_threads == cannot_be_attached) {
1117 return "Cannot attach to JVMCI runtime that is shutting down";
1118 }
1119 runtime->pre_attach_thread(thread);
1120 runtime->attach_thread(thread);
1121 return nullptr;
1122 }
1123 }
1124 return "Cannot find JVMCI runtime";
1125 }
1126
1127 void JVMCIRuntime::pre_attach_thread(JavaThread* thread) {
1128 assert(JVMCI_lock->owner() == thread, "must be");
1129 _num_attached_threads++;
1130 }
1131
1132 void JVMCIRuntime::attach_thread(JavaThread* thread) {
1133 assert(thread->libjvmci_runtime() == nullptr, "must be");
1134 thread->set_libjvmci_runtime(this);
1135 guarantee(this == JVMCI::_shutdown_compiler_runtime ||
1136 _num_attached_threads > 0,
1137 "missing reservation in JVMCI runtime %d: _num_attached_threads=%d", _id, _num_attached_threads);
1138 JVMCI_event_1("attached to JVMCI runtime %d%s", _id, JVMCI::in_shutdown() ? " [in JVMCI shutdown]" : "");
1139 }
1140
1141 void JVMCIRuntime::repack(JavaThread* thread) {
1142 JVMCIRuntime* new_runtime = nullptr;
1143 {
1144 MutexLocker locker(JVMCI_lock);
1145 if (JVMCI::using_singleton_shared_library_runtime() || _num_attached_threads != 1 || JVMCI::in_shutdown()) {
1146 return;
1147 }
1148 new_runtime = select_runtime(thread, this, nullptr);
1149 }
1150 if (new_runtime != nullptr) {
1151 JVMCI_event_1("Moving thread from JVMCI runtime %d to JVMCI runtime %d (%d attached)", _id, new_runtime->_id, new_runtime->_num_attached_threads - 1);
1152 detach_thread(thread, "moving thread to another JVMCI runtime");
1153 new_runtime->attach_thread(thread);
1154 }
1155 }
1156
1157 bool JVMCIRuntime::detach_thread(JavaThread* thread, const char* reason, bool can_destroy_javavm) {
1158 if (this == JVMCI::_shutdown_compiler_runtime || JVMCI::in_shutdown()) {
1159 // Do minimal work when shutting down JVMCI
1160 thread->set_libjvmci_runtime(nullptr);
1161 return false;
1162 }
1163 bool should_shutdown;
1164 bool destroyed_javavm = false;
1165 {
1166 MutexLocker locker(JVMCI_lock);
1167 _num_attached_threads--;
1168 JVMCI_event_1("detaching from JVMCI runtime %d: %s (%d other threads still attached)", _id, reason, _num_attached_threads);
1169 should_shutdown = _num_attached_threads == 0 && !JVMCI::in_shutdown();
1170 if (should_shutdown && !can_destroy_javavm) {
1171 // If it's not possible to destroy the JavaVM on this thread then the VM must
1172 // not be shutdown. This can happen when a shared library thread is the last
1173 // thread to detach from a shared library JavaVM (e.g. GraalServiceThread).
1174 JVMCI_event_1("Cancelled shut down of JVMCI runtime %d", _id);
1175 should_shutdown = false;
1176 }
1177 if (should_shutdown) {
1178 // Prevent other threads from attaching to this runtime
1179 // while it is shutting down and destroying its JavaVM
1180 _num_attached_threads = cannot_be_attached;
1181 }
1182 }
1183 if (should_shutdown) {
1184 // Release the JavaVM resources associated with this
1185 // runtime once there are no threads attached to it.
1186 shutdown();
1187 if (can_destroy_javavm) {
1188 destroyed_javavm = destroy_shared_library_javavm();
1189 if (destroyed_javavm) {
1190 // Can release all handles now that there's no code executing
1191 // that could be using them. Handles for the Java JVMCI runtime
1192 // are never released as we cannot guarantee all compiler threads
1193 // using it have been stopped.
1194 int released = release_and_clear_oop_handles();
1195 JVMCI_event_1("releasing handles for JVMCI runtime %d: oop handles=%d, metadata handles={total=%d, live=%d, blocks=%d}",
1196 _id,
1197 released,
1198 _metadata_handles->num_handles(),
1199 _metadata_handles->num_handles() - _metadata_handles->num_free_handles(),
1200 _metadata_handles->num_blocks());
1201
1202 // No need to acquire _lock since this is the only thread accessing this runtime
1203 _metadata_handles->clear();
1204 }
1205 }
1206 // Allow other threads to attach to this runtime now
1207 MutexLocker locker(JVMCI_lock);
1208 _num_attached_threads = 0;
1209 if (JVMCI::using_singleton_shared_library_runtime()) {
1210 // Notify any thread waiting to attach to the
1211 // singleton JVMCIRuntime
1212 JVMCI_lock->notify();
1213 }
1214 }
1215 thread->set_libjvmci_runtime(nullptr);
1216 JVMCI_event_1("detached from JVMCI runtime %d", _id);
1217 return destroyed_javavm;
1218 }
1219
1220 JNIEnv* JVMCIRuntime::init_shared_library_javavm(int* create_JavaVM_err, const char** err_msg) {
1221 MutexLocker locker(_lock);
1222 JavaVM* javaVM = _shared_library_javavm;
1223 if (javaVM == nullptr) {
1224 #ifdef ASSERT
1225 const char* val = Arguments::PropertyList_get_value(Arguments::system_properties(), "test.jvmci.forceEnomemOnLibjvmciInit");
1226 if (val != nullptr && strcmp(val, "true") == 0) {
1227 *create_JavaVM_err = JNI_ENOMEM;
1228 return nullptr;
1229 }
1230 #endif
1231
1232 char* sl_path;
1233 void* sl_handle = JVMCI::get_shared_library(sl_path, true);
1234
1235 jint (*JNI_CreateJavaVM)(JavaVM **pvm, void **penv, void *args);
1236 typedef jint (*JNI_CreateJavaVM_t)(JavaVM **pvm, void **penv, void *args);
1237
1238 JNI_CreateJavaVM = CAST_TO_FN_PTR(JNI_CreateJavaVM_t, os::dll_lookup(sl_handle, "JNI_CreateJavaVM"));
1239 if (JNI_CreateJavaVM == nullptr) {
1240 fatal("Unable to find JNI_CreateJavaVM in %s", sl_path);
1241 }
1242
1243 ResourceMark rm;
1244 JavaVMInitArgs vm_args;
1245 vm_args.version = JNI_VERSION_1_2;
1246 vm_args.ignoreUnrecognized = JNI_TRUE;
1247 JavaVMOption options[6];
1248 jlong javaVM_id = 0;
1249
1250 // Protocol: JVMCI shared library JavaVM should support a non-standard "_javavm_id"
1251 // option whose extraInfo info field is a pointer to which a unique id for the
1252 // JavaVM should be written.
1253 options[0].optionString = (char*) "_javavm_id";
1254 options[0].extraInfo = &javaVM_id;
1255
1256 options[1].optionString = (char*) "_log";
1257 options[1].extraInfo = (void*) _log;
1258 options[2].optionString = (char*) "_flush_log";
1259 options[2].extraInfo = (void*) _flush_log;
1260 options[3].optionString = (char*) "_fatal";
1261 options[3].extraInfo = (void*) _fatal;
1262 options[4].optionString = (char*) "_fatal_log";
1263 options[4].extraInfo = (void*) _fatal_log;
1264 options[5].optionString = (char*) "_createvm_errorstr";
1265 options[5].extraInfo = (void*) err_msg;
1266
1267 vm_args.version = JNI_VERSION_1_2;
1268 vm_args.options = options;
1269 vm_args.nOptions = sizeof(options) / sizeof(JavaVMOption);
1270
1271 JNIEnv* env = nullptr;
1272 int result = (*JNI_CreateJavaVM)(&javaVM, (void**) &env, &vm_args);
1273 if (result == JNI_OK) {
1274 guarantee(env != nullptr, "missing env");
1275 _shared_library_javavm_id = javaVM_id;
1276 _shared_library_javavm = javaVM;
1277 JVMCI_event_1("created JavaVM[%ld]@" PTR_FORMAT " for JVMCI runtime %d", javaVM_id, p2i(javaVM), _id);
1278 return env;
1279 } else {
1280 *create_JavaVM_err = result;
1281 }
1282 }
1283 return nullptr;
1284 }
1285
1286 void JVMCIRuntime::init_JavaVM_info(jlongArray info, JVMCI_TRAPS) {
1287 if (info != nullptr) {
1288 typeArrayOop info_oop = (typeArrayOop) JNIHandles::resolve(info);
1289 if (info_oop->length() < 4) {
1290 JVMCI_THROW_MSG(ArrayIndexOutOfBoundsException, err_msg("%d < 4", info_oop->length()));
1291 }
1292 JavaVM* javaVM = _shared_library_javavm;
1293 info_oop->long_at_put(0, (jlong) (address) javaVM);
1294 info_oop->long_at_put(1, (jlong) (address) javaVM->functions->reserved0);
1295 info_oop->long_at_put(2, (jlong) (address) javaVM->functions->reserved1);
1296 info_oop->long_at_put(3, (jlong) (address) javaVM->functions->reserved2);
1297 }
1298 }
1299
1300 #define JAVAVM_CALL_BLOCK \
1301 guarantee(thread != nullptr && _shared_library_javavm != nullptr, "npe"); \
1302 ThreadToNativeFromVM ttnfv(thread); \
1303 JavaVM* javavm = _shared_library_javavm;
1304
1305 jint JVMCIRuntime::AttachCurrentThread(JavaThread* thread, void **penv, void *args) {
1306 JAVAVM_CALL_BLOCK
1307 return javavm->AttachCurrentThread(penv, args);
1308 }
1309
1310 jint JVMCIRuntime::AttachCurrentThreadAsDaemon(JavaThread* thread, void **penv, void *args) {
1311 JAVAVM_CALL_BLOCK
1312 return javavm->AttachCurrentThreadAsDaemon(penv, args);
1313 }
1314
1315 jint JVMCIRuntime::DetachCurrentThread(JavaThread* thread) {
1316 JAVAVM_CALL_BLOCK
1317 return javavm->DetachCurrentThread();
1318 }
1319
1320 jint JVMCIRuntime::GetEnv(JavaThread* thread, void **penv, jint version) {
1321 JAVAVM_CALL_BLOCK
1322 return javavm->GetEnv(penv, version);
1323 }
1324 #undef JAVAVM_CALL_BLOCK \
1325
1326 void JVMCIRuntime::initialize_HotSpotJVMCIRuntime(JVMCI_TRAPS) {
1327 if (is_HotSpotJVMCIRuntime_initialized()) {
1328 if (JVMCIENV->is_hotspot() && UseJVMCINativeLibrary) {
1329 JVMCI_THROW_MSG(InternalError, "JVMCI has already been enabled in the JVMCI shared library");
1330 }
1331 }
1332
1333 initialize(JVMCI_CHECK);
1334
1335 // This should only be called in the context of the JVMCI class being initialized
1336 JVMCIObject result = JVMCIENV->call_HotSpotJVMCIRuntime_runtime(JVMCI_CHECK);
1337 result = JVMCIENV->make_global(result);
1338
1339 OrderAccess::storestore(); // Ensure handle is fully constructed before publishing
1340 _HotSpotJVMCIRuntime_instance = result;
1341
1342 JVMCI::_is_initialized = true;
1343 }
1344
1345 JVMCIRuntime::InitState JVMCIRuntime::_shared_library_javavm_refs_init_state = JVMCIRuntime::uninitialized;
1346 JVMCIRuntime::InitState JVMCIRuntime::_hotspot_javavm_refs_init_state = JVMCIRuntime::uninitialized;
1347
1348 class JavaVMRefsInitialization: public StackObj {
1349 JVMCIRuntime::InitState *_state;
1350 int _id;
1351 public:
1352 JavaVMRefsInitialization(JVMCIRuntime::InitState *state, int id) {
1353 _state = state;
1354 _id = id;
1355 // All classes, methods and fields in the JVMCI shared library
1356 // are in the read-only part of the image. As such, these
1357 // values (and any global handle derived from them via NewGlobalRef)
1358 // are the same for all JavaVM instances created in the
1359 // shared library which means they only need to be initialized
1360 // once. In non-product mode, we check this invariant.
1361 // See com.oracle.svm.jni.JNIImageHeapHandles.
1362 // The same is true for Klass* and field offsets in HotSpotJVMCI.
1363 if (*state == JVMCIRuntime::uninitialized DEBUG_ONLY( || true)) {
1364 *state = JVMCIRuntime::being_initialized;
1365 JVMCI_event_1("initializing JavaVM references in JVMCI runtime %d", id);
1366 } else {
1367 while (*state != JVMCIRuntime::fully_initialized) {
1368 JVMCI_event_1("waiting for JavaVM references initialization in JVMCI runtime %d", id);
1369 JVMCI_lock->wait();
1370 }
1371 JVMCI_event_1("done waiting for JavaVM references initialization in JVMCI runtime %d", id);
1372 }
1373 }
1374
1375 ~JavaVMRefsInitialization() {
1376 if (*_state == JVMCIRuntime::being_initialized) {
1377 *_state = JVMCIRuntime::fully_initialized;
1378 JVMCI_event_1("initialized JavaVM references in JVMCI runtime %d", _id);
1379 JVMCI_lock->notify_all();
1380 }
1381 }
1382
1383 bool should_init() {
1384 return *_state == JVMCIRuntime::being_initialized;
1385 }
1386 };
1387
1388 void JVMCIRuntime::initialize(JVMCI_TRAPS) {
1389 // Check first without _lock
1390 if (_init_state == fully_initialized) {
1391 return;
1392 }
1393
1394 JavaThread* THREAD = JavaThread::current();
1395
1396 MutexLocker locker(_lock);
1397 // Check again under _lock
1398 if (_init_state == fully_initialized) {
1399 return;
1400 }
1401
1402 while (_init_state == being_initialized) {
1403 JVMCI_event_1("waiting for initialization of JVMCI runtime %d", _id);
1404 _lock->wait();
1405 if (_init_state == fully_initialized) {
1406 JVMCI_event_1("done waiting for initialization of JVMCI runtime %d", _id);
1407 return;
1408 }
1409 }
1410
1411 JVMCI_event_1("initializing JVMCI runtime %d", _id);
1412 _init_state = being_initialized;
1413
1414 {
1415 MutexUnlocker unlock(_lock);
1416
1417 HandleMark hm(THREAD);
1418 ResourceMark rm(THREAD);
1419 {
1420 MutexLocker lock_jvmci(JVMCI_lock);
1421 if (JVMCIENV->is_hotspot()) {
1422 JavaVMRefsInitialization initialization(&_hotspot_javavm_refs_init_state, _id);
1423 if (initialization.should_init()) {
1424 MutexUnlocker unlock_jvmci(JVMCI_lock);
1425 HotSpotJVMCI::compute_offsets(CHECK_EXIT);
1426 }
1427 } else {
1428 JavaVMRefsInitialization initialization(&_shared_library_javavm_refs_init_state, _id);
1429 if (initialization.should_init()) {
1430 MutexUnlocker unlock_jvmci(JVMCI_lock);
1431 JNIAccessMark jni(JVMCIENV, THREAD);
1432
1433 JNIJVMCI::initialize_ids(jni.env());
1434 if (jni()->ExceptionCheck()) {
1435 jni()->ExceptionDescribe();
1436 fatal("JNI exception during init");
1437 }
1438 // _lock is re-locked at this point
1439 }
1440 }
1441 }
1442
1443 if (!JVMCIENV->is_hotspot()) {
1444 JNIAccessMark jni(JVMCIENV, THREAD);
1445 JNIJVMCI::register_natives(jni.env());
1446 }
1447 create_jvmci_primitive_type(T_BOOLEAN, JVMCI_CHECK_EXIT_((void)0));
1448 create_jvmci_primitive_type(T_BYTE, JVMCI_CHECK_EXIT_((void)0));
1449 create_jvmci_primitive_type(T_CHAR, JVMCI_CHECK_EXIT_((void)0));
1450 create_jvmci_primitive_type(T_SHORT, JVMCI_CHECK_EXIT_((void)0));
1451 create_jvmci_primitive_type(T_INT, JVMCI_CHECK_EXIT_((void)0));
1452 create_jvmci_primitive_type(T_LONG, JVMCI_CHECK_EXIT_((void)0));
1453 create_jvmci_primitive_type(T_FLOAT, JVMCI_CHECK_EXIT_((void)0));
1454 create_jvmci_primitive_type(T_DOUBLE, JVMCI_CHECK_EXIT_((void)0));
1455 create_jvmci_primitive_type(T_VOID, JVMCI_CHECK_EXIT_((void)0));
1456
1457 DEBUG_ONLY(CodeInstaller::verify_bci_constants(JVMCIENV);)
1458 }
1459
1460 _init_state = fully_initialized;
1461 JVMCI_event_1("initialized JVMCI runtime %d", _id);
1462 _lock->notify_all();
1463 }
1464
1465 JVMCIObject JVMCIRuntime::create_jvmci_primitive_type(BasicType type, JVMCI_TRAPS) {
1466 JavaThread* THREAD = JavaThread::current(); // For exception macros.
1467 // These primitive types are long lived and are created before the runtime is fully set up
1468 // so skip registering them for scanning.
1469 JVMCIObject mirror = JVMCIENV->get_object_constant(java_lang_Class::primitive_mirror(type), false, true);
1470 if (JVMCIENV->is_hotspot()) {
1471 JavaValue result(T_OBJECT);
1472 JavaCallArguments args;
1473 args.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(mirror)));
1474 args.push_int(type2char(type));
1475 JavaCalls::call_static(&result, HotSpotJVMCI::HotSpotResolvedPrimitiveType::klass(), vmSymbols::fromMetaspace_name(), vmSymbols::primitive_fromMetaspace_signature(), &args, CHECK_(JVMCIObject()));
1476
1477 return JVMCIENV->wrap(JNIHandles::make_local(result.get_oop()));
1478 } else {
1479 JNIAccessMark jni(JVMCIENV);
1480 jobject result = jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotResolvedPrimitiveType::clazz(),
1481 JNIJVMCI::HotSpotResolvedPrimitiveType_fromMetaspace_method(),
1482 mirror.as_jobject(), type2char(type));
1483 if (jni()->ExceptionCheck()) {
1484 return JVMCIObject();
1485 }
1486 return JVMCIENV->wrap(result);
1487 }
1488 }
1489
1490 void JVMCIRuntime::initialize_JVMCI(JVMCI_TRAPS) {
1491 if (!is_HotSpotJVMCIRuntime_initialized()) {
1492 initialize(JVMCI_CHECK);
1493 JVMCIENV->call_JVMCI_getRuntime(JVMCI_CHECK);
1494 guarantee(_HotSpotJVMCIRuntime_instance.is_non_null(), "NPE in JVMCI runtime %d", _id);
1495 }
1496 }
1497
1498 JVMCIObject JVMCIRuntime::get_HotSpotJVMCIRuntime(JVMCI_TRAPS) {
1499 initialize(JVMCI_CHECK_(JVMCIObject()));
1500 initialize_JVMCI(JVMCI_CHECK_(JVMCIObject()));
1501 return _HotSpotJVMCIRuntime_instance;
1502 }
1503
1504 // Implementation of CompilerToVM.registerNatives()
1505 // When called from libjvmci, `libjvmciOrHotspotEnv` is a libjvmci env so use JVM_ENTRY_NO_ENV.
1506 JVM_ENTRY_NO_ENV(void, JVM_RegisterJVMCINatives(JNIEnv *libjvmciOrHotspotEnv, jclass c2vmClass))
1507 JVMCIENV_FROM_JNI(thread, libjvmciOrHotspotEnv);
1508
1509 if (!EnableJVMCI) {
1510 JVMCI_THROW_MSG(InternalError, JVMCI_NOT_ENABLED_ERROR_MESSAGE);
1511 }
1512
1513 JVMCIENV->runtime()->initialize(JVMCIENV);
1514
1515 {
1516 ResourceMark rm(thread);
1517 HandleMark hm(thread);
1518 ThreadToNativeFromVM trans(thread);
1519
1520 // Ensure _non_oop_bits is initialized
1521 Universe::non_oop_word();
1522 JNIEnv *env = libjvmciOrHotspotEnv;
1523 if (JNI_OK != env->RegisterNatives(c2vmClass, CompilerToVM::methods, CompilerToVM::methods_count())) {
1524 if (!env->ExceptionCheck()) {
1525 for (int i = 0; i < CompilerToVM::methods_count(); i++) {
1526 if (JNI_OK != env->RegisterNatives(c2vmClass, CompilerToVM::methods + i, 1)) {
1527 guarantee(false, "Error registering JNI method %s%s", CompilerToVM::methods[i].name, CompilerToVM::methods[i].signature);
1528 break;
1529 }
1530 }
1531 } else {
1532 env->ExceptionDescribe();
1533 }
1534 guarantee(false, "Failed registering CompilerToVM native methods");
1535 }
1536 }
1537 JVM_END
1538
1539
1540 void JVMCIRuntime::shutdown() {
1541 if (_HotSpotJVMCIRuntime_instance.is_non_null()) {
1542 JVMCI_event_1("shutting down HotSpotJVMCIRuntime for JVMCI runtime %d", _id);
1543 JVMCIEnv __stack_jvmci_env__(JavaThread::current(), _HotSpotJVMCIRuntime_instance.is_hotspot(),__FILE__, __LINE__);
1544 JVMCIEnv* JVMCIENV = &__stack_jvmci_env__;
1545 if (JVMCIENV->init_error() == JNI_OK) {
1546 JVMCIENV->call_HotSpotJVMCIRuntime_shutdown(_HotSpotJVMCIRuntime_instance);
1547 } else {
1548 JVMCI_event_1("Error in JVMCIEnv for shutdown (err: %d)", JVMCIENV->init_error());
1549 }
1550 if (_num_attached_threads == cannot_be_attached) {
1551 // Only when no other threads are attached to this runtime
1552 // is it safe to reset these fields.
1553 _HotSpotJVMCIRuntime_instance = JVMCIObject();
1554 _init_state = uninitialized;
1555 JVMCI_event_1("shut down JVMCI runtime %d", _id);
1556 }
1557 }
1558 }
1559
1560 bool JVMCIRuntime::destroy_shared_library_javavm() {
1561 guarantee(_num_attached_threads == cannot_be_attached,
1562 "cannot destroy JavaVM for JVMCI runtime %d with %d attached threads", _id, _num_attached_threads);
1563 JavaVM* javaVM;
1564 jlong javaVM_id = _shared_library_javavm_id;
1565 {
1566 // Exactly one thread can destroy the JavaVM
1567 // and release the handle to it.
1568 MutexLocker only_one(_lock);
1569 javaVM = _shared_library_javavm;
1570 if (javaVM != nullptr) {
1571 _shared_library_javavm = nullptr;
1572 _shared_library_javavm_id = 0;
1573 }
1574 }
1575 if (javaVM != nullptr) {
1576 int result;
1577 {
1578 // Must transition into native before calling into libjvmci
1579 ThreadToNativeFromVM ttnfv(JavaThread::current());
1580 result = javaVM->DestroyJavaVM();
1581 }
1582 if (result == JNI_OK) {
1583 JVMCI_event_1("destroyed JavaVM[" JLONG_FORMAT "]@" PTR_FORMAT " for JVMCI runtime %d", javaVM_id, p2i(javaVM), _id);
1584 } else {
1585 warning("Non-zero result (%d) when calling JNI_DestroyJavaVM on JavaVM[" JLONG_FORMAT "]@" PTR_FORMAT, result, javaVM_id, p2i(javaVM));
1586 }
1587 return true;
1588 }
1589 return false;
1590 }
1591
1592 void JVMCIRuntime::bootstrap_finished(TRAPS) {
1593 if (_HotSpotJVMCIRuntime_instance.is_non_null()) {
1594 JVMCIENV_FROM_THREAD(THREAD);
1595 JVMCIENV->check_init(CHECK);
1596 JVMCIENV->call_HotSpotJVMCIRuntime_bootstrapFinished(_HotSpotJVMCIRuntime_instance, JVMCIENV);
1597 }
1598 }
1599
1600 void JVMCIRuntime::describe_pending_hotspot_exception(JavaThread* THREAD) {
1601 if (HAS_PENDING_EXCEPTION) {
1602 Handle exception(THREAD, PENDING_EXCEPTION);
1603 CLEAR_PENDING_EXCEPTION;
1604 java_lang_Throwable::print_stack_trace(exception, tty);
1605
1606 // Clear and ignore any exceptions raised during printing
1607 CLEAR_PENDING_EXCEPTION;
1608 }
1609 }
1610
1611
1612 void JVMCIRuntime::fatal_exception(JVMCIEnv* JVMCIENV, const char* message) {
1613 JavaThread* THREAD = JavaThread::current(); // For exception macros.
1614
1615 static volatile int report_error = 0;
1616 if (!report_error && Atomic::cmpxchg(&report_error, 0, 1) == 0) {
1617 // Only report an error once
1618 tty->print_raw_cr(message);
1619 if (JVMCIENV != nullptr) {
1620 JVMCIENV->describe_pending_exception(tty);
1621 } else {
1622 describe_pending_hotspot_exception(THREAD);
1623 }
1624 } else {
1625 // Allow error reporting thread time to print the stack trace.
1626 THREAD->sleep(200);
1627 }
1628 fatal("Fatal JVMCI exception (see JVMCI Events for stack trace): %s", message);
1629 }
1630
1631 // ------------------------------------------------------------------
1632 // Note: the logic of this method should mirror the logic of
1633 // constantPoolOopDesc::verify_constant_pool_resolve.
1634 bool JVMCIRuntime::check_klass_accessibility(Klass* accessing_klass, Klass* resolved_klass) {
1635 if (accessing_klass->is_objArray_klass()) {
1636 accessing_klass = ObjArrayKlass::cast(accessing_klass)->bottom_klass();
1637 }
1638 if (!accessing_klass->is_instance_klass()) {
1639 return true;
1640 }
1641
1642 if (resolved_klass->is_objArray_klass()) {
1643 // Find the element klass, if this is an array.
1644 resolved_klass = ObjArrayKlass::cast(resolved_klass)->bottom_klass();
1645 }
1646 if (resolved_klass->is_instance_klass()) {
1647 Reflection::VerifyClassAccessResults result =
1648 Reflection::verify_class_access(accessing_klass, InstanceKlass::cast(resolved_klass), true);
1649 return result == Reflection::ACCESS_OK;
1650 }
1651 return true;
1652 }
1653
1654 // ------------------------------------------------------------------
1655 Klass* JVMCIRuntime::get_klass_by_name_impl(Klass*& accessing_klass,
1656 const constantPoolHandle& cpool,
1657 Symbol* sym,
1658 bool require_local) {
1659 JVMCI_EXCEPTION_CONTEXT;
1660
1661 // Now we need to check the SystemDictionary
1662 if (sym->char_at(0) == JVM_SIGNATURE_CLASS &&
1663 sym->char_at(sym->utf8_length()-1) == JVM_SIGNATURE_ENDCLASS) {
1664 // This is a name from a signature. Strip off the trimmings.
1665 // Call recursive to keep scope of strippedsym.
1666 TempNewSymbol strippedsym = SymbolTable::new_symbol(sym->as_utf8()+1,
1667 sym->utf8_length()-2);
1668 return get_klass_by_name_impl(accessing_klass, cpool, strippedsym, require_local);
1669 }
1670
1671 Handle loader;
1672 if (accessing_klass != nullptr) {
1673 loader = Handle(THREAD, accessing_klass->class_loader());
1674 }
1675
1676 Klass* found_klass = require_local ?
1677 SystemDictionary::find_instance_or_array_klass(THREAD, sym, loader) :
1678 SystemDictionary::find_constrained_instance_or_array_klass(THREAD, sym, loader);
1679
1680 // If we fail to find an array klass, look again for its element type.
1681 // The element type may be available either locally or via constraints.
1682 // In either case, if we can find the element type in the system dictionary,
1683 // we must build an array type around it. The CI requires array klasses
1684 // to be loaded if their element klasses are loaded, except when memory
1685 // is exhausted.
1686 if (sym->char_at(0) == JVM_SIGNATURE_ARRAY &&
1687 (sym->char_at(1) == JVM_SIGNATURE_ARRAY || sym->char_at(1) == JVM_SIGNATURE_CLASS)) {
1688 // We have an unloaded array.
1689 // Build it on the fly if the element class exists.
1690 TempNewSymbol elem_sym = SymbolTable::new_symbol(sym->as_utf8()+1,
1691 sym->utf8_length()-1);
1692
1693 // Get element Klass recursively.
1694 Klass* elem_klass =
1695 get_klass_by_name_impl(accessing_klass,
1696 cpool,
1697 elem_sym,
1698 require_local);
1699 if (elem_klass != nullptr) {
1700 // Now make an array for it
1701 return elem_klass->array_klass(THREAD);
1702 }
1703 }
1704
1705 if (found_klass == nullptr && !cpool.is_null() && cpool->has_preresolution()) {
1706 // Look inside the constant pool for pre-resolved class entries.
1707 for (int i = cpool->length() - 1; i >= 1; i--) {
1708 if (cpool->tag_at(i).is_klass()) {
1709 Klass* kls = cpool->resolved_klass_at(i);
1710 if (kls->name() == sym) {
1711 return kls;
1712 }
1713 }
1714 }
1715 }
1716
1717 return found_klass;
1718 }
1719
1720 // ------------------------------------------------------------------
1721 Klass* JVMCIRuntime::get_klass_by_name(Klass* accessing_klass,
1722 Symbol* klass_name,
1723 bool require_local) {
1724 ResourceMark rm;
1725 constantPoolHandle cpool;
1726 return get_klass_by_name_impl(accessing_klass,
1727 cpool,
1728 klass_name,
1729 require_local);
1730 }
1731
1732 // ------------------------------------------------------------------
1733 // Implementation of get_klass_by_index.
1734 Klass* JVMCIRuntime::get_klass_by_index_impl(const constantPoolHandle& cpool,
1735 int index,
1736 bool& is_accessible,
1737 Klass* accessor) {
1738 JVMCI_EXCEPTION_CONTEXT;
1739 Klass* klass = ConstantPool::klass_at_if_loaded(cpool, index);
1740 Symbol* klass_name = nullptr;
1741 if (klass == nullptr) {
1742 klass_name = cpool->klass_name_at(index);
1743 }
1744
1745 if (klass == nullptr) {
1746 // Not found in constant pool. Use the name to do the lookup.
1747 Klass* k = get_klass_by_name_impl(accessor,
1748 cpool,
1749 klass_name,
1750 false);
1751 // Calculate accessibility the hard way.
1752 if (k == nullptr) {
1753 is_accessible = false;
1754 } else if (k->class_loader() != accessor->class_loader() &&
1755 get_klass_by_name_impl(accessor, cpool, k->name(), true) == nullptr) {
1756 // Loaded only remotely. Not linked yet.
1757 is_accessible = false;
1758 } else {
1759 // Linked locally, and we must also check public/private, etc.
1760 is_accessible = check_klass_accessibility(accessor, k);
1761 }
1762 if (!is_accessible) {
1763 return nullptr;
1764 }
1765 return k;
1766 }
1767
1768 // It is known to be accessible, since it was found in the constant pool.
1769 is_accessible = true;
1770 return klass;
1771 }
1772
1773 // ------------------------------------------------------------------
1774 // Get a klass from the constant pool.
1775 Klass* JVMCIRuntime::get_klass_by_index(const constantPoolHandle& cpool,
1776 int index,
1777 bool& is_accessible,
1778 Klass* accessor) {
1779 ResourceMark rm;
1780 Klass* result = get_klass_by_index_impl(cpool, index, is_accessible, accessor);
1781 return result;
1782 }
1783
1784 // ------------------------------------------------------------------
1785 // Perform an appropriate method lookup based on accessor, holder,
1786 // name, signature, and bytecode.
1787 Method* JVMCIRuntime::lookup_method(InstanceKlass* accessor,
1788 Klass* holder,
1789 Symbol* name,
1790 Symbol* sig,
1791 Bytecodes::Code bc,
1792 constantTag tag) {
1793 // Accessibility checks are performed in JVMCIEnv::get_method_by_index_impl().
1794 assert(check_klass_accessibility(accessor, holder), "holder not accessible");
1795
1796 LinkInfo link_info(holder, name, sig, accessor,
1797 LinkInfo::AccessCheck::required,
1798 LinkInfo::LoaderConstraintCheck::required,
1799 tag);
1800 switch (bc) {
1801 case Bytecodes::_invokestatic:
1802 return LinkResolver::resolve_static_call_or_null(link_info);
1803 case Bytecodes::_invokespecial:
1804 return LinkResolver::resolve_special_call_or_null(link_info);
1805 case Bytecodes::_invokeinterface:
1806 return LinkResolver::linktime_resolve_interface_method_or_null(link_info);
1807 case Bytecodes::_invokevirtual:
1808 return LinkResolver::linktime_resolve_virtual_method_or_null(link_info);
1809 default:
1810 fatal("Unhandled bytecode: %s", Bytecodes::name(bc));
1811 return nullptr; // silence compiler warnings
1812 }
1813 }
1814
1815
1816 // ------------------------------------------------------------------
1817 Method* JVMCIRuntime::get_method_by_index_impl(const constantPoolHandle& cpool,
1818 int index, Bytecodes::Code bc,
1819 InstanceKlass* accessor) {
1820 if (bc == Bytecodes::_invokedynamic) {
1821 if (cpool->resolved_indy_entry_at(index)->is_resolved()) {
1822 return cpool->resolved_indy_entry_at(index)->method();
1823 }
1824
1825 return nullptr;
1826 }
1827
1828 int holder_index = cpool->klass_ref_index_at(index, bc);
1829 bool holder_is_accessible;
1830 Klass* holder = get_klass_by_index_impl(cpool, holder_index, holder_is_accessible, accessor);
1831
1832 // Get the method's name and signature.
1833 Symbol* name_sym = cpool->name_ref_at(index, bc);
1834 Symbol* sig_sym = cpool->signature_ref_at(index, bc);
1835
1836 if (cpool->has_preresolution()
1837 || ((holder == vmClasses::MethodHandle_klass() || holder == vmClasses::VarHandle_klass()) &&
1838 MethodHandles::is_signature_polymorphic_name(holder, name_sym))) {
1839 // Short-circuit lookups for JSR 292-related call sites.
1840 // That is, do not rely only on name-based lookups, because they may fail
1841 // if the names are not resolvable in the boot class loader (7056328).
1842 switch (bc) {
1843 case Bytecodes::_invokevirtual:
1844 case Bytecodes::_invokeinterface:
1845 case Bytecodes::_invokespecial:
1846 case Bytecodes::_invokestatic:
1847 {
1848 Method* m = ConstantPool::method_at_if_loaded(cpool, index);
1849 if (m != nullptr) {
1850 return m;
1851 }
1852 }
1853 break;
1854 default:
1855 break;
1856 }
1857 }
1858
1859 if (holder_is_accessible) { // Our declared holder is loaded.
1860 constantTag tag = cpool->tag_ref_at(index, bc);
1861 Method* m = lookup_method(accessor, holder, name_sym, sig_sym, bc, tag);
1862 if (m != nullptr) {
1863 // We found the method.
1864 return m;
1865 }
1866 }
1867
1868 // Either the declared holder was not loaded, or the method could
1869 // not be found.
1870
1871 return nullptr;
1872 }
1873
1874 // ------------------------------------------------------------------
1875 InstanceKlass* JVMCIRuntime::get_instance_klass_for_declared_method_holder(Klass* method_holder) {
1876 // For the case of <array>.clone(), the method holder can be an ArrayKlass*
1877 // instead of an InstanceKlass*. For that case simply pretend that the
1878 // declared holder is Object.clone since that's where the call will bottom out.
1879 if (method_holder->is_instance_klass()) {
1880 return InstanceKlass::cast(method_holder);
1881 } else if (method_holder->is_array_klass()) {
1882 return vmClasses::Object_klass();
1883 } else {
1884 ShouldNotReachHere();
1885 }
1886 return nullptr;
1887 }
1888
1889
1890 // ------------------------------------------------------------------
1891 Method* JVMCIRuntime::get_method_by_index(const constantPoolHandle& cpool,
1892 int index, Bytecodes::Code bc,
1893 InstanceKlass* accessor) {
1894 ResourceMark rm;
1895 return get_method_by_index_impl(cpool, index, bc, accessor);
1896 }
1897
1898 // ------------------------------------------------------------------
1899 // Check for changes to the system dictionary during compilation
1900 // class loads, evolution, breakpoints
1901 JVMCI::CodeInstallResult JVMCIRuntime::validate_compile_task_dependencies(Dependencies* dependencies,
1902 JVMCICompileState* compile_state,
1903 char** failure_detail,
1904 bool& failing_dep_is_call_site)
1905 {
1906 failing_dep_is_call_site = false;
1907 // If JVMTI capabilities were enabled during compile, the compilation is invalidated.
1908 if (compile_state != nullptr && compile_state->jvmti_state_changed()) {
1909 *failure_detail = (char*) "Jvmti state change during compilation invalidated dependencies";
1910 return JVMCI::dependencies_failed;
1911 }
1912
1913 CompileTask* task = compile_state == nullptr ? nullptr : compile_state->task();
1914 Dependencies::DepType result = dependencies->validate_dependencies(task, failure_detail);
1915
1916 if (result == Dependencies::end_marker) {
1917 return JVMCI::ok;
1918 }
1919 if (result == Dependencies::call_site_target_value) {
1920 failing_dep_is_call_site = true;
1921 }
1922 return JVMCI::dependencies_failed;
1923 }
1924
1925 // Called after an upcall to `function` while compiling `method`.
1926 // If an exception occurred, it is cleared, the compilation state
1927 // is updated with the failure and this method returns true.
1928 // Otherwise, it returns false.
1929 static bool after_compiler_upcall(JVMCIEnv* JVMCIENV, JVMCICompiler* compiler, const methodHandle& method, const char* function) {
1930 if (JVMCIENV->has_pending_exception()) {
1931 ResourceMark rm;
1932 bool reason_on_C_heap = true;
1933 const char* pending_string = nullptr;
1934 const char* pending_stack_trace = nullptr;
1935 JVMCIENV->pending_exception_as_string(&pending_string, &pending_stack_trace);
1936 if (pending_string == nullptr) pending_string = "null";
1937 // Using stringStream instead of err_msg to avoid truncation
1938 stringStream st;
1939 st.print("uncaught exception in %s [%s]", function, pending_string);
1940 const char* failure_reason = os::strdup(st.freeze(), mtJVMCI);
1941 if (failure_reason == nullptr) {
1942 failure_reason = "uncaught exception";
1943 reason_on_C_heap = false;
1944 }
1945 JVMCI_event_1("%s", failure_reason);
1946 Log(jit, compilation) log;
1947 if (log.is_info()) {
1948 log.info("%s while compiling %s", failure_reason, method->name_and_sig_as_C_string());
1949 if (pending_stack_trace != nullptr) {
1950 LogStream ls(log.info());
1951 ls.print_raw_cr(pending_stack_trace);
1952 }
1953 }
1954 JVMCICompileState* compile_state = JVMCIENV->compile_state();
1955 compile_state->set_failure(true, failure_reason, reason_on_C_heap);
1956 compiler->on_upcall(failure_reason, compile_state);
1957 return true;
1958 }
1959 return false;
1960 }
1961
1962 void JVMCIRuntime::compile_method(JVMCIEnv* JVMCIENV, JVMCICompiler* compiler, const methodHandle& method, int entry_bci) {
1963 JVMCI_EXCEPTION_CONTEXT
1964
1965 JVMCICompileState* compile_state = JVMCIENV->compile_state();
1966
1967 bool is_osr = entry_bci != InvocationEntryBci;
1968 if (compiler->is_bootstrapping() && is_osr) {
1969 // no OSR compilations during bootstrap - the compiler is just too slow at this point,
1970 // and we know that there are no endless loops
1971 compile_state->set_failure(true, "No OSR during bootstrap");
1972 return;
1973 }
1974 if (JVMCI::in_shutdown()) {
1975 if (UseJVMCINativeLibrary) {
1976 JVMCIRuntime *runtime = JVMCI::compiler_runtime(thread, false);
1977 if (runtime != nullptr) {
1978 runtime->detach_thread(thread, "JVMCI shutdown pre-empted compilation");
1979 }
1980 }
1981 compile_state->set_failure(false, "Avoiding compilation during shutdown");
1982 return;
1983 }
1984
1985 HandleMark hm(thread);
1986 JVMCIObject receiver = get_HotSpotJVMCIRuntime(JVMCIENV);
1987 if (after_compiler_upcall(JVMCIENV, compiler, method, "get_HotSpotJVMCIRuntime")) {
1988 return;
1989 }
1990 JVMCIObject jvmci_method = JVMCIENV->get_jvmci_method(method, JVMCIENV);
1991 if (after_compiler_upcall(JVMCIENV, compiler, method, "get_jvmci_method")) {
1992 return;
1993 }
1994
1995 JVMCIObject result_object = JVMCIENV->call_HotSpotJVMCIRuntime_compileMethod(receiver, jvmci_method, entry_bci,
1996 (jlong) compile_state, compile_state->task()->compile_id());
1997 #ifdef ASSERT
1998 if (JVMCIENV->has_pending_exception()) {
1999 const char* val = Arguments::PropertyList_get_value(Arguments::system_properties(), "test.jvmci.compileMethodExceptionIsFatal");
2000 if (val != nullptr && strcmp(val, "true") == 0) {
2001 fatal_exception(JVMCIENV, "testing JVMCI fatal exception handling");
2002 }
2003 }
2004 #endif
2005
2006 if (after_compiler_upcall(JVMCIENV, compiler, method, "call_HotSpotJVMCIRuntime_compileMethod")) {
2007 return;
2008 }
2009 compiler->on_upcall(nullptr);
2010 guarantee(result_object.is_non_null(), "call_HotSpotJVMCIRuntime_compileMethod returned null");
2011 JVMCIObject failure_message = JVMCIENV->get_HotSpotCompilationRequestResult_failureMessage(result_object);
2012 if (failure_message.is_non_null()) {
2013 // Copy failure reason into resource memory first ...
2014 const char* failure_reason = JVMCIENV->as_utf8_string(failure_message);
2015 // ... and then into the C heap.
2016 failure_reason = os::strdup(failure_reason, mtJVMCI);
2017 bool retryable = JVMCIENV->get_HotSpotCompilationRequestResult_retry(result_object) != 0;
2018 compile_state->set_failure(retryable, failure_reason, true);
2019 } else {
2020 if (!compile_state->task()->is_success()) {
2021 compile_state->set_failure(true, "no nmethod produced");
2022 } else {
2023 compile_state->task()->set_num_inlined_bytecodes(JVMCIENV->get_HotSpotCompilationRequestResult_inlinedBytecodes(result_object));
2024 compiler->inc_methods_compiled();
2025 }
2026 }
2027 if (compiler->is_bootstrapping()) {
2028 compiler->set_bootstrap_compilation_request_handled();
2029 }
2030 }
2031
2032 bool JVMCIRuntime::is_gc_supported(JVMCIEnv* JVMCIENV, CollectedHeap::Name name) {
2033 JVMCI_EXCEPTION_CONTEXT
2034
2035 JVMCIObject receiver = get_HotSpotJVMCIRuntime(JVMCIENV);
2036 if (JVMCIENV->has_pending_exception()) {
2037 fatal_exception(JVMCIENV, "Exception during HotSpotJVMCIRuntime initialization");
2038 }
2039 return JVMCIENV->call_HotSpotJVMCIRuntime_isGCSupported(receiver, (int) name);
2040 }
2041
2042 bool JVMCIRuntime::is_intrinsic_supported(JVMCIEnv* JVMCIENV, jint id) {
2043 JVMCI_EXCEPTION_CONTEXT
2044
2045 JVMCIObject receiver = get_HotSpotJVMCIRuntime(JVMCIENV);
2046 if (JVMCIENV->has_pending_exception()) {
2047 fatal_exception(JVMCIENV, "Exception during HotSpotJVMCIRuntime initialization");
2048 }
2049 return JVMCIENV->call_HotSpotJVMCIRuntime_isIntrinsicSupported(receiver, id);
2050 }
2051
2052 // ------------------------------------------------------------------
2053 JVMCI::CodeInstallResult JVMCIRuntime::register_method(JVMCIEnv* JVMCIENV,
2054 const methodHandle& method,
2055 nmethod*& nm,
2056 int entry_bci,
2057 CodeOffsets* offsets,
2058 int orig_pc_offset,
2059 CodeBuffer* code_buffer,
2060 int frame_words,
2061 OopMapSet* oop_map_set,
2062 ExceptionHandlerTable* handler_table,
2063 ImplicitExceptionTable* implicit_exception_table,
2064 AbstractCompiler* compiler,
2065 DebugInformationRecorder* debug_info,
2066 Dependencies* dependencies,
2067 int compile_id,
2068 bool has_monitors,
2069 bool has_unsafe_access,
2070 bool has_scoped_access,
2071 bool has_wide_vector,
2072 JVMCIObject compiled_code,
2073 JVMCIObject nmethod_mirror,
2074 FailedSpeculation** failed_speculations,
2075 char* speculations,
2076 int speculations_len,
2077 int nmethod_entry_patch_offset) {
2078 JVMCI_EXCEPTION_CONTEXT;
2079 CompLevel comp_level = CompLevel_full_optimization;
2080 char* failure_detail = nullptr;
2081
2082 bool install_default = JVMCIENV->get_HotSpotNmethod_isDefault(nmethod_mirror) != 0;
2083 assert(JVMCIENV->isa_HotSpotNmethod(nmethod_mirror), "must be");
2084 JVMCIObject name = JVMCIENV->get_InstalledCode_name(nmethod_mirror);
2085 const char* nmethod_mirror_name = name.is_null() ? nullptr : JVMCIENV->as_utf8_string(name);
2086 int nmethod_mirror_index;
2087 if (!install_default) {
2088 // Reserve or initialize mirror slot in the oops table.
2089 OopRecorder* oop_recorder = debug_info->oop_recorder();
2090 nmethod_mirror_index = oop_recorder->allocate_oop_index(nmethod_mirror.is_hotspot() ? nmethod_mirror.as_jobject() : nullptr);
2091 } else {
2092 // A default HotSpotNmethod mirror is never tracked by the nmethod
2093 nmethod_mirror_index = -1;
2094 }
2095
2096 JVMCI::CodeInstallResult result(JVMCI::ok);
2097
2098 // We require method counters to store some method state (max compilation levels) required by the compilation policy.
2099 if (method->get_method_counters(THREAD) == nullptr) {
2100 result = JVMCI::cache_full;
2101 failure_detail = (char*) "can't create method counters";
2102 }
2103
2104 if (result == JVMCI::ok) {
2105 // Check if memory should be freed before allocation
2106 CodeCache::gc_on_allocation();
2107
2108 // To prevent compile queue updates.
2109 MutexLocker locker(THREAD, MethodCompileQueue_lock);
2110
2111 // Prevent InstanceKlass::add_to_hierarchy from running
2112 // and invalidating our dependencies until we install this method.
2113 MutexLocker ml(Compile_lock);
2114
2115 // Encode the dependencies now, so we can check them right away.
2116 dependencies->encode_content_bytes();
2117
2118 // Record the dependencies for the current compile in the log
2119 if (LogCompilation) {
2120 for (Dependencies::DepStream deps(dependencies); deps.next(); ) {
2121 deps.log_dependency();
2122 }
2123 }
2124
2125 // Check for {class loads, evolution, breakpoints} during compilation
2126 JVMCICompileState* compile_state = JVMCIENV->compile_state();
2127 bool failing_dep_is_call_site;
2128 result = validate_compile_task_dependencies(dependencies, compile_state, &failure_detail, failing_dep_is_call_site);
2129 if (result != JVMCI::ok) {
2130 // While not a true deoptimization, it is a preemptive decompile.
2131 MethodData* mdp = method()->method_data();
2132 if (mdp != nullptr && !failing_dep_is_call_site) {
2133 mdp->inc_decompile_count();
2134 #ifdef ASSERT
2135 if (mdp->decompile_count() > (uint)PerMethodRecompilationCutoff) {
2136 ResourceMark m;
2137 tty->print_cr("WARN: endless recompilation of %s. Method was set to not compilable.", method()->name_and_sig_as_C_string());
2138 }
2139 #endif
2140 }
2141
2142 // All buffers in the CodeBuffer are allocated in the CodeCache.
2143 // If the code buffer is created on each compile attempt
2144 // as in C2, then it must be freed.
2145 //code_buffer->free_blob();
2146 } else {
2147 JVMCINMethodData* data = JVMCINMethodData::create(nmethod_mirror_index,
2148 nmethod_entry_patch_offset,
2149 nmethod_mirror_name,
2150 failed_speculations);
2151 nm = nmethod::new_nmethod(method,
2152 compile_id,
2153 entry_bci,
2154 offsets,
2155 orig_pc_offset,
2156 debug_info, dependencies, code_buffer,
2157 frame_words, oop_map_set,
2158 handler_table, implicit_exception_table,
2159 compiler, comp_level, nullptr /* AOTCodeEntry */,
2160 speculations, speculations_len, data);
2161
2162
2163 // Free codeBlobs
2164 if (nm == nullptr) {
2165 // The CodeCache is full. Print out warning and disable compilation.
2166 {
2167 MutexUnlocker ml(Compile_lock);
2168 MutexUnlocker locker(MethodCompileQueue_lock);
2169 CompileBroker::handle_full_code_cache(CodeCache::get_code_blob_type(comp_level));
2170 }
2171 result = JVMCI::cache_full;
2172 } else {
2173 nm->set_has_unsafe_access(has_unsafe_access);
2174 nm->set_has_wide_vectors(has_wide_vector);
2175 nm->set_has_monitors(has_monitors);
2176 nm->set_has_scoped_access(has_scoped_access);
2177
2178 JVMCINMethodData* data = nm->jvmci_nmethod_data();
2179 assert(data != nullptr, "must be");
2180 if (install_default) {
2181 assert(!nmethod_mirror.is_hotspot() || data->get_nmethod_mirror(nm, /* phantom_ref */ false) == nullptr, "must be");
2182 if (entry_bci == InvocationEntryBci) {
2183 // If there is an old version we're done with it
2184 nmethod* old = method->code();
2185 if (TraceMethodReplacement && old != nullptr) {
2186 ResourceMark rm;
2187 char *method_name = method->name_and_sig_as_C_string();
2188 tty->print_cr("Replacing method %s", method_name);
2189 }
2190 if (old != nullptr) {
2191 old->make_not_entrant("JVMCI register method");
2192 }
2193
2194 LogTarget(Info, nmethod, install) lt;
2195 if (lt.is_enabled()) {
2196 ResourceMark rm;
2197 char *method_name = method->name_and_sig_as_C_string();
2198 lt.print("Installing method (%d) %s [entry point: %p]",
2199 comp_level, method_name, nm->entry_point());
2200 }
2201 // Allow the code to be executed
2202 MutexLocker ml(NMethodState_lock, Mutex::_no_safepoint_check_flag);
2203 if (nm->make_in_use()) {
2204 method->set_code(method, nm);
2205 } else {
2206 result = JVMCI::nmethod_reclaimed;
2207 }
2208 } else {
2209 LogTarget(Info, nmethod, install) lt;
2210 if (lt.is_enabled()) {
2211 ResourceMark rm;
2212 char *method_name = method->name_and_sig_as_C_string();
2213 lt.print("Installing osr method (%d) %s @ %d",
2214 comp_level, method_name, entry_bci);
2215 }
2216 MutexLocker ml(NMethodState_lock, Mutex::_no_safepoint_check_flag);
2217 if (nm->make_in_use()) {
2218 InstanceKlass::cast(method->method_holder())->add_osr_nmethod(nm);
2219 } else {
2220 result = JVMCI::nmethod_reclaimed;
2221 }
2222 }
2223 } else {
2224 assert(!nmethod_mirror.is_hotspot() || data->get_nmethod_mirror(nm, /* phantom_ref */ false) == HotSpotJVMCI::resolve(nmethod_mirror), "must be");
2225 MutexLocker ml(NMethodState_lock, Mutex::_no_safepoint_check_flag);
2226 if (!nm->make_in_use()) {
2227 result = JVMCI::nmethod_reclaimed;
2228 }
2229 }
2230 }
2231 }
2232 }
2233
2234 // String creation must be done outside lock
2235 if (failure_detail != nullptr) {
2236 // A failure to allocate the string is silently ignored.
2237 JVMCIObject message = JVMCIENV->create_string(failure_detail, JVMCIENV);
2238 JVMCIENV->set_HotSpotCompiledNmethod_installationFailureMessage(compiled_code, message);
2239 }
2240
2241 if (result == JVMCI::ok) {
2242 JVMCICompileState* state = JVMCIENV->compile_state();
2243 if (state != nullptr) {
2244 // Compilation succeeded, post what we know about it
2245 nm->post_compiled_method(state->task());
2246 }
2247 }
2248
2249 return result;
2250 }
2251
2252 void JVMCIRuntime::post_compile(JavaThread* thread) {
2253 if (UseJVMCINativeLibrary && JVMCI::one_shared_library_javavm_per_compilation()) {
2254 if (thread->libjvmci_runtime() != nullptr) {
2255 detach_thread(thread, "single use JavaVM");
2256 } else {
2257 // JVMCI shutdown may have already detached the thread
2258 }
2259 }
2260 }