1 /*
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_RUNTIME_INTERFACESUPPORT_HPP
26 #define SHARE_VM_RUNTIME_INTERFACESUPPORT_HPP
27
28 #include "memory/gcLocker.hpp"
29 #include "runtime/handles.inline.hpp"
30 #include "runtime/mutexLocker.hpp"
31 #include "runtime/orderAccess.hpp"
32 #include "runtime/os.hpp"
33 #include "runtime/safepoint.hpp"
34 #include "runtime/vmThread.hpp"
35 #include "utilities/globalDefinitions.hpp"
36 #include "utilities/preserveException.hpp"
37 #include "utilities/top.hpp"
38 #ifdef TARGET_OS_FAMILY_linux
39 # include "thread_linux.inline.hpp"
40 #endif
41 #ifdef TARGET_OS_FAMILY_solaris
42 # include "thread_solaris.inline.hpp"
43 #endif
44 #ifdef TARGET_OS_FAMILY_windows
45 # include "thread_windows.inline.hpp"
46 #endif
47 #ifdef TARGET_OS_FAMILY_bsd
48 # include "thread_bsd.inline.hpp"
49 #endif
50
51 // Wrapper for all entry points to the virtual machine.
52 // The HandleMarkCleaner is a faster version of HandleMark.
53 // It relies on the fact that there is a HandleMark further
54 // down the stack (in JavaCalls::call_helper), and just resets
55 // to the saved values in that HandleMark.
56
57 class HandleMarkCleaner: public StackObj {
58 private:
59 Thread* _thread;
60 public:
61 HandleMarkCleaner(Thread* thread) {
62 _thread = thread;
63 _thread->last_handle_mark()->push();
64 }
65 ~HandleMarkCleaner() {
66 _thread->last_handle_mark()->pop_and_restore();
67 }
68
69 private:
70 inline void* operator new(size_t size, void* ptr) {
71 return ptr;
72 }
73 };
74
75 // InterfaceSupport provides functionality used by the VM_LEAF_BASE and
76 // VM_ENTRY_BASE macros. These macros are used to guard entry points into
77 // the VM and perform checks upon leave of the VM.
78
79
80 class InterfaceSupport: AllStatic {
81 # ifdef ASSERT
82 public:
83 static long _scavenge_alot_counter;
84 static long _fullgc_alot_counter;
85 static long _number_of_calls;
86 static long _fullgc_alot_invocation;
87
88 // tracing
89 static void trace(const char* result_type, const char* header);
90
91 // Helper methods used to implement +ScavengeALot and +FullGCALot
92 static void check_gc_alot() { if (ScavengeALot || FullGCALot) gc_alot(); }
93 static void gc_alot();
94
95 static void walk_stack_from(vframe* start_vf);
96 static void walk_stack();
97
98 # ifdef ENABLE_ZAP_DEAD_LOCALS
99 static void zap_dead_locals_old();
100 # endif
101
102 static void zombieAll();
103 static void unlinkSymbols();
104 static void deoptimizeAll();
105 static void stress_derived_pointers();
106 static void verify_stack();
107 static void verify_last_frame();
108 # endif
109
110 public:
111 // OS dependent stuff
112 #ifdef TARGET_OS_FAMILY_linux
113 # include "interfaceSupport_linux.hpp"
114 #endif
115 #ifdef TARGET_OS_FAMILY_solaris
116 # include "interfaceSupport_solaris.hpp"
117 #endif
118 #ifdef TARGET_OS_FAMILY_windows
119 # include "interfaceSupport_windows.hpp"
120 #endif
121 #ifdef TARGET_OS_FAMILY_bsd
122 # include "interfaceSupport_bsd.hpp"
123 #endif
124
125 };
126
127
128 // Basic class for all thread transition classes.
129
130 class ThreadStateTransition : public StackObj {
131 protected:
132 JavaThread* _thread;
133 public:
134 ThreadStateTransition(JavaThread *thread) {
135 _thread = thread;
136 assert(thread != NULL && thread->is_Java_thread(), "must be Java thread");
137 }
138
139 // Change threadstate in a manner, so safepoint can detect changes.
140 // Time-critical: called on exit from every runtime routine
141 static inline void transition(JavaThread *thread, JavaThreadState from, JavaThreadState to) {
142 assert(from != _thread_in_Java, "use transition_from_java");
143 assert(from != _thread_in_native, "use transition_from_native");
144 assert((from & 1) == 0 && (to & 1) == 0, "odd numbers are transitions states");
145 assert(thread->thread_state() == from, "coming from wrong thread state");
146 // Change to transition state (assumes total store ordering! -Urs)
147 thread->set_thread_state((JavaThreadState)(from + 1));
148
149 // Make sure new state is seen by VM thread
150 if (os::is_MP()) {
151 if (UseMembar) {
152 // Force a fence between the write above and read below
153 OrderAccess::fence();
154 } else {
155 // store to serialize page so VM thread can do pseudo remote membar
156 os::write_memory_serialize_page(thread);
157 }
158 }
159
160 if (SafepointSynchronize::do_call_back()) {
161 SafepointSynchronize::block(thread);
162 }
163 thread->set_thread_state(to);
164
165 CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();)
166 }
167
168 // transition_and_fence must be used on any thread state transition
169 // where there might not be a Java call stub on the stack, in
170 // particular on Windows where the Structured Exception Handler is
171 // set up in the call stub. os::write_memory_serialize_page() can
172 // fault and we can't recover from it on Windows without a SEH in
173 // place.
174 static inline void transition_and_fence(JavaThread *thread, JavaThreadState from, JavaThreadState to) {
175 assert(thread->thread_state() == from, "coming from wrong thread state");
176 assert((from & 1) == 0 && (to & 1) == 0, "odd numbers are transitions states");
177 // Change to transition state (assumes total store ordering! -Urs)
178 thread->set_thread_state((JavaThreadState)(from + 1));
179
180 // Make sure new state is seen by VM thread
181 if (os::is_MP()) {
182 if (UseMembar) {
183 // Force a fence between the write above and read below
184 OrderAccess::fence();
185 } else {
186 // Must use this rather than serialization page in particular on Windows
187 InterfaceSupport::serialize_memory(thread);
188 }
189 }
190
191 if (SafepointSynchronize::do_call_back()) {
192 SafepointSynchronize::block(thread);
193 }
194 thread->set_thread_state(to);
195
196 CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();)
197 }
198
199 // Same as above, but assumes from = _thread_in_Java. This is simpler, since we
200 // never block on entry to the VM. This will break the code, since e.g. preserve arguments
201 // have not been setup.
202 static inline void transition_from_java(JavaThread *thread, JavaThreadState to) {
203 assert(thread->thread_state() == _thread_in_Java, "coming from wrong thread state");
204 thread->set_thread_state(to);
205 }
206
207 static inline void transition_from_native(JavaThread *thread, JavaThreadState to) {
208 assert((to & 1) == 0, "odd numbers are transitions states");
209 assert(thread->thread_state() == _thread_in_native, "coming from wrong thread state");
210 // Change to transition state (assumes total store ordering! -Urs)
211 thread->set_thread_state(_thread_in_native_trans);
212
213 // Make sure new state is seen by GC thread
214 if (os::is_MP()) {
215 if (UseMembar) {
216 // Force a fence between the write above and read below
217 OrderAccess::fence();
218 } else {
219 // Must use this rather than serialization page in particular on Windows
220 InterfaceSupport::serialize_memory(thread);
221 }
222 }
223
224 // We never install asynchronous exceptions when coming (back) in
225 // to the runtime from native code because the runtime is not set
226 // up to handle exceptions floating around at arbitrary points.
227 if (SafepointSynchronize::do_call_back() || thread->is_suspend_after_native()) {
228 JavaThread::check_safepoint_and_suspend_for_native_trans(thread);
229
230 // Clear unhandled oops anywhere where we could block, even if we don't.
231 CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();)
232 }
233
234 thread->set_thread_state(to);
235 }
236 protected:
237 void trans(JavaThreadState from, JavaThreadState to) { transition(_thread, from, to); }
238 void trans_from_java(JavaThreadState to) { transition_from_java(_thread, to); }
239 void trans_from_native(JavaThreadState to) { transition_from_native(_thread, to); }
240 void trans_and_fence(JavaThreadState from, JavaThreadState to) { transition_and_fence(_thread, from, to); }
241 };
242
243
244 class ThreadInVMfromJava : public ThreadStateTransition {
245 public:
246 ThreadInVMfromJava(JavaThread* thread) : ThreadStateTransition(thread) {
247 trans_from_java(_thread_in_vm);
248 }
249 ~ThreadInVMfromJava() {
250 trans(_thread_in_vm, _thread_in_Java);
251 // Check for pending. async. exceptions or suspends.
252 if (_thread->has_special_runtime_exit_condition()) _thread->handle_special_runtime_exit_condition();
253 }
254 };
255
256
257 class ThreadInVMfromUnknown {
258 private:
259 JavaThread* _thread;
260 public:
261 ThreadInVMfromUnknown() : _thread(NULL) {
262 Thread* t = Thread::current();
263 if (t->is_Java_thread()) {
264 JavaThread* t2 = (JavaThread*) t;
265 if (t2->thread_state() == _thread_in_native) {
266 _thread = t2;
267 ThreadStateTransition::transition_from_native(t2, _thread_in_vm);
268 // Used to have a HandleMarkCleaner but that is dangerous as
269 // it could free a handle in our (indirect, nested) caller.
270 // We expect any handles will be short lived and figure we
271 // don't need an actual HandleMark.
272 }
273 }
274 }
275 ~ThreadInVMfromUnknown() {
276 if (_thread) {
277 ThreadStateTransition::transition_and_fence(_thread, _thread_in_vm, _thread_in_native);
278 }
279 }
280 };
281
282
283 class ThreadInVMfromNative : public ThreadStateTransition {
284 public:
285 ThreadInVMfromNative(JavaThread* thread) : ThreadStateTransition(thread) {
286 trans_from_native(_thread_in_vm);
287 }
288 ~ThreadInVMfromNative() {
289 trans_and_fence(_thread_in_vm, _thread_in_native);
290 }
291 };
292
293
294 class ThreadToNativeFromVM : public ThreadStateTransition {
295 public:
296 ThreadToNativeFromVM(JavaThread *thread) : ThreadStateTransition(thread) {
297 // We are leaving the VM at this point and going directly to native code.
298 // Block, if we are in the middle of a safepoint synchronization.
299 assert(!thread->owns_locks(), "must release all locks when leaving VM");
300 thread->frame_anchor()->make_walkable(thread);
301 trans_and_fence(_thread_in_vm, _thread_in_native);
302 // Check for pending. async. exceptions or suspends.
303 if (_thread->has_special_runtime_exit_condition()) _thread->handle_special_runtime_exit_condition(false);
304 }
305
306 ~ThreadToNativeFromVM() {
307 trans_from_native(_thread_in_vm);
308 // We don't need to clear_walkable because it will happen automagically when we return to java
309 }
310 };
311
312
313 class ThreadBlockInVM : public ThreadStateTransition {
314 public:
315 ThreadBlockInVM(JavaThread *thread)
316 : ThreadStateTransition(thread) {
317 // Once we are blocked vm expects stack to be walkable
318 thread->frame_anchor()->make_walkable(thread);
319 trans_and_fence(_thread_in_vm, _thread_blocked);
320 }
321 ~ThreadBlockInVM() {
322 trans_and_fence(_thread_blocked, _thread_in_vm);
323 // We don't need to clear_walkable because it will happen automagically when we return to java
324 }
325 };
326
327
328 // This special transition class is only used to prevent asynchronous exceptions
329 // from being installed on vm exit in situations where we can't tolerate them.
330 // See bugs: 4324348, 4854693, 4998314, 5040492, 5050705.
331 class ThreadInVMfromJavaNoAsyncException : public ThreadStateTransition {
332 public:
333 ThreadInVMfromJavaNoAsyncException(JavaThread* thread) : ThreadStateTransition(thread) {
334 trans_from_java(_thread_in_vm);
335 }
336 ~ThreadInVMfromJavaNoAsyncException() {
337 trans(_thread_in_vm, _thread_in_Java);
338 // NOTE: We do not check for pending. async. exceptions.
339 // If we did and moved the pending async exception over into the
340 // pending exception field, we would need to deopt (currently C2
341 // only). However, to do so would require that we transition back
342 // to the _thread_in_vm state. Instead we postpone the handling of
343 // the async exception.
344
345 // Check for pending. suspends only.
346 if (_thread->has_special_runtime_exit_condition())
347 _thread->handle_special_runtime_exit_condition(false);
348 }
349 };
350
351 // Debug class instantiated in JRT_ENTRY and ITR_ENTRY macro.
352 // Can be used to verify properties on enter/exit of the VM.
353
354 #ifdef ASSERT
355 class VMEntryWrapper {
356 public:
357 VMEntryWrapper() {
358 if (VerifyLastFrame) {
359 InterfaceSupport::verify_last_frame();
360 }
361 }
362
363 ~VMEntryWrapper() {
364 InterfaceSupport::check_gc_alot();
365 if (WalkStackALot) {
366 InterfaceSupport::walk_stack();
367 }
368 #ifdef ENABLE_ZAP_DEAD_LOCALS
369 if (ZapDeadLocalsOld) {
370 InterfaceSupport::zap_dead_locals_old();
371 }
372 #endif
373 #ifdef COMPILER2
374 // This option is not used by Compiler 1
375 if (StressDerivedPointers) {
376 InterfaceSupport::stress_derived_pointers();
377 }
378 #endif
379 if (DeoptimizeALot || DeoptimizeRandom) {
380 InterfaceSupport::deoptimizeAll();
381 }
382 if (ZombieALot) {
383 InterfaceSupport::zombieAll();
384 }
385 if (UnlinkSymbolsALot) {
386 InterfaceSupport::unlinkSymbols();
387 }
388 // do verification AFTER potential deoptimization
389 if (VerifyStack) {
390 InterfaceSupport::verify_stack();
391 }
392
393 }
394 };
395
396
397 class VMNativeEntryWrapper {
398 public:
399 VMNativeEntryWrapper() {
400 if (GCALotAtAllSafepoints) InterfaceSupport::check_gc_alot();
401 }
402
403 ~VMNativeEntryWrapper() {
404 if (GCALotAtAllSafepoints) InterfaceSupport::check_gc_alot();
405 }
406 };
407
408 #endif
409
410
411 // VM-internal runtime interface support
412
413 #ifdef ASSERT
414
415 class RuntimeHistogramElement : public HistogramElement {
416 public:
417 RuntimeHistogramElement(const char* name);
418 };
419
420 #define TRACE_CALL(result_type, header) \
421 InterfaceSupport::_number_of_calls++; \
422 if (TraceRuntimeCalls) \
423 InterfaceSupport::trace(#result_type, #header); \
424 if (CountRuntimeCalls) { \
425 static RuntimeHistogramElement* e = new RuntimeHistogramElement(#header); \
426 if (e != NULL) e->increment_count(); \
427 }
428 #else
429 #define TRACE_CALL(result_type, header) \
430 /* do nothing */
431 #endif
432
433
434 // LEAF routines do not lock, GC or throw exceptions
435
436 #define VM_LEAF_BASE(result_type, header) \
437 TRACE_CALL(result_type, header) \
438 debug_only(NoHandleMark __hm;) \
439 os::verify_stack_alignment(); \
440 /* begin of body */
441
442
443 // ENTRY routines may lock, GC and throw exceptions
444
445 #define VM_ENTRY_BASE(result_type, header, thread) \
446 TRACE_CALL(result_type, header) \
447 HandleMarkCleaner __hm(thread); \
448 Thread* THREAD = thread; \
449 os::verify_stack_alignment(); \
450 /* begin of body */
451
452
453 // QUICK_ENTRY routines behave like ENTRY but without a handle mark
454
455 #define VM_QUICK_ENTRY_BASE(result_type, header, thread) \
456 TRACE_CALL(result_type, header) \
457 debug_only(NoHandleMark __hm;) \
458 Thread* THREAD = thread; \
459 os::verify_stack_alignment(); \
460 /* begin of body */
461
462
463 // Definitions for IRT (Interpreter Runtime)
464 // (thread is an argument passed in to all these routines)
465
466 #define IRT_ENTRY(result_type, header) \
467 result_type header { \
468 ThreadInVMfromJava __tiv(thread); \
469 VM_ENTRY_BASE(result_type, header, thread) \
470 debug_only(VMEntryWrapper __vew;)
471
472
473 #define IRT_LEAF(result_type, header) \
474 result_type header { \
475 VM_LEAF_BASE(result_type, header) \
476 debug_only(No_Safepoint_Verifier __nspv(true);)
477
478
479 #define IRT_ENTRY_NO_ASYNC(result_type, header) \
480 result_type header { \
481 ThreadInVMfromJavaNoAsyncException __tiv(thread); \
482 VM_ENTRY_BASE(result_type, header, thread) \
483 debug_only(VMEntryWrapper __vew;)
484
485 // Another special case for nmethod_entry_point so the nmethod that the
486 // interpreter is about to branch to doesn't get flushed before as we
487 // branch to it's interpreter_entry_point. Skip stress testing here too.
488 // Also we don't allow async exceptions because it is just too painful.
489 #define IRT_ENTRY_FOR_NMETHOD(result_type, header) \
490 result_type header { \
491 nmethodLocker _nmlock(nm); \
492 ThreadInVMfromJavaNoAsyncException __tiv(thread); \
493 VM_ENTRY_BASE(result_type, header, thread)
494
495 #define IRT_END }
496
497
498 // Definitions for JRT (Java (Compiler/Shared) Runtime)
499
500 #define JRT_ENTRY(result_type, header) \
501 result_type header { \
502 ThreadInVMfromJava __tiv(thread); \
503 VM_ENTRY_BASE(result_type, header, thread) \
504 debug_only(VMEntryWrapper __vew;)
505
506
507 #define JRT_LEAF(result_type, header) \
508 result_type header { \
509 VM_LEAF_BASE(result_type, header) \
510 debug_only(JRT_Leaf_Verifier __jlv;)
511
512
513 #define JRT_ENTRY_NO_ASYNC(result_type, header) \
514 result_type header { \
515 ThreadInVMfromJavaNoAsyncException __tiv(thread); \
516 VM_ENTRY_BASE(result_type, header, thread) \
517 debug_only(VMEntryWrapper __vew;)
518
519 // Same as JRT Entry but allows for return value after the safepoint
520 // to get back into Java from the VM
521 #define JRT_BLOCK_ENTRY(result_type, header) \
522 result_type header { \
523 TRACE_CALL(result_type, header) \
524 HandleMarkCleaner __hm(thread);
525
526 #define JRT_BLOCK \
527 { \
528 ThreadInVMfromJava __tiv(thread); \
529 Thread* THREAD = thread; \
530 debug_only(VMEntryWrapper __vew;)
531
532 #define JRT_BLOCK_END }
533
534 #define JRT_END }
535
536 // Definitions for JNI
537
538 #define JNI_ENTRY(result_type, header) \
539 JNI_ENTRY_NO_PRESERVE(result_type, header) \
540 WeakPreserveExceptionMark __wem(thread);
541
542 #define JNI_ENTRY_NO_PRESERVE(result_type, header) \
543 extern "C" { \
544 result_type JNICALL header { \
545 JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
546 assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
547 ThreadInVMfromNative __tiv(thread); \
548 debug_only(VMNativeEntryWrapper __vew;) \
549 VM_ENTRY_BASE(result_type, header, thread)
550
551
552 // Ensure that the VMNativeEntryWrapper constructor, which can cause
553 // a GC, is called outside the NoHandleMark (set via VM_QUICK_ENTRY_BASE).
554 #define JNI_QUICK_ENTRY(result_type, header) \
555 extern "C" { \
556 result_type JNICALL header { \
557 JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
558 assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
559 ThreadInVMfromNative __tiv(thread); \
560 debug_only(VMNativeEntryWrapper __vew;) \
561 VM_QUICK_ENTRY_BASE(result_type, header, thread)
562
563
564 #define JNI_LEAF(result_type, header) \
565 extern "C" { \
566 result_type JNICALL header { \
567 JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
568 assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
569 VM_LEAF_BASE(result_type, header)
570
571
572 // Close the routine and the extern "C"
573 #define JNI_END } }
574
575
576
577 // Definitions for JVM
578
579 #define JVM_ENTRY(result_type, header) \
580 extern "C" { \
581 result_type JNICALL header { \
582 JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
583 ThreadInVMfromNative __tiv(thread); \
584 debug_only(VMNativeEntryWrapper __vew;) \
585 VM_ENTRY_BASE(result_type, header, thread)
586
587
588 #define JVM_ENTRY_NO_ENV(result_type, header) \
589 extern "C" { \
590 result_type JNICALL header { \
591 JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread(); \
592 ThreadInVMfromNative __tiv(thread); \
593 debug_only(VMNativeEntryWrapper __vew;) \
594 VM_ENTRY_BASE(result_type, header, thread)
595
596
597 #define JVM_QUICK_ENTRY(result_type, header) \
598 extern "C" { \
599 result_type JNICALL header { \
600 JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
601 ThreadInVMfromNative __tiv(thread); \
602 debug_only(VMNativeEntryWrapper __vew;) \
603 VM_QUICK_ENTRY_BASE(result_type, header, thread)
604
605
606 #define JVM_LEAF(result_type, header) \
607 extern "C" { \
608 result_type JNICALL header { \
609 VM_Exit::block_if_vm_exited(); \
610 VM_LEAF_BASE(result_type, header)
611
612
613 #define JVM_END } }
614
615 #endif // SHARE_VM_RUNTIME_INTERFACESUPPORT_HPP