truffle: src/cpu/ppc/vm/sharedRuntime

comparison src/cpu/ppc/vm/sharedRuntime_ppc.cpp @ 14726:92aa6797d639

Backed out merge changeset: b51e29501f30 Backed out merge revision to its first parent (8f483e200405)

author	Doug Simon <doug.simon@oracle.com>
date	Mon, 24 Mar 2014 21:30:43 +0100
parents	58cf34613a72
children

comparison

equal deleted inserted replaced

-:0bdd0d157040
+:92aa6797d639
 /*
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
-* Copyright 2012, 2014 SAP AG. All rights reserved.
+* Copyright 2012, 2013 SAP AG. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 return_pc_is_lr,
 return_pc_is_r4,
 return_pc_is_thread_saved_exception_pc
 };
-static OopMap* push_frame_reg_args_and_save_live_registers(MacroAssembler* masm,
+static OopMap* push_frame_abi112_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_reg_args_and_save_live_registers(MacroAssembler* masm,
+OopMap* RegisterSaver::push_frame_abi112_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 abi_reg_args-frame and store all registers which may be live.
+// Push an abi112-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_reg_args_size;
++ frame::abi_112_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_reg_args_and_save_live_registers {");
+BLOCK_COMMENT("push_frame_abi112_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_reg_args_and_save_live_registers");
+BLOCK_COMMENT("} push_frame_abi112_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_REG_ARGS.
+// Leave room for C-compatible ABI_112.
-int stk = (frame::abi_reg_args_size - frame::jit_out_preserve_size) / VMRegImpl::stack_slot_size;
+int stk = (frame::abi_112_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.
 // Jump to the interpreter just as if interpreter was doing it.
 #ifdef CC_INTERP
 const Register tos = R17_tos;
-#else
-const Register tos = R15_esp;
-__ load_const_optimized(R25_templateTableBase, (address)Interpreter::dispatch_table((TosState)0), R11_scratch1);
 #endif
 // load TOS
 __ addi(tos, R1_SP, st_off);
 int total_args_passed,
 int comp_args_on_stack,
 const BasicType *sig_bt,
 const VMRegPair *regs) {
-// Load method's entry-point from method.
+// Load method's entry-point from methodOop.
 __ ld(R12_scratch2, in_bytes(Method::from_compiled_offset()), R19_method);
 __ mtctr(R12_scratch2);
 // We will only enter here from an interpreted frame and never from after
 // passing thru a c2i. Azul allowed this but we do not. If we lose the
 // save code can segv when fxsave instructions find improperly
 // aligned stack pointer.
 #ifdef CC_INTERP
 const Register ld_ptr = R17_tos;
-#else
-const Register ld_ptr = R15_esp;
 #endif
 const Register value_regs[] = { R22_tmp2, R23_tmp3, R24_tmp4, R25_tmp5, R26_tmp6 };
 const int num_value_regs = sizeof(value_regs) / sizeof(Register);
 int value_regs_index = 0;
 int ld_offset = total_args_passed*wordSize;
 }
 }
 }
 }
-BLOCK_COMMENT("Store method");
+BLOCK_COMMENT("Store method oop");
-// Store method into thread->callee_target.
+// Store method oop into thread->callee_target.
 // We might end up in handle_wrong_method if the callee is
 // deoptimized as we race thru here. If that happens we don't want
 // to take a safepoint because the caller frame will look
 // interpreted and arguments are now "compiled" so it is much better
 // to make this transition invisible to the stack walking
 __ 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_REG_ARGS]             <-- 1) R1_SP
+// NW     [ABI_112]                  <-- 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_REG_ARGS.
+// Save argument registers and leave room for C-compatible ABI_112.
-int frame_size = frame::abi_reg_args_size +
+int frame_size = frame::abi_112_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.
 __ std(pc_reg, _abi(lr), R1_SP);
 __ push_frame(frame_size_reg, R0/*tmp*/);
 #ifdef CC_INTERP
 __ std(R1_SP, _parent_ijava_frame_abi(initial_caller_sp), R1_SP);
 #else
-#ifdef ASSERT
+Unimplemented();
-__ load_const_optimized(pc_reg, 0x5afe);
-__ std(pc_reg, _ijava_state_neg(ijava_reserved), R1_SP);
 #endif
-__ std(R1_SP, _ijava_state_neg(sender_sp), R1_SP);
-#endif // CC_INTERP
 __ addi(number_of_frames_reg, number_of_frames_reg, -1);
 __ addi(frame_sizes_reg, frame_sizes_reg, wordSize);
 __ addi(pcs_reg, pcs_reg, wordSize);
 }
 // In the case where we have resized a c2i frame above, the optional
 // alignment below the locals has size 32 (why?).
 __ std(R12_scratch2, _abi(lr), R1_SP);
 // Initialize initial_caller_sp.
-#ifdef CC_INTERP
 __ std(frame_size_reg/*old_sp*/, _parent_ijava_frame_abi(initial_caller_sp), R1_SP);
-#else
-#ifdef ASSERT
-__ load_const_optimized(pc_reg, 0x5afe);
-__ std(pc_reg, _ijava_state_neg(ijava_reserved), R1_SP);
-#endif
-__ std(frame_size_reg, _ijava_state_neg(sender_sp), R1_SP);
-#endif // CC_INTERP
 #ifdef ASSERT
 // Make sure that there is at least one entry in the array.
 __ cmpdi(CCR0, number_of_frames_reg, 0);
 __ asm_assert_ne("array_size must be > 0", 0x205);
 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_reg_args_spill_size;
+const int frame_size_in_bytes = frame::abi_112_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_reg_args_and_save_live_registers(masm,
+map = RegisterSaver::push_frame_abi112_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_reg_args_and_save_live_registers(masm,
+RegisterSaver::push_frame_abi112_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_reg_args_spill(spill_ret),  R1_SP);
+__ std( R3_RET,  _abi_112_spill(spill_ret),  R1_SP);
-__ stfd(F1_RET, _abi_reg_args_spill(spill_fret), R1_SP);
+__ stfd(F1_RET, _abi_112_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_reg_args_spill(spill_ret),  R1_SP);
+__ ld( R3_RET, _abi_112_spill(spill_ret),  R1_SP);
-__ lfd(F1_RET, _abi_reg_args_spill(spill_fret), R1_SP);
+__ lfd(F1_RET, _abi_112_spill(spill_fret), R1_SP);
 // Pop the unpack frame.
 __ pop_frame();
 __ restore_LR_CR(R0);
 // stack: (top interpreter frame, ..., optional interpreter frame,
 // optional c2i, caller of deoptee, ...).
 // Initialize R14_state.
-#ifdef CC_INTERP
 __ ld(R14_state, 0, R1_SP);
 __ addi(R14_state, R14_state, -frame::interpreter_frame_cinterpreterstate_size_in_bytes());
 // Also inititialize R15_prev_state.
 __ restore_prev_state();
-#else
-__ restore_interpreter_state(R11_scratch1);
-__ load_const_optimized(R25_templateTableBase, (address)Interpreter::dispatch_table((TosState)0), R11_scratch1);
-#endif // CC_INTERP
 // Return to the interpreter entry point.
 __ blr();
 __ flush();
 #else // COMPILER2
 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_reg_args_size;
+int frame_size_in_bytes = frame::abi_112_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_reg_args(0, R11_scratch1);
+__ push_frame_abi112(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_reg_args(0, R11_scratch1);
+__ push_frame_abi112(0, R11_scratch1);
 // stack: (unpack frame, skeletal interpreter frame, ..., optional
 // skeletal interpreter frame, optional c2i, caller of deoptee,
 // ...).
 __ restore_LR_CR(R11_scratch1);
 // stack: (top interpreter frame, ..., optional interpreter frame,
 // optional c2i, caller of deoptee, ...).
-#ifdef CC_INTERP
 // Initialize R14_state, ...
 __ ld(R11_scratch1, 0, R1_SP);
 __ addi(R14_state, R11_scratch1, -frame::interpreter_frame_cinterpreterstate_size_in_bytes());
 // also initialize R15_prev_state.
 __ restore_prev_state();
-#else
-__ restore_interpreter_state(R11_scratch1);
-__ load_const_optimized(R25_templateTableBase, (address)Interpreter::dispatch_table((TosState)0), R11_scratch1);
-#endif // CC_INTERP
 // Return to the interpreter entry point.
 __ blr();
 masm->flush();
 // 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_reg_args_and_save_live_registers(masm,
+map = RegisterSaver::push_frame_abi112_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);
 // Exception pending
 RegisterSaver::restore_live_registers_and_pop_frame(masm,
 frame_size_in_bytes,
 /*restore_ctr=*/true);
 BLOCK_COMMENT("  Jump to forward_exception_entry.");
 // Jump to forward_exception_entry, with the issuing PC in LR
 // so it looks like the original nmethod called forward_exception_entry.
 __ b64_patchable(StubRoutines::forward_exception_entry(), relocInfo::runtime_call_type);
 OopMapSet *oop_maps = new OopMapSet();
 OopMap* map = NULL;
 address start = __ pc();
-map = RegisterSaver::push_frame_reg_args_and_save_live_registers(masm,
+map = RegisterSaver::push_frame_abi112_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);
 __ mtctr(R3_RET); // Ctr will not be touched by restore_live_registers_and_pop_frame.
 RegisterSaver::restore_live_registers_and_pop_frame(masm, frame_size_in_bytes, /*restore_ctr*/ false);
-// Get the returned method.
+// Get the returned methodOop.
 __ get_vm_result_2(R19_method);
 __ bctr();

Mercurial > hg > truffle

comparison src/cpu/ppc/vm/sharedRuntime_ppc.cpp @ 14726:92aa6797d639