jdk8-mips64-public/hotspot: src/cpu/ppc/vm/cppInterpreter

src/cpu/ppc/vm/cppInterpreter_ppc.cpp@0bf37f737702 (annotated)

src/cpu/ppc/vm/cppInterpreter_ppc.cpp

Tue, 01 Apr 2014 09:36:49 +0200

author: roland
date: Tue, 01 Apr 2014 09:36:49 +0200
changeset 6723: 0bf37f737702
parent 6660: 63c5920a038d
child 6876: 710a3c8b516e
permissions: -rw-r--r--

8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
Summary: make compiled code bang the stack by the worst case size of the interpreter frame at deoptimization points.
Reviewed-by: twisti, kvn

 /*
  * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
  * Copyright 2012, 2014 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.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 #include "precompiled.hpp"
 #include "asm/assembler.hpp"
 #include "asm/macroAssembler.inline.hpp"
 #include "interpreter/bytecodeHistogram.hpp"
 #include "interpreter/cppInterpreter.hpp"
 #include "interpreter/interpreter.hpp"
 #include "interpreter/interpreterGenerator.hpp"
 #include "interpreter/interpreterRuntime.hpp"
 #include "oops/arrayOop.hpp"
 #include "oops/methodData.hpp"
 #include "oops/method.hpp"
 #include "oops/oop.inline.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "prims/jvmtiThreadState.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/deoptimization.hpp"
 #include "runtime/frame.inline.hpp"
 #include "runtime/interfaceSupport.hpp"
 #include "runtime/sharedRuntime.hpp"
 #include "runtime/stubRoutines.hpp"
 #include "runtime/synchronizer.hpp"
 #include "runtime/timer.hpp"
 #include "runtime/vframeArray.hpp"
 #include "utilities/debug.hpp"
 #ifdef SHARK
 #include "shark/shark_globals.hpp"
 #endif
 #ifdef CC_INTERP
 #define __ _masm->
 // Contains is used for identifying interpreter frames during a stack-walk.
 // A frame with a PC in InterpretMethod must be identified as a normal C frame.
 bool CppInterpreter::contains(address pc) {
   return _code->contains(pc);
 }
 #ifdef PRODUCT
 #define BLOCK_COMMENT(str) // nothing
 #else
 #define BLOCK_COMMENT(str) __ block_comment(str)
 #endif
 #define BIND(label) bind(label); BLOCK_COMMENT(#label ":")
 static address interpreter_frame_manager        = NULL;
 static address frame_manager_specialized_return = NULL;
 static address native_entry                     = NULL;
 static address interpreter_return_address       = NULL;
 static address unctrap_frame_manager_entry      = NULL;
 static address deopt_frame_manager_return_atos  = NULL;
 static address deopt_frame_manager_return_btos  = NULL;
 static address deopt_frame_manager_return_itos  = NULL;
 static address deopt_frame_manager_return_ltos  = NULL;
 static address deopt_frame_manager_return_ftos  = NULL;
 static address deopt_frame_manager_return_dtos  = NULL;
 static address deopt_frame_manager_return_vtos  = NULL;
 // A result handler converts/unboxes a native call result into
 // a java interpreter/compiler result. The current frame is an
 // interpreter frame.
 address CppInterpreterGenerator::generate_result_handler_for(BasicType type) {
   return AbstractInterpreterGenerator::generate_result_handler_for(type);
 }
 // tosca based result to c++ interpreter stack based result.
 address CppInterpreterGenerator::generate_tosca_to_stack_converter(BasicType type) {
   //
   // A result is in the native abi result register from a native
   // method call. We need to return this result to the interpreter by
   // pushing the result on the interpreter's stack.
   //
   // Registers alive:
   //   R3_ARG1(R3_RET)/F1_ARG1(F1_RET) - result to move
   //   R4_ARG2                         - address of tos
   //   LR
   //
   // Registers updated:
   //   R3_RET(R3_ARG1)   - address of new tos (== R17_tos for T_VOID)
   //
   int number_of_used_slots = 1;
   const Register tos = R4_ARG2;
   Label done;
   Label is_false;
   address entry = __ pc();
   switch (type) {
   case T_BOOLEAN:
     __ cmpwi(CCR0, R3_RET, 0);
     __ beq(CCR0, is_false);
     __ li(R3_RET, 1);
     __ stw(R3_RET, 0, tos);
     __ b(done);
     __ bind(is_false);
     __ li(R3_RET, 0);
     __ stw(R3_RET, 0, tos);
     break;
   case T_BYTE:
   case T_CHAR:
   case T_SHORT:
   case T_INT:
     __ stw(R3_RET, 0, tos);
     break;
   case T_LONG:
     number_of_used_slots = 2;
     // mark unused slot for debugging
     // long goes to topmost slot
     __ std(R3_RET, -BytesPerWord, tos);
     __ li(R3_RET, 0);
     __ std(R3_RET, 0, tos);
     break;
   case T_OBJECT:
     __ verify_oop(R3_RET);
     __ std(R3_RET, 0, tos);
     break;
   case T_FLOAT:
     __ stfs(F1_RET, 0, tos);
     break;
   case T_DOUBLE:
     number_of_used_slots = 2;
     // mark unused slot for debugging
     __ li(R3_RET, 0);
     __ std(R3_RET, 0, tos);
     // double goes to topmost slot
     __ stfd(F1_RET, -BytesPerWord, tos);
     break;
   case T_VOID:
     number_of_used_slots = 0;
     break;
   default:
     ShouldNotReachHere();
   }
   __ BIND(done);
   // new expression stack top
   __ addi(R3_RET, tos, -BytesPerWord * number_of_used_slots);
   __ blr();
   return entry;
 }
 address CppInterpreterGenerator::generate_stack_to_stack_converter(BasicType type) {
   //
   // Copy the result from the callee's stack to the caller's stack,
   // caller and callee both being interpreted.
   //
   // Registers alive
   //   R3_ARG1        - address of callee's tos + BytesPerWord
   //   R4_ARG2        - address of caller's tos [i.e. free location]
   //   LR
   //
   //   stack grows upwards, memory grows downwards.
   //
   //   [      free         ]  <-- callee's tos
   //   [  optional result  ]  <-- R3_ARG1
   //   [  optional dummy   ]
   //          ...
   //   [      free         ]  <-- caller's tos, R4_ARG2
   //          ...
   // Registers updated
   //   R3_RET(R3_ARG1) - address of caller's new tos
   //
   //   stack grows upwards, memory grows downwards.
   //
   //   [      free         ]  <-- current tos, R3_RET
   //   [  optional result  ]
   //   [  optional dummy   ]
   //          ...
   //
   const Register from = R3_ARG1;
   const Register ret  = R3_ARG1;
   const Register tos  = R4_ARG2;
   const Register tmp1 = R21_tmp1;
   const Register tmp2 = R22_tmp2;
   address entry = __ pc();
   switch (type) {
   case T_BOOLEAN:
   case T_BYTE:
   case T_CHAR:
   case T_SHORT:
   case T_INT:
   case T_FLOAT:
     __ lwz(tmp1, 0, from);
     __ stw(tmp1, 0, tos);
     // New expression stack top.
     __ addi(ret, tos, - BytesPerWord);
     break;
   case T_LONG:
   case T_DOUBLE:
     // Move both entries for debug purposes even though only one is live.
     __ ld(tmp1, BytesPerWord, from);
     __ ld(tmp2, 0, from);
     __ std(tmp1, 0, tos);
     __ std(tmp2, -BytesPerWord, tos);
     // New expression stack top.
     __ addi(ret, tos, - 2 * BytesPerWord); // two slots
     break;
   case T_OBJECT:
     __ ld(tmp1, 0, from);
     __ verify_oop(tmp1);
     __ std(tmp1, 0, tos);
     // New expression stack top.
     __ addi(ret, tos, - BytesPerWord);
     break;
   case T_VOID:
     // New expression stack top.
     __ mr(ret, tos);
     break;
   default:
     ShouldNotReachHere();
   }
   __ blr();
   return entry;
 }
 address CppInterpreterGenerator::generate_stack_to_native_abi_converter(BasicType type) {
   //
   // Load a result from the callee's stack into the caller's expecting
   // return register, callee being interpreted, caller being call stub
   // or jit code.
   //
   // Registers alive
   //   R3_ARG1   - callee expression tos + BytesPerWord
   //   LR
   //
   //   stack grows upwards, memory grows downwards.
   //
   //   [      free         ]  <-- callee's tos
   //   [  optional result  ]  <-- R3_ARG1
   //   [  optional dummy   ]
   //          ...
   //
   // Registers updated
   //   R3_RET(R3_ARG1)/F1_RET - result
   //
   const Register from = R3_ARG1;
   const Register ret = R3_ARG1;
   const FloatRegister fret = F1_ARG1;
   address entry = __ pc();
   // Implemented uniformly for both kinds of endianness. The interpreter
   // implements boolean, byte, char, and short as jint (4 bytes).
   switch (type) {
   case T_BOOLEAN:
   case T_CHAR:
     // zero extension
     __ lwz(ret, 0, from);
     break;
   case T_BYTE:
   case T_SHORT:
   case T_INT:
     // sign extension
     __ lwa(ret, 0, from);
     break;
   case T_LONG:
     __ ld(ret, 0, from);
     break;
   case T_OBJECT:
     __ ld(ret, 0, from);
     __ verify_oop(ret);
     break;
   case T_FLOAT:
     __ lfs(fret, 0, from);
     break;
   case T_DOUBLE:
     __ lfd(fret, 0, from);
     break;
   case T_VOID:
     break;
   default:
     ShouldNotReachHere();
   }
   __ blr();
   return entry;
 }
 address CppInterpreter::return_entry(TosState state, int length, Bytecodes::Code code) {
   assert(interpreter_return_address != NULL, "Not initialized");
   return interpreter_return_address;
 }
 address CppInterpreter::deopt_entry(TosState state, int length) {
   address ret = NULL;
   if (length != 0) {
     switch (state) {
       case atos: ret = deopt_frame_manager_return_atos; break;
       case btos: ret = deopt_frame_manager_return_itos; break;
       case ctos:
       case stos:
       case itos: ret = deopt_frame_manager_return_itos; break;
       case ltos: ret = deopt_frame_manager_return_ltos; break;
       case ftos: ret = deopt_frame_manager_return_ftos; break;
       case dtos: ret = deopt_frame_manager_return_dtos; break;
       case vtos: ret = deopt_frame_manager_return_vtos; break;
       default: ShouldNotReachHere();
     }
   } else {
     ret = unctrap_frame_manager_entry;  // re-execute the bytecode (e.g. uncommon trap, popframe)
   }
   assert(ret != NULL, "Not initialized");
   return ret;
 }
 //
 // Helpers for commoning out cases in the various type of method entries.
 //
 //
 // Registers alive
 //   R16_thread      - JavaThread*
 //   R1_SP           - old stack pointer
 //   R19_method      - callee's Method
 //   R17_tos         - address of caller's tos (prepushed)
 //   R15_prev_state  - address of caller's BytecodeInterpreter or 0
 //   return_pc in R21_tmp15 (only when called within generate_native_entry)
 //
 // Registers updated
 //   R14_state       - address of callee's interpreter state
 //   R1_SP           - new stack pointer
 //   CCR4_is_synced  - current method is synchronized
 //
 void CppInterpreterGenerator::generate_compute_interpreter_state(Label& stack_overflow_return) {
   //
   // Stack layout at this point:
   //
   //   F1      [TOP_IJAVA_FRAME_ABI]              <-- R1_SP
   //           alignment (optional)
   //           [F1's outgoing Java arguments]     <-- R17_tos
   //           ...
   //   F2      [PARENT_IJAVA_FRAME_ABI]
   //            ...
   //=============================================================================
   // Allocate space for locals other than the parameters, the
   // interpreter state, monitors, and the expression stack.
   const Register local_count        = R21_tmp1;
   const Register parameter_count    = R22_tmp2;
   const Register max_stack          = R23_tmp3;
   // Must not be overwritten within this method!
   // const Register return_pc         = R29_tmp9;
   const ConditionRegister is_synced = CCR4_is_synced;
   const ConditionRegister is_native = CCR6;
   const ConditionRegister is_static = CCR7;
   assert(is_synced != is_native, "condition code registers must be distinct");
   assert(is_synced != is_static, "condition code registers must be distinct");
   assert(is_native != is_static, "condition code registers must be distinct");
   {
   // Local registers
   const Register top_frame_size     = R24_tmp4;
   const Register access_flags       = R25_tmp5;
   const Register state_offset       = R26_tmp6;
   Register mem_stack_limit          = R27_tmp7;
   const Register page_size          = R28_tmp8;
   BLOCK_COMMENT("compute_interpreter_state {");
   // access_flags = method->access_flags();
   // TODO: PPC port: assert(4 == sizeof(AccessFlags), "unexpected field size");
   __ lwa(access_flags, method_(access_flags));
   // parameter_count = method->constMethod->size_of_parameters();
   // TODO: PPC port: assert(2 == ConstMethod::sz_size_of_parameters(), "unexpected field size");
   __ ld(max_stack, in_bytes(Method::const_offset()), R19_method);   // Max_stack holds constMethod for a while.
   __ lhz(parameter_count, in_bytes(ConstMethod::size_of_parameters_offset()), max_stack);
   // local_count = method->constMethod()->max_locals();
   // TODO: PPC port: assert(2 == ConstMethod::sz_max_locals(), "unexpected field size");
   __ lhz(local_count, in_bytes(ConstMethod::size_of_locals_offset()), max_stack);
   // max_stack = method->constMethod()->max_stack();
   // TODO: PPC port: assert(2 == ConstMethod::sz_max_stack(), "unexpected field size");
   __ lhz(max_stack, in_bytes(ConstMethod::max_stack_offset()), max_stack);
   if (EnableInvokeDynamic) {
     // Take into account 'extra_stack_entries' needed by method handles (see method.hpp).
     __ addi(max_stack, max_stack, Method::extra_stack_entries());
   }
   // mem_stack_limit = thread->stack_limit();
   __ ld(mem_stack_limit, thread_(stack_overflow_limit));
   // Point locals at the first argument. Method's locals are the
   // parameters on top of caller's expression stack.
   // tos points past last Java argument
   __ sldi(R18_locals, parameter_count, Interpreter::logStackElementSize);
   __ add(R18_locals, R17_tos, R18_locals);
   // R18_locals - i*BytesPerWord points to i-th Java local (i starts at 0)
   // Set is_native, is_synced, is_static - will be used later.
   __ testbitdi(is_native, R0, access_flags, JVM_ACC_NATIVE_BIT);
   __ testbitdi(is_synced, R0, access_flags, JVM_ACC_SYNCHRONIZED_BIT);
   assert(is_synced->is_nonvolatile(), "is_synced must be non-volatile");
   __ testbitdi(is_static, R0, access_flags, JVM_ACC_STATIC_BIT);
   // PARENT_IJAVA_FRAME_ABI
   //
   // frame_size =
   //   round_to((local_count - parameter_count)*BytesPerWord +
   //              2*BytesPerWord +
   //              alignment +
   //              frame::interpreter_frame_cinterpreterstate_size_in_bytes()
   //              sizeof(PARENT_IJAVA_FRAME_ABI)
   //              method->is_synchronized() ? sizeof(BasicObjectLock) : 0 +
   //              max_stack*BytesPerWord,
   //            16)
   //
   // Note that this calculation is exactly mirrored by
   // AbstractInterpreter::layout_activation_impl() [ and
   // AbstractInterpreter::size_activation() ]. Which is used by
   // deoptimization so that it can allocate the proper sized
   // frame. This only happens for interpreted frames so the extra
   // notes below about max_stack below are not important. The other
   // thing to note is that for interpreter frames other than the
   // current activation the size of the stack is the size of the live
   // portion of the stack at the particular bcp and NOT the maximum
   // stack that the method might use.
   //
   // If we're calling a native method, we replace max_stack (which is
   // zero) with space for the worst-case signature handler varargs
   // vector, which is:
   //
   //   max_stack = max(Argument::n_register_parameters, parameter_count+2);
   //
   // We add two slots to the parameter_count, one for the jni
   // environment and one for a possible native mirror.  We allocate
   // space for at least the number of ABI registers, even though
   // InterpreterRuntime::slow_signature_handler won't write more than
   // parameter_count+2 words when it creates the varargs vector at the
   // top of the stack.  The generated slow signature handler will just
   // load trash into registers beyond the necessary number.  We're
   // still going to cut the stack back by the ABI register parameter
   // count so as to get SP+16 pointing at the ABI outgoing parameter
   // area, so we need to allocate at least that much even though we're
   // going to throw it away.
   //
   // Adjust max_stack for native methods:
   Label skip_native_calculate_max_stack;
   __ bfalse(is_native, skip_native_calculate_max_stack);
   // if (is_native) {
   //  max_stack = max(Argument::n_register_parameters, parameter_count+2);
   __ addi(max_stack, parameter_count, 2*Interpreter::stackElementWords);
   __ cmpwi(CCR0, max_stack, Argument::n_register_parameters);
   __ bge(CCR0, skip_native_calculate_max_stack);
   __ li(max_stack,  Argument::n_register_parameters);
   // }
   __ bind(skip_native_calculate_max_stack);
   // max_stack is now in bytes
   __ slwi(max_stack, max_stack, Interpreter::logStackElementSize);
   // Calculate number of non-parameter locals (in slots):
   Label not_java;
   __ btrue(is_native, not_java);
   // if (!is_native) {
   //   local_count = non-parameter local count
   __ sub(local_count, local_count, parameter_count);
   // } else {
   //   // nothing to do: method->max_locals() == 0 for native methods
   // }
   __ bind(not_java);
   // Calculate top_frame_size and parent_frame_resize.
   {
   const Register parent_frame_resize = R12_scratch2;
   BLOCK_COMMENT("Compute top_frame_size.");
   // top_frame_size = TOP_IJAVA_FRAME_ABI
   //                  + size of interpreter state
   __ li(top_frame_size, frame::top_ijava_frame_abi_size
                         + frame::interpreter_frame_cinterpreterstate_size_in_bytes());
   //                  + max_stack
   __ add(top_frame_size, top_frame_size, max_stack);
   //                  + stack slots for a BasicObjectLock for synchronized methods
   {
     Label not_synced;
     __ bfalse(is_synced, not_synced);
     __ addi(top_frame_size, top_frame_size, frame::interpreter_frame_monitor_size_in_bytes());
     __ bind(not_synced);
   }
   // align
   __ round_to(top_frame_size, frame::alignment_in_bytes);
   BLOCK_COMMENT("Compute parent_frame_resize.");
   // parent_frame_resize = R1_SP - R17_tos
   __ sub(parent_frame_resize, R1_SP, R17_tos);
   //__ li(parent_frame_resize, 0);
   //                       + PARENT_IJAVA_FRAME_ABI
   //                       + extra two slots for the no-parameter/no-locals
   //                         method result
   __ addi(parent_frame_resize, parent_frame_resize,
                                       frame::parent_ijava_frame_abi_size
                                     + 2*Interpreter::stackElementSize);
   //                       + (locals_count - params_count)
   __ sldi(R0, local_count, Interpreter::logStackElementSize);
   __ add(parent_frame_resize, parent_frame_resize, R0);
   // align
   __ round_to(parent_frame_resize, frame::alignment_in_bytes);
   //
   // Stack layout at this point:
   //
   // The new frame F0 hasn't yet been pushed, F1 is still the top frame.
   //
   //   F0      [TOP_IJAVA_FRAME_ABI]
   //           alignment (optional)
   //           [F0's full operand stack]
   //           [F0's monitors] (optional)
   //           [F0's BytecodeInterpreter object]
   //   F1      [PARENT_IJAVA_FRAME_ABI]
   //           alignment (optional)
   //           [F0's Java result]
   //           [F0's non-arg Java locals]
   //           [F1's outgoing Java arguments]     <-- R17_tos
   //           ...
   //   F2      [PARENT_IJAVA_FRAME_ABI]
   //            ...
   // Calculate new R14_state
   // and
   // test that the new memory stack pointer is above the limit,
   // throw a StackOverflowError otherwise.
   __ sub(R11_scratch1/*F1's SP*/,  R1_SP, parent_frame_resize);
   __ addi(R14_state, R11_scratch1/*F1's SP*/,
               -frame::interpreter_frame_cinterpreterstate_size_in_bytes());
   __ sub(R11_scratch1/*F0's SP*/,
              R11_scratch1/*F1's SP*/, top_frame_size);
   BLOCK_COMMENT("Test for stack overflow:");
   __ cmpld(CCR0/*is_stack_overflow*/, R11_scratch1, mem_stack_limit);
   __ blt(CCR0/*is_stack_overflow*/, stack_overflow_return);
   //=============================================================================
   // Frame_size doesn't overflow the stack. Allocate new frame and
   // initialize interpreter state.
   // Register state
   //
   //   R15            - local_count
   //   R16            - parameter_count
   //   R17            - max_stack
   //
   //   R18            - frame_size
   //   R19            - access_flags
   //   CCR4_is_synced - is_synced
   //
   //   GR_Lstate      - pointer to the uninitialized new BytecodeInterpreter.
   // _last_Java_pc just needs to be close enough that we can identify
   // the frame as an interpreted frame. It does not need to be the
   // exact return address from either calling
   // BytecodeInterpreter::InterpretMethod or the call to a jni native method.
   // So we can initialize it here with a value of a bundle in this
   // code fragment. We only do this initialization for java frames
   // where InterpretMethod needs a a way to get a good pc value to
   // store in the thread state. For interpreter frames used to call
   // jni native code we just zero the value in the state and move an
   // ip as needed in the native entry code.
   //
   // const Register last_Java_pc_addr     = GR24_SCRATCH;  // QQQ 27
   // const Register last_Java_pc          = GR26_SCRATCH;
   // Must reference stack before setting new SP since Windows
   // will not be able to deliver the exception on a bad SP.
   // Windows also insists that we bang each page one at a time in order
   // for the OS to map in the reserved pages. If we bang only
   // the final page, Windows stops delivering exceptions to our
   // VectoredExceptionHandler and terminates our program.
   // Linux only requires a single bang but it's rare to have
   // to bang more than 1 page so the code is enabled for both OS's.
   // BANG THE STACK
   //
   // Nothing to do for PPC, because updating the SP will automatically
   // bang the page.
   // Up to here we have calculated the delta for the new C-frame and
   // checked for a stack-overflow. Now we can savely update SP and
   // resize the C-frame.
   // R14_state has already been calculated.
   __ push_interpreter_frame(top_frame_size, parent_frame_resize,
                             R25_tmp5, R26_tmp6, R27_tmp7, R28_tmp8);
   }
   //
   // Stack layout at this point:
   //
   //   F0 has been been pushed!
   //
   //   F0      [TOP_IJAVA_FRAME_ABI]              <-- R1_SP
   //           alignment (optional)               (now it's here, if required)
   //           [F0's full operand stack]
   //           [F0's monitors] (optional)
   //           [F0's BytecodeInterpreter object]
   //   F1      [PARENT_IJAVA_FRAME_ABI]
   //           alignment (optional)               (now it's here, if required)
   //           [F0's Java result]
   //           [F0's non-arg Java locals]
   //           [F1's outgoing Java arguments]
   //           ...
   //   F2      [PARENT_IJAVA_FRAME_ABI]
   //           ...
   //
   // R14_state points to F0's BytecodeInterpreter object.
   //
   }
   //=============================================================================
   // new BytecodeInterpreter-object is save, let's initialize it:
   BLOCK_COMMENT("New BytecodeInterpreter-object is save.");
   {
   // Locals
   const Register bytecode_addr = R24_tmp4;
   const Register constants     = R25_tmp5;
   const Register tos           = R26_tmp6;
   const Register stack_base    = R27_tmp7;
   const Register local_addr    = R28_tmp8;
   {
     Label L;
     __ btrue(is_native, L);
     // if (!is_native) {
       // bytecode_addr = constMethod->codes();
       __ ld(bytecode_addr, method_(const));
       __ addi(bytecode_addr, bytecode_addr, in_bytes(ConstMethod::codes_offset()));
     // }
     __ bind(L);
   }
   __ ld(constants, in_bytes(Method::const_offset()), R19_method);
   __ ld(constants, in_bytes(ConstMethod::constants_offset()), constants);
   // state->_prev_link = prev_state;
   __ std(R15_prev_state, state_(_prev_link));
   // For assertions only.
   // TODO: not needed anyway because it coincides with `_monitor_base'. remove!
   // state->_self_link = state;
   DEBUG_ONLY(__ std(R14_state, state_(_self_link));)
   // state->_thread = thread;
   __ std(R16_thread, state_(_thread));
   // state->_method = method;
   __ std(R19_method, state_(_method));
   // state->_locals = locals;
   __ std(R18_locals, state_(_locals));
   // state->_oop_temp = NULL;
   __ li(R0, 0);
   __ std(R0, state_(_oop_temp));
   // state->_last_Java_fp = *R1_SP // Use *R1_SP as fp
   __ ld(R0, _abi(callers_sp), R1_SP);
   __ std(R0, state_(_last_Java_fp));
   BLOCK_COMMENT("load Stack base:");
   {
     // Stack_base.
     // if (!method->synchronized()) {
     //   stack_base = state;
     // } else {
     //   stack_base = (uintptr_t)state - sizeof(BasicObjectLock);
     // }
     Label L;
     __ mr(stack_base, R14_state);
     __ bfalse(is_synced, L);
     __ addi(stack_base, stack_base, -frame::interpreter_frame_monitor_size_in_bytes());
     __ bind(L);
   }
   // state->_mdx = NULL;
   __ li(R0, 0);
   __ std(R0, state_(_mdx));
   {
     // if (method->is_native()) state->_bcp = NULL;
     // else state->_bcp = bytecode_addr;
     Label label1, label2;
     __ bfalse(is_native, label1);
     __ std(R0, state_(_bcp));
     __ b(label2);
     __ bind(label1);
     __ std(bytecode_addr, state_(_bcp));
     __ bind(label2);
   }
   // state->_result._to_call._callee = NULL;
   __ std(R0, state_(_result._to_call._callee));
   // state->_monitor_base = state;
   __ std(R14_state, state_(_monitor_base));
   // state->_msg = BytecodeInterpreter::method_entry;
   __ li(R0, BytecodeInterpreter::method_entry);
   __ stw(R0, state_(_msg));
   // state->_last_Java_sp = R1_SP;
   __ std(R1_SP, state_(_last_Java_sp));
   // state->_stack_base = stack_base;
   __ std(stack_base, state_(_stack_base));
   // tos = stack_base - 1 slot (prepushed);
   // state->_stack.Tos(tos);
   __ addi(tos, stack_base, - Interpreter::stackElementSize);
   __ std(tos,  state_(_stack));
   {
     BLOCK_COMMENT("get last_Java_pc:");
     // if (!is_native) state->_last_Java_pc = <some_ip_in_this_code_buffer>;
     // else state->_last_Java_pc = NULL; (just for neatness)
     Label label1, label2;
     __ btrue(is_native, label1);
     __ get_PC_trash_LR(R0);
     __ std(R0, state_(_last_Java_pc));
     __ b(label2);
     __ bind(label1);
     __ li(R0, 0);
     __ std(R0, state_(_last_Java_pc));
     __ bind(label2);
   }
   // stack_limit = tos - max_stack;
   __ sub(R0, tos, max_stack);
   // state->_stack_limit = stack_limit;
   __ std(R0, state_(_stack_limit));
   // cache = method->constants()->cache();
    __ ld(R0, ConstantPool::cache_offset_in_bytes(), constants);
   // state->_constants = method->constants()->cache();
   __ std(R0, state_(_constants));
   //=============================================================================
   // synchronized method, allocate and initialize method object lock.
   // if (!method->is_synchronized()) goto fill_locals_with_0x0s;
   Label fill_locals_with_0x0s;
   __ bfalse(is_synced, fill_locals_with_0x0s);
   //   pool_holder = method->constants()->pool_holder();
   const int mirror_offset = in_bytes(Klass::java_mirror_offset());
   {
     Label label1, label2;
     // lockee = NULL; for java methods, correct value will be inserted in BytecodeInterpretMethod.hpp
     __ li(R0,0);
     __ bfalse(is_native, label2);
     __ bfalse(is_static, label1);
     // if (method->is_static()) lockee =
     // pool_holder->klass_part()->java_mirror();
     __ ld(R11_scratch1/*pool_holder*/, ConstantPool::pool_holder_offset_in_bytes(), constants);
     __ ld(R0/*lockee*/, mirror_offset, R11_scratch1/*pool_holder*/);
     __ b(label2);
     __ bind(label1);
     // else lockee = *(oop*)locals;
     __ ld(R0/*lockee*/, 0, R18_locals);
     __ bind(label2);
     // monitor->set_obj(lockee);
     __ std(R0/*lockee*/, BasicObjectLock::obj_offset_in_bytes(), stack_base);
   }
   // See if we need to zero the locals
   __ BIND(fill_locals_with_0x0s);
   //=============================================================================
   // fill locals with 0x0s
   Label locals_zeroed;
   __ btrue(is_native, locals_zeroed);
   if (true /* zerolocals */ || ClearInterpreterLocals) {
     // local_count is already num_locals_slots - num_param_slots
     __ sldi(R0, parameter_count, Interpreter::logStackElementSize);
     __ sub(local_addr, R18_locals, R0);
     __ cmpdi(CCR0, local_count, 0);
     __ ble(CCR0, locals_zeroed);
     __ mtctr(local_count);
     //__ ld_const_addr(R0, (address) 0xcafe0000babe);
     __ li(R0, 0);
     Label zero_slot;
     __ bind(zero_slot);
     // first local is at local_addr
     __ std(R0, 0, local_addr);
     __ addi(local_addr, local_addr, -BytesPerWord);
     __ bdnz(zero_slot);
   }
    __ BIND(locals_zeroed);
   }
   BLOCK_COMMENT("} compute_interpreter_state");
 }
 // Generate code to initiate compilation on invocation counter overflow.
 void CppInterpreterGenerator::generate_counter_overflow(Label& continue_entry) {
   // Registers alive
   //   R14_state
   //   R16_thread
   //
   // Registers updated
   //   R14_state
   //   R3_ARG1 (=R3_RET)
   //   R4_ARG2
   // After entering the vm we remove the activation and retry the
   // entry point in case the compilation is complete.
   // InterpreterRuntime::frequency_counter_overflow takes one argument
   // that indicates if the counter overflow occurs at a backwards
   // branch (NULL bcp). We pass zero. The call returns the address
   // of the verified entry point for the method or NULL if the
   // compilation did not complete (either went background or bailed
   // out).
   __ li(R4_ARG2, 0);
   // Pass false to call_VM so it doesn't check for pending exceptions,
   // since at this point in the method invocation the exception
   // handler would try to exit the monitor of synchronized methods
   // which haven't been entered yet.
   //
   // Returns verified_entry_point or NULL, we don't care which.
   //
   // Do not use the variant `frequency_counter_overflow' that returns
   // a structure, because this will change the argument list by a
   // hidden parameter (gcc 4.1).
   __ call_VM(noreg,
              CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow),
              R4_ARG2,
              false);
   // Returns verified_entry_point or NULL, we don't care which as we ignore it
   // and run interpreted.
   // Reload method, it may have moved.
   __ ld(R19_method, state_(_method));
   // We jump now to the label "continue_after_compile".
   __ b(continue_entry);
 }
 // Increment invocation count and check for overflow.
 //
 // R19_method must contain Method* of method to profile.
 void CppInterpreterGenerator::generate_counter_incr(Label& overflow) {
   Label done;
   const Register Rcounters             = R12_scratch2;
   const Register iv_be_count           = R11_scratch1;
   const Register invocation_limit      = R12_scratch2;
   const Register invocation_limit_addr = invocation_limit;
   // Load and ev. allocate MethodCounters object.
   __ get_method_counters(R19_method, Rcounters, done);
   // Update standard invocation counters.
   __ increment_invocation_counter(Rcounters, iv_be_count, R0);
   // Compare against limit.
   BLOCK_COMMENT("Compare counter against limit:");
   assert(4 == sizeof(InvocationCounter::InterpreterInvocationLimit),
          "must be 4 bytes");
   __ load_const(invocation_limit_addr, (address)&InvocationCounter::InterpreterInvocationLimit);
   __ lwa(invocation_limit, 0, invocation_limit_addr);
   __ cmpw(CCR0, iv_be_count, invocation_limit);
   __ bge(CCR0, overflow);
   __ bind(done);
 }
 //
 // Call a JNI method.
 //
 // Interpreter stub for calling a native method. (C++ interpreter)
 // This sets up a somewhat different looking stack for calling the native method
 // than the typical interpreter frame setup.
 //
 address CppInterpreterGenerator::generate_native_entry(void) {
   if (native_entry != NULL) return native_entry;
   address entry = __ pc();
   // Read
   //   R16_thread
   //   R15_prev_state  - address of caller's BytecodeInterpreter, if this snippet
   //                     gets called by the frame manager.
   //   R19_method      - callee's Method
   //   R17_tos         - address of caller's tos
   //   R1_SP           - caller's stack pointer
   //   R21_sender_SP   - initial caller sp
   //
   // Update
   //   R14_state       - address of caller's BytecodeInterpreter
   //   R3_RET          - integer result, if any.
   //   F1_RET          - float result, if any.
   //
   //
   // Stack layout at this point:
   //
   //    0       [TOP_IJAVA_FRAME_ABI]         <-- R1_SP
   //            alignment (optional)
   //            [outgoing Java arguments]     <-- R17_tos
   //            ...
   //    PARENT  [PARENT_IJAVA_FRAME_ABI]
   //            ...
   //
   const bool inc_counter = UseCompiler || CountCompiledCalls;
   const Register signature_handler_fd   = R21_tmp1;
   const Register pending_exception      = R22_tmp2;
   const Register result_handler_addr    = R23_tmp3;
   const Register native_method_fd       = R24_tmp4;
   const Register access_flags           = R25_tmp5;
   const Register active_handles         = R26_tmp6;
   const Register sync_state             = R27_tmp7;
   const Register sync_state_addr        = sync_state;     // Address is dead after use.
   const Register suspend_flags          = R24_tmp4;
   const Register return_pc              = R28_tmp8;       // Register will be locked for some time.
   const ConditionRegister is_synced     = CCR4_is_synced; // Live-on-exit from compute_interpreter_state.
   // R1_SP still points to caller's SP at this point.
   // Save initial_caller_sp to caller's abi. The caller frame must be
   // resized before returning to get rid of the c2i arguments (if
   // any).
   // Override the saved SP with the senderSP so we can pop c2i
   // arguments (if any) off when we return
   __ std(R21_sender_SP, _top_ijava_frame_abi(initial_caller_sp), R1_SP);
   // Save LR to caller's frame. We don't use _abi(lr) here, because it is not safe.
   __ mflr(return_pc);
   __ std(return_pc, _top_ijava_frame_abi(frame_manager_lr), R1_SP);
   assert(return_pc->is_nonvolatile(), "return_pc must be a non-volatile register");
   __ verify_method_ptr(R19_method);
   //=============================================================================
   // If this snippet gets called by the frame manager (at label
   // `call_special'), then R15_prev_state is valid. If this snippet
   // is not called by the frame manager, but e.g. by the call stub or
   // by compiled code, then R15_prev_state is invalid.
   {
     // Set R15_prev_state to 0 if we don't return to the frame
     // manager; we will return to the call_stub or to compiled code
     // instead. If R15_prev_state is 0 there will be only one
     // interpreter frame (we will set this up later) in this C frame!
     // So we must take care about retrieving prev_state_(_prev_link)
     // and restoring R1_SP when popping that interpreter.
     Label prev_state_is_valid;
     __ load_const(R11_scratch1/*frame_manager_returnpc_addr*/, (address)&frame_manager_specialized_return);
     __ ld(R12_scratch2/*frame_manager_returnpc*/, 0, R11_scratch1/*frame_manager_returnpc_addr*/);
     __ cmpd(CCR0, return_pc, R12_scratch2/*frame_manager_returnpc*/);
     __ beq(CCR0, prev_state_is_valid);
     __ li(R15_prev_state, 0);
     __ BIND(prev_state_is_valid);
   }
   //=============================================================================
   // Allocate new frame and initialize interpreter state.
   Label exception_return;
   Label exception_return_sync_check;
   Label stack_overflow_return;
   // Generate new interpreter state and jump to stack_overflow_return in case of
   // a stack overflow.
   generate_compute_interpreter_state(stack_overflow_return);
   //=============================================================================
   // Increment invocation counter. On overflow, entry to JNI method
   // will be compiled.
   Label invocation_counter_overflow;
   if (inc_counter) {
     generate_counter_incr(invocation_counter_overflow);
   }
   Label continue_after_compile;
   __ BIND(continue_after_compile);
   // access_flags = method->access_flags();
   // Load access flags.
   assert(access_flags->is_nonvolatile(),
          "access_flags must be in a non-volatile register");
   // Type check.
   // TODO: PPC port: assert(4 == sizeof(AccessFlags), "unexpected field size");
   __ lwz(access_flags, method_(access_flags));
   // We don't want to reload R19_method and access_flags after calls
   // to some helper functions.
   assert(R19_method->is_nonvolatile(), "R19_method must be a non-volatile register");
   // Check for synchronized methods. Must happen AFTER invocation counter
   // check, so method is not locked if counter overflows.
   {
     Label method_is_not_synced;
     // Is_synced is still alive.
     assert(is_synced->is_nonvolatile(), "is_synced must be non-volatile");
     __ bfalse(is_synced, method_is_not_synced);
     lock_method();
     // Reload method, it may have moved.
     __ ld(R19_method, state_(_method));
     __ BIND(method_is_not_synced);
   }
   // jvmti/jvmpi support
   __ notify_method_entry();
   // Reload method, it may have moved.
   __ ld(R19_method, state_(_method));
   //=============================================================================
   // Get and call the signature handler
   __ ld(signature_handler_fd, method_(signature_handler));
   Label call_signature_handler;
   __ cmpdi(CCR0, signature_handler_fd, 0);
   __ bne(CCR0, call_signature_handler);
   // Method has never been called. Either generate a specialized
   // handler or point to the slow one.
   //
   // Pass parameter 'false' to avoid exception check in call_VM.
   __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), R19_method, false);
   // Check for an exception while looking up the target method. If we
   // incurred one, bail.
   __ ld(pending_exception, thread_(pending_exception));
   __ cmpdi(CCR0, pending_exception, 0);
   __ bne(CCR0, exception_return_sync_check); // has pending exception
   // reload method
   __ ld(R19_method, state_(_method));
   // Reload signature handler, it may have been created/assigned in the meanwhile
   __ ld(signature_handler_fd, method_(signature_handler));
   __ BIND(call_signature_handler);
   // Before we call the signature handler we push a new frame to
   // protect the interpreter frame volatile registers when we return
   // from jni but before we can get back to Java.
   // First set the frame anchor while the SP/FP registers are
   // convenient and the slow signature handler can use this same frame
   // anchor.
   // We have a TOP_IJAVA_FRAME here, which belongs to us.
   __ set_top_ijava_frame_at_SP_as_last_Java_frame(R1_SP, R12_scratch2/*tmp*/);
   // Now the interpreter frame (and its call chain) have been
   // invalidated and flushed. We are now protected against eager
   // being enabled in native code. Even if it goes eager the
   // registers will be reloaded as clean and we will invalidate after
   // the call so no spurious flush should be possible.
   // Call signature handler and pass locals address.
   //
   // Our signature handlers copy required arguments to the C stack
   // (outgoing C args), R3_ARG1 to R10_ARG8, and F1_ARG1 to
   // F13_ARG13.
   __ mr(R3_ARG1, R18_locals);
 #if !defined(ABI_ELFv2)
   __ ld(signature_handler_fd, 0, signature_handler_fd);
 #endif
   __ call_stub(signature_handler_fd);
   // reload method
   __ ld(R19_method, state_(_method));
   // Remove the register parameter varargs slots we allocated in
   // compute_interpreter_state. SP+16 ends up pointing to the ABI
   // outgoing argument area.
   //
   // Not needed on PPC64.
   //__ add(SP, SP, Argument::n_register_parameters*BytesPerWord);
   assert(result_handler_addr->is_nonvolatile(), "result_handler_addr must be in a non-volatile register");
   // Save across call to native method.
   __ mr(result_handler_addr, R3_RET);
   // Set up fixed parameters and call the native method.
   // If the method is static, get mirror into R4_ARG2.
   {
     Label method_is_not_static;
     // access_flags is non-volatile and still, no need to restore it
     // restore access flags
     __ testbitdi(CCR0, R0, access_flags, JVM_ACC_STATIC_BIT);
     __ bfalse(CCR0, method_is_not_static);
     // constants = method->constants();
     __ ld(R11_scratch1, in_bytes(Method::const_offset()), R19_method);
     __ ld(R11_scratch1/*constants*/, in_bytes(ConstMethod::constants_offset()), R11_scratch1);
     // pool_holder = method->constants()->pool_holder();
     __ ld(R11_scratch1/*pool_holder*/, ConstantPool::pool_holder_offset_in_bytes(),
           R11_scratch1/*constants*/);
     const int mirror_offset = in_bytes(Klass::java_mirror_offset());
     // mirror = pool_holder->klass_part()->java_mirror();
     __ ld(R0/*mirror*/, mirror_offset, R11_scratch1/*pool_holder*/);
     // state->_native_mirror = mirror;
     __ std(R0/*mirror*/, state_(_oop_temp));
     // R4_ARG2 = &state->_oop_temp;
     __ addir(R4_ARG2, state_(_oop_temp));
     __ BIND(method_is_not_static);
   }
   // At this point, arguments have been copied off the stack into
   // their JNI positions. Oops are boxed in-place on the stack, with
   // handles copied to arguments. The result handler address is in a
   // register.
   // pass JNIEnv address as first parameter
   __ addir(R3_ARG1, thread_(jni_environment));
   // Load the native_method entry before we change the thread state.
   __ ld(native_method_fd, method_(native_function));
   //=============================================================================
   // Transition from _thread_in_Java to _thread_in_native. As soon as
   // we make this change the safepoint code needs to be certain that
   // the last Java frame we established is good. The pc in that frame
   // just needs to be near here not an actual return address.
   // We use release_store_fence to update values like the thread state, where
   // we don't want the current thread to continue until all our prior memory
   // accesses (including the new thread state) are visible to other threads.
   __ li(R0, _thread_in_native);
   __ release();
   // TODO: PPC port: assert(4 == JavaThread::sz_thread_state(), "unexpected field size");
   __ stw(R0, thread_(thread_state));
   if (UseMembar) {
     __ fence();
   }
   //=============================================================================
   // Call the native method. Argument registers must not have been
   // overwritten since "__ call_stub(signature_handler);" (except for
   // ARG1 and ARG2 for static methods)
   __ call_c(native_method_fd);
   __ std(R3_RET, state_(_native_lresult));
   __ stfd(F1_RET, state_(_native_fresult));
   // The frame_manager_lr field, which we use for setting the last
   // java frame, gets overwritten by the signature handler. Restore
   // it now.
   __ get_PC_trash_LR(R11_scratch1);
   __ std(R11_scratch1, _top_ijava_frame_abi(frame_manager_lr), R1_SP);
   // Because of GC R19_method may no longer be valid.
   // Block, if necessary, before resuming in _thread_in_Java state.
   // In order for GC to work, don't clear the last_Java_sp until after
   // blocking.
   //=============================================================================
   // Switch thread to "native transition" state before reading the
   // synchronization state.  This additional state is necessary
   // because reading and testing the synchronization state is not
   // atomic w.r.t. GC, as this scenario demonstrates: Java thread A,
   // in _thread_in_native state, loads _not_synchronized and is
   // preempted.  VM thread changes sync state to synchronizing and
   // suspends threads for GC. Thread A is resumed to finish this
   // native method, but doesn't block here since it didn't see any
   // synchronization in progress, and escapes.
   // We use release_store_fence to update values like the thread state, where
   // we don't want the current thread to continue until all our prior memory
   // accesses (including the new thread state) are visible to other threads.
   __ li(R0/*thread_state*/, _thread_in_native_trans);
   __ release();
   __ stw(R0/*thread_state*/, thread_(thread_state));
   if (UseMembar) {
     __ fence();
   }
   // Write serialization page so that the VM thread can do a pseudo remote
   // membar. We use the current thread pointer to calculate a thread
   // specific offset to write to within the page. This minimizes bus
   // traffic due to cache line collision.
   else {
     __ serialize_memory(R16_thread, R11_scratch1, R12_scratch2);
   }
   // Now before we return to java we must look for a current safepoint
   // (a new safepoint can not start since we entered native_trans).
   // We must check here because a current safepoint could be modifying
   // the callers registers right this moment.
   // Acquire isn't strictly necessary here because of the fence, but
   // sync_state is declared to be volatile, so we do it anyway.
   __ load_const(sync_state_addr, SafepointSynchronize::address_of_state());
   // TODO: PPC port: assert(4 == SafepointSynchronize::sz_state(), "unexpected field size");
   __ lwz(sync_state, 0, sync_state_addr);
   // TODO: PPC port: assert(4 == Thread::sz_suspend_flags(), "unexpected field size");
   __ lwz(suspend_flags, thread_(suspend_flags));
   __ acquire();
   Label sync_check_done;
   Label do_safepoint;
   // No synchronization in progress nor yet synchronized
   __ cmpwi(CCR0, sync_state, SafepointSynchronize::_not_synchronized);
   // not suspended
   __ cmpwi(CCR1, suspend_flags, 0);
   __ bne(CCR0, do_safepoint);
   __ beq(CCR1, sync_check_done);
   __ bind(do_safepoint);
   // Block.  We do the call directly and leave the current
   // last_Java_frame setup undisturbed.  We must save any possible
   // native result acrosss the call. No oop is present
   __ mr(R3_ARG1, R16_thread);
 #if defined(ABI_ELFv2)
   __ call_c(CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans),
             relocInfo::none);
 #else
   __ call_c(CAST_FROM_FN_PTR(FunctionDescriptor*, JavaThread::check_special_condition_for_native_trans),
             relocInfo::none);
 #endif
   __ bind(sync_check_done);
   //=============================================================================
   // <<<<<< Back in Interpreter Frame >>>>>
   // We are in thread_in_native_trans here and back in the normal
   // interpreter frame. We don't have to do anything special about
   // safepoints and we can switch to Java mode anytime we are ready.
   // Note: frame::interpreter_frame_result has a dependency on how the
   // method result is saved across the call to post_method_exit. For
   // native methods it assumes that the non-FPU/non-void result is
   // saved in _native_lresult and a FPU result in _native_fresult. If
   // this changes then the interpreter_frame_result implementation
   // will need to be updated too.
   // On PPC64, we have stored the result directly after the native call.
   //=============================================================================
   // back in Java
   // We use release_store_fence to update values like the thread state, where
   // we don't want the current thread to continue until all our prior memory
   // accesses (including the new thread state) are visible to other threads.
   __ li(R0/*thread_state*/, _thread_in_Java);
   __ release();
   __ stw(R0/*thread_state*/, thread_(thread_state));
   if (UseMembar) {
     __ fence();
   }
   __ reset_last_Java_frame();
   // Reload GR27_method, call killed it. We can't look at
   // state->_method until we're back in java state because in java
   // state gc can't happen until we get to a safepoint.
   //
   // We've set thread_state to _thread_in_Java already, so restoring
   // R19_method from R14_state works; R19_method is invalid, because
   // GC may have happened.
   __ ld(R19_method, state_(_method)); // reload method, may have moved
   // jvmdi/jvmpi support. Whether we've got an exception pending or
   // not, and whether unlocking throws an exception or not, we notify
   // on native method exit. If we do have an exception, we'll end up
   // in the caller's context to handle it, so if we don't do the
   // notify here, we'll drop it on the floor.
   __ notify_method_exit(true/*native method*/,
                         ilgl /*illegal state (not used for native methods)*/,
                         InterpreterMacroAssembler::NotifyJVMTI,
                         false /*check_exceptions*/);
   //=============================================================================
   // Handle exceptions
   // See if we must unlock.
   //
   {
     Label method_is_not_synced;
     // is_synced is still alive
     assert(is_synced->is_nonvolatile(), "is_synced must be non-volatile");
     __ bfalse(is_synced, method_is_not_synced);
     unlock_method();
     __ bind(method_is_not_synced);
   }
   // Reset active handles after returning from native.
   // thread->active_handles()->clear();
   __ ld(active_handles, thread_(active_handles));
   // JNIHandleBlock::_top is an int.
   // TODO:  PPC port: assert(4 == JNIHandleBlock::top_size_in_bytes(), "unexpected field size");
   __ li(R0, 0);
   __ stw(R0, JNIHandleBlock::top_offset_in_bytes(), active_handles);
   Label no_pending_exception_from_native_method;
   __ ld(R0/*pending_exception*/, thread_(pending_exception));
   __ cmpdi(CCR0, R0/*pending_exception*/, 0);
   __ beq(CCR0, no_pending_exception_from_native_method);
   //-----------------------------------------------------------------------------
   // An exception is pending. We call into the runtime only if the
   // caller was not interpreted. If it was interpreted the
   // interpreter will do the correct thing. If it isn't interpreted
   // (call stub/compiled code) we will change our return and continue.
   __ BIND(exception_return);
   Label return_to_initial_caller_with_pending_exception;
   __ cmpdi(CCR0, R15_prev_state, 0);
   __ beq(CCR0, return_to_initial_caller_with_pending_exception);
   // We are returning to an interpreter activation, just pop the state,
   // pop our frame, leave the exception pending, and return.
   __ pop_interpreter_state(/*prev_state_may_be_0=*/false);
   __ pop_interpreter_frame(R11_scratch1, R12_scratch2, R21_tmp1 /* set to return pc */, R22_tmp2);
   __ mtlr(R21_tmp1);
   __ blr();
   __ BIND(exception_return_sync_check);
   assert(is_synced->is_nonvolatile(), "is_synced must be non-volatile");
   __ bfalse(is_synced, exception_return);
   unlock_method();
   __ b(exception_return);
   __ BIND(return_to_initial_caller_with_pending_exception);
   // We are returning to a c2i-adapter / call-stub, get the address of the
   // exception handler, pop the frame and return to the handler.
   // First, pop to caller's frame.
   __ pop_interpreter_frame(R11_scratch1, R12_scratch2, R21_tmp1  /* set to return pc */, R22_tmp2);
   __ push_frame_reg_args(0, R11_scratch1);
   // Get the address of the exception handler.
   __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address),
                   R16_thread,
                   R21_tmp1 /* return pc */);
   __ pop_frame();
   // Load the PC of the the exception handler into LR.
   __ mtlr(R3_RET);
   // Load exception into R3_ARG1 and clear pending exception in thread.
   __ ld(R3_ARG1/*exception*/, thread_(pending_exception));
   __ li(R4_ARG2, 0);
   __ std(R4_ARG2, thread_(pending_exception));
   // Load the original return pc into R4_ARG2.
   __ mr(R4_ARG2/*issuing_pc*/, R21_tmp1);
   // Resize frame to get rid of a potential extension.
   __ resize_frame_to_initial_caller(R11_scratch1, R12_scratch2);
   // Return to exception handler.
   __ blr();
   //-----------------------------------------------------------------------------
   // No exception pending.
   __ BIND(no_pending_exception_from_native_method);
   // Move native method result back into proper registers and return.
   // Invoke result handler (may unbox/promote).
   __ ld(R3_RET, state_(_native_lresult));
   __ lfd(F1_RET, state_(_native_fresult));
   __ call_stub(result_handler_addr);
   // We have created a new BytecodeInterpreter object, now we must destroy it.
   //
   // Restore previous R14_state and caller's SP.  R15_prev_state may
   // be 0 here, because our caller may be the call_stub or compiled
   // code.
   __ pop_interpreter_state(/*prev_state_may_be_0=*/true);
   __ pop_interpreter_frame(R11_scratch1, R12_scratch2, R21_tmp1 /* set to return pc */, R22_tmp2);
   // Resize frame to get rid of a potential extension.
   __ resize_frame_to_initial_caller(R11_scratch1, R12_scratch2);
   // Must use the return pc which was loaded from the caller's frame
   // as the VM uses return-pc-patching for deoptimization.
   __ mtlr(R21_tmp1);
   __ blr();
   //=============================================================================
   // We encountered an exception while computing the interpreter
   // state, so R14_state isn't valid. Act as if we just returned from
   // the callee method with a pending exception.
   __ BIND(stack_overflow_return);
   //
   // Register state:
   //   R14_state         invalid; trashed by compute_interpreter_state
   //   R15_prev_state    valid, but may be 0
   //
   //   R1_SP             valid, points to caller's SP; wasn't yet updated by
   //                     compute_interpreter_state
   //
   // Create exception oop and make it pending.
   // Throw the exception via RuntimeStub "throw_StackOverflowError_entry".
   //
   // Previously, we called C-Code directly. As a consequence, a
   // possible GC tried to process the argument oops of the top frame
   // (see RegisterMap::clear, which sets the corresponding flag to
   // true). This lead to crashes because:
   //   1. The top register map did not contain locations for the argument registers
   //   2. The arguments are dead anyway, could be already overwritten in the worst case
   // Solution: Call via special runtime stub that pushes it's own
   // frame. This runtime stub has the flag "CodeBlob::caller_must_gc_arguments()"
   // set to "false", what prevents the dead arguments getting GC'd.
   //
   // 2 cases exist:
   // 1. We were called by the c2i adapter / call stub
   // 2. We were called by the frame manager
   //
   // Both cases are handled by this code:
   // 1. - initial_caller_sp was saved in both cases on entry, so it's safe to load it back even if it was not changed.
   //    - control flow will be:
   //      throw_stackoverflow_stub->VM->throw_stackoverflow_stub->forward_excep->excp_blob of caller method
   // 2. - control flow will be:
   //      throw_stackoverflow_stub->VM->throw_stackoverflow_stub->forward_excep->rethrow_excp_entry of frame manager->resume_method
   //      Since we restored the caller SP above, the rethrow_excp_entry can restore the original interpreter state
   //      registers using the stack and resume the calling method with a pending excp.
   // Pop any c2i extension from the stack, restore LR just to be sure
   __ ld(R0, _top_ijava_frame_abi(frame_manager_lr), R1_SP);
   __ mtlr(R0);
   // Resize frame to get rid of a potential extension.
   __ resize_frame_to_initial_caller(R11_scratch1, R12_scratch2);
   assert(StubRoutines::throw_StackOverflowError_entry() != NULL, "generated in wrong order");
   // Load target address of the runtime stub.
   __ load_const(R12_scratch2, (StubRoutines::throw_StackOverflowError_entry()));
   __ mtctr(R12_scratch2);
   __ bctr();
   //=============================================================================
   // Counter overflow.
   if (inc_counter) {
     // Handle invocation counter overflow
     __ bind(invocation_counter_overflow);
     generate_counter_overflow(continue_after_compile);
   }
   native_entry = entry;
   return entry;
 }
 bool AbstractInterpreter::can_be_compiled(methodHandle m) {
   // No special entry points that preclude compilation.
   return true;
 }
 // Unlock the current method.
 //
 void CppInterpreterGenerator::unlock_method(void) {
   // Find preallocated monitor and unlock method. Method monitor is
   // the first one.
   // Registers alive
   //   R14_state
   //
   // Registers updated
   //   volatiles
   //
   const Register monitor = R4_ARG2;
   // Pass address of initial monitor we allocated.
   //
   // First monitor.
   __ addi(monitor, R14_state, -frame::interpreter_frame_monitor_size_in_bytes());
   // Unlock method
   __ unlock_object(monitor);
 }
 // Lock the current method.
 //
 void CppInterpreterGenerator::lock_method(void) {
   // Find preallocated monitor and lock method. Method monitor is the
   // first one.
   //
   // Registers alive
   //   R14_state
   //
   // Registers updated
   //   volatiles
   //
   const Register monitor = R4_ARG2;
   const Register object  = R5_ARG3;
   // Pass address of initial monitor we allocated.
   __ addi(monitor, R14_state, -frame::interpreter_frame_monitor_size_in_bytes());
   // Pass object address.
   __ ld(object, BasicObjectLock::obj_offset_in_bytes(), monitor);
   // Lock method.
   __ lock_object(monitor, object);
 }
 // Generate code for handling resuming a deopted method.
 void CppInterpreterGenerator::generate_deopt_handling(Register result_index) {
   //=============================================================================
   // Returning from a compiled method into a deopted method. The
   // bytecode at the bcp has completed. The result of the bytecode is
   // in the native abi (the tosca for the template based
   // interpreter). Any stack space that was used by the bytecode that
   // has completed has been removed (e.g. parameters for an invoke) so
   // all that we have to do is place any pending result on the
   // expression stack and resume execution on the next bytecode.
   Label return_from_deopt_common;
   // R3_RET and F1_RET are live here! Load the array index of the
   // required result stub address and continue at return_from_deopt_common.
   // Deopt needs to jump to here to enter the interpreter (return a result).
   deopt_frame_manager_return_atos = __ pc();
   __ li(result_index, AbstractInterpreter::BasicType_as_index(T_OBJECT));
   __ b(return_from_deopt_common);
   deopt_frame_manager_return_btos = __ pc();
   __ li(result_index, AbstractInterpreter::BasicType_as_index(T_BOOLEAN));
   __ b(return_from_deopt_common);
   deopt_frame_manager_return_itos = __ pc();
   __ li(result_index, AbstractInterpreter::BasicType_as_index(T_INT));
   __ b(return_from_deopt_common);
   deopt_frame_manager_return_ltos = __ pc();
   __ li(result_index, AbstractInterpreter::BasicType_as_index(T_LONG));
   __ b(return_from_deopt_common);
   deopt_frame_manager_return_ftos = __ pc();
   __ li(result_index, AbstractInterpreter::BasicType_as_index(T_FLOAT));
   __ b(return_from_deopt_common);
   deopt_frame_manager_return_dtos = __ pc();
   __ li(result_index, AbstractInterpreter::BasicType_as_index(T_DOUBLE));
   __ b(return_from_deopt_common);
   deopt_frame_manager_return_vtos = __ pc();
   __ li(result_index, AbstractInterpreter::BasicType_as_index(T_VOID));
   // Last one, fall-through to return_from_deopt_common.
   // Deopt return common. An index is present that lets us move any
   // possible result being return to the interpreter's stack.
   //
   __ BIND(return_from_deopt_common);
 }
 // Generate the code to handle a more_monitors message from the c++ interpreter.
 void CppInterpreterGenerator::generate_more_monitors() {
   //
   // Registers alive
   //   R16_thread      - JavaThread*
   //   R15_prev_state  - previous BytecodeInterpreter or 0
   //   R14_state       - BytecodeInterpreter* address of receiver's interpreter state
   //   R1_SP           - old stack pointer
   //
   // Registers updated
   //   R1_SP          - new stack pointer
   //
   // Very-local scratch registers.
   const Register old_tos         = R21_tmp1;
   const Register new_tos         = R22_tmp2;
   const Register stack_base      = R23_tmp3;
   const Register stack_limit     = R24_tmp4;
   const Register slot            = R25_tmp5;
   const Register n_slots         = R25_tmp5;
   // Interpreter state fields.
   const Register msg             = R24_tmp4;
   // Load up relevant interpreter state.
   __ ld(stack_base, state_(_stack_base));                // Old stack_base
   __ ld(old_tos, state_(_stack));                        // Old tos
   __ ld(stack_limit, state_(_stack_limit));              // Old stack_limit
   // extracted monitor_size
   int monitor_size = frame::interpreter_frame_monitor_size_in_bytes();
   assert(Assembler::is_aligned((unsigned int)monitor_size,
                                (unsigned int)frame::alignment_in_bytes),
          "size of a monitor must respect alignment of SP");
   // Save and restore top LR
   __ ld(R12_scratch2, _top_ijava_frame_abi(frame_manager_lr), R1_SP);
   __ resize_frame(-monitor_size, R11_scratch1);// Allocate space for new monitor
   __ std(R12_scratch2, _top_ijava_frame_abi(frame_manager_lr), R1_SP);
     // Initial_caller_sp is used as unextended_sp for non initial callers.
   __ std(R1_SP, _top_ijava_frame_abi(initial_caller_sp), R1_SP);
   __ addi(stack_base, stack_base, -monitor_size);        // New stack_base
   __ addi(new_tos, old_tos, -monitor_size);              // New tos
   __ addi(stack_limit, stack_limit, -monitor_size);      // New stack_limit
   __ std(R1_SP, state_(_last_Java_sp));                  // Update frame_bottom
   __ std(stack_base, state_(_stack_base));               // Update stack_base
   __ std(new_tos, state_(_stack));                       // Update tos
   __ std(stack_limit, state_(_stack_limit));             // Update stack_limit
   __ li(msg, BytecodeInterpreter::got_monitors);         // Tell interpreter we allocated the lock
   __ stw(msg, state_(_msg));
   // Shuffle expression stack down. Recall that stack_base points
   // just above the new expression stack bottom. Old_tos and new_tos
   // are used to scan thru the old and new expression stacks.
   Label copy_slot, copy_slot_finished;
   __ sub(n_slots, stack_base, new_tos);
   __ srdi_(n_slots, n_slots, LogBytesPerWord);           // compute number of slots to copy
   assert(LogBytesPerWord == 3, "conflicts assembler instructions");
   __ beq(CCR0, copy_slot_finished);                       // nothing to copy
   __ mtctr(n_slots);
   // loop
   __ bind(copy_slot);
   __ ldu(slot, BytesPerWord, old_tos);                   // slot = *++old_tos;
   __ stdu(slot, BytesPerWord, new_tos);                  // *++new_tos = slot;
   __ bdnz(copy_slot);
   __ bind(copy_slot_finished);
   // Restart interpreter
   __ li(R0, 0);
   __ std(R0, BasicObjectLock::obj_offset_in_bytes(), stack_base);  // Mark lock as unused
 }
 address CppInterpreterGenerator::generate_normal_entry(void) {
   if (interpreter_frame_manager != NULL) return interpreter_frame_manager;
   address entry = __ pc();
   address return_from_native_pc = (address) NULL;
   // Initial entry to frame manager (from call_stub or c2i_adapter)
   //
   // Registers alive
   //   R16_thread               - JavaThread*
   //   R19_method               - callee's Method (method to be invoked)
   //   R17_tos                  - address of sender tos (prepushed)
   //   R1_SP                    - SP prepared by call stub such that caller's outgoing args are near top
   //   LR                       - return address to caller (call_stub or c2i_adapter)
   //   R21_sender_SP            - initial caller sp
   //
   // Registers updated
   //   R15_prev_state           - 0
   //
   // Stack layout at this point:
   //
   //   0       [TOP_IJAVA_FRAME_ABI]         <-- R1_SP
   //           alignment (optional)
   //           [outgoing Java arguments]     <-- R17_tos
   //           ...
   //   PARENT  [PARENT_IJAVA_FRAME_ABI]
   //           ...
   //
   // Save initial_caller_sp to caller's abi.
   // The caller frame must be resized before returning to get rid of
   // the c2i part on top of the calling compiled frame (if any).
   // R21_tmp1 must match sender_sp in gen_c2i_adapter.
   // Now override the saved SP with the senderSP so we can pop c2i
   // arguments (if any) off when we return.
   __ std(R21_sender_SP, _top_ijava_frame_abi(initial_caller_sp), R1_SP);
   // Save LR to caller's frame. We don't use _abi(lr) here,
   // because it is not safe.
   __ mflr(R0);
   __ std(R0, _top_ijava_frame_abi(frame_manager_lr), R1_SP);
   // If we come here, it is the first invocation of the frame manager.
   // So there is no previous interpreter state.
   __ li(R15_prev_state, 0);
   // Fall through to where "recursive" invocations go.
   //=============================================================================
   // Dispatch an instance of the interpreter. Recursive activations
   // come here.
   Label re_dispatch;
   __ BIND(re_dispatch);
   //
   // Registers alive
   //    R16_thread        - JavaThread*
   //    R19_method        - callee's Method
   //    R17_tos           - address of caller's tos (prepushed)
   //    R15_prev_state    - address of caller's BytecodeInterpreter or 0
   //    R1_SP             - caller's SP trimmed such that caller's outgoing args are near top.
   //
   // Stack layout at this point:
   //
   //   0       [TOP_IJAVA_FRAME_ABI]
   //           alignment (optional)
   //           [outgoing Java arguments]
   //           ...
   //   PARENT  [PARENT_IJAVA_FRAME_ABI]
   //           ...
   // fall through to interpreted execution
   //=============================================================================
   // Allocate a new Java frame and initialize the new interpreter state.
   Label stack_overflow_return;
   // Create a suitable new Java frame plus a new BytecodeInterpreter instance
   // in the current (frame manager's) C frame.
   generate_compute_interpreter_state(stack_overflow_return);
   // fall through
   //=============================================================================
   // Interpreter dispatch.
   Label call_interpreter;
   __ BIND(call_interpreter);
   //
   // Registers alive
   //   R16_thread       - JavaThread*
   //   R15_prev_state   - previous BytecodeInterpreter or 0
   //   R14_state        - address of receiver's BytecodeInterpreter
   //   R1_SP            - receiver's stack pointer
   //
   // Thread fields.
   const Register pending_exception = R21_tmp1;
   // Interpreter state fields.
   const Register msg               = R24_tmp4;
   // Method fields.
   const Register parameter_count   = R25_tmp5;
   const Register result_index      = R26_tmp6;
   const Register dummy             = R28_tmp8;
   // Address of various interpreter stubs.
   // R29_tmp9 is reserved.
   const Register stub_addr         = R27_tmp7;
   // Uncommon trap needs to jump to here to enter the interpreter
   // (re-execute current bytecode).
   unctrap_frame_manager_entry  = __ pc();
   // If we are profiling, store our fp (BSP) in the thread so we can
   // find it during a tick.
   if (Arguments::has_profile()) {
     // On PPC64 we store the pointer to the current BytecodeInterpreter,
     // instead of the bsp of ia64. This should suffice to be able to
     // find all interesting information.
     __ std(R14_state, thread_(last_interpreter_fp));
   }
   // R16_thread, R14_state and R15_prev_state are nonvolatile
   // registers. There is no need to save these. If we needed to save
   // some state in the current Java frame, this could be a place to do
   // so.
   // Call Java bytecode dispatcher passing "BytecodeInterpreter* istate".
   __ call_VM_leaf(CAST_FROM_FN_PTR(address,
                                    JvmtiExport::can_post_interpreter_events()
                                    ? BytecodeInterpreter::runWithChecks
                                    : BytecodeInterpreter::run),
                   R14_state);
   interpreter_return_address  = __ last_calls_return_pc();
   // R16_thread, R14_state and R15_prev_state have their values preserved.
   // If we are profiling, clear the fp in the thread to tell
   // the profiler that we are no longer in the interpreter.
   if (Arguments::has_profile()) {
     __ li(R11_scratch1, 0);
     __ std(R11_scratch1, thread_(last_interpreter_fp));
   }
   // Load message from bytecode dispatcher.
   // TODO: PPC port: guarantee(4 == BytecodeInterpreter::sz_msg(), "unexpected field size");
   __ lwz(msg, state_(_msg));
   Label more_monitors;
   Label return_from_native;
   Label return_from_native_common;
   Label return_from_native_no_exception;
   Label return_from_interpreted_method;
   Label return_from_recursive_activation;
   Label unwind_recursive_activation;
   Label resume_interpreter;
   Label return_to_initial_caller;
   Label unwind_initial_activation;
   Label unwind_initial_activation_pending_exception;
   Label call_method;
   Label call_special;
   Label retry_method;
   Label retry_method_osr;
   Label popping_frame;
   Label throwing_exception;
   // Branch according to the received message
   __ cmpwi(CCR1, msg, BytecodeInterpreter::call_method);
   __ cmpwi(CCR2, msg, BytecodeInterpreter::return_from_method);
   __ beq(CCR1, call_method);
   __ beq(CCR2, return_from_interpreted_method);
   __ cmpwi(CCR3, msg, BytecodeInterpreter::more_monitors);
   __ cmpwi(CCR4, msg, BytecodeInterpreter::throwing_exception);
   __ beq(CCR3, more_monitors);
   __ beq(CCR4, throwing_exception);
   __ cmpwi(CCR5, msg, BytecodeInterpreter::popping_frame);
   __ cmpwi(CCR6, msg, BytecodeInterpreter::do_osr);
   __ beq(CCR5, popping_frame);
   __ beq(CCR6, retry_method_osr);
   __ stop("bad message from interpreter");
   //=============================================================================
   // Add a monitor just below the existing one(s). State->_stack_base
   // points to the lowest existing one, so we insert the new one just
   // below it and shuffle the expression stack down. Ref. the above
   // stack layout picture, we must update _stack_base, _stack, _stack_limit
   // and _last_Java_sp in the interpreter state.
   __ BIND(more_monitors);
   generate_more_monitors();
   __ b(call_interpreter);
   generate_deopt_handling(result_index);
   // Restoring the R14_state is already done by the deopt_blob.
   // Current tos includes no parameter slots.
   __ ld(R17_tos, state_(_stack));
   __ li(msg, BytecodeInterpreter::deopt_resume);
   __ b(return_from_native_common);
   // We are sent here when we are unwinding from a native method or
   // adapter with an exception pending. We need to notify the interpreter
   // that there is an exception to process.
   // We arrive here also if the frame manager called an (interpreted) target
   // which returns with a StackOverflow exception.
   // The control flow is in this case is:
   // frame_manager->throw_excp_stub->forward_excp->rethrow_excp_entry
   AbstractInterpreter::_rethrow_exception_entry = __ pc();
   // Restore R14_state.
   __ ld(R14_state, 0, R1_SP);
   __ addi(R14_state, R14_state,
               -frame::interpreter_frame_cinterpreterstate_size_in_bytes());
   // Store exception oop into thread object.
   __ std(R3_RET, thread_(pending_exception));
   __ li(msg, BytecodeInterpreter::method_resume /*rethrow_exception*/);
   //
   // NOTE: the interpreter frame as setup be deopt does NOT include
   // any parameter slots (good thing since we have no callee here
   // and couldn't remove them) so we don't have to do any calculations
   // here to figure it out.
   //
   __ ld(R17_tos, state_(_stack));
   __ b(return_from_native_common);
   //=============================================================================
   // Returning from a native method.  Result is in the native abi
   // location so we must move it to the java expression stack.
   __ BIND(return_from_native);
   guarantee(return_from_native_pc == (address) NULL, "precondition");
   return_from_native_pc = __ pc();
   // Restore R14_state.
   __ ld(R14_state, 0, R1_SP);
   __ addi(R14_state, R14_state, -frame::interpreter_frame_cinterpreterstate_size_in_bytes());
   //
   // Registers alive
   //   R16_thread
   //   R14_state    - address of caller's BytecodeInterpreter.
   //   R3_RET       - integer result, if any.
   //   F1_RET       - float result, if any.
   //
   // Registers updated
   //   R19_method   - callee's Method
   //   R17_tos      - caller's tos, with outgoing args popped
   //   result_index - index of result handler.
   //   msg          - message for resuming interpreter.
   //
   // Very-local scratch registers.
   const ConditionRegister have_pending_exception = CCR0;
   // Load callee Method, gc may have moved it.
   __ ld(R19_method, state_(_result._to_call._callee));
   // Load address of caller's tos. includes parameter slots.
   __ ld(R17_tos, state_(_stack));
   // Pop callee's parameters.
   __ ld(parameter_count, in_bytes(Method::const_offset()), R19_method);
   __ lhz(parameter_count, in_bytes(ConstMethod::size_of_parameters_offset()), parameter_count);
   __ sldi(parameter_count, parameter_count, Interpreter::logStackElementSize);
   __ add(R17_tos, R17_tos, parameter_count);
   // Result stub address array index
   // TODO: PPC port: assert(4 == sizeof(AccessFlags), "unexpected field size");
   __ lwa(result_index, method_(result_index));
   __ li(msg, BytecodeInterpreter::method_resume);
   //
   // Registers alive
   //   R16_thread
   //   R14_state    - address of caller's BytecodeInterpreter.
   //   R17_tos      - address of caller's tos with outgoing args already popped
   //   R3_RET       - integer return value, if any.
   //   F1_RET       - float return value, if any.
   //   result_index - index of result handler.
   //   msg          - message for resuming interpreter.
   //
   // Registers updated
   //   R3_RET       - new address of caller's tos, including result, if any
   //
   __ BIND(return_from_native_common);
   // Check for pending exception
   __ ld(pending_exception, thread_(pending_exception));
   __ cmpdi(CCR0, pending_exception, 0);
   __ beq(CCR0, return_from_native_no_exception);
   // If there's a pending exception, we really have no result, so
   // R3_RET is dead. Resume_interpreter assumes the new tos is in
   // R3_RET.
   __ mr(R3_RET, R17_tos);
   // `resume_interpreter' expects R15_prev_state to be alive.
   __ ld(R15_prev_state, state_(_prev_link));
   __ b(resume_interpreter);
   __ BIND(return_from_native_no_exception);
   // No pending exception, copy method result from native ABI register
   // to tos.
   // Address of stub descriptor address array.
   __ load_const(stub_addr, CppInterpreter::tosca_result_to_stack());
   // Pass address of tos to stub.
   __ mr(R4_ARG2, R17_tos);
   // Address of stub descriptor address.
   __ sldi(result_index, result_index, LogBytesPerWord);
   __ add(stub_addr, stub_addr, result_index);
   // Stub descriptor address.
   __ ld(stub_addr, 0, stub_addr);
   // TODO: don't do this via a call, do it in place!
   //
   // call stub via descriptor
   // in R3_ARG1/F1_ARG1: result value (R3_RET or F1_RET)
   __ call_stub(stub_addr);
   // new tos = result of call in R3_RET
   // `resume_interpreter' expects R15_prev_state to be alive.
   __ ld(R15_prev_state, state_(_prev_link));
   __ b(resume_interpreter);
   //=============================================================================
   // We encountered an exception while computing the interpreter
   // state, so R14_state isn't valid. Act as if we just returned from
   // the callee method with a pending exception.
   __ BIND(stack_overflow_return);
   //
   // Registers alive
   //   R16_thread        - JavaThread*
   //   R1_SP             - old stack pointer
   //   R19_method        - callee's Method
   //   R17_tos           - address of caller's tos (prepushed)
   //   R15_prev_state    - address of caller's BytecodeInterpreter or 0
   //   R18_locals        - address of callee's locals array
   //
   // Registers updated
   //   R3_RET           - address of resuming tos, if recursive unwind
   Label Lskip_unextend_SP;
   {
   const ConditionRegister is_initial_call = CCR0;
   const Register tos_save = R21_tmp1;
   const Register tmp = R22_tmp2;
   assert(tos_save->is_nonvolatile(), "need a nonvolatile");
   // Is the exception thrown in the initial Java frame of this frame
   // manager frame?
   __ cmpdi(is_initial_call, R15_prev_state, 0);
   __ bne(is_initial_call, Lskip_unextend_SP);
   // Pop any c2i extension from the stack. This is necessary in the
   // non-recursive case (that is we were called by the c2i adapter,
   // meaning we have to prev state). In this case we entered the frame
   // manager through a special entry which pushes the orignal
   // unextended SP to the stack. Here we load it back.
   __ ld(R0, _top_ijava_frame_abi(frame_manager_lr), R1_SP);
   __ mtlr(R0);
   // Resize frame to get rid of a potential extension.
   __ resize_frame_to_initial_caller(R11_scratch1, R12_scratch2);
   // Fall through
   __ bind(Lskip_unextend_SP);
   // Throw the exception via RuntimeStub "throw_StackOverflowError_entry".
   //
   // Previously, we called C-Code directly. As a consequence, a
   // possible GC tried to process the argument oops of the top frame
   // (see RegisterMap::clear, which sets the corresponding flag to
   // true). This lead to crashes because:
   // 1. The top register map did not contain locations for the argument registers
   // 2. The arguments are dead anyway, could be already overwritten in the worst case
   // Solution: Call via special runtime stub that pushes it's own frame. This runtime stub has the flag
   // "CodeBlob::caller_must_gc_arguments()" set to "false", what prevents the dead arguments getting GC'd.
   //
   // 2 cases exist:
   // 1. We were called by the c2i adapter / call stub
   // 2. We were called by the frame manager
   //
   // Both cases are handled by this code:
   // 1. - initial_caller_sp was saved on stack => Load it back and we're ok
   //    - control flow will be:
   //      throw_stackoverflow_stub->VM->throw_stackoverflow_stub->forward_excep->excp_blob of calling method
   // 2. - control flow will be:
   //      throw_stackoverflow_stub->VM->throw_stackoverflow_stub->forward_excep->
   //        ->rethrow_excp_entry of frame manager->resume_method
   //      Since we restored the caller SP above, the rethrow_excp_entry can restore the original interpreter state
   //      registers using the stack and resume the calling method with a pending excp.
   assert(StubRoutines::throw_StackOverflowError_entry() != NULL, "generated in wrong order");
   __ load_const(R3_ARG1, (StubRoutines::throw_StackOverflowError_entry()));
   __ mtctr(R3_ARG1);
   __ bctr();
   }
   //=============================================================================
   // We have popped a frame from an interpreted call. We are assured
   // of returning to an interpreted call by the popframe abi. We have
   // no return value all we have to do is pop the current frame and
   // then make sure that the top of stack (of the caller) gets set to
   // where it was when we entered the callee (i.e. the args are still
   // in place).  Or we are returning to the interpreter. In the first
   // case we must extract result (if any) from the java expression
   // stack and store it in the location the native abi would expect
   // for a call returning this type. In the second case we must simply
   // do a stack to stack move as we unwind.
   __ BIND(popping_frame);
   // Registers alive
   //   R14_state
   //   R15_prev_state
   //   R17_tos
   //
   // Registers updated
   //   R19_method
   //   R3_RET
   //   msg
   {
     Label L;
     // Reload callee method, gc may have moved it.
     __ ld(R19_method, state_(_method));
     // We may be returning to a deoptimized frame in which case the
     // usual assumption of a recursive return is not true.
     // not equal = is recursive call
     __ cmpdi(CCR0, R15_prev_state, 0);
     __ bne(CCR0, L);
     // Pop_frame capability.
     // The pop_frame api says that the underlying frame is a Java frame, in this case
     // (prev_state==null) it must be a compiled frame:
     //
     // Stack at this point: I, C2I + C, ...
     //
     // The outgoing arguments of the call have just been copied (popframe_preserve_args).
     // By the pop_frame api, we must end up in an interpreted frame. So the compiled frame
     // will be deoptimized. Deoptimization will restore the outgoing arguments from
     // popframe_preserve_args, adjust the tos such that it includes the popframe_preserve_args,
     // and adjust the bci such that the call will be executed again.
     // We have no results, just pop the interpreter frame, resize the compiled frame to get rid
     // of the c2i extension and return to the deopt_handler.
     __ b(unwind_initial_activation);
     // is recursive call
     __ bind(L);
     // Resume_interpreter expects the original tos in R3_RET.
     __ ld(R3_RET, prev_state_(_stack));
     // We're done.
     __ li(msg, BytecodeInterpreter::popping_frame);
     __ b(unwind_recursive_activation);
   }
   //=============================================================================
   // We have finished an interpreted call. We are either returning to
   // native (call_stub/c2) or we are returning to the interpreter.
   // When returning to native, we must extract the result (if any)
   // from the java expression stack and store it in the location the
   // native abi expects. When returning to the interpreter we must
   // simply do a stack to stack move as we unwind.
   __ BIND(return_from_interpreted_method);
   //
   // Registers alive
   //   R16_thread     - JavaThread*
   //   R15_prev_state - address of caller's BytecodeInterpreter or 0
   //   R14_state      - address of callee's interpreter state
   //   R1_SP          - callee's stack pointer
   //
   // Registers updated
   //   R19_method     - callee's method
   //   R3_RET         - address of result (new caller's tos),
   //
   // if returning to interpreted
   //   msg  - message for interpreter,
   // if returning to interpreted
   //
   // Check if this is the initial invocation of the frame manager.
   // If so, R15_prev_state will be null.
   __ cmpdi(CCR0, R15_prev_state, 0);
   // Reload callee method, gc may have moved it.
   __ ld(R19_method, state_(_method));
   // Load the method's result type.
   __ lwz(result_index, method_(result_index));
   // Go to return_to_initial_caller if R15_prev_state is null.
   __ beq(CCR0, return_to_initial_caller);
   // Copy callee's result to caller's expression stack via inline stack-to-stack
   // converters.
   {
     Register new_tos   = R3_RET;
     Register from_temp = R4_ARG2;
     Register from      = R5_ARG3;
     Register tos       = R6_ARG4;
     Register tmp1      = R7_ARG5;
     Register tmp2      = R8_ARG6;
     ConditionRegister result_type_is_void   = CCR1;
     ConditionRegister result_type_is_long   = CCR2;
     ConditionRegister result_type_is_double = CCR3;
     Label stack_to_stack_void;
     Label stack_to_stack_double_slot; // T_LONG, T_DOUBLE
     Label stack_to_stack_single_slot; // T_BOOLEAN, T_BYTE, T_CHAR, T_SHORT, T_INT, T_FLOAT, T_OBJECT
     Label stack_to_stack_done;
     // Pass callee's address of tos + BytesPerWord
     __ ld(from_temp, state_(_stack));
     // result type: void
     __ cmpwi(result_type_is_void, result_index, AbstractInterpreter::BasicType_as_index(T_VOID));
     // Pass caller's tos == callee's locals address
     __ ld(tos, state_(_locals));
     // result type: long
     __ cmpwi(result_type_is_long, result_index, AbstractInterpreter::BasicType_as_index(T_LONG));
     __ addi(from, from_temp, Interpreter::stackElementSize);
     // !! don't branch above this line !!
     // handle void
     __ beq(result_type_is_void,   stack_to_stack_void);
     // result type: double
     __ cmpwi(result_type_is_double, result_index, AbstractInterpreter::BasicType_as_index(T_DOUBLE));
     // handle long or double
     __ beq(result_type_is_long, stack_to_stack_double_slot);
     __ beq(result_type_is_double, stack_to_stack_double_slot);
     // fall through to single slot types (incl. object)
     {
       __ BIND(stack_to_stack_single_slot);
       // T_BOOLEAN, T_BYTE, T_CHAR, T_SHORT, T_INT, T_FLOAT, T_OBJECT
       __ ld(tmp1, 0, from);
       __ std(tmp1, 0, tos);
       // New expression stack top
       __ addi(new_tos, tos, - BytesPerWord);
       __ b(stack_to_stack_done);
     }
     {
       __ BIND(stack_to_stack_double_slot);
       // T_LONG, T_DOUBLE
       // Move both entries for debug purposes even though only one is live
       __ ld(tmp1, BytesPerWord, from);
       __ ld(tmp2, 0, from);
       __ std(tmp1, 0, tos);
       __ std(tmp2, -BytesPerWord, tos);
       // new expression stack top
       __ addi(new_tos, tos, - 2 * BytesPerWord); // two slots
       __ b(stack_to_stack_done);
     }
     {
       __ BIND(stack_to_stack_void);
       // T_VOID
       // new expression stack top
       __ mr(new_tos, tos);
       // fall through to stack_to_stack_done
     }
     __ BIND(stack_to_stack_done);
   }
   // new tos = R3_RET
   // Get the message for the interpreter
   __ li(msg, BytecodeInterpreter::method_resume);
   // And fall thru
   //=============================================================================
   // Restore caller's interpreter state and pass pointer to caller's
   // new tos to caller.
   __ BIND(unwind_recursive_activation);
   //
   // Registers alive
   //   R15_prev_state   - address of caller's BytecodeInterpreter
   //   R3_RET           - address of caller's tos
   //   msg              - message for caller's BytecodeInterpreter
   //   R1_SP            - callee's stack pointer
   //
   // Registers updated
   //   R14_state        - address of caller's BytecodeInterpreter
   //   R15_prev_state   - address of its parent or 0
   //
   // Pop callee's interpreter and set R14_state to caller's interpreter.
   __ pop_interpreter_state(/*prev_state_may_be_0=*/false);
   // And fall thru
   //=============================================================================
   // Resume the (calling) interpreter after a call.
   __ BIND(resume_interpreter);
   //
   // Registers alive
   //   R14_state        - address of resuming BytecodeInterpreter
   //   R15_prev_state   - address of its parent or 0
   //   R3_RET           - address of resuming tos
   //   msg              - message for resuming interpreter
   //   R1_SP            - callee's stack pointer
   //
   // Registers updated
   //   R1_SP            - caller's stack pointer
   //
   // Restore C stack pointer of caller (resuming interpreter),
   // R14_state already points to the resuming BytecodeInterpreter.
   __ pop_interpreter_frame_to_state(R14_state, R21_tmp1, R11_scratch1, R12_scratch2);
   // Store new address of tos (holding return value) in interpreter state.
   __ std(R3_RET, state_(_stack));
   // Store message for interpreter.
   __ stw(msg, state_(_msg));
   __ b(call_interpreter);
   //=============================================================================
   // Interpreter returning to native code (call_stub/c1/c2) from
   // initial activation. Convert stack result and unwind activation.
   __ BIND(return_to_initial_caller);
   //
   // Registers alive
   //   R19_method       - callee's Method
   //   R14_state        - address of callee's interpreter state
   //   R16_thread       - JavaThread
   //   R1_SP            - callee's stack pointer
   //
   // Registers updated
   //   R3_RET/F1_RET - result in expected output register
   //
   // If we have an exception pending we have no result and we
   // must figure out where to really return to.
   //
   __ ld(pending_exception, thread_(pending_exception));
   __ cmpdi(CCR0, pending_exception, 0);
   __ bne(CCR0, unwind_initial_activation_pending_exception);
   __ lwa(result_index, method_(result_index));
   // Address of stub descriptor address array.
   __ load_const(stub_addr, CppInterpreter::stack_result_to_native());
   // Pass address of callee's tos + BytesPerWord.
   // Will then point directly to result.
   __ ld(R3_ARG1, state_(_stack));
   __ addi(R3_ARG1, R3_ARG1, Interpreter::stackElementSize);
   // Address of stub descriptor address
   __ sldi(result_index, result_index, LogBytesPerWord);
   __ add(stub_addr, stub_addr, result_index);
   // Stub descriptor address
   __ ld(stub_addr, 0, stub_addr);
   // TODO: don't do this via a call, do it in place!
   //
   // call stub via descriptor
   __ call_stub(stub_addr);
   __ BIND(unwind_initial_activation);
   // Unwind from initial activation. No exception is pending.
   //
   // Stack layout at this point:
   //
   //    0       [TOP_IJAVA_FRAME_ABI]         <-- R1_SP
   //            ...
   //    CALLER  [PARENT_IJAVA_FRAME_ABI]
   //            ...
   //    CALLER  [unextended ABI]
   //            ...
   //
   //  The CALLER frame has a C2I adapter or is an entry-frame.
   //
   // An interpreter frame exists, we may pop the TOP_IJAVA_FRAME and
   // turn the caller's PARENT_IJAVA_FRAME back into a TOP_IJAVA_FRAME.
   // But, we simply restore the return pc from the caller's frame and
   // use the caller's initial_caller_sp as the new SP which pops the
   // interpreter frame and "resizes" the caller's frame to its "unextended"
   // size.
   // get rid of top frame
   __ pop_frame();
   // Load return PC from parent frame.
   __ ld(R21_tmp1, _parent_ijava_frame_abi(lr), R1_SP);
   // Resize frame to get rid of a potential extension.
   __ resize_frame_to_initial_caller(R11_scratch1, R12_scratch2);
   // update LR
   __ mtlr(R21_tmp1);
   // return
   __ blr();
   //=============================================================================
   // Unwind from initial activation. An exception is pending
   __ BIND(unwind_initial_activation_pending_exception);
   //
   // Stack layout at this point:
   //
   //   0       [TOP_IJAVA_FRAME_ABI]         <-- R1_SP
   //           ...
   //   CALLER  [PARENT_IJAVA_FRAME_ABI]
   //           ...
   //   CALLER  [unextended ABI]
   //           ...
   //
   // The CALLER frame has a C2I adapter or is an entry-frame.
   //
   // An interpreter frame exists, we may pop the TOP_IJAVA_FRAME and
   // turn the caller's PARENT_IJAVA_FRAME back into a TOP_IJAVA_FRAME.
   // But, we just pop the current TOP_IJAVA_FRAME and fall through
   __ pop_frame();
   __ ld(R3_ARG1, _top_ijava_frame_abi(lr), R1_SP);
   //
   // Stack layout at this point:
   //
   //   CALLER  [PARENT_IJAVA_FRAME_ABI]      <-- R1_SP
   //           ...
   //   CALLER  [unextended ABI]
   //           ...
   //
   // The CALLER frame has a C2I adapter or is an entry-frame.
   //
   // Registers alive
   //   R16_thread
   //   R3_ARG1 - return address to caller
   //
   // Registers updated
   //   R3_ARG1 - address of pending exception
   //   R4_ARG2 - issuing pc = return address to caller
   //   LR      - address of exception handler stub
   //
   // Resize frame to get rid of a potential extension.
   __ resize_frame_to_initial_caller(R11_scratch1, R12_scratch2);
   __ mr(R14, R3_ARG1);   // R14 := ARG1
   __ mr(R4_ARG2, R3_ARG1);  // ARG2 := ARG1
   // Find the address of the "catch_exception" stub.
   __ push_frame_reg_args(0, R11_scratch1);
   __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address),
                   R16_thread,
                   R4_ARG2);
   __ pop_frame();
   // Load continuation address into LR.
   __ mtlr(R3_RET);
   // Load address of pending exception and clear it in thread object.
   __ ld(R3_ARG1/*R3_RET*/, thread_(pending_exception));
   __ li(R4_ARG2, 0);
   __ std(R4_ARG2, thread_(pending_exception));
   // re-load issuing pc
   __ mr(R4_ARG2, R14);
   // Branch to found exception handler.
   __ blr();
   //=============================================================================
   // Call a new method. Compute new args and trim the expression stack
   // to only what we are currently using and then recurse.
   __ BIND(call_method);
   //
   //  Registers alive
   //    R16_thread
   //    R14_state      - address of caller's BytecodeInterpreter
   //    R1_SP          - caller's stack pointer
   //
   //  Registers updated
   //    R15_prev_state - address of caller's BytecodeInterpreter
   //    R17_tos        - address of caller's tos
   //    R19_method     - callee's Method
   //    R1_SP          - trimmed back
   //
   // Very-local scratch registers.
   const Register offset = R21_tmp1;
   const Register tmp    = R22_tmp2;
   const Register self_entry  = R23_tmp3;
   const Register stub_entry  = R24_tmp4;
   const ConditionRegister cr = CCR0;
   // Load the address of the frame manager.
   __ load_const(self_entry, &interpreter_frame_manager);
   __ ld(self_entry, 0, self_entry);
   // Load BytecodeInterpreter._result._to_call._callee (callee's Method).
   __ ld(R19_method, state_(_result._to_call._callee));
   // Load BytecodeInterpreter._stack (outgoing tos).
   __ ld(R17_tos, state_(_stack));
   // Save address of caller's BytecodeInterpreter.
   __ mr(R15_prev_state, R14_state);
   // Load the callee's entry point.
   // Load BytecodeInterpreter._result._to_call._callee_entry_point.
   __ ld(stub_entry, state_(_result._to_call._callee_entry_point));
   // Check whether stub_entry is equal to self_entry.
   __ cmpd(cr, self_entry, stub_entry);
   // if (self_entry == stub_entry)
   //   do a re-dispatch
   __ beq(cr, re_dispatch);
   // else
   //   call the specialized entry (adapter for jni or compiled code)
   __ BIND(call_special);
   //
   // Call the entry generated by `InterpreterGenerator::generate_native_entry'.
   //
   // Registers alive
   //   R16_thread
   //   R15_prev_state    - address of caller's BytecodeInterpreter
   //   R19_method        - callee's Method
   //   R17_tos           - address of caller's tos
   //   R1_SP             - caller's stack pointer
   //
   // Mark return from specialized entry for generate_native_entry.
   guarantee(return_from_native_pc != (address) NULL, "precondition");
   frame_manager_specialized_return = return_from_native_pc;
   // Set sender_SP in case we call interpreter native wrapper which
   // will expect it. Compiled code should not care.
   __ mr(R21_sender_SP, R1_SP);
   // Do a tail call here, and let the link register point to
   // frame_manager_specialized_return which is return_from_native_pc.
   __ load_const(tmp, frame_manager_specialized_return);
   __ call_stub_and_return_to(stub_entry,  tmp /* return_pc=tmp */);
   //=============================================================================
   //
   // InterpretMethod triggered OSR compilation of some Java method M
   // and now asks to run the compiled code.  We call this code the
   // `callee'.
   //
   // This is our current idea on how OSR should look like on PPC64:
   //
   // While interpreting a Java method M the stack is:
   //
   //  (InterpretMethod (M), IJAVA_FRAME (M), ANY_FRAME, ...).
   //
   // After having OSR compiled M, `InterpretMethod' returns to the
   // frame manager, sending the message `retry_method_osr'.  The stack
   // is:
   //
   //  (IJAVA_FRAME (M), ANY_FRAME, ...).
   //
   // The compiler will have generated an `nmethod' suitable for
   // continuing execution of M at the bytecode index at which OSR took
   // place.  So now the frame manager calls the OSR entry.  The OSR
   // entry sets up a JIT_FRAME for M and continues execution of M with
   // initial state determined by the IJAVA_FRAME.
   //
   //  (JIT_FRAME (M), IJAVA_FRAME (M), ANY_FRAME, ...).
   //
   __ BIND(retry_method_osr);
   {
   //
   // Registers alive
   //   R16_thread
   //   R15_prev_state     - address of caller's BytecodeInterpreter
   //   R14_state          - address of callee's BytecodeInterpreter
   //   R1_SP              - callee's SP before call to InterpretMethod
   //
   // Registers updated
   //   R17                - pointer to callee's locals array
   //                       (declared via `interpreter_arg_ptr_reg' in the AD file)
   //   R19_method         - callee's Method
   //   R1_SP              - callee's SP (will become SP of OSR adapter frame)
   //
   // Provide a debugger breakpoint in the frame manager if breakpoints
   // in osr'd methods are requested.
 #ifdef COMPILER2
   NOT_PRODUCT( if (OptoBreakpointOSR) { __ illtrap(); } )
 #endif
   // Load callee's pointer to locals array from callee's state.
   //  __ ld(R17, state_(_locals));
   // Load osr entry.
   __ ld(R12_scratch2, state_(_result._osr._osr_entry));
   // Load address of temporary osr buffer to arg1.
   __ ld(R3_ARG1, state_(_result._osr._osr_buf));
   __ mtctr(R12_scratch2);
   // Load method, gc may move it during execution of osr'd method.
   __ ld(R22_tmp2, state_(_method));
   // Load message 'call_method'.
   __ li(R23_tmp3, BytecodeInterpreter::call_method);
   {
     // Pop the IJAVA frame of the method which we are going to call osr'd.
     Label no_state, skip_no_state;
     __ pop_interpreter_state(/*prev_state_may_be_0=*/true);
     __ cmpdi(CCR0, R14_state,0);
     __ beq(CCR0, no_state);
     // return to interpreter
     __ pop_interpreter_frame_to_state(R14_state, R11_scratch1, R12_scratch2, R21_tmp1);
     // Init _result._to_call._callee and tell gc that it contains a valid oop
     // by setting _msg to 'call_method'.
     __ std(R22_tmp2, state_(_result._to_call._callee));
     // TODO: PPC port: assert(4 == BytecodeInterpreter::sz_msg(), "unexpected field size");
     __ stw(R23_tmp3, state_(_msg));
     __ load_const(R21_tmp1, frame_manager_specialized_return);
     __ b(skip_no_state);
     __ bind(no_state);
     // Return to initial caller.
     // Get rid of top frame.
     __ pop_frame();
     // Load return PC from parent frame.
     __ ld(R21_tmp1, _parent_ijava_frame_abi(lr), R1_SP);
     // Resize frame to get rid of a potential extension.
     __ resize_frame_to_initial_caller(R11_scratch1, R12_scratch2);
     __ bind(skip_no_state);
     // Update LR with return pc.
     __ mtlr(R21_tmp1);
   }
   // Jump to the osr entry point.
   __ bctr();
   }
   //=============================================================================
   // Interpreted method "returned" with an exception, pass it on.
   // Pass no result, unwind activation and continue/return to
   // interpreter/call_stub/c2.
   __ BIND(throwing_exception);
   // Check if this is the initial invocation of the frame manager.  If
   // so, previous interpreter state in R15_prev_state will be null.
   // New tos of caller is callee's first parameter address, that is
   // callee's incoming arguments are popped.
   __ ld(R3_RET, state_(_locals));
   // Check whether this is an initial call.
   __ cmpdi(CCR0, R15_prev_state, 0);
   // Yes, called from the call stub or from generated code via a c2i frame.
   __ beq(CCR0, unwind_initial_activation_pending_exception);
   // Send resume message, interpreter will see the exception first.
   __ li(msg, BytecodeInterpreter::method_resume);
   __ b(unwind_recursive_activation);
   //=============================================================================
   // Push the last instruction out to the code buffer.
   {
     __ unimplemented("end of InterpreterGenerator::generate_normal_entry", 128);
   }
   interpreter_frame_manager = entry;
   return interpreter_frame_manager;
 }
 // Generate code for various sorts of method entries
 //
 address AbstractInterpreterGenerator::generate_method_entry(AbstractInterpreter::MethodKind kind) {
   address entry_point = NULL;
   switch (kind) {
     case Interpreter::zerolocals                 :                                                                              break;
     case Interpreter::zerolocals_synchronized    :                                                                              break;
     case Interpreter::native                     : // Fall thru
     case Interpreter::native_synchronized        : entry_point = ((CppInterpreterGenerator*)this)->generate_native_entry();     break;
     case Interpreter::empty                      :                                                                              break;
     case Interpreter::accessor                   : entry_point = ((InterpreterGenerator*)this)->generate_accessor_entry();      break;
     case Interpreter::abstract                   : entry_point = ((InterpreterGenerator*)this)->generate_abstract_entry();      break;
     // These are special interpreter intrinsics which we don't support so far.
     case Interpreter::java_lang_math_sin         :                                                                              break;
     case Interpreter::java_lang_math_cos         :                                                                              break;
     case Interpreter::java_lang_math_tan         :                                                                              break;
     case Interpreter::java_lang_math_abs         :                                                                              break;
     case Interpreter::java_lang_math_log         :                                                                              break;
     case Interpreter::java_lang_math_log10       :                                                                              break;
     case Interpreter::java_lang_math_sqrt        :                                                                              break;
     case Interpreter::java_lang_math_pow         :                                                                              break;
     case Interpreter::java_lang_math_exp         :                                                                              break;
     case Interpreter::java_lang_ref_reference_get: entry_point = ((InterpreterGenerator*)this)->generate_Reference_get_entry(); break;
     default                                      : ShouldNotReachHere();                                                        break;
   }
   if (entry_point) {
     return entry_point;
   }
   return ((InterpreterGenerator*)this)->generate_normal_entry();
 }
 InterpreterGenerator::InterpreterGenerator(StubQueue* code)
  : CppInterpreterGenerator(code) {
    generate_all(); // down here so it can be "virtual"
 }
 // How much stack a topmost interpreter method activation needs in words.
 int AbstractInterpreter::size_top_interpreter_activation(Method* method) {
   // Computation is in bytes not words to match layout_activation_impl
   // below, but the return is in words.
   //
   //  0       [TOP_IJAVA_FRAME_ABI]                                                    \
   //          alignment (optional)                                             \       |
   //          [operand stack / Java parameters] > stack                        |       |
   //          [monitors] (optional)             > monitors                     |       |
   //          [PARENT_IJAVA_FRAME_ABI]                                \        |       |
   //          [BytecodeInterpreter object]      > interpreter \       |        |       |
   //          alignment (optional)                            | round | parent | round | top
   //          [Java result] (2 slots)           > result      |       |        |       |
   //          [Java non-arg locals]             \ locals      |       |        |       |
   //          [arg locals]                      /             /       /        /       /
   //
   int locals = method->max_locals() * BytesPerWord;
   int interpreter = frame::interpreter_frame_cinterpreterstate_size_in_bytes();
   int result = 2 * BytesPerWord;
   int parent = round_to(interpreter + result + locals, 16) + frame::parent_ijava_frame_abi_size;
   int stack = method->max_stack() * BytesPerWord;
   int monitors = method->is_synchronized() ? frame::interpreter_frame_monitor_size_in_bytes() : 0;
   int top = round_to(parent + monitors + stack, 16) + frame::top_ijava_frame_abi_size;
   return (top / BytesPerWord);
 }
 void BytecodeInterpreter::layout_interpreterState(interpreterState to_fill,
                                                   frame* caller,
                                                   frame* current,
                                                   Method* method,
                                                   intptr_t* locals,
                                                   intptr_t* stack,
                                                   intptr_t* stack_base,
                                                   intptr_t* monitor_base,
                                                   intptr_t* frame_sp,
                                                   bool is_top_frame) {
   // What about any vtable?
   //
   to_fill->_thread = JavaThread::current();
   // This gets filled in later but make it something recognizable for now.
   to_fill->_bcp = method->code_base();
   to_fill->_locals = locals;
   to_fill->_constants = method->constants()->cache();
   to_fill->_method = method;
   to_fill->_mdx = NULL;
   to_fill->_stack = stack;
   if (is_top_frame && JavaThread::current()->popframe_forcing_deopt_reexecution()) {
     to_fill->_msg = deopt_resume2;
   } else {
     to_fill->_msg = method_resume;
   }
   to_fill->_result._to_call._bcp_advance = 0;
   to_fill->_result._to_call._callee_entry_point = NULL; // doesn't matter to anyone
   to_fill->_result._to_call._callee = NULL; // doesn't matter to anyone
   to_fill->_prev_link = NULL;
   if (caller->is_interpreted_frame()) {
     interpreterState prev  = caller->get_interpreterState();
     // Support MH calls. Make sure the interpreter will return the right address:
     // 1. Caller did ordinary interpreted->compiled call call: Set a prev_state
     //    which makes the CPP interpreter return to frame manager "return_from_interpreted_method"
     //    entry after finishing execution.
     // 2. Caller did a MH call: If the caller has a MethodHandleInvoke in it's
     //    state (invariant: must be the caller of the bottom vframe) we used the
     //    "call_special" entry to do the call, meaning the arguments have not been
     //    popped from the stack. Therefore, don't enter a prev state in this case
     //    in order to return to "return_from_native" frame manager entry which takes
     //    care of popping arguments. Also, don't overwrite the MH.invoke Method in
     //    the prev_state in order to be able to figure out the number of arguments to
     //     pop.
     // The parameter method can represent MethodHandle.invokeExact(...).
     // The MethodHandleCompiler generates these synthetic Methods,
     // including bytecodes, if an invokedynamic call gets inlined. In
     // this case we want to return like from any other interpreted
     // Java call, so we set _prev_link.
     to_fill->_prev_link = prev;
     if (*prev->_bcp == Bytecodes::_invokeinterface || *prev->_bcp == Bytecodes::_invokedynamic) {
       prev->_result._to_call._bcp_advance = 5;
     } else {
       prev->_result._to_call._bcp_advance = 3;
     }
   }
   to_fill->_oop_temp = NULL;
   to_fill->_stack_base = stack_base;
   // Need +1 here because stack_base points to the word just above the
   // first expr stack entry and stack_limit is supposed to point to
   // the word just below the last expr stack entry. See
   // generate_compute_interpreter_state.
   to_fill->_stack_limit = stack_base - (method->max_stack() + 1);
   to_fill->_monitor_base = (BasicObjectLock*) monitor_base;
   to_fill->_frame_bottom = frame_sp;
   // PPC64 specific
   to_fill->_last_Java_pc = NULL;
   to_fill->_last_Java_fp = NULL;
   to_fill->_last_Java_sp = frame_sp;
 #ifdef ASSERT
   to_fill->_self_link = to_fill;
   to_fill->_native_fresult = 123456.789;
   to_fill->_native_lresult = CONST64(0xdeafcafedeadc0de);
 #endif
 }
 void BytecodeInterpreter::pd_layout_interpreterState(interpreterState istate,
                                                      address last_Java_pc,
                                                      intptr_t* last_Java_fp) {
   istate->_last_Java_pc = last_Java_pc;
   istate->_last_Java_fp = last_Java_fp;
 }
 // Computes monitor_size and top_frame_size in bytes.
 static void frame_size_helper(int max_stack,
                               int monitors,
                               int& monitor_size,
                               int& top_frame_size) {
   monitor_size = frame::interpreter_frame_monitor_size_in_bytes() * monitors;
   top_frame_size = round_to(frame::interpreter_frame_cinterpreterstate_size_in_bytes()
                             + monitor_size
                             + max_stack * Interpreter::stackElementSize
                             + 2 * Interpreter::stackElementSize,
                             frame::alignment_in_bytes)
                    + frame::top_ijava_frame_abi_size;
 }
 // Returns number of stackElementWords needed for the interpreter frame with the
 // given sections.
 int AbstractInterpreter::size_activation(int max_stack,
                                          int temps,
                                          int extra_args,
                                          int monitors,
                                          int callee_params,
                                          int callee_locals,
                                          bool is_top_frame) {
   int monitor_size = 0;
   int top_frame_size = 0;
   frame_size_helper(max_stack, monitors, monitor_size, top_frame_size);
   int frame_size;
   if (is_top_frame) {
     frame_size = top_frame_size;
   } else {
     frame_size = round_to(frame::interpreter_frame_cinterpreterstate_size_in_bytes()
                           + monitor_size
                           + (temps - callee_params + callee_locals) * Interpreter::stackElementSize
                           + 2 * Interpreter::stackElementSize,
                           frame::alignment_in_bytes)
                  + frame::parent_ijava_frame_abi_size;
     assert(extra_args == 0, "non-zero for top_frame only");
   }
   return frame_size / Interpreter::stackElementSize;
 }
 void AbstractInterpreter::layout_activation(Method* method,
                                             int temps,        // Number of slots on java expression stack in use.
                                             int popframe_args,
                                             int monitors,     // Number of active monitors.
                                             int caller_actual_parameters,
                                             int callee_params,// Number of slots for callee parameters.
                                             int callee_locals,// Number of slots for locals.
                                             frame* caller,
                                             frame* interpreter_frame,
                                             bool is_top_frame,
                                             bool is_bottom_frame) {
   // NOTE this code must exactly mimic what
   // InterpreterGenerator::generate_compute_interpreter_state() does
   // as far as allocating an interpreter frame. However there is an
   // exception. With the C++ based interpreter only the top most frame
   // has a full sized expression stack.  The 16 byte slop factor is
   // both the abi scratch area and a place to hold a result from a
   // callee on its way to the callers stack.
   int monitor_size = 0;
   int top_frame_size = 0;
   frame_size_helper(method->max_stack(), monitors, monitor_size, top_frame_size);
   intptr_t sp = (intptr_t)interpreter_frame->sp();
   intptr_t fp = *(intptr_t *)sp;
   assert(fp == (intptr_t)caller->sp(), "fp must match");
   interpreterState cur_state =
     (interpreterState)(fp - frame::interpreter_frame_cinterpreterstate_size_in_bytes());
   // Now fill in the interpreterState object.
   intptr_t* locals;
   if (caller->is_interpreted_frame()) {
     // Locals must agree with the caller because it will be used to set the
     // caller's tos when we return.
     interpreterState prev  = caller->get_interpreterState();
     // Calculate start of "locals" for MH calls.  For MH calls, the
     // current method() (= MH target) and prev->callee() (=
     // MH.invoke*()) are different and especially have different
     // signatures. To pop the argumentsof the caller, we must use
     // the prev->callee()->size_of_arguments() because that's what
     // the caller actually pushed.  Currently, for synthetic MH
     // calls (deoptimized from inlined MH calls), detected by
     // is_method_handle_invoke(), we use the callee's arguments
     // because here, the caller's and callee's signature match.
     if (true /*!caller->is_at_mh_callsite()*/) {
       locals = prev->stack() + method->size_of_parameters();
     } else {
       // Normal MH call.
       locals = prev->stack() + prev->callee()->size_of_parameters();
     }
   } else {
     bool is_deopted;
     locals = (intptr_t*) (fp + ((method->max_locals() - 1) * BytesPerWord) +
                           frame::parent_ijava_frame_abi_size);
   }
   intptr_t* monitor_base = (intptr_t*) cur_state;
   intptr_t* stack_base   = (intptr_t*) ((intptr_t) monitor_base - monitor_size);
   // Provide pop_frame capability on PPC64, add popframe_args.
   // +1 because stack is always prepushed.
   intptr_t* stack = (intptr_t*) ((intptr_t) stack_base - (temps + popframe_args + 1) * BytesPerWord);
   BytecodeInterpreter::layout_interpreterState(cur_state,
                                                caller,
                                                interpreter_frame,
                                                method,
                                                locals,
                                                stack,
                                                stack_base,
                                                monitor_base,
                                                (intptr_t*)(((intptr_t)fp) - top_frame_size),
                                                is_top_frame);
   BytecodeInterpreter::pd_layout_interpreterState(cur_state, interpreter_return_address,
                                                   interpreter_frame->fp());
 }
 #endif // CC_INTERP

Mercurial > jdk8-mips64-public > hotspot / annotate

src/cpu/ppc/vm/cppInterpreter_ppc.cpp@0bf37f737702 (annotated)

src/cpu/ppc/vm/cppInterpreter_ppc.cpp