truffle: src/cpu/ppc/vm/sharedRuntime

comparison src/cpu/ppc/vm/sharedRuntime_ppc.cpp @ 14684:e5e8aa897002

8035647: PPC64: Support for elf v2 abi. Summary: ELFv2 ABI used by the little endian PowerPC64 on Linux. Reviewed-by: kvn Contributed-by: asmundak@google.com

author	goetz
date	Thu, 06 Mar 2014 10:55:28 -0800
parents	67fa91961822
children	58cf34613a72

comparison

equal deleted inserted replaced

-:84eafecdb9a9
+:e5e8aa897002
 return_pc_is_lr,
 return_pc_is_r4,
 return_pc_is_thread_saved_exception_pc
 };
-static OopMap* push_frame_abi112_and_save_live_registers(MacroAssembler* masm,
+static OopMap* push_frame_reg_args_and_save_live_registers(MacroAssembler* masm,
 int* out_frame_size_in_bytes,
 bool generate_oop_map,
 int return_pc_adjustment,
 ReturnPCLocation return_pc_location);
 static void    restore_live_registers_and_pop_frame(MacroAssembler* masm,
 RegisterSaver_LiveIntReg(   R29 ),
 RegisterSaver_LiveIntReg(   R31 ),
 RegisterSaver_LiveIntReg(   R30 ), // r30 must be the last register
 };
-OopMap* RegisterSaver::push_frame_abi112_and_save_live_registers(MacroAssembler* masm,
+OopMap* RegisterSaver::push_frame_reg_args_and_save_live_registers(MacroAssembler* masm,
 int* out_frame_size_in_bytes,
 bool generate_oop_map,
 int return_pc_adjustment,
 ReturnPCLocation return_pc_location) {
-// Push an abi112-frame and store all registers which may be live.
+// Push an abi_reg_args-frame and store all registers which may be live.
 // If requested, create an OopMap: Record volatile registers as
 // callee-save values in an OopMap so their save locations will be
 // propagated to the RegisterMap of the caller frame during
 // StackFrameStream construction (needed for deoptimization; see
 // compiledVFrame::create_stack_value).
 // calcualte frame size
 const int regstosave_num       = sizeof(RegisterSaver_LiveRegs) /
 sizeof(RegisterSaver::LiveRegType);
 const int register_save_size   = regstosave_num * reg_size;
 const int frame_size_in_bytes  = round_to(register_save_size, frame::alignment_in_bytes)
-+ frame::abi_112_size;
++ frame::abi_reg_args_size;
 *out_frame_size_in_bytes       = frame_size_in_bytes;
 const int frame_size_in_slots  = frame_size_in_bytes / sizeof(jint);
 const int register_save_offset = frame_size_in_bytes - register_save_size;
 // OopMap frame size is in c2 stack slots (sizeof(jint)) not bytes or words.
 OopMap* map = generate_oop_map ? new OopMap(frame_size_in_slots, 0) : NULL;
-BLOCK_COMMENT("push_frame_abi112_and_save_live_registers {");
+BLOCK_COMMENT("push_frame_reg_args_and_save_live_registers {");
 // Save r30 in the last slot of the not yet pushed frame so that we
 // can use it as scratch reg.
 __ std(R30, -reg_size, R1_SP);
 assert(-reg_size == register_save_offset - frame_size_in_bytes + ((regstosave_num-1)*reg_size),
 RegisterSaver_LiveRegs[i].vmreg->next());
 }
 offset += reg_size;
 }
-BLOCK_COMMENT("} push_frame_abi112_and_save_live_registers");
+BLOCK_COMMENT("} push_frame_reg_args_and_save_live_registers");
 // And we're done.
 return map;
 }
 const int inc_stk_for_intfloat   = 2; // 2 slots for ints and floats
 const int inc_stk_for_longdouble = 2; // 2 slots for longs and doubles
 int i;
 VMReg reg;
-// Leave room for C-compatible ABI_112.
+// Leave room for C-compatible ABI_REG_ARGS.
-int stk = (frame::abi_112_size - frame::jit_out_preserve_size) / VMRegImpl::stack_slot_size;
+int stk = (frame::abi_reg_args_size - frame::jit_out_preserve_size) / VMRegImpl::stack_slot_size;
 int arg = 0;
 int freg = 0;
 // Avoid passing C arguments in the wrong stack slots.
+#if defined(ABI_ELFv2)
+assert((SharedRuntime::out_preserve_stack_slots() + stk) * VMRegImpl::stack_slot_size == 96,
+"passing C arguments in wrong stack slots");
+#else
 assert((SharedRuntime::out_preserve_stack_slots() + stk) * VMRegImpl::stack_slot_size == 112,
 "passing C arguments in wrong stack slots");
+#endif
 // We fill-out regs AND regs2 if an argument must be passed in a
 // register AND in a stack slot. If regs2 is NULL in such a
 // situation, we bail-out with a fatal error.
 for (int i = 0; i < total_args_passed; ++i, ++arg) {
 // Initialize regs2 to BAD.
 __ mr(R3_ARG1, R16_thread);
 __ set_last_Java_frame(R1_SP, noreg);
 __ block_comment("block_for_jni_critical");
 address entry_point = CAST_FROM_FN_PTR(address, SharedRuntime::block_for_jni_critical);
+#if defined(ABI_ELFv2)
+__ call_c(entry_point, relocInfo::runtime_call_type);
+#else
 __ call_c(CAST_FROM_FN_PTR(FunctionDescriptor*, entry_point), relocInfo::runtime_call_type);
+#endif
 address start           = __ pc() - __ offset(),
 calls_return_pc = __ last_calls_return_pc();
 oop_maps->add_gc_map(calls_return_pc - start, map);
 __ reset_last_Java_frame();
 //   7) alignment
 //
 // Layout of the native wrapper frame:
 // (stack grows upwards, memory grows downwards)
 //
-// NW     [ABI_112]                  <-- 1) R1_SP
+// NW     [ABI_REG_ARGS]             <-- 1) R1_SP
 //        [outgoing arguments]       <-- 2) R1_SP + out_arg_slot_offset
 //        [oopHandle area]           <-- 3) R1_SP + oop_handle_offset (save area for critical natives)
 //        klass                      <-- 4) R1_SP + klass_offset
 //        lock                       <-- 5) R1_SP + lock_offset
 //        [workspace]                <-- 6) R1_SP + workspace_offset
 // None of the above fast optimizations worked so we have to get into the
 // slow case of monitor enter. Inline a special case of call_VM that
 // disallows any pending_exception.
-// Save argument registers and leave room for C-compatible ABI_112.
+// Save argument registers and leave room for C-compatible ABI_REG_ARGS.
-int frame_size = frame::abi_112_size +
+int frame_size = frame::abi_reg_args_size +
 round_to(total_c_args * wordSize, frame::alignment_in_bytes);
 __ mr(R11_scratch1, R1_SP);
 RegisterSaver::push_frame_and_save_argument_registers(masm, R12_scratch2, frame_size, total_c_args, out_regs, out_regs2);
 // Do the call.
 }
 // The JNI call
 // --------------------------------------------------------------------------
+#if defined(ABI_ELFv2)
+__ call_c(native_func, relocInfo::runtime_call_type);
+#else
 FunctionDescriptor* fd_native_method = (FunctionDescriptor*) native_func;
 __ call_c(fd_native_method, relocInfo::runtime_call_type);
+#endif
 // Now, we are back from the native code.
 int frame_size_in_words;
 OopMap* map = NULL;
 OopMapSet *oop_maps = new OopMapSet();
 // size of ABI112 plus spill slots for R3_RET and F1_RET.
-const int frame_size_in_bytes = frame::abi_112_spill_size;
+const int frame_size_in_bytes = frame::abi_reg_args_spill_size;
 const int frame_size_in_slots = frame_size_in_bytes / sizeof(jint);
 int first_frame_size_in_bytes = 0; // frame size of "unpack frame" for call to fetch_unroll_info.
 const Register exec_mode_reg = R21_tmp1;
 // of the return pc.
 const int return_pc_adjustment_no_exception = -size_deopt_handler();
 // Push the "unpack frame"
 // Save everything in sight.
-map = RegisterSaver::push_frame_abi112_and_save_live_registers(masm,
+map = RegisterSaver::push_frame_reg_args_and_save_live_registers(masm,
 &first_frame_size_in_bytes,
 /*generate_oop_map=*/ true,
 return_pc_adjustment_no_exception,
 RegisterSaver::return_pc_is_lr);
 assert(map != NULL, "OopMap must have been created");
 __ li(exec_mode_reg, Deoptimization::Unpack_deopt);
 // Save exec mode for unpack_frames.
 __ b(exec_mode_initialized);
 const int return_pc_adjustment_exception = 0;
 // Push the "unpack frame".
 // Save everything in sight.
 assert(R4 == R4_ARG2, "exception pc must be in r4");
-RegisterSaver::push_frame_abi112_and_save_live_registers(masm,
+RegisterSaver::push_frame_reg_args_and_save_live_registers(masm,
 &first_frame_size_in_bytes,
 /*generate_oop_map=*/ false,
 return_pc_adjustment_exception,
 RegisterSaver::return_pc_is_r4);
 // Deopt during an exception. Save exec mode for unpack_frames.
 __ li(exec_mode_reg, Deoptimization::Unpack_exception);
 // Store exception oop and pc in thread (location known to GC).
 // stack: (unpack frame, skeletal interpreter frame, ..., optional
 // skeletal interpreter frame, optional c2i, caller of deoptee,
 // ...).
 // Spill live volatile registers since we'll do a call.
-__ std( R3_RET,  _abi_112_spill(spill_ret),  R1_SP);
+__ std( R3_RET, _abi_reg_args_spill(spill_ret),  R1_SP);
-__ stfd(F1_RET, _abi_112_spill(spill_fret), R1_SP);
+__ stfd(F1_RET, _abi_reg_args_spill(spill_fret), R1_SP);
 // Let the unpacker layout information in the skeletal frames just
 // allocated.
 __ get_PC_trash_LR(R3_RET);
 __ set_last_Java_frame(/*sp*/R1_SP, /*pc*/R3_RET);
 __ call_VM_leaf(CAST_FROM_FN_PTR(address, Deoptimization::unpack_frames),
 R16_thread/*thread*/, exec_mode_reg/*exec_mode*/);
 __ reset_last_Java_frame();
 // Restore the volatiles saved above.
-__ ld( R3_RET, _abi_112_spill(spill_ret),  R1_SP);
+__ ld( R3_RET, _abi_reg_args_spill(spill_ret),  R1_SP);
-__ lfd(F1_RET, _abi_112_spill(spill_fret), R1_SP);
+__ lfd(F1_RET, _abi_reg_args_spill(spill_fret), R1_SP);
 // Pop the unpack frame.
 __ pop_frame();
 __ restore_LR_CR(R0);
 Register unroll_block_reg = R21_tmp1;
 Register klass_index_reg  = R22_tmp2;
 Register unc_trap_reg     = R23_tmp3;
 OopMapSet* oop_maps = new OopMapSet();
-int frame_size_in_bytes = frame::abi_112_size;
+int frame_size_in_bytes = frame::abi_reg_args_size;
 OopMap* map = new OopMap(frame_size_in_bytes / sizeof(jint), 0);
 // stack: (deoptee, optional i2c, caller_of_deoptee, ...).
 // Push a dummy `unpack_frame' and call
 // Save LR to compiled frame.
 __ save_LR_CR(R11_scratch1);
 // Push an "uncommon_trap" frame.
-__ push_frame_abi112(0, R11_scratch1);
+__ push_frame_reg_args(0, R11_scratch1);
 // stack: (unpack frame, deoptee, optional i2c, caller_of_deoptee, ...).
 // Set the `unpack_frame' as last_Java_frame.
 // `Deoptimization::uncommon_trap' expects it and considers its
 // Push a dummy `unpack_frame' taking care of float return values.
 // Call `Deoptimization::unpack_frames' to layout information in the
 // interpreter frames just created.
 // Push a simple "unpack frame" here.
-__ push_frame_abi112(0, R11_scratch1);
+__ push_frame_reg_args(0, R11_scratch1);
 // stack: (unpack frame, skeletal interpreter frame, ..., optional
 // skeletal interpreter frame, optional c2i, caller of deoptee,
 // ...).
 // Use thread()->saved_exception_pc() as return pc.
 return_pc_location = RegisterSaver::return_pc_is_thread_saved_exception_pc;
 }
 // Save registers, fpu state, and flags.
-map = RegisterSaver::push_frame_abi112_and_save_live_registers(masm,
+map = RegisterSaver::push_frame_reg_args_and_save_live_registers(masm,
 &frame_size_in_bytes,
 /*generate_oop_map=*/ true,
 /*return_pc_adjustment=*/0,
 return_pc_location);
 // The following is basically a call_VM. However, we need the precise
 // address of the call in order to generate an oopmap. Hence, we do all the
 // work outselves.
 __ set_last_Java_frame(/*sp=*/R1_SP, /*pc=*/noreg);
 OopMapSet *oop_maps = new OopMapSet();
 OopMap* map = NULL;
 address start = __ pc();
-map = RegisterSaver::push_frame_abi112_and_save_live_registers(masm,
+map = RegisterSaver::push_frame_reg_args_and_save_live_registers(masm,
 &frame_size_in_bytes,
 /*generate_oop_map*/ true,
 /*return_pc_adjustment*/ 0,
 RegisterSaver::return_pc_is_lr);
 // Use noreg as last_Java_pc, the return pc will be reconstructed
 // from the physical frame.
 __ set_last_Java_frame(/*sp*/R1_SP, noreg);

Mercurial > hg > truffle

comparison src/cpu/ppc/vm/sharedRuntime_ppc.cpp @ 14684:e5e8aa897002