graal-compiler: src/cpu/x86/vm/sharedRuntime_x86

comparison src/cpu/x86/vm/sharedRuntime_x86_64.cpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	89152779163c 0bf37f737702
children	33a783b15758

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 return AdapterHandlerLibrary::new_entry(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry);
 }
 int SharedRuntime::c_calling_convention(const BasicType *sig_bt,
 VMRegPair *regs,
+VMRegPair *regs2,
 int total_args_passed) {
+assert(regs2 == NULL, "not needed on x86");
 // We return the amount of VMRegImpl stack slots we need to reserve for all
 // the arguments NOT counting out_preserve_stack_slots.
 // NOTE: These arrays will have to change when c1 is ported
 #ifdef _WIN64
 }
 // Now figure out where the args must be stored and how much stack space
 // they require.
 int out_arg_slots;
-out_arg_slots = c_calling_convention(out_sig_bt, out_regs, total_c_args);
+out_arg_slots = c_calling_convention(out_sig_bt, out_regs, NULL, total_c_args);
 // Compute framesize for the wrapper.  We need to handlize all oops in
 // incoming registers
 // Calculate the total number of stack slots we will need.
 __ subptr(rsp, stack_size - 2*wordSize);
 // Frame is now completed as far as size and linkage.
 int frame_complete = ((intptr_t)__ pc()) - start;
+if (UseRTMLocking) {
+// Abort RTM transaction before calling JNI
+// because critical section will be large and will be
+// aborted anyway. Also nmethod could be deoptimized.
+__ xabort(0);
+}
 #ifdef ASSERT
 {
 Label L;
 __ mov(rax, rsp);
 __ andptr(rax, -16); // must be 16 byte boundary (see amd64 ABI)
 }
 if (!is_critical_native) {
 // reset handle block
 __ movptr(rcx, Address(r15_thread, JavaThread::active_handles_offset()));
-__ movptr(Address(rcx, JNIHandleBlock::top_offset_in_bytes()), (int32_t)NULL_WORD);
+__ movl(Address(rcx, JNIHandleBlock::top_offset_in_bytes()), (int32_t)NULL_WORD);
 }
 // pop our frame
 __ leave();
 // Now figure out where the args must be stored and how much stack space
 // they require (neglecting out_preserve_stack_slots but space for storing
 // the 1st six register arguments). It's weird see int_stk_helper.
 int out_arg_slots;
-out_arg_slots = c_calling_convention(out_sig_bt, out_regs, total_c_args);
+out_arg_slots = c_calling_convention(out_sig_bt, out_regs, NULL, total_c_args);
 // Calculate the total number of stack slots we will need.
 // First count the abi requirement plus all of the outgoing args
 int stack_slots = SharedRuntime::out_preserve_stack_slots() + out_arg_slots;
 // Pick up the initial fp we should save
 // restore rbp before stack bang because if stack overflow is thrown it needs to be pushed (and preserved)
 __ movptr(rbp, Address(rdi, Deoptimization::UnrollBlock::initial_info_offset_in_bytes()));
-// Stack bang to make sure there's enough room for these interpreter frames.
+#ifdef ASSERT
+// Compilers generate code that bang the stack by as much as the
+// interpreter would need. So this stack banging should never
+// trigger a fault. Verify that it does not on non product builds.
 if (UseStackBanging) {
 __ movl(rbx, Address(rdi, Deoptimization::UnrollBlock::total_frame_sizes_offset_in_bytes()));
 __ bang_stack_size(rbx, rcx);
 }
+#endif
 // Load address of array of frame pcs into rcx
 __ movptr(rcx, Address(rdi, Deoptimization::UnrollBlock::frame_pcs_offset_in_bytes()));
 // Trash the old pc
 assert(SimpleRuntimeFrame::framesize % 4 == 0, "sp not 16-byte aligned");
 address start = __ pc();
+if (UseRTMLocking) {
+// Abort RTM transaction before possible nmethod deoptimization.
+__ xabort(0);
+}
 // Push self-frame.  We get here with a return address on the
 // stack, so rsp is 8-byte aligned until we allocate our frame.
 __ subptr(rsp, SimpleRuntimeFrame::return_off << LogBytesPerInt); // Epilog!
 // No callee saved registers. rbp is assumed implicitly saved
 // Pick up the initial fp we should save
 // restore rbp before stack bang because if stack overflow is thrown it needs to be pushed (and preserved)
 __ movptr(rbp, Address(rdi, Deoptimization::UnrollBlock::initial_info_offset_in_bytes()));
-// Stack bang to make sure there's enough room for these interpreter frames.
+#ifdef ASSERT
+// Compilers generate code that bang the stack by as much as the
+// interpreter would need. So this stack banging should never
+// trigger a fault. Verify that it does not on non product builds.
 if (UseStackBanging) {
 __ movl(rbx, Address(rdi ,Deoptimization::UnrollBlock::total_frame_sizes_offset_in_bytes()));
 __ bang_stack_size(rbx, rcx);
 }
+#endif
 // Load address of array of frame pcs into rcx (address*)
 __ movptr(rcx, Address(rdi, Deoptimization::UnrollBlock::frame_pcs_offset_in_bytes()));
 // Trash the return pc
 address start   = __ pc();
 address call_pc = NULL;
 int frame_size_in_words;
 bool cause_return = (poll_type == POLL_AT_RETURN);
 bool save_vectors = (poll_type == POLL_AT_VECTOR_LOOP);
+if (UseRTMLocking) {
+// Abort RTM transaction before calling runtime
+// because critical section will be large and will be
+// aborted anyway. Also nmethod could be deoptimized.
+__ xabort(0);
+}
 // Make room for return address (or push it again)
 if (!cause_return) {
 __ push(rbx);
 }

Mercurial > hg > graal-compiler

comparison src/cpu/x86/vm/sharedRuntime_x86_64.cpp @ 18041:52b4284cb496