1 /*

     2  * Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.

     3  * Copyright (c) 2015, 2017, SAP SE. All rights reserved.

     4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     5  *

     6  * This code is free software; you can redistribute it and/or modify it

     7  * under the terms of the GNU General Public License version 2 only, as

     8  * published by the Free Software Foundation.

     9  *

    10  * This code is distributed in the hope that it will be useful, but WITHOUT

    11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    13  * version 2 for more details (a copy is included in the LICENSE file that

    14  * accompanied this code).

    15  *

    16  * You should have received a copy of the GNU General Public License version

    17  * 2 along with this work; if not, write to the Free Software Foundation,

    18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    19  *

    20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    21  * or visit www.oracle.com if you need additional information or have any

    22  * questions.

    23  *

    24  */

    25 

    26 #include "precompiled.hpp"

    27 #include "asm/macroAssembler.inline.hpp"

    28 #include "interpreter/bytecodeHistogram.hpp"

    29 #include "interpreter/interpreter.hpp"

    30 #include "interpreter/interpreterRuntime.hpp"

    31 #include "interpreter/interp_masm.hpp"

    32 #include "interpreter/templateInterpreterGenerator.hpp"

    33 #include "interpreter/templateTable.hpp"

    34 #include "oops/arrayOop.hpp"

    35 #include "oops/methodData.hpp"

    36 #include "oops/method.hpp"

    37 #include "oops/oop.inline.hpp"

    38 #include "prims/jvmtiExport.hpp"

    39 #include "prims/jvmtiThreadState.hpp"

    40 #include "runtime/arguments.hpp"

    41 #include "runtime/deoptimization.hpp"

    42 #include "runtime/frame.inline.hpp"

    43 #include "runtime/sharedRuntime.hpp"

    44 #include "runtime/stubRoutines.hpp"

    45 #include "runtime/synchronizer.hpp"

    46 #include "runtime/timer.hpp"

    47 #include "runtime/vframeArray.hpp"

    48 #include "utilities/debug.hpp"

    49 #include "utilities/macros.hpp"

    50 

    51 #undef __

    52 #define __ _masm->

    53 

    54 // Size of interpreter code.  Increase if too small.  Interpreter will

    55 // fail with a guarantee ("not enough space for interpreter generation");

    56 // if too small.

    57 // Run with +PrintInterpreter to get the VM to print out the size.

    58 // Max size with JVMTI

    59 int TemplateInterpreter::InterpreterCodeSize = 256*K;

    60 

    61 #ifdef PRODUCT

    62 #define BLOCK_COMMENT(str) /* nothing */

    63 #else

    64 #define BLOCK_COMMENT(str) __ block_comment(str)

    65 #endif

    66 

    67 #define BIND(label)        __ bind(label); BLOCK_COMMENT(#label ":")

    68 

    69 //-----------------------------------------------------------------------------

    70 

    71 address TemplateInterpreterGenerator::generate_slow_signature_handler() {

    72   // Slow_signature handler that respects the PPC C calling conventions.

    73   //

    74   // We get called by the native entry code with our output register

    75   // area == 8. First we call InterpreterRuntime::get_result_handler

    76   // to copy the pointer to the signature string temporarily to the

    77   // first C-argument and to return the result_handler in

    78   // R3_RET. Since native_entry will copy the jni-pointer to the

    79   // first C-argument slot later on, it is OK to occupy this slot

    80   // temporarilly. Then we copy the argument list on the java

    81   // expression stack into native varargs format on the native stack

    82   // and load arguments into argument registers. Integer arguments in

    83   // the varargs vector will be sign-extended to 8 bytes.

    84   //

    85   // On entry:

    86   //   R3_ARG1        - intptr_t*     Address of java argument list in memory.

    87   //   R15_prev_state - BytecodeInterpreter* Address of interpreter state for

    88   //     this method

    89   //   R19_method

    90   //

    91   // On exit (just before return instruction):

    92   //   R3_RET            - contains the address of the result_handler.

    93   //   R4_ARG2           - is not updated for static methods and contains "this" otherwise.

    94   //   R5_ARG3-R10_ARG8: - When the (i-2)th Java argument is not of type float or double,

    95   //                       ARGi contains this argument. Otherwise, ARGi is not updated.

    96   //   F1_ARG1-F13_ARG13 - contain the first 13 arguments of type float or double.

    97 

    98   const int LogSizeOfTwoInstructions = 3;

    99 

   100   // FIXME: use Argument:: GL: Argument names different numbers!

   101   const int max_fp_register_arguments  = 13;

   102   const int max_int_register_arguments = 6;  // first 2 are reserved

   103 

   104   const Register arg_java       = R21_tmp1;

   105   const Register arg_c          = R22_tmp2;

   106   const Register signature      = R23_tmp3;  // is string

   107   const Register sig_byte       = R24_tmp4;

   108   const Register fpcnt          = R25_tmp5;

   109   const Register argcnt         = R26_tmp6;

   110   const Register intSlot        = R27_tmp7;

   111   const Register target_sp      = R28_tmp8;

   112   const FloatRegister floatSlot = F0;

   113 

   114   address entry = __ function_entry();

   115 

   116   __ save_LR_CR(R0);

   117   __ save_nonvolatile_gprs(R1_SP, _spill_nonvolatiles_neg(r14));

   118   // We use target_sp for storing arguments in the C frame.

   119   __ mr(target_sp, R1_SP);

   120   __ push_frame_reg_args_nonvolatiles(0, R11_scratch1);

   121 

   122   __ mr(arg_java, R3_ARG1);

   123 

   124   __ call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::get_signature), R16_thread, R19_method);

   125 

   126   // Signature is in R3_RET. Signature is callee saved.

   127   __ mr(signature, R3_RET);

   128 

   129   // Get the result handler.

   130   __ call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::get_result_handler), R16_thread, R19_method);

   131 

   132   {

   133     Label L;

   134     // test if static

   135     // _access_flags._flags must be at offset 0.

   136     // TODO PPC port: requires change in shared code.

   137     //assert(in_bytes(AccessFlags::flags_offset()) == 0,

   138     //       "MethodDesc._access_flags == MethodDesc._access_flags._flags");

   139     // _access_flags must be a 32 bit value.

   140     assert(sizeof(AccessFlags) == 4, "wrong size");

   141     __ lwa(R11_scratch1/*access_flags*/, method_(access_flags));

   142     // testbit with condition register.

   143     __ testbitdi(CCR0, R0, R11_scratch1/*access_flags*/, JVM_ACC_STATIC_BIT);

   144     __ btrue(CCR0, L);

   145     // For non-static functions, pass "this" in R4_ARG2 and copy it

   146     // to 2nd C-arg slot.

   147     // We need to box the Java object here, so we use arg_java

   148     // (address of current Java stack slot) as argument and don't

   149     // dereference it as in case of ints, floats, etc.

   150     __ mr(R4_ARG2, arg_java);

   151     __ addi(arg_java, arg_java, -BytesPerWord);

   152     __ std(R4_ARG2, _abi(carg_2), target_sp);

   153     __ bind(L);

   154   }

   155 

   156   // Will be incremented directly after loop_start. argcnt=0

   157   // corresponds to 3rd C argument.

   158   __ li(argcnt, -1);

   159   // arg_c points to 3rd C argument

   160   __ addi(arg_c, target_sp, _abi(carg_3));

   161   // no floating-point args parsed so far

   162   __ li(fpcnt, 0);

   163 

   164   Label move_intSlot_to_ARG, move_floatSlot_to_FARG;

   165   Label loop_start, loop_end;

   166   Label do_int, do_long, do_float, do_double, do_dontreachhere, do_object, do_array, do_boxed;

   167 

   168   // signature points to '(' at entry

   169 #ifdef ASSERT

   170   __ lbz(sig_byte, 0, signature);

   171   __ cmplwi(CCR0, sig_byte, '(');

   172   __ bne(CCR0, do_dontreachhere);

   173 #endif

   174 

   175   __ bind(loop_start);

   176 

   177   __ addi(argcnt, argcnt, 1);

   178   __ lbzu(sig_byte, 1, signature);

   179 

   180   __ cmplwi(CCR0, sig_byte, ')'); // end of signature

   181   __ beq(CCR0, loop_end);

   182 

   183   __ cmplwi(CCR0, sig_byte, 'B'); // byte

   184   __ beq(CCR0, do_int);

   185 

   186   __ cmplwi(CCR0, sig_byte, 'C'); // char

   187   __ beq(CCR0, do_int);

   188 

   189   __ cmplwi(CCR0, sig_byte, 'D'); // double

   190   __ beq(CCR0, do_double);

   191 

   192   __ cmplwi(CCR0, sig_byte, 'F'); // float

   193   __ beq(CCR0, do_float);

   194 

   195   __ cmplwi(CCR0, sig_byte, 'I'); // int

   196   __ beq(CCR0, do_int);

   197 

   198   __ cmplwi(CCR0, sig_byte, 'J'); // long

   199   __ beq(CCR0, do_long);

   200 

   201   __ cmplwi(CCR0, sig_byte, 'S'); // short

   202   __ beq(CCR0, do_int);

   203 

   204   __ cmplwi(CCR0, sig_byte, 'Z'); // boolean

   205   __ beq(CCR0, do_int);

   206 

   207   __ cmplwi(CCR0, sig_byte, 'L'); // object

   208   __ beq(CCR0, do_object);

   209 

   210   __ cmplwi(CCR0, sig_byte, '['); // array

   211   __ beq(CCR0, do_array);

   212 

   213   //  __ cmplwi(CCR0, sig_byte, 'V'); // void cannot appear since we do not parse the return type

   214   //  __ beq(CCR0, do_void);

   215 

   216   __ bind(do_dontreachhere);

   217 

   218   __ unimplemented("ShouldNotReachHere in slow_signature_handler", 120);

   219 

   220   __ bind(do_array);

   221 

   222   {

   223     Label start_skip, end_skip;

   224 

   225     __ bind(start_skip);

   226     __ lbzu(sig_byte, 1, signature);

   227     __ cmplwi(CCR0, sig_byte, '[');

   228     __ beq(CCR0, start_skip); // skip further brackets

   229     __ cmplwi(CCR0, sig_byte, '9');

   230     __ bgt(CCR0, end_skip);   // no optional size

   231     __ cmplwi(CCR0, sig_byte, '0');

   232     __ bge(CCR0, start_skip); // skip optional size

   233     __ bind(end_skip);

   234 

   235     __ cmplwi(CCR0, sig_byte, 'L');

   236     __ beq(CCR0, do_object);  // for arrays of objects, the name of the object must be skipped

   237     __ b(do_boxed);          // otherwise, go directly to do_boxed

   238   }

   239 

   240   __ bind(do_object);

   241   {

   242     Label L;

   243     __ bind(L);

   244     __ lbzu(sig_byte, 1, signature);

   245     __ cmplwi(CCR0, sig_byte, ';');

   246     __ bne(CCR0, L);

   247    }

   248   // Need to box the Java object here, so we use arg_java (address of

   249   // current Java stack slot) as argument and don't dereference it as

   250   // in case of ints, floats, etc.

   251   Label do_null;

   252   __ bind(do_boxed);

   253   __ ld(R0,0, arg_java);

   254   __ cmpdi(CCR0, R0, 0);

   255   __ li(intSlot,0);

   256   __ beq(CCR0, do_null);

   257   __ mr(intSlot, arg_java);

   258   __ bind(do_null);

   259   __ std(intSlot, 0, arg_c);

   260   __ addi(arg_java, arg_java, -BytesPerWord);

   261   __ addi(arg_c, arg_c, BytesPerWord);

   262   __ cmplwi(CCR0, argcnt, max_int_register_arguments);

   263   __ blt(CCR0, move_intSlot_to_ARG);

   264   __ b(loop_start);

   265 

   266   __ bind(do_int);

   267   __ lwa(intSlot, 0, arg_java);

   268   __ std(intSlot, 0, arg_c);

   269   __ addi(arg_java, arg_java, -BytesPerWord);

   270   __ addi(arg_c, arg_c, BytesPerWord);

   271   __ cmplwi(CCR0, argcnt, max_int_register_arguments);

   272   __ blt(CCR0, move_intSlot_to_ARG);

   273   __ b(loop_start);

   274 

   275   __ bind(do_long);

   276   __ ld(intSlot, -BytesPerWord, arg_java);

   277   __ std(intSlot, 0, arg_c);

   278   __ addi(arg_java, arg_java, - 2 * BytesPerWord);

   279   __ addi(arg_c, arg_c, BytesPerWord);

   280   __ cmplwi(CCR0, argcnt, max_int_register_arguments);

   281   __ blt(CCR0, move_intSlot_to_ARG);

   282   __ b(loop_start);

   283 

   284   __ bind(do_float);

   285   __ lfs(floatSlot, 0, arg_java);

   286 #if defined(LINUX)

   287   // Linux uses ELF ABI. Both original ELF and ELFv2 ABIs have float

   288   // in the least significant word of an argument slot.

   289 #if defined(VM_LITTLE_ENDIAN)

   290   __ stfs(floatSlot, 0, arg_c);

   291 #else

   292   __ stfs(floatSlot, 4, arg_c);

   293 #endif

   294 #elif defined(AIX)

   295   // Although AIX runs on big endian CPU, float is in most significant

   296   // word of an argument slot.

   297   __ stfs(floatSlot, 0, arg_c);

   298 #else

   299 #error "unknown OS"

   300 #endif

   301   __ addi(arg_java, arg_java, -BytesPerWord);

   302   __ addi(arg_c, arg_c, BytesPerWord);

   303   __ cmplwi(CCR0, fpcnt, max_fp_register_arguments);

   304   __ blt(CCR0, move_floatSlot_to_FARG);

   305   __ b(loop_start);

   306 

   307   __ bind(do_double);

   308   __ lfd(floatSlot, - BytesPerWord, arg_java);

   309   __ stfd(floatSlot, 0, arg_c);

   310   __ addi(arg_java, arg_java, - 2 * BytesPerWord);

   311   __ addi(arg_c, arg_c, BytesPerWord);

   312   __ cmplwi(CCR0, fpcnt, max_fp_register_arguments);

   313   __ blt(CCR0, move_floatSlot_to_FARG);

   314   __ b(loop_start);

   315 

   316   __ bind(loop_end);

   317 

   318   __ pop_frame();

   319   __ restore_nonvolatile_gprs(R1_SP, _spill_nonvolatiles_neg(r14));

   320   __ restore_LR_CR(R0);

   321 

   322   __ blr();

   323 

   324   Label move_int_arg, move_float_arg;

   325   __ bind(move_int_arg); // each case must consist of 2 instructions (otherwise adapt LogSizeOfTwoInstructions)

   326   __ mr(R5_ARG3, intSlot);  __ b(loop_start);

   327   __ mr(R6_ARG4, intSlot);  __ b(loop_start);

   328   __ mr(R7_ARG5, intSlot);  __ b(loop_start);

   329   __ mr(R8_ARG6, intSlot);  __ b(loop_start);

   330   __ mr(R9_ARG7, intSlot);  __ b(loop_start);

   331   __ mr(R10_ARG8, intSlot); __ b(loop_start);

   332 

   333   __ bind(move_float_arg); // each case must consist of 2 instructions (otherwise adapt LogSizeOfTwoInstructions)

   334   __ fmr(F1_ARG1, floatSlot);   __ b(loop_start);

   335   __ fmr(F2_ARG2, floatSlot);   __ b(loop_start);

   336   __ fmr(F3_ARG3, floatSlot);   __ b(loop_start);

   337   __ fmr(F4_ARG4, floatSlot);   __ b(loop_start);

   338   __ fmr(F5_ARG5, floatSlot);   __ b(loop_start);

   339   __ fmr(F6_ARG6, floatSlot);   __ b(loop_start);

   340   __ fmr(F7_ARG7, floatSlot);   __ b(loop_start);

   341   __ fmr(F8_ARG8, floatSlot);   __ b(loop_start);

   342   __ fmr(F9_ARG9, floatSlot);   __ b(loop_start);

   343   __ fmr(F10_ARG10, floatSlot); __ b(loop_start);

   344   __ fmr(F11_ARG11, floatSlot); __ b(loop_start);

   345   __ fmr(F12_ARG12, floatSlot); __ b(loop_start);

   346   __ fmr(F13_ARG13, floatSlot); __ b(loop_start);

   347 

   348   __ bind(move_intSlot_to_ARG);

   349   __ sldi(R0, argcnt, LogSizeOfTwoInstructions);

   350   __ load_const(R11_scratch1, move_int_arg); // Label must be bound here.

   351   __ add(R11_scratch1, R0, R11_scratch1);

   352   __ mtctr(R11_scratch1/*branch_target*/);

   353   __ bctr();

   354   __ bind(move_floatSlot_to_FARG);

   355   __ sldi(R0, fpcnt, LogSizeOfTwoInstructions);

   356   __ addi(fpcnt, fpcnt, 1);

   357   __ load_const(R11_scratch1, move_float_arg); // Label must be bound here.

   358   __ add(R11_scratch1, R0, R11_scratch1);

   359   __ mtctr(R11_scratch1/*branch_target*/);

   360   __ bctr();

   361 

   362   return entry;

   363 }

   364 

   365 address TemplateInterpreterGenerator::generate_result_handler_for(BasicType type) {

   366   //

   367   // Registers alive

   368   //   R3_RET

   369   //   LR

   370   //

   371   // Registers updated

   372   //   R3_RET

   373   //

   374 

   375   Label done;

   376   address entry = __ pc();

   377 

   378   switch (type) {

   379   case T_BOOLEAN:

   380     // convert !=0 to 1

   381     __ neg(R0, R3_RET);

   382     __ orr(R0, R3_RET, R0);

   383     __ srwi(R3_RET, R0, 31);

   384     break;

   385   case T_BYTE:

   386      // sign extend 8 bits

   387      __ extsb(R3_RET, R3_RET);

   388      break;

   389   case T_CHAR:

   390      // zero extend 16 bits

   391      __ clrldi(R3_RET, R3_RET, 48);

   392      break;

   393   case T_SHORT:

   394      // sign extend 16 bits

   395      __ extsh(R3_RET, R3_RET);

   396      break;

   397   case T_INT:

   398      // sign extend 32 bits

   399      __ extsw(R3_RET, R3_RET);

   400      break;

   401   case T_LONG:

   402      break;

   403   case T_OBJECT:

   404     // JNIHandles::resolve result.

   405     __ resolve_jobject(R3_RET, R11_scratch1, R12_scratch2, /* needs_frame */ true); // kills R31

   406     break;

   407   case T_FLOAT:

   408      break;

   409   case T_DOUBLE:

   410      break;

   411   case T_VOID:

   412      break;

   413   default: ShouldNotReachHere();

   414   }

   415 

   416   BIND(done);

   417   __ blr();

   418 

   419   return entry;

   420 }

   421 

   422 // Abstract method entry.

   423 //

   424 address TemplateInterpreterGenerator::generate_abstract_entry(void) {

   425   address entry = __ pc();

   426 

   427   //

   428   // Registers alive

   429   //   R16_thread     - JavaThread*

   430   //   R19_method     - callee's method (method to be invoked)

   431   //   R1_SP          - SP prepared such that caller's outgoing args are near top

   432   //   LR             - return address to caller

   433   //

   434   // Stack layout at this point:

   435   //

   436   //   0       [TOP_IJAVA_FRAME_ABI]         <-- R1_SP

   437   //           alignment (optional)

   438   //           [outgoing Java arguments]

   439   //           ...

   440   //   PARENT  [PARENT_IJAVA_FRAME_ABI]

   441   //            ...

   442   //

   443 

   444   // Can't use call_VM here because we have not set up a new

   445   // interpreter state. Make the call to the vm and make it look like

   446   // our caller set up the JavaFrameAnchor.

   447   __ set_top_ijava_frame_at_SP_as_last_Java_frame(R1_SP, R12_scratch2/*tmp*/);

   448 

   449   // Push a new C frame and save LR.

   450   __ save_LR_CR(R0);

   451   __ push_frame_reg_args(0, R11_scratch1);

   452 

   453   // This is not a leaf but we have a JavaFrameAnchor now and we will

   454   // check (create) exceptions afterward so this is ok.

   455   __ call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError),

   456                   R16_thread);

   457 

   458   // Pop the C frame and restore LR.

   459   __ pop_frame();

   460   __ restore_LR_CR(R0);

   461 

   462   // Reset JavaFrameAnchor from call_VM_leaf above.

   463   __ reset_last_Java_frame();

   464 

   465   // We don't know our caller, so jump to the general forward exception stub,

   466   // which will also pop our full frame off. Satisfy the interface of

   467   // SharedRuntime::generate_forward_exception()

   468   __ load_const_optimized(R11_scratch1, StubRoutines::forward_exception_entry(), R0);

   469   __ mtctr(R11_scratch1);

   470   __ bctr();

   471 

   472   return entry;

   473 }

   474 

   475 // Interpreter intrinsic for WeakReference.get().

   476 // 1. Don't push a full blown frame and go on dispatching, but fetch the value

   477 //    into R8 and return quickly

   478 // 2. If G1 is active we *must* execute this intrinsic for corrrectness:

   479 //    It contains a GC barrier which puts the reference into the satb buffer

   480 //    to indicate that someone holds a strong reference to the object the

   481 //    weak ref points to!

   482 address TemplateInterpreterGenerator::generate_Reference_get_entry(void) {

   483   // Code: _aload_0, _getfield, _areturn

   484   // parameter size = 1

   485   //

   486   // The code that gets generated by this routine is split into 2 parts:

   487   //    1. the "intrinsified" code for G1 (or any SATB based GC),

   488   //    2. the slow path - which is an expansion of the regular method entry.

   489   //

   490   // Notes:

   491   // * In the G1 code we do not check whether we need to block for

   492   //   a safepoint. If G1 is enabled then we must execute the specialized

   493   //   code for Reference.get (except when the Reference object is null)

   494   //   so that we can log the value in the referent field with an SATB

   495   //   update buffer.

   496   //   If the code for the getfield template is modified so that the

   497   //   G1 pre-barrier code is executed when the current method is

   498   //   Reference.get() then going through the normal method entry

   499   //   will be fine.

   500   // * The G1 code can, however, check the receiver object (the instance

   501   //   of java.lang.Reference) and jump to the slow path if null. If the

   502   //   Reference object is null then we obviously cannot fetch the referent

   503   //   and so we don't need to call the G1 pre-barrier. Thus we can use the

   504   //   regular method entry code to generate the NPE.

   505   //

   506 

   507   if (UseG1GC) {

   508     address entry = __ pc();

   509 

   510     const int referent_offset = java_lang_ref_Reference::referent_offset;

   511     guarantee(referent_offset > 0, "referent offset not initialized");

   512 

   513     Label slow_path;

   514 

   515     // Debugging not possible, so can't use __ skip_if_jvmti_mode(slow_path, GR31_SCRATCH);

   516 

   517     // In the G1 code we don't check if we need to reach a safepoint. We

   518     // continue and the thread will safepoint at the next bytecode dispatch.

   519 

   520     // If the receiver is null then it is OK to jump to the slow path.

   521     __ ld(R3_RET, Interpreter::stackElementSize, R15_esp); // get receiver

   522 

   523     // Check if receiver == NULL and go the slow path.

   524     __ cmpdi(CCR0, R3_RET, 0);

   525     __ beq(CCR0, slow_path);

   526 

   527     // Load the value of the referent field.

   528     __ load_heap_oop(R3_RET, referent_offset, R3_RET);

   529 

   530     // Generate the G1 pre-barrier code to log the value of

   531     // the referent field in an SATB buffer. Note with

   532     // these parameters the pre-barrier does not generate

   533     // the load of the previous value.

   534 

   535     // Restore caller sp for c2i case.

   536 #ifdef ASSERT

   537       __ ld(R9_ARG7, 0, R1_SP);

   538       __ ld(R10_ARG8, 0, R21_sender_SP);

   539       __ cmpd(CCR0, R9_ARG7, R10_ARG8);

   540       __ asm_assert_eq("backlink", 0x544);

   541 #endif // ASSERT

   542     __ mr(R1_SP, R21_sender_SP); // Cut the stack back to where the caller started.

   543 

   544     __ g1_write_barrier_pre(noreg,         // obj

   545                             noreg,         // offset

   546                             R3_RET,        // pre_val

   547                             R11_scratch1,  // tmp

   548                             R12_scratch2,  // tmp

   549                             true);         // needs_frame

   550 

   551     __ blr();

   552 

   553     // Generate regular method entry.

   554     __ bind(slow_path);

   555     __ jump_to_entry(Interpreter::entry_for_kind(Interpreter::zerolocals), R11_scratch1);

   556     return entry;

   557   }

   558 

   559   return NULL;

   560 }

   561 

   562 address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {

   563   address entry = __ pc();

   564 

   565   // Expression stack must be empty before entering the VM if an

   566   // exception happened.

   567   __ empty_expression_stack();

   568   // Throw exception.

   569   __ call_VM(noreg,

   570              CAST_FROM_FN_PTR(address,

   571                               InterpreterRuntime::throw_StackOverflowError));

   572   return entry;

   573 }

   574 

   575 address TemplateInterpreterGenerator::generate_ArrayIndexOutOfBounds_handler(const char* name) {

   576   address entry = __ pc();

   577   __ empty_expression_stack();

   578   __ load_const_optimized(R4_ARG2, (address) name);

   579   // Index is in R17_tos.

   580   __ mr(R5_ARG3, R17_tos);

   581   __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ArrayIndexOutOfBoundsException));

   582   return entry;

   583 }

   584 

   585 #if 0

   586 // Call special ClassCastException constructor taking object to cast

   587 // and target class as arguments.

   588 address TemplateInterpreterGenerator::generate_ClassCastException_verbose_handler() {

   589   address entry = __ pc();

   590 

   591   // Expression stack must be empty before entering the VM if an

   592   // exception happened.

   593   __ empty_expression_stack();

   594 

   595   // Thread will be loaded to R3_ARG1.

   596   // Target class oop is in register R5_ARG3 by convention!

   597   __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ClassCastException_verbose), R17_tos, R5_ARG3);

   598   // Above call must not return here since exception pending.

   599   DEBUG_ONLY(__ should_not_reach_here();)

   600   return entry;

   601 }

   602 #endif

   603 

   604 address TemplateInterpreterGenerator::generate_ClassCastException_handler() {

   605   address entry = __ pc();

   606   // Expression stack must be empty before entering the VM if an

   607   // exception happened.

   608   __ empty_expression_stack();

   609 

   610   // Load exception object.

   611   // Thread will be loaded to R3_ARG1.

   612   __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ClassCastException), R17_tos);

   613 #ifdef ASSERT

   614   // Above call must not return here since exception pending.

   615   __ should_not_reach_here();

   616 #endif

   617   return entry;

   618 }

   619 

   620 address TemplateInterpreterGenerator::generate_exception_handler_common(const char* name, const char* message, bool pass_oop) {

   621   address entry = __ pc();

   622   //__ untested("generate_exception_handler_common");

   623   Register Rexception = R17_tos;

   624 

   625   // Expression stack must be empty before entering the VM if an exception happened.

   626   __ empty_expression_stack();

   627 

   628   __ load_const_optimized(R4_ARG2, (address) name, R11_scratch1);

   629   if (pass_oop) {

   630     __ mr(R5_ARG3, Rexception);

   631     __ call_VM(Rexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_klass_exception), false);

   632   } else {

   633     __ load_const_optimized(R5_ARG3, (address) message, R11_scratch1);

   634     __ call_VM(Rexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), false);

   635   }

   636 

   637   // Throw exception.

   638   __ mr(R3_ARG1, Rexception);

   639   __ load_const_optimized(R11_scratch1, Interpreter::throw_exception_entry(), R12_scratch2);

   640   __ mtctr(R11_scratch1);

   641   __ bctr();

   642 

   643   return entry;

   644 }

   645 

   646 // This entry is returned to when a call returns to the interpreter.

   647 // When we arrive here, we expect that the callee stack frame is already popped.

   648 address TemplateInterpreterGenerator::generate_return_entry_for(TosState state, int step, size_t index_size) {

   649   address entry = __ pc();

   650 

   651   // Move the value out of the return register back to the TOS cache of current frame.

   652   switch (state) {

   653     case ltos:

   654     case btos:

   655     case ztos:

   656     case ctos:

   657     case stos:

   658     case atos:

   659     case itos: __ mr(R17_tos, R3_RET); break;   // RET -> TOS cache

   660     case ftos:

   661     case dtos: __ fmr(F15_ftos, F1_RET); break; // TOS cache -> GR_FRET

   662     case vtos: break;                           // Nothing to do, this was a void return.

   663     default  : ShouldNotReachHere();

   664   }

   665 

   666   __ restore_interpreter_state(R11_scratch1); // Sets R11_scratch1 = fp.

   667   __ ld(R12_scratch2, _ijava_state_neg(top_frame_sp), R11_scratch1);

   668   __ resize_frame_absolute(R12_scratch2, R11_scratch1, R0);

   669 

   670   // Compiled code destroys templateTableBase, reload.

   671   __ load_const_optimized(R25_templateTableBase, (address)Interpreter::dispatch_table((TosState)0), R12_scratch2);

   672 

   673   if (state == atos) {

   674     __ profile_return_type(R3_RET, R11_scratch1, R12_scratch2);

   675   }

   676 

   677   const Register cache = R11_scratch1;

   678   const Register size  = R12_scratch2;

   679   __ get_cache_and_index_at_bcp(cache, 1, index_size);

   680 

   681   // Get least significant byte of 64 bit value:

   682 #if defined(VM_LITTLE_ENDIAN)

   683   __ lbz(size, in_bytes(ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset()), cache);

   684 #else

   685   __ lbz(size, in_bytes(ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset()) + 7, cache);

   686 #endif

   687   __ sldi(size, size, Interpreter::logStackElementSize);

   688   __ add(R15_esp, R15_esp, size);

   689 

   690  __ check_and_handle_popframe(R11_scratch1);

   691  __ check_and_handle_earlyret(R11_scratch1);

   692 

   693   __ dispatch_next(state, step);

   694   return entry;

   695 }

   696 

   697 address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state, int step) {

   698   address entry = __ pc();

   699   // If state != vtos, we're returning from a native method, which put it's result

   700   // into the result register. So move the value out of the return register back

   701   // to the TOS cache of current frame.

   702 

   703   switch (state) {

   704     case ltos:

   705     case btos:

   706     case ztos:

   707     case ctos:

   708     case stos:

   709     case atos:

   710     case itos: __ mr(R17_tos, R3_RET); break;   // GR_RET -> TOS cache

   711     case ftos:

   712     case dtos: __ fmr(F15_ftos, F1_RET); break; // TOS cache -> GR_FRET

   713     case vtos: break;                           // Nothing to do, this was a void return.

   714     default  : ShouldNotReachHere();

   715   }

   716 

   717   // Load LcpoolCache @@@ should be already set!

   718   __ get_constant_pool_cache(R27_constPoolCache);

   719 

   720   // Handle a pending exception, fall through if none.

   721   __ check_and_forward_exception(R11_scratch1, R12_scratch2);

   722 

   723   // Start executing bytecodes.

   724   __ dispatch_next(state, step);

   725 

   726   return entry;

   727 }

   728 

   729 address TemplateInterpreterGenerator::generate_safept_entry_for(TosState state, address runtime_entry) {

   730   address entry = __ pc();

   731 

   732   __ push(state);

   733   __ call_VM(noreg, runtime_entry);

   734   __ dispatch_via(vtos, Interpreter::_normal_table.table_for(vtos));

   735 

   736   return entry;

   737 }

   738 

   739 // Helpers for commoning out cases in the various type of method entries.

   740 

   741 // Increment invocation count & check for overflow.

   742 //

   743 // Note: checking for negative value instead of overflow

   744 //       so we have a 'sticky' overflow test.

   745 //

   746 void TemplateInterpreterGenerator::generate_counter_incr(Label* overflow, Label* profile_method, Label* profile_method_continue) {

   747   // Note: In tiered we increment either counters in method or in MDO depending if we're profiling or not.

   748   Register Rscratch1   = R11_scratch1;

   749   Register Rscratch2   = R12_scratch2;

   750   Register R3_counters = R3_ARG1;

   751   Label done;

   752 

   753   if (TieredCompilation) {

   754     const int increment = InvocationCounter::count_increment;

   755     Label no_mdo;

   756     if (ProfileInterpreter) {

   757       const Register Rmdo = R3_counters;

   758       // If no method data exists, go to profile_continue.

   759       __ ld(Rmdo, in_bytes(Method::method_data_offset()), R19_method);

   760       __ cmpdi(CCR0, Rmdo, 0);

   761       __ beq(CCR0, no_mdo);

   762 

   763       // Increment invocation counter in the MDO.

   764       const int mdo_ic_offs = in_bytes(MethodData::invocation_counter_offset()) + in_bytes(InvocationCounter::counter_offset());

   765       __ lwz(Rscratch2, mdo_ic_offs, Rmdo);

   766       __ lwz(Rscratch1, in_bytes(MethodData::invoke_mask_offset()), Rmdo);

   767       __ addi(Rscratch2, Rscratch2, increment);

   768       __ stw(Rscratch2, mdo_ic_offs, Rmdo);

   769       __ and_(Rscratch1, Rscratch2, Rscratch1);

   770       __ bne(CCR0, done);

   771       __ b(*overflow);

   772     }

   773 

   774     // Increment counter in MethodCounters*.

   775     const int mo_ic_offs = in_bytes(MethodCounters::invocation_counter_offset()) + in_bytes(InvocationCounter::counter_offset());

   776     __ bind(no_mdo);

   777     __ get_method_counters(R19_method, R3_counters, done);

   778     __ lwz(Rscratch2, mo_ic_offs, R3_counters);

   779     __ lwz(Rscratch1, in_bytes(MethodCounters::invoke_mask_offset()), R3_counters);

   780     __ addi(Rscratch2, Rscratch2, increment);

   781     __ stw(Rscratch2, mo_ic_offs, R3_counters);

   782     __ and_(Rscratch1, Rscratch2, Rscratch1);

   783     __ beq(CCR0, *overflow);

   784 

   785     __ bind(done);

   786 

   787   } else {

   788 

   789     // Update standard invocation counters.

   790     Register Rsum_ivc_bec = R4_ARG2;

   791     __ get_method_counters(R19_method, R3_counters, done);

   792     __ increment_invocation_counter(R3_counters, Rsum_ivc_bec, R12_scratch2);

   793     // Increment interpreter invocation counter.

   794     if (ProfileInterpreter) {  // %%% Merge this into methodDataOop.

   795       __ lwz(R12_scratch2, in_bytes(MethodCounters::interpreter_invocation_counter_offset()), R3_counters);

   796       __ addi(R12_scratch2, R12_scratch2, 1);

   797       __ stw(R12_scratch2, in_bytes(MethodCounters::interpreter_invocation_counter_offset()), R3_counters);

   798     }

   799     // Check if we must create a method data obj.

   800     if (ProfileInterpreter && profile_method != NULL) {

   801       const Register profile_limit = Rscratch1;

   802       __ lwz(profile_limit, in_bytes(MethodCounters::interpreter_profile_limit_offset()), R3_counters);

   803       // Test to see if we should create a method data oop.

   804       __ cmpw(CCR0, Rsum_ivc_bec, profile_limit);

   805       __ blt(CCR0, *profile_method_continue);

   806       // If no method data exists, go to profile_method.

   807       __ test_method_data_pointer(*profile_method);

   808     }

   809     // Finally check for counter overflow.

   810     if (overflow) {

   811       const Register invocation_limit = Rscratch1;

   812       __ lwz(invocation_limit, in_bytes(MethodCounters::interpreter_invocation_limit_offset()), R3_counters);

   813       __ cmpw(CCR0, Rsum_ivc_bec, invocation_limit);

   814       __ bge(CCR0, *overflow);

   815     }

   816 

   817     __ bind(done);

   818   }

   819 }

   820 

   821 // Generate code to initiate compilation on invocation counter overflow.

   822 void TemplateInterpreterGenerator::generate_counter_overflow(Label& continue_entry) {

   823   // Generate code to initiate compilation on the counter overflow.

   824 

   825   // InterpreterRuntime::frequency_counter_overflow takes one arguments,

   826   // which indicates if the counter overflow occurs at a backwards branch (NULL bcp)

   827   // We pass zero in.

   828   // The call returns the address of the verified entry point for the method or NULL

   829   // if the compilation did not complete (either went background or bailed out).

   830   //

   831   // Unlike the C++ interpreter above: Check exceptions!

   832   // Assumption: Caller must set the flag "do_not_unlock_if_sychronized" if the monitor of a sync'ed

   833   // method has not yet been created. Thus, no unlocking of a non-existing monitor can occur.

   834 

   835   __ li(R4_ARG2, 0);

   836   __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow), R4_ARG2, true);

   837 

   838   // Returns verified_entry_point or NULL.

   839   // We ignore it in any case.

   840   __ b(continue_entry);

   841 }

   842 

   843 // See if we've got enough room on the stack for locals plus overhead below

   844 // JavaThread::stack_overflow_limit(). If not, throw a StackOverflowError

   845 // without going through the signal handler, i.e., reserved and yellow zones

   846 // will not be made usable. The shadow zone must suffice to handle the

   847 // overflow.

   848 //

   849 // Kills Rmem_frame_size, Rscratch1.

   850 void TemplateInterpreterGenerator::generate_stack_overflow_check(Register Rmem_frame_size, Register Rscratch1) {

   851   Label done;

   852   assert_different_registers(Rmem_frame_size, Rscratch1);

   853 

   854   BLOCK_COMMENT("stack_overflow_check_with_compare {");

   855   __ sub(Rmem_frame_size, R1_SP, Rmem_frame_size);

   856   __ ld(Rscratch1, thread_(stack_overflow_limit));

   857   __ cmpld(CCR0/*is_stack_overflow*/, Rmem_frame_size, Rscratch1);

   858   __ bgt(CCR0/*is_stack_overflow*/, done);

   859 

   860   // The stack overflows. Load target address of the runtime stub and call it.

   861   assert(StubRoutines::throw_StackOverflowError_entry() != NULL, "generated in wrong order");

   862   __ load_const_optimized(Rscratch1, (StubRoutines::throw_StackOverflowError_entry()), R0);

   863   __ mtctr(Rscratch1);

   864   // Restore caller_sp.

   865 #ifdef ASSERT

   866   __ ld(Rscratch1, 0, R1_SP);

   867   __ ld(R0, 0, R21_sender_SP);

   868   __ cmpd(CCR0, R0, Rscratch1);

   869   __ asm_assert_eq("backlink", 0x547);

   870 #endif // ASSERT

   871   __ mr(R1_SP, R21_sender_SP);

   872   __ bctr();

   873 

   874   __ align(32, 12);

   875   __ bind(done);

   876   BLOCK_COMMENT("} stack_overflow_check_with_compare");

   877 }

   878 

   879 // Lock the current method, interpreter register window must be set up!

   880 void TemplateInterpreterGenerator::lock_method(Register Rflags, Register Rscratch1, Register Rscratch2, bool flags_preloaded) {

   881   const Register Robj_to_lock = Rscratch2;

   882 

   883   {

   884     if (!flags_preloaded) {

   885       __ lwz(Rflags, method_(access_flags));

   886     }

   887 

   888 #ifdef ASSERT

   889     // Check if methods needs synchronization.

   890     {

   891       Label Lok;

   892       __ testbitdi(CCR0, R0, Rflags, JVM_ACC_SYNCHRONIZED_BIT);

   893       __ btrue(CCR0,Lok);

   894       __ stop("method doesn't need synchronization");

   895       __ bind(Lok);

   896     }

   897 #endif // ASSERT

   898   }

   899 

   900   // Get synchronization object to Rscratch2.

   901   {

   902     Label Lstatic;

   903     Label Ldone;

   904 

   905     __ testbitdi(CCR0, R0, Rflags, JVM_ACC_STATIC_BIT);

   906     __ btrue(CCR0, Lstatic);

   907 

   908     // Non-static case: load receiver obj from stack and we're done.

   909     __ ld(Robj_to_lock, R18_locals);

   910     __ b(Ldone);

   911 

   912     __ bind(Lstatic); // Static case: Lock the java mirror

   913     // Load mirror from interpreter frame.

   914     __ ld(Robj_to_lock, _abi(callers_sp), R1_SP);

   915     __ ld(Robj_to_lock, _ijava_state_neg(mirror), Robj_to_lock);

   916 

   917     __ bind(Ldone);

   918     __ verify_oop(Robj_to_lock);

   919   }

   920 

   921   // Got the oop to lock => execute!

   922   __ add_monitor_to_stack(true, Rscratch1, R0);

   923 

   924   __ std(Robj_to_lock, BasicObjectLock::obj_offset_in_bytes(), R26_monitor);

   925   __ lock_object(R26_monitor, Robj_to_lock);

   926 }

   927 

   928 // Generate a fixed interpreter frame for pure interpreter

   929 // and I2N native transition frames.

   930 //

   931 // Before (stack grows downwards):

   932 //

   933 //         |  ...         |

   934 //         |------------- |

   935 //         |  java arg0   |

   936 //         |  ...         |

   937 //         |  java argn   |

   938 //         |              |   <-   R15_esp

   939 //         |              |

   940 //         |--------------|

   941 //         | abi_112      |

   942 //         |              |   <-   R1_SP

   943 //         |==============|

   944 //

   945 //

   946 // After:

   947 //

   948 //         |  ...         |

   949 //         |  java arg0   |<-   R18_locals

   950 //         |  ...         |

   951 //         |  java argn   |

   952 //         |--------------|

   953 //         |              |

   954 //         |  java locals |

   955 //         |              |

   956 //         |--------------|

   957 //         |  abi_48      |

   958 //         |==============|

   959 //         |              |

   960 //         |   istate     |

   961 //         |              |

   962 //         |--------------|

   963 //         |   monitor    |<-   R26_monitor

   964 //         |--------------|

   965 //         |              |<-   R15_esp

   966 //         | expression   |

   967 //         | stack        |

   968 //         |              |

   969 //         |--------------|

   970 //         |              |

   971 //         | abi_112      |<-   R1_SP

   972 //         |==============|

   973 //

   974 // The top most frame needs an abi space of 112 bytes. This space is needed,

   975 // since we call to c. The c function may spill their arguments to the caller

   976 // frame. When we call to java, we don't need these spill slots. In order to save

   977 // space on the stack, we resize the caller. However, java locals reside in

   978 // the caller frame and the frame has to be increased. The frame_size for the

   979 // current frame was calculated based on max_stack as size for the expression

   980 // stack. At the call, just a part of the expression stack might be used.

   981 // We don't want to waste this space and cut the frame back accordingly.

   982 // The resulting amount for resizing is calculated as follows:

   983 // resize =   (number_of_locals - number_of_arguments) * slot_size

   984 //          + (R1_SP - R15_esp) + 48

   985 //

   986 // The size for the callee frame is calculated:

   987 // framesize = 112 + max_stack + monitor + state_size

   988 //

   989 // maxstack:   Max number of slots on the expression stack, loaded from the method.

   990 // monitor:    We statically reserve room for one monitor object.

   991 // state_size: We save the current state of the interpreter to this area.

   992 //

   993 void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call, Register Rsize_of_parameters, Register Rsize_of_locals) {

   994   Register parent_frame_resize = R6_ARG4, // Frame will grow by this number of bytes.

   995            top_frame_size      = R7_ARG5,

   996            Rconst_method       = R8_ARG6;

   997 

   998   assert_different_registers(Rsize_of_parameters, Rsize_of_locals, parent_frame_resize, top_frame_size);

   999 

  1000   __ ld(Rconst_method, method_(const));

  1001   __ lhz(Rsize_of_parameters /* number of params */,

  1002          in_bytes(ConstMethod::size_of_parameters_offset()), Rconst_method);

  1003   if (native_call) {

  1004     // If we're calling a native method, we reserve space for the worst-case signature

  1005     // handler varargs vector, which is max(Argument::n_register_parameters, parameter_count+2).

  1006     // We add two slots to the parameter_count, one for the jni

  1007     // environment and one for a possible native mirror.

  1008     Label skip_native_calculate_max_stack;

  1009     __ addi(top_frame_size, Rsize_of_parameters, 2);

  1010     __ cmpwi(CCR0, top_frame_size, Argument::n_register_parameters);

  1011     __ bge(CCR0, skip_native_calculate_max_stack);

  1012     __ li(top_frame_size, Argument::n_register_parameters);

  1013     __ bind(skip_native_calculate_max_stack);

  1014     __ sldi(Rsize_of_parameters, Rsize_of_parameters, Interpreter::logStackElementSize);

  1015     __ sldi(top_frame_size, top_frame_size, Interpreter::logStackElementSize);

  1016     __ sub(parent_frame_resize, R1_SP, R15_esp); // <0, off by Interpreter::stackElementSize!

  1017     assert(Rsize_of_locals == noreg, "Rsize_of_locals not initialized"); // Only relevant value is Rsize_of_parameters.

  1018   } else {

  1019     __ lhz(Rsize_of_locals /* number of params */, in_bytes(ConstMethod::size_of_locals_offset()), Rconst_method);

  1020     __ sldi(Rsize_of_parameters, Rsize_of_parameters, Interpreter::logStackElementSize);

  1021     __ sldi(Rsize_of_locals, Rsize_of_locals, Interpreter::logStackElementSize);

  1022     __ lhz(top_frame_size, in_bytes(ConstMethod::max_stack_offset()), Rconst_method);

  1023     __ sub(R11_scratch1, Rsize_of_locals, Rsize_of_parameters); // >=0

  1024     __ sub(parent_frame_resize, R1_SP, R15_esp); // <0, off by Interpreter::stackElementSize!

  1025     __ sldi(top_frame_size, top_frame_size, Interpreter::logStackElementSize);

  1026     __ add(parent_frame_resize, parent_frame_resize, R11_scratch1);

  1027   }

  1028 

  1029   // Compute top frame size.

  1030   __ addi(top_frame_size, top_frame_size, frame::abi_reg_args_size + frame::ijava_state_size);

  1031 

  1032   // Cut back area between esp and max_stack.

  1033   __ addi(parent_frame_resize, parent_frame_resize, frame::abi_minframe_size - Interpreter::stackElementSize);

  1034 

  1035   __ round_to(top_frame_size, frame::alignment_in_bytes);

  1036   __ round_to(parent_frame_resize, frame::alignment_in_bytes);

  1037   // parent_frame_resize = (locals-parameters) - (ESP-SP-ABI48) Rounded to frame alignment size.

  1038   // Enlarge by locals-parameters (not in case of native_call), shrink by ESP-SP-ABI48.

  1039 

  1040   if (!native_call) {

  1041     // Stack overflow check.

  1042     // Native calls don't need the stack size check since they have no

  1043     // expression stack and the arguments are already on the stack and

  1044     // we only add a handful of words to the stack.

  1045     __ add(R11_scratch1, parent_frame_resize, top_frame_size);

  1046     generate_stack_overflow_check(R11_scratch1, R12_scratch2);

  1047   }

  1048 

  1049   // Set up interpreter state registers.

  1050 

  1051   __ add(R18_locals, R15_esp, Rsize_of_parameters);

  1052   __ ld(R27_constPoolCache, in_bytes(ConstMethod::constants_offset()), Rconst_method);

  1053   __ ld(R27_constPoolCache, ConstantPool::cache_offset_in_bytes(), R27_constPoolCache);

  1054 

  1055   // Set method data pointer.

  1056   if (ProfileInterpreter) {

  1057     Label zero_continue;

  1058     __ ld(R28_mdx, method_(method_data));

  1059     __ cmpdi(CCR0, R28_mdx, 0);

  1060     __ beq(CCR0, zero_continue);

  1061     __ addi(R28_mdx, R28_mdx, in_bytes(MethodData::data_offset()));

  1062     __ bind(zero_continue);

  1063   }

  1064 

  1065   if (native_call) {

  1066     __ li(R14_bcp, 0); // Must initialize.

  1067   } else {

  1068     __ add(R14_bcp, in_bytes(ConstMethod::codes_offset()), Rconst_method);

  1069   }

  1070 

  1071   // Resize parent frame.

  1072   __ mflr(R12_scratch2);

  1073   __ neg(parent_frame_resize, parent_frame_resize);

  1074   __ resize_frame(parent_frame_resize, R11_scratch1);

  1075   __ std(R12_scratch2, _abi(lr), R1_SP);

  1076 

  1077   // Get mirror and store it in the frame as GC root for this Method*.

  1078   __ load_mirror_from_const_method(R12_scratch2, Rconst_method);

  1079 

  1080   __ addi(R26_monitor, R1_SP, - frame::ijava_state_size);

  1081   __ addi(R15_esp, R26_monitor, - Interpreter::stackElementSize);

  1082 

  1083   // Store values.

  1084   // R15_esp, R14_bcp, R26_monitor, R28_mdx are saved at java calls

  1085   // in InterpreterMacroAssembler::call_from_interpreter.

  1086   __ std(R19_method, _ijava_state_neg(method), R1_SP);

  1087   __ std(R12_scratch2, _ijava_state_neg(mirror), R1_SP);

  1088   __ std(R21_sender_SP, _ijava_state_neg(sender_sp), R1_SP);

  1089   __ std(R27_constPoolCache, _ijava_state_neg(cpoolCache), R1_SP);

  1090   __ std(R18_locals, _ijava_state_neg(locals), R1_SP);

  1091 

  1092   // Note: esp, bcp, monitor, mdx live in registers. Hence, the correct version can only

  1093   // be found in the frame after save_interpreter_state is done. This is always true

  1094   // for non-top frames. But when a signal occurs, dumping the top frame can go wrong,

  1095   // because e.g. frame::interpreter_frame_bcp() will not access the correct value

  1096   // (Enhanced Stack Trace).

  1097   // The signal handler does not save the interpreter state into the frame.

  1098   __ li(R0, 0);

  1099 #ifdef ASSERT

  1100   // Fill remaining slots with constants.

  1101   __ load_const_optimized(R11_scratch1, 0x5afe);

  1102   __ load_const_optimized(R12_scratch2, 0xdead);

  1103 #endif

  1104   // We have to initialize some frame slots for native calls (accessed by GC).

  1105   if (native_call) {

  1106     __ std(R26_monitor, _ijava_state_neg(monitors), R1_SP);

  1107     __ std(R14_bcp, _ijava_state_neg(bcp), R1_SP);

  1108     if (ProfileInterpreter) { __ std(R28_mdx, _ijava_state_neg(mdx), R1_SP); }

  1109   }

  1110 #ifdef ASSERT

  1111   else {

  1112     __ std(R12_scratch2, _ijava_state_neg(monitors), R1_SP);

  1113     __ std(R12_scratch2, _ijava_state_neg(bcp), R1_SP);

  1114     __ std(R12_scratch2, _ijava_state_neg(mdx), R1_SP);

  1115   }

  1116   __ std(R11_scratch1, _ijava_state_neg(ijava_reserved), R1_SP);

  1117   __ std(R12_scratch2, _ijava_state_neg(esp), R1_SP);

  1118   __ std(R12_scratch2, _ijava_state_neg(lresult), R1_SP);

  1119   __ std(R12_scratch2, _ijava_state_neg(fresult), R1_SP);

  1120 #endif

  1121   __ subf(R12_scratch2, top_frame_size, R1_SP);

  1122   __ std(R0, _ijava_state_neg(oop_tmp), R1_SP);

  1123   __ std(R12_scratch2, _ijava_state_neg(top_frame_sp), R1_SP);

  1124 

  1125   // Push top frame.

  1126   __ push_frame(top_frame_size, R11_scratch1);

  1127 }

  1128 

  1129 // End of helpers

  1130 

  1131 address TemplateInterpreterGenerator::generate_math_entry(AbstractInterpreter::MethodKind kind) {

  1132 

  1133   // Decide what to do: Use same platform specific instructions and runtime calls as compilers.

  1134   bool use_instruction = false;