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