1 /*
2 * Copyright (c) 2012, 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 "asm/codeBuffer.hpp"
26 #include "classfile/javaClasses.inline.hpp"
27 #include "code/codeCache.hpp"
28 #include "compiler/compileBroker.hpp"
29 #include "compiler/disassembler.hpp"
30 #include "jvmci/jvmciRuntime.hpp"
31 #include "jvmci/jvmciCompilerToVM.hpp"
32 #include "jvmci/jvmciCompiler.hpp"
33 #include "jvmci/jvmciJavaClasses.hpp"
34 #include "jvmci/jvmciEnv.hpp"
35 #include "logging/log.hpp"
36 #include "memory/oopFactory.hpp"
37 #include "oops/oop.inline.hpp"
38 #include "oops/objArrayOop.inline.hpp"
39 #include "prims/jvm.h"
40 #include "runtime/biasedLocking.hpp"
41 #include "runtime/interfaceSupport.hpp"
42 #include "runtime/reflection.hpp"
43 #include "runtime/sharedRuntime.hpp"
44 #include "utilities/debug.hpp"
45 #include "utilities/defaultStream.hpp"
46
47 #if defined(_MSC_VER)
48 #define strtoll _strtoi64
49 #endif
50
51 jobject JVMCIRuntime::_HotSpotJVMCIRuntime_instance = NULL;
52 bool JVMCIRuntime::_HotSpotJVMCIRuntime_initialized = false;
53 bool JVMCIRuntime::_well_known_classes_initialized = false;
54 int JVMCIRuntime::_trivial_prefixes_count = 0;
55 char** JVMCIRuntime::_trivial_prefixes = NULL;
56 bool JVMCIRuntime::_shutdown_called = false;
57
58 BasicType JVMCIRuntime::kindToBasicType(Handle kind, TRAPS) {
59 if (kind.is_null()) {
60 THROW_(vmSymbols::java_lang_NullPointerException(), T_ILLEGAL);
61 }
62 jchar ch = JavaKind::typeChar(kind);
63 switch(ch) {
64 case 'z': return T_BOOLEAN;
65 case 'b': return T_BYTE;
66 case 's': return T_SHORT;
67 case 'c': return T_CHAR;
68 case 'i': return T_INT;
69 case 'f': return T_FLOAT;
70 case 'j': return T_LONG;
71 case 'd': return T_DOUBLE;
72 case 'a': return T_OBJECT;
73 case '-': return T_ILLEGAL;
74 default:
75 JVMCI_ERROR_(T_ILLEGAL, "unexpected Kind: %c", ch);
76 }
77 }
78
79 // Simple helper to see if the caller of a runtime stub which
80 // entered the VM has been deoptimized
81
82 static bool caller_is_deopted() {
83 JavaThread* thread = JavaThread::current();
84 RegisterMap reg_map(thread, false);
85 frame runtime_frame = thread->last_frame();
86 frame caller_frame = runtime_frame.sender(®_map);
87 assert(caller_frame.is_compiled_frame(), "must be compiled");
88 return caller_frame.is_deoptimized_frame();
89 }
90
91 // Stress deoptimization
92 static void deopt_caller() {
93 if ( !caller_is_deopted()) {
94 JavaThread* thread = JavaThread::current();
95 RegisterMap reg_map(thread, false);
96 frame runtime_frame = thread->last_frame();
97 frame caller_frame = runtime_frame.sender(®_map);
98 Deoptimization::deoptimize_frame(thread, caller_frame.id(), Deoptimization::Reason_constraint);
99 assert(caller_is_deopted(), "Must be deoptimized");
100 }
101 }
102
103 JRT_BLOCK_ENTRY(void, JVMCIRuntime::new_instance(JavaThread* thread, Klass* klass))
104 JRT_BLOCK;
105 assert(klass->is_klass(), "not a class");
106 instanceKlassHandle h(thread, klass);
107 h->check_valid_for_instantiation(true, CHECK);
108 // make sure klass is initialized
109 h->initialize(CHECK);
110 // allocate instance and return via TLS
111 oop obj = h->allocate_instance(CHECK);
112 thread->set_vm_result(obj);
113 JRT_BLOCK_END;
114
115 if (ReduceInitialCardMarks) {
116 new_store_pre_barrier(thread);
117 }
118 JRT_END
119
120 JRT_BLOCK_ENTRY(void, JVMCIRuntime::new_array(JavaThread* thread, Klass* array_klass, jint length))
121 JRT_BLOCK;
122 // Note: no handle for klass needed since they are not used
123 // anymore after new_objArray() and no GC can happen before.
124 // (This may have to change if this code changes!)
125 assert(array_klass->is_klass(), "not a class");
126 oop obj;
127 if (array_klass->is_typeArray_klass()) {
128 BasicType elt_type = TypeArrayKlass::cast(array_klass)->element_type();
129 obj = oopFactory::new_typeArray(elt_type, length, CHECK);
130 } else {
131 Klass* elem_klass = ObjArrayKlass::cast(array_klass)->element_klass();
132 obj = oopFactory::new_objArray(elem_klass, length, CHECK);
133 }
134 thread->set_vm_result(obj);
135 // This is pretty rare but this runtime patch is stressful to deoptimization
136 // if we deoptimize here so force a deopt to stress the path.
137 if (DeoptimizeALot) {
138 static int deopts = 0;
139 // Alternate between deoptimizing and raising an error (which will also cause a deopt)
140 if (deopts++ % 2 == 0) {
141 ResourceMark rm(THREAD);
142 THROW(vmSymbols::java_lang_OutOfMemoryError());
143 } else {
144 deopt_caller();
145 }
146 }
147 JRT_BLOCK_END;
148
149 if (ReduceInitialCardMarks) {
150 new_store_pre_barrier(thread);
151 }
152 JRT_END
153
154 void JVMCIRuntime::new_store_pre_barrier(JavaThread* thread) {
155 // After any safepoint, just before going back to compiled code,
156 // we inform the GC that we will be doing initializing writes to
157 // this object in the future without emitting card-marks, so
158 // GC may take any compensating steps.
159 // NOTE: Keep this code consistent with GraphKit::store_barrier.
160
161 oop new_obj = thread->vm_result();
162 if (new_obj == NULL) return;
163
164 assert(Universe::heap()->can_elide_tlab_store_barriers(),
165 "compiler must check this first");
166 // GC may decide to give back a safer copy of new_obj.
167 new_obj = Universe::heap()->new_store_pre_barrier(thread, new_obj);
168 thread->set_vm_result(new_obj);
169 }
170
171 JRT_ENTRY(void, JVMCIRuntime::new_multi_array(JavaThread* thread, Klass* klass, int rank, jint* dims))
172 assert(klass->is_klass(), "not a class");
173 assert(rank >= 1, "rank must be nonzero");
174 oop obj = ArrayKlass::cast(klass)->multi_allocate(rank, dims, CHECK);
175 thread->set_vm_result(obj);
176 JRT_END
177
178 JRT_ENTRY(void, JVMCIRuntime::dynamic_new_array(JavaThread* thread, oopDesc* element_mirror, jint length))
179 oop obj = Reflection::reflect_new_array(element_mirror, length, CHECK);
180 thread->set_vm_result(obj);
181 JRT_END
182
183 JRT_ENTRY(void, JVMCIRuntime::dynamic_new_instance(JavaThread* thread, oopDesc* type_mirror))
184 instanceKlassHandle klass(THREAD, java_lang_Class::as_Klass(type_mirror));
185
186 if (klass == NULL) {
187 ResourceMark rm(THREAD);
188 THROW(vmSymbols::java_lang_InstantiationException());
189 }
190
191 // Create new instance (the receiver)
192 klass->check_valid_for_instantiation(false, CHECK);
193
194 // Make sure klass gets initialized
195 klass->initialize(CHECK);
196
197 oop obj = klass->allocate_instance(CHECK);
198 thread->set_vm_result(obj);
199 JRT_END
200
201 extern void vm_exit(int code);
202
203 // Enter this method from compiled code handler below. This is where we transition
204 // to VM mode. This is done as a helper routine so that the method called directly
205 // from compiled code does not have to transition to VM. This allows the entry
206 // method to see if the nmethod that we have just looked up a handler for has
207 // been deoptimized while we were in the vm. This simplifies the assembly code
208 // cpu directories.
209 //
210 // We are entering here from exception stub (via the entry method below)
211 // If there is a compiled exception handler in this method, we will continue there;
212 // otherwise we will unwind the stack and continue at the caller of top frame method
213 // Note: we enter in Java using a special JRT wrapper. This wrapper allows us to
214 // control the area where we can allow a safepoint. After we exit the safepoint area we can
215 // check to see if the handler we are going to return is now in a nmethod that has
216 // been deoptimized. If that is the case we return the deopt blob
217 // unpack_with_exception entry instead. This makes life for the exception blob easier
218 // because making that same check and diverting is painful from assembly language.
219 JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* thread, oopDesc* ex, address pc, nmethod*& nm))
220 // Reset method handle flag.
221 thread->set_is_method_handle_return(false);
222
223 Handle exception(thread, ex);
224 nm = CodeCache::find_nmethod(pc);
225 assert(nm != NULL, "this is not a compiled method");
226 // Adjust the pc as needed/
227 if (nm->is_deopt_pc(pc)) {
228 RegisterMap map(thread, false);
229 frame exception_frame = thread->last_frame().sender(&map);
230 // if the frame isn't deopted then pc must not correspond to the caller of last_frame
231 assert(exception_frame.is_deoptimized_frame(), "must be deopted");
232 pc = exception_frame.pc();
233 }
234 #ifdef ASSERT
235 assert(exception.not_null(), "NULL exceptions should be handled by throw_exception");
236 assert(exception->is_oop(), "just checking");
237 // Check that exception is a subclass of Throwable, otherwise we have a VerifyError
238 if (!(exception->is_a(SystemDictionary::Throwable_klass()))) {
239 if (ExitVMOnVerifyError) vm_exit(-1);
240 ShouldNotReachHere();
241 }
242 #endif
243
244 // Check the stack guard pages and reenable them if necessary and there is
245 // enough space on the stack to do so. Use fast exceptions only if the guard
246 // pages are enabled.
247 bool guard_pages_enabled = thread->stack_guards_enabled();
248 if (!guard_pages_enabled) guard_pages_enabled = thread->reguard_stack();
249
250 if (JvmtiExport::can_post_on_exceptions()) {
251 // To ensure correct notification of exception catches and throws
252 // we have to deoptimize here. If we attempted to notify the
253 // catches and throws during this exception lookup it's possible
254 // we could deoptimize on the way out of the VM and end back in
255 // the interpreter at the throw site. This would result in double
256 // notifications since the interpreter would also notify about
257 // these same catches and throws as it unwound the frame.
258
259 RegisterMap reg_map(thread);
260 frame stub_frame = thread->last_frame();
261 frame caller_frame = stub_frame.sender(®_map);
262
263 // We don't really want to deoptimize the nmethod itself since we
264 // can actually continue in the exception handler ourselves but I
265 // don't see an easy way to have the desired effect.
266 Deoptimization::deoptimize_frame(thread, caller_frame.id(), Deoptimization::Reason_constraint);
267 assert(caller_is_deopted(), "Must be deoptimized");
268
269 return SharedRuntime::deopt_blob()->unpack_with_exception_in_tls();
270 }
271
272 // ExceptionCache is used only for exceptions at call sites and not for implicit exceptions
273 if (guard_pages_enabled) {
274 address fast_continuation = nm->handler_for_exception_and_pc(exception, pc);
275 if (fast_continuation != NULL) {
276 // Set flag if return address is a method handle call site.
277 thread->set_is_method_handle_return(nm->is_method_handle_return(pc));
278 return fast_continuation;
279 }
280 }
281
282 // If the stack guard pages are enabled, check whether there is a handler in
283 // the current method. Otherwise (guard pages disabled), force an unwind and
284 // skip the exception cache update (i.e., just leave continuation==NULL).
285 address continuation = NULL;
286 if (guard_pages_enabled) {
287
288 // New exception handling mechanism can support inlined methods
289 // with exception handlers since the mappings are from PC to PC
290
291 // debugging support
292 // tracing
293 if (log_is_enabled(Info, exceptions)) {
294 ResourceMark rm;
295 stringStream tempst;
296 tempst.print("compiled method <%s>\n"
297 " at PC" INTPTR_FORMAT " for thread " INTPTR_FORMAT,
298 nm->method()->print_value_string(), p2i(pc), p2i(thread));
299 Exceptions::log_exception(exception, tempst);
300 }
301 // for AbortVMOnException flag
302 NOT_PRODUCT(Exceptions::debug_check_abort(exception));
303
304 // Clear out the exception oop and pc since looking up an
305 // exception handler can cause class loading, which might throw an
306 // exception and those fields are expected to be clear during
307 // normal bytecode execution.
308 thread->clear_exception_oop_and_pc();
309
310 continuation = SharedRuntime::compute_compiled_exc_handler(nm, pc, exception, false, false);
311 // If an exception was thrown during exception dispatch, the exception oop may have changed
312 thread->set_exception_oop(exception());
313 thread->set_exception_pc(pc);
314
315 // the exception cache is used only by non-implicit exceptions
316 if (continuation != NULL && !SharedRuntime::deopt_blob()->contains(continuation)) {
317 nm->add_handler_for_exception_and_pc(exception, pc, continuation);
318 }
319 }
320
321 // Set flag if return address is a method handle call site.
322 thread->set_is_method_handle_return(nm->is_method_handle_return(pc));
323
324 if (log_is_enabled(Info, exceptions)) {
325 ResourceMark rm;
326 log_info(exceptions)("Thread " PTR_FORMAT " continuing at PC " PTR_FORMAT
327 " for exception thrown at PC " PTR_FORMAT,
328 p2i(thread), p2i(continuation), p2i(pc));
329 }
330
331 return continuation;
332 JRT_END
333
334 // Enter this method from compiled code only if there is a Java exception handler
335 // in the method handling the exception.
336 // We are entering here from exception stub. We don't do a normal VM transition here.
337 // We do it in a helper. This is so we can check to see if the nmethod we have just
338 // searched for an exception handler has been deoptimized in the meantime.
339 address JVMCIRuntime::exception_handler_for_pc(JavaThread* thread) {
340 oop exception = thread->exception_oop();
341 address pc = thread->exception_pc();
342 // Still in Java mode
343 DEBUG_ONLY(ResetNoHandleMark rnhm);
344 nmethod* nm = NULL;
345 address continuation = NULL;
346 {
347 // Enter VM mode by calling the helper
348 ResetNoHandleMark rnhm;
349 continuation = exception_handler_for_pc_helper(thread, exception, pc, nm);
350 }
351 // Back in JAVA, use no oops DON'T safepoint
352
353 // Now check to see if the compiled method we were called from is now deoptimized.
354 // If so we must return to the deopt blob and deoptimize the nmethod
355 if (nm != NULL && caller_is_deopted()) {
356 continuation = SharedRuntime::deopt_blob()->unpack_with_exception_in_tls();
357 }
358
359 assert(continuation != NULL, "no handler found");
360 return continuation;
361 }
362
363 JRT_ENTRY(void, JVMCIRuntime::create_null_exception(JavaThread* thread))
364 SharedRuntime::throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_NullPointerException());
365 thread->set_vm_result(PENDING_EXCEPTION);
366 CLEAR_PENDING_EXCEPTION;
367 JRT_END
368
369 JRT_ENTRY(void, JVMCIRuntime::create_out_of_bounds_exception(JavaThread* thread, jint index))
370 char message[jintAsStringSize];
371 sprintf(message, "%d", index);
372 SharedRuntime::throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), message);
373 thread->set_vm_result(PENDING_EXCEPTION);
374 CLEAR_PENDING_EXCEPTION;
375 JRT_END
376
377 JRT_ENTRY_NO_ASYNC(void, JVMCIRuntime::monitorenter(JavaThread* thread, oopDesc* obj, BasicLock* lock))
378 IF_TRACE_jvmci_3 {
379 char type[O_BUFLEN];
380 obj->klass()->name()->as_C_string(type, O_BUFLEN);
381 markOop mark = obj->mark();
382 TRACE_jvmci_3("%s: entered locking slow case with obj=" INTPTR_FORMAT ", type=%s, mark=" INTPTR_FORMAT ", lock=" INTPTR_FORMAT, thread->name(), p2i(obj), type, p2i(mark), p2i(lock));
383 tty->flush();
384 }
385 #ifdef ASSERT
386 if (PrintBiasedLockingStatistics) {
387 Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
388 }
389 #endif
390 Handle h_obj(thread, obj);
391 assert(h_obj()->is_oop(), "must be NULL or an object");
392 if (UseBiasedLocking) {
393 // Retry fast entry if bias is revoked to avoid unnecessary inflation
394 ObjectSynchronizer::fast_enter(h_obj, lock, true, CHECK);
395 } else {
396 if (JVMCIUseFastLocking) {
397 // When using fast locking, the compiled code has already tried the fast case
398 ObjectSynchronizer::slow_enter(h_obj, lock, THREAD);
399 } else {
400 ObjectSynchronizer::fast_enter(h_obj, lock, false, THREAD);
401 }
402 }
403 TRACE_jvmci_3("%s: exiting locking slow with obj=" INTPTR_FORMAT, thread->name(), p2i(obj));
404 JRT_END
405
406 JRT_LEAF(void, JVMCIRuntime::monitorexit(JavaThread* thread, oopDesc* obj, BasicLock* lock))
407 assert(thread == JavaThread::current(), "threads must correspond");
408 assert(thread->last_Java_sp(), "last_Java_sp must be set");
409 // monitorexit is non-blocking (leaf routine) => no exceptions can be thrown
410 EXCEPTION_MARK;
411
412 #ifdef DEBUG
413 if (!obj->is_oop()) {
414 ResetNoHandleMark rhm;
415 nmethod* method = thread->last_frame().cb()->as_nmethod_or_null();
416 if (method != NULL) {
417 tty->print_cr("ERROR in monitorexit in method %s wrong obj " INTPTR_FORMAT, method->name(), p2i(obj));
418 }
419 thread->print_stack_on(tty);
420 assert(false, "invalid lock object pointer dected");
421 }
422 #endif
423
424 if (JVMCIUseFastLocking) {
425 // When using fast locking, the compiled code has already tried the fast case
426 ObjectSynchronizer::slow_exit(obj, lock, THREAD);
427 } else {
428 ObjectSynchronizer::fast_exit(obj, lock, THREAD);
429 }
430 IF_TRACE_jvmci_3 {
431 char type[O_BUFLEN];
432 obj->klass()->name()->as_C_string(type, O_BUFLEN);
433 TRACE_jvmci_3("%s: exited locking slow case with obj=" INTPTR_FORMAT ", type=%s, mark=" INTPTR_FORMAT ", lock=" INTPTR_FORMAT, thread->name(), p2i(obj), type, p2i(obj->mark()), p2i(lock));
434 tty->flush();
435 }
436 JRT_END
437
438 JRT_LEAF(void, JVMCIRuntime::log_object(JavaThread* thread, oopDesc* obj, bool as_string, bool newline))
439 ttyLocker ttyl;
440
441 if (obj == NULL) {
442 tty->print("NULL");
443 } else if (obj->is_oop_or_null(true) && (!as_string || !java_lang_String::is_instance(obj))) {
444 if (obj->is_oop_or_null(true)) {
445 char buf[O_BUFLEN];
446 tty->print("%s@" INTPTR_FORMAT, obj->klass()->name()->as_C_string(buf, O_BUFLEN), p2i(obj));
447 } else {
448 tty->print(INTPTR_FORMAT, p2i(obj));
449 }
450 } else {
451 ResourceMark rm;
452 assert(obj != NULL && java_lang_String::is_instance(obj), "must be");
453 char *buf = java_lang_String::as_utf8_string(obj);
454 tty->print_raw(buf);
455 }
456 if (newline) {
457 tty->cr();
458 }
459 JRT_END
460
461 JRT_LEAF(void, JVMCIRuntime::write_barrier_pre(JavaThread* thread, oopDesc* obj))
462 thread->satb_mark_queue().enqueue(obj);
463 JRT_END
464
465 JRT_LEAF(void, JVMCIRuntime::write_barrier_post(JavaThread* thread, void* card_addr))
466 thread->dirty_card_queue().enqueue(card_addr);
467 JRT_END
468
469 JRT_LEAF(jboolean, JVMCIRuntime::validate_object(JavaThread* thread, oopDesc* parent, oopDesc* child))
470 bool ret = true;
471 if(!Universe::heap()->is_in_closed_subset(parent)) {
472 tty->print_cr("Parent Object " INTPTR_FORMAT " not in heap", p2i(parent));
473 parent->print();
474 ret=false;
475 }
476 if(!Universe::heap()->is_in_closed_subset(child)) {
477 tty->print_cr("Child Object " INTPTR_FORMAT " not in heap", p2i(child));
478 child->print();
479 ret=false;
480 }
481 return (jint)ret;
482 JRT_END
483
484 JRT_ENTRY(void, JVMCIRuntime::vm_error(JavaThread* thread, jlong where, jlong format, jlong value))
485 ResourceMark rm;
486 const char *error_msg = where == 0L ? "<internal JVMCI error>" : (char*) (address) where;
487 char *detail_msg = NULL;
488 if (format != 0L) {
489 const char* buf = (char*) (address) format;
490 size_t detail_msg_length = strlen(buf) * 2;
491 detail_msg = (char *) NEW_RESOURCE_ARRAY(u_char, detail_msg_length);
492 jio_snprintf(detail_msg, detail_msg_length, buf, value);
493 report_vm_error(__FILE__, __LINE__, error_msg, "%s", detail_msg);
494 } else {
495 report_vm_error(__FILE__, __LINE__, error_msg);
496 }
497 JRT_END
498
499 JRT_LEAF(oopDesc*, JVMCIRuntime::load_and_clear_exception(JavaThread* thread))
500 oop exception = thread->exception_oop();
501 assert(exception != NULL, "npe");
502 thread->set_exception_oop(NULL);
503 thread->set_exception_pc(0);
504 return exception;
505 JRT_END
506
507 PRAGMA_DIAG_PUSH
508 PRAGMA_FORMAT_NONLITERAL_IGNORED
509 JRT_LEAF(void, JVMCIRuntime::log_printf(JavaThread* thread, oopDesc* format, jlong v1, jlong v2, jlong v3))
510 ResourceMark rm;
511 assert(format != NULL && java_lang_String::is_instance(format), "must be");
512 char *buf = java_lang_String::as_utf8_string(format);
513 tty->print((const char*)buf, v1, v2, v3);
514 JRT_END
515 PRAGMA_DIAG_POP
516
517 static void decipher(jlong v, bool ignoreZero) {
518 if (v != 0 || !ignoreZero) {
519 void* p = (void *)(address) v;
520 CodeBlob* cb = CodeCache::find_blob(p);
521 if (cb) {
522 if (cb->is_nmethod()) {
523 char buf[O_BUFLEN];
524 tty->print("%s [" INTPTR_FORMAT "+" JLONG_FORMAT "]", cb->as_nmethod_or_null()->method()->name_and_sig_as_C_string(buf, O_BUFLEN), p2i(cb->code_begin()), (jlong)((address)v - cb->code_begin()));
525 return;
526 }
527 cb->print_value_on(tty);
528 return;
529 }
530 if (Universe::heap()->is_in(p)) {
531 oop obj = oop(p);
532 obj->print_value_on(tty);
533 return;
534 }
535 tty->print(INTPTR_FORMAT " [long: " JLONG_FORMAT ", double %lf, char %c]",p2i((void *)v), (jlong)v, (jdouble)v, (char)v);
536 }
537 }
538
539 PRAGMA_DIAG_PUSH
540 PRAGMA_FORMAT_NONLITERAL_IGNORED
541 JRT_LEAF(void, JVMCIRuntime::vm_message(jboolean vmError, jlong format, jlong v1, jlong v2, jlong v3))
542 ResourceMark rm;
543 const char *buf = (const char*) (address) format;
544 if (vmError) {
545 if (buf != NULL) {
546 fatal(buf, v1, v2, v3);
547 } else {
548 fatal("<anonymous error>");
549 }
550 } else if (buf != NULL) {
551 tty->print(buf, v1, v2, v3);
552 } else {
553 assert(v2 == 0, "v2 != 0");
554 assert(v3 == 0, "v3 != 0");
555 decipher(v1, false);
556 }
557 JRT_END
558 PRAGMA_DIAG_POP
559
560 JRT_LEAF(void, JVMCIRuntime::log_primitive(JavaThread* thread, jchar typeChar, jlong value, jboolean newline))
561 union {
562 jlong l;
563 jdouble d;
564 jfloat f;
565 } uu;
566 uu.l = value;
567 switch (typeChar) {
568 case 'z': tty->print(value == 0 ? "false" : "true"); break;
569 case 'b': tty->print("%d", (jbyte) value); break;
570 case 'c': tty->print("%c", (jchar) value); break;
571 case 's': tty->print("%d", (jshort) value); break;
572 case 'i': tty->print("%d", (jint) value); break;
573 case 'f': tty->print("%f", uu.f); break;
574 case 'j': tty->print(JLONG_FORMAT, value); break;
575 case 'd': tty->print("%lf", uu.d); break;
576 default: assert(false, "unknown typeChar"); break;
577 }
578 if (newline) {
579 tty->cr();
580 }
581 JRT_END
582
583 JRT_ENTRY(jint, JVMCIRuntime::identity_hash_code(JavaThread* thread, oopDesc* obj))
584 return (jint) obj->identity_hash();
585 JRT_END
586
587 JRT_ENTRY(jboolean, JVMCIRuntime::thread_is_interrupted(JavaThread* thread, oopDesc* receiver, jboolean clear_interrupted))
588 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate.
589 // This locking requires thread_in_vm which is why this method cannot be JRT_LEAF.
590 Handle receiverHandle(thread, receiver);
591 MutexLockerEx ml(thread->threadObj() == (void*)receiver ? NULL : Threads_lock);
592 JavaThread* receiverThread = java_lang_Thread::thread(receiverHandle());
593 if (receiverThread == NULL) {
594 // The other thread may exit during this process, which is ok so return false.
595 return JNI_FALSE;
596 } else {
597 return (jint) Thread::is_interrupted(receiverThread, clear_interrupted != 0);
598 }
599 JRT_END
600
601 JRT_ENTRY(jint, JVMCIRuntime::test_deoptimize_call_int(JavaThread* thread, int value))
602 deopt_caller();
603 return value;
604 JRT_END
605
606 // private static JVMCIRuntime JVMCI.initializeRuntime()
607 JVM_ENTRY(jobject, JVM_GetJVMCIRuntime(JNIEnv *env, jclass c))
608 if (!EnableJVMCI) {
609 THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "JVMCI is not enabled")
610 }
611 JVMCIRuntime::initialize_HotSpotJVMCIRuntime(CHECK_NULL);
612 jobject ret = JVMCIRuntime::get_HotSpotJVMCIRuntime_jobject(CHECK_NULL);
613 return ret;
614 JVM_END
615
616 Handle JVMCIRuntime::callStatic(const char* className, const char* methodName, const char* signature, JavaCallArguments* args, TRAPS) {
617 guarantee(!_HotSpotJVMCIRuntime_initialized, "cannot reinitialize HotSpotJVMCIRuntime");
618
619 TempNewSymbol name = SymbolTable::new_symbol(className, CHECK_(Handle()));
620 KlassHandle klass = SystemDictionary::resolve_or_fail(name, true, CHECK_(Handle()));
621 TempNewSymbol runtime = SymbolTable::new_symbol(methodName, CHECK_(Handle()));
622 TempNewSymbol sig = SymbolTable::new_symbol(signature, CHECK_(Handle()));
623 JavaValue result(T_OBJECT);
624 if (args == NULL) {
625 JavaCalls::call_static(&result, klass, runtime, sig, CHECK_(Handle()));
626 } else {
627 JavaCalls::call_static(&result, klass, runtime, sig, args, CHECK_(Handle()));
628 }
629 return Handle((oop)result.get_jobject());
630 }
631
632 void JVMCIRuntime::initialize_HotSpotJVMCIRuntime(TRAPS) {
633 if (JNIHandles::resolve(_HotSpotJVMCIRuntime_instance) == NULL) {
634 ResourceMark rm;
635 #ifdef ASSERT
636 // This should only be called in the context of the JVMCI class being initialized
637 TempNewSymbol name = SymbolTable::new_symbol("jdk/vm/ci/runtime/JVMCI", CHECK);
638 Klass* k = SystemDictionary::resolve_or_null(name, CHECK);
639 instanceKlassHandle klass = InstanceKlass::cast(k);
640 assert(klass->is_being_initialized() && klass->is_reentrant_initialization(THREAD),
641 "HotSpotJVMCIRuntime initialization should only be triggered through JVMCI initialization");
642 #endif
643
644 Handle result = callStatic("jdk/vm/ci/hotspot/HotSpotJVMCIRuntime",
645 "runtime",
646 "()Ljdk/vm/ci/hotspot/HotSpotJVMCIRuntime;", NULL, CHECK);
647 objArrayOop trivial_prefixes = HotSpotJVMCIRuntime::trivialPrefixes(result);
648 if (trivial_prefixes != NULL) {
649 char** prefixes = NEW_C_HEAP_ARRAY(char*, trivial_prefixes->length(), mtCompiler);
650 for (int i = 0; i < trivial_prefixes->length(); i++) {
651 oop str = trivial_prefixes->obj_at(i);
652 if (str == NULL) {
653 THROW(vmSymbols::java_lang_NullPointerException());
654 } else {
655 prefixes[i] = strdup(java_lang_String::as_utf8_string(str));
656 }
657 }
658 _trivial_prefixes = prefixes;
659 _trivial_prefixes_count = trivial_prefixes->length();
660 }
661 _HotSpotJVMCIRuntime_initialized = true;
662 _HotSpotJVMCIRuntime_instance = JNIHandles::make_global(result());
663 }
664 }
665
666 void JVMCIRuntime::initialize_JVMCI(TRAPS) {
667 if (JNIHandles::resolve(_HotSpotJVMCIRuntime_instance) == NULL) {
668 callStatic("jdk/vm/ci/runtime/JVMCI",
669 "getRuntime",
670 "()Ljdk/vm/ci/runtime/JVMCIRuntime;", NULL, CHECK);
671 }
672 assert(_HotSpotJVMCIRuntime_initialized == true, "what?");
673 }
674
675 void JVMCIRuntime::initialize_well_known_classes(TRAPS) {
676 if (JVMCIRuntime::_well_known_classes_initialized == false) {
677 SystemDictionary::WKID scan = SystemDictionary::FIRST_JVMCI_WKID;
678 SystemDictionary::initialize_wk_klasses_through(SystemDictionary::LAST_JVMCI_WKID, scan, CHECK);
679 JVMCIJavaClasses::compute_offsets(CHECK);
680 JVMCIRuntime::_well_known_classes_initialized = true;
681 }
682 }
683
684 void JVMCIRuntime::metadata_do(void f(Metadata*)) {
685 // For simplicity, the existence of HotSpotJVMCIMetaAccessContext in
686 // the SystemDictionary well known classes should ensure the other
687 // classes have already been loaded, so make sure their order in the
688 // table enforces that.
689 assert(SystemDictionary::WK_KLASS_ENUM_NAME(jdk_vm_ci_hotspot_HotSpotResolvedJavaMethodImpl) <
690 SystemDictionary::WK_KLASS_ENUM_NAME(jdk_vm_ci_hotspot_HotSpotJVMCIMetaAccessContext), "must be loaded earlier");
691 assert(SystemDictionary::WK_KLASS_ENUM_NAME(jdk_vm_ci_hotspot_HotSpotConstantPool) <
692 SystemDictionary::WK_KLASS_ENUM_NAME(jdk_vm_ci_hotspot_HotSpotJVMCIMetaAccessContext), "must be loaded earlier");
693 assert(SystemDictionary::WK_KLASS_ENUM_NAME(jdk_vm_ci_hotspot_HotSpotResolvedObjectTypeImpl) <
694 SystemDictionary::WK_KLASS_ENUM_NAME(jdk_vm_ci_hotspot_HotSpotJVMCIMetaAccessContext), "must be loaded earlier");
695
696 if (HotSpotJVMCIMetaAccessContext::klass() == NULL ||
697 !HotSpotJVMCIMetaAccessContext::klass()->is_linked()) {
698 // Nothing could be registered yet
699 return;
700 }
701
702 // WeakReference<HotSpotJVMCIMetaAccessContext>[]
703 objArrayOop allContexts = HotSpotJVMCIMetaAccessContext::allContexts();
704 if (allContexts == NULL) {
705 return;
706 }
707
708 // These must be loaded at this point but the linking state doesn't matter.
709 assert(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass() != NULL, "must be loaded");
710 assert(SystemDictionary::HotSpotConstantPool_klass() != NULL, "must be loaded");
711 assert(SystemDictionary::HotSpotResolvedObjectTypeImpl_klass() != NULL, "must be loaded");
712
713 for (int i = 0; i < allContexts->length(); i++) {
714 oop ref = allContexts->obj_at(i);
715 if (ref != NULL) {
716 oop referent = java_lang_ref_Reference::referent(ref);
717 if (referent != NULL) {
718 // Chunked Object[] with last element pointing to next chunk
719 objArrayOop metadataRoots = HotSpotJVMCIMetaAccessContext::metadataRoots(referent);
720 while (metadataRoots != NULL) {
721 for (int typeIndex = 0; typeIndex < metadataRoots->length() - 1; typeIndex++) {
722 oop reference = metadataRoots->obj_at(typeIndex);
723 if (reference == NULL) {
724 continue;
725 }
726 oop metadataRoot = java_lang_ref_Reference::referent(reference);
727 if (metadataRoot == NULL) {
728 continue;
729 }
730 if (metadataRoot->is_a(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass())) {
731 Method* method = CompilerToVM::asMethod(metadataRoot);
732 f(method);
733 } else if (metadataRoot->is_a(SystemDictionary::HotSpotConstantPool_klass())) {
734 ConstantPool* constantPool = CompilerToVM::asConstantPool(metadataRoot);
735 f(constantPool);
736 } else if (metadataRoot->is_a(SystemDictionary::HotSpotResolvedObjectTypeImpl_klass())) {
737 Klass* klass = CompilerToVM::asKlass(metadataRoot);
738 f(klass);
739 } else {
740 metadataRoot->print();
741 ShouldNotReachHere();
742 }
743 }
744 metadataRoots = (objArrayOop)metadataRoots->obj_at(metadataRoots->length() - 1);
745 assert(metadataRoots == NULL || metadataRoots->is_objArray(), "wrong type");
746 }
747 }
748 }
749 }
750 }
751
752 // private static void CompilerToVM.registerNatives()
753 JVM_ENTRY(void, JVM_RegisterJVMCINatives(JNIEnv *env, jclass c2vmClass))
754 if (!EnableJVMCI) {
755 THROW_MSG(vmSymbols::java_lang_InternalError(), "JVMCI is not enabled");
756 }
757
758 #ifdef _LP64
759 #ifndef TARGET_ARCH_sparc
760 uintptr_t heap_end = (uintptr_t) Universe::heap()->reserved_region().end();
761 uintptr_t allocation_end = heap_end + ((uintptr_t)16) * 1024 * 1024 * 1024;
762 guarantee(heap_end < allocation_end, "heap end too close to end of address space (might lead to erroneous TLAB allocations)");
763 #endif // TARGET_ARCH_sparc
764 #else
765 fatal("check TLAB allocation code for address space conflicts");
766 #endif
767
768 JVMCIRuntime::initialize_well_known_classes(CHECK);
769
770 {
771 ThreadToNativeFromVM trans(thread);
772 env->RegisterNatives(c2vmClass, CompilerToVM::methods, CompilerToVM::methods_count());
773 }
774 JVM_END
775
776 #define CHECK_WARN_ABORT_(message) THREAD); \
777 if (HAS_PENDING_EXCEPTION) { \
778 warning(message); \
779 char buf[512]; \
780 jio_snprintf(buf, 512, "Uncaught exception at %s:%d", __FILE__, __LINE__); \
781 JVMCIRuntime::abort_on_pending_exception(PENDING_EXCEPTION, buf); \
782 return; \
783 } \
784 (void)(0
785
786 void JVMCIRuntime::shutdown(TRAPS) {
787 if (_HotSpotJVMCIRuntime_instance != NULL) {
788 _shutdown_called = true;
789 HandleMark hm(THREAD);
790 Handle receiver = get_HotSpotJVMCIRuntime(CHECK);
791 JavaValue result(T_VOID);
792 JavaCallArguments args;
793 args.push_oop(receiver);
794 JavaCalls::call_special(&result, receiver->klass(), vmSymbols::shutdown_method_name(), vmSymbols::void_method_signature(), &args, CHECK);
795 }
796 }
797
798 bool JVMCIRuntime::treat_as_trivial(Method* method) {
799 if (_HotSpotJVMCIRuntime_initialized) {
800 oop loader = method->method_holder()->class_loader();
801 if (loader == NULL) {
802 for (int i = 0; i < _trivial_prefixes_count; i++) {
803 if (method->method_holder()->name()->starts_with(_trivial_prefixes[i])) {
804 return true;
805 }
806 }
807 }
808 }
809 return false;
810 }