Attachment #522456 for bug #647954




  /* do nothing */
#endif

#if defined(__GNUC__) && defined(LINUX) && !defined(_LP64)
#define ALIGN_ATTR __attribute__((force_align_arg_pointer))
#else
#define ALIGN_ATTR
#endif

// LEAF routines do not lock, GC or throw exceptions


// (thread is an argument passed in to all these routines)

#define IRT_ENTRY(result_type, header)                               \
  ALIGN_ATTR result_type header {                                    \
    ThreadInVMfromJava __tiv(thread);                                \
    VM_ENTRY_BASE(result_type, header, thread)                       \
    debug_only(VMEntryWrapper __vew;)


#define IRT_LEAF(result_type, header)                                \
  ALIGN_ATTR result_type header {                                    \
    VM_LEAF_BASE(result_type, header)                                \
    debug_only(No_Safepoint_Verifier __nspv(true);)


#define IRT_ENTRY_NO_ASYNC(result_type, header)                      \
  ALIGN_ATTR result_type header {                                    \
    ThreadInVMfromJavaNoAsyncException __tiv(thread);                \
    VM_ENTRY_BASE(result_type, header, thread)                       \
    debug_only(VMEntryWrapper __vew;)

// Definitions for JRT (Java (Compiler/Shared) Runtime)

#define JRT_ENTRY(result_type, header)                               \
  ALIGN_ATTR result_type header {                                    \
    ThreadInVMfromJava __tiv(thread);                                \
    VM_ENTRY_BASE(result_type, header, thread)                       \
    debug_only(VMEntryWrapper __vew;)


#define JRT_LEAF(result_type, header)                                \
  ALIGN_ATTR result_type header {                                    \
  VM_LEAF_BASE(result_type, header)                                  \
  debug_only(JRT_Leaf_Verifier __jlv;)


#define JRT_ENTRY_NO_ASYNC(result_type, header)                      \
  ALIGN_ATTR result_type header {                                    \
    ThreadInVMfromJavaNoAsyncException __tiv(thread);                \
    VM_ENTRY_BASE(result_type, header, thread)                       \
    debug_only(VMEntryWrapper __vew;)

// Same as JRT Entry but allows for return value after the safepoint
// to get back into Java from the VM
#define JRT_BLOCK_ENTRY(result_type, header)                         \
  ALIGN_ATTR result_type header {                                    \
    TRACE_CALL(result_type, header)                                  \
    HandleMarkCleaner __hm(thread);



#define JNI_ENTRY_NO_PRESERVE(result_type, header)             \
extern "C" {                                                         \
  ALIGN_ATTR result_type JNICALL header {                            \
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
    assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
    ThreadInVMfromNative __tiv(thread);                              \

// a GC, is called outside the NoHandleMark (set via VM_QUICK_ENTRY_BASE).
#define JNI_QUICK_ENTRY(result_type, header)                         \
extern "C" {                                                         \
  ALIGN_ATTR result_type JNICALL header {                            \
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
    assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
    ThreadInVMfromNative __tiv(thread);                              \


#define JNI_LEAF(result_type, header)                                \
extern "C" {                                                         \
  ALIGN_ATTR result_type JNICALL header {                            \
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
    assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
    VM_LEAF_BASE(result_type, header)


#define JVM_ENTRY(result_type, header)                               \
extern "C" {                                                         \
  ALIGN_ATTR result_type JNICALL header {                            \
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
    ThreadInVMfromNative __tiv(thread);                              \
    debug_only(VMNativeEntryWrapper __vew;)                          \


#define JVM_ENTRY_NO_ENV(result_type, header)                        \
extern "C" {                                                         \
  ALIGN_ATTR result_type JNICALL header {                            \
    JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread();  \
    ThreadInVMfromNative __tiv(thread);                              \
    debug_only(VMNativeEntryWrapper __vew;)                          \


#define JVM_QUICK_ENTRY(result_type, header)                         \
extern "C" {                                                         \
  ALIGN_ATTR result_type JNICALL header {                            \
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
    ThreadInVMfromNative __tiv(thread);                              \
    debug_only(VMNativeEntryWrapper __vew;)                          \


#define JVM_LEAF(result_type, header)                                \
extern "C" {                                                         \
  ALIGN_ATTR result_type JNICALL header {                            \
    VM_Exit::block_if_vm_exited();                                   \
    VM_LEAF_BASE(result_type, header)


Return to bug 647954

Lines 422-427 Link Here

(-)a/openjdk/hotspot/src/share/vm/runtime/interfaceSupport.hpp (-14 / +19 lines)
422	/* do nothing */	422	/* do nothing */
423	#endif	423	#endif
424		424
		425	#if defined(__GNUC__) && defined(LINUX) && !defined(_LP64)
		426	#define ALIGN_ATTR __attribute__((force_align_arg_pointer))
		427	#else
		428	#define ALIGN_ATTR
		429	#endif
425		430
426	// LEAF routines do not lock, GC or throw exceptions	431	// LEAF routines do not lock, GC or throw exceptions
427		432
Lines 464-483 Link Here
464	// (thread is an argument passed in to all these routines)	469	// (thread is an argument passed in to all these routines)
465		470
466	#define IRT_ENTRY(result_type, header) \	471	#define IRT_ENTRY(result_type, header) \
467	result_type header { \	472	ALIGN_ATTR result_type header { \
468	ThreadInVMfromJava __tiv(thread); \	473	ThreadInVMfromJava __tiv(thread); \
469	VM_ENTRY_BASE(result_type, header, thread) \	474	VM_ENTRY_BASE(result_type, header, thread) \
470	debug_only(VMEntryWrapper __vew;)	475	debug_only(VMEntryWrapper __vew;)
471		476
472		477
473	#define IRT_LEAF(result_type, header) \	478	#define IRT_LEAF(result_type, header) \
474	result_type header { \	479	ALIGN_ATTR result_type header { \
475	VM_LEAF_BASE(result_type, header) \	480	VM_LEAF_BASE(result_type, header) \
476	debug_only(No_Safepoint_Verifier __nspv(true);)	481	debug_only(No_Safepoint_Verifier __nspv(true);)
477		482
478		483
479	#define IRT_ENTRY_NO_ASYNC(result_type, header) \	484	#define IRT_ENTRY_NO_ASYNC(result_type, header) \
480	result_type header { \	485	ALIGN_ATTR result_type header { \
481	ThreadInVMfromJavaNoAsyncException __tiv(thread); \	486	ThreadInVMfromJavaNoAsyncException __tiv(thread); \
482	VM_ENTRY_BASE(result_type, header, thread) \	487	VM_ENTRY_BASE(result_type, header, thread) \
483	debug_only(VMEntryWrapper __vew;)	488	debug_only(VMEntryWrapper __vew;)
Lines 488-507 Link Here
488	// Definitions for JRT (Java (Compiler/Shared) Runtime)	493	// Definitions for JRT (Java (Compiler/Shared) Runtime)
489		494
490	#define JRT_ENTRY(result_type, header) \	495	#define JRT_ENTRY(result_type, header) \
491	result_type header { \	496	ALIGN_ATTR result_type header { \
492	ThreadInVMfromJava __tiv(thread); \	497	ThreadInVMfromJava __tiv(thread); \
493	VM_ENTRY_BASE(result_type, header, thread) \	498	VM_ENTRY_BASE(result_type, header, thread) \
494	debug_only(VMEntryWrapper __vew;)	499	debug_only(VMEntryWrapper __vew;)
495		500
496		501
497	#define JRT_LEAF(result_type, header) \	502	#define JRT_LEAF(result_type, header) \
498	result_type header { \	503	ALIGN_ATTR result_type header { \
499	VM_LEAF_BASE(result_type, header) \	504	VM_LEAF_BASE(result_type, header) \
500	debug_only(JRT_Leaf_Verifier __jlv;)	505	debug_only(JRT_Leaf_Verifier __jlv;)
501		506
502		507
503	#define JRT_ENTRY_NO_ASYNC(result_type, header) \	508	#define JRT_ENTRY_NO_ASYNC(result_type, header) \
504	result_type header { \	509	ALIGN_ATTR result_type header { \
505	ThreadInVMfromJavaNoAsyncException __tiv(thread); \	510	ThreadInVMfromJavaNoAsyncException __tiv(thread); \
506	VM_ENTRY_BASE(result_type, header, thread) \	511	VM_ENTRY_BASE(result_type, header, thread) \
507	debug_only(VMEntryWrapper __vew;)	512	debug_only(VMEntryWrapper __vew;)
Lines 509-515 Link Here
509	// Same as JRT Entry but allows for return value after the safepoint	514	// Same as JRT Entry but allows for return value after the safepoint
510	// to get back into Java from the VM	515	// to get back into Java from the VM
511	#define JRT_BLOCK_ENTRY(result_type, header) \	516	#define JRT_BLOCK_ENTRY(result_type, header) \
512	result_type header { \	517	ALIGN_ATTR result_type header { \
513	TRACE_CALL(result_type, header) \	518	TRACE_CALL(result_type, header) \
514	HandleMarkCleaner __hm(thread);	519	HandleMarkCleaner __hm(thread);
515		520
Lines 531-537 Link Here
531		536
532	#define JNI_ENTRY_NO_PRESERVE(result_type, header) \	537	#define JNI_ENTRY_NO_PRESERVE(result_type, header) \
533	extern "C" { \	538	extern "C" { \
534	result_type JNICALL header { \	539	ALIGN_ATTR result_type JNICALL header { \
535	JavaThread* thread=JavaThread::thread_from_jni_environment(env); \	540	JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
536	assert( !VerifyJNIEnvThread \|\| (thread == Thread::current()), "JNIEnv is only valid in same thread"); \	541	assert( !VerifyJNIEnvThread \|\| (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
537	ThreadInVMfromNative __tiv(thread); \	542	ThreadInVMfromNative __tiv(thread); \
Lines 543-549 Link Here
543	// a GC, is called outside the NoHandleMark (set via VM_QUICK_ENTRY_BASE).	548	// a GC, is called outside the NoHandleMark (set via VM_QUICK_ENTRY_BASE).
544	#define JNI_QUICK_ENTRY(result_type, header) \	549	#define JNI_QUICK_ENTRY(result_type, header) \
545	extern "C" { \	550	extern "C" { \
546	result_type JNICALL header { \	551	ALIGN_ATTR result_type JNICALL header { \
547	JavaThread* thread=JavaThread::thread_from_jni_environment(env); \	552	JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
548	assert( !VerifyJNIEnvThread \|\| (thread == Thread::current()), "JNIEnv is only valid in same thread"); \	553	assert( !VerifyJNIEnvThread \|\| (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
549	ThreadInVMfromNative __tiv(thread); \	554	ThreadInVMfromNative __tiv(thread); \
Lines 553-559 Link Here
553		558
554	#define JNI_LEAF(result_type, header) \	559	#define JNI_LEAF(result_type, header) \
555	extern "C" { \	560	extern "C" { \
556	result_type JNICALL header { \	561	ALIGN_ATTR result_type JNICALL header { \
557	JavaThread* thread=JavaThread::thread_from_jni_environment(env); \	562	JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
558	assert( !VerifyJNIEnvThread \|\| (thread == Thread::current()), "JNIEnv is only valid in same thread"); \	563	assert( !VerifyJNIEnvThread \|\| (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
559	VM_LEAF_BASE(result_type, header)	564	VM_LEAF_BASE(result_type, header)
Lines 568-574 Link Here
568		573
569	#define JVM_ENTRY(result_type, header) \	574	#define JVM_ENTRY(result_type, header) \
570	extern "C" { \	575	extern "C" { \
571	result_type JNICALL header { \	576	ALIGN_ATTR result_type JNICALL header { \
572	JavaThread* thread=JavaThread::thread_from_jni_environment(env); \	577	JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
573	ThreadInVMfromNative __tiv(thread); \	578	ThreadInVMfromNative __tiv(thread); \
574	debug_only(VMNativeEntryWrapper __vew;) \	579	debug_only(VMNativeEntryWrapper __vew;) \
Lines 577-583 Link Here
577		582
578	#define JVM_ENTRY_NO_ENV(result_type, header) \	583	#define JVM_ENTRY_NO_ENV(result_type, header) \
579	extern "C" { \	584	extern "C" { \
580	result_type JNICALL header { \	585	ALIGN_ATTR result_type JNICALL header { \
581	JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread(); \	586	JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread(); \
582	ThreadInVMfromNative __tiv(thread); \	587	ThreadInVMfromNative __tiv(thread); \
583	debug_only(VMNativeEntryWrapper __vew;) \	588	debug_only(VMNativeEntryWrapper __vew;) \
Lines 586-592 Link Here
586		591
587	#define JVM_QUICK_ENTRY(result_type, header) \	592	#define JVM_QUICK_ENTRY(result_type, header) \
588	extern "C" { \	593	extern "C" { \
589	result_type JNICALL header { \	594	ALIGN_ATTR result_type JNICALL header { \
590	JavaThread* thread=JavaThread::thread_from_jni_environment(env); \	595	JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
591	ThreadInVMfromNative __tiv(thread); \	596	ThreadInVMfromNative __tiv(thread); \
592	debug_only(VMNativeEntryWrapper __vew;) \	597	debug_only(VMNativeEntryWrapper __vew;) \
Lines 595-601 Link Here
595		600
596	#define JVM_LEAF(result_type, header) \	601	#define JVM_LEAF(result_type, header) \
597	extern "C" { \	602	extern "C" { \
598	result_type JNICALL header { \	603	ALIGN_ATTR result_type JNICALL header { \
599	VM_Exit::block_if_vm_exited(); \	604	VM_Exit::block_if_vm_exited(); \
600	VM_LEAF_BASE(result_type, header)	605	VM_LEAF_BASE(result_type, header)
601		606