1 /*

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

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

     4  *

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

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

     7  * published by the Free Software Foundation.

     8  *

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

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

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

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

    13  * accompanied this code).

    14  *

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

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

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

    18  *

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

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

    21  * questions.

    22  *

    23  */

    24 

    25 #include "precompiled.hpp"

    26 #include "asm/macroAssembler.hpp"

    27 #include "interpreter/bytecodeHistogram.hpp"

    28 #include "interpreter/interpreter.hpp"

    29 #include "interpreter/interpreterGenerator.hpp"

    30 #include "interpreter/interpreterRuntime.hpp"

    31 #include "interpreter/interp_masm.hpp"

    32 #include "interpreter/templateTable.hpp"

    33 #include "oops/arrayOop.hpp"

    34 #include "oops/methodData.hpp"

    35 #include "oops/method.hpp"

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

    37 #include "prims/jvmtiExport.hpp"

    38 #include "prims/jvmtiThreadState.hpp"

    39 #include "runtime/arguments.hpp"

    40 #include "runtime/deoptimization.hpp"

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

    42 #include "runtime/sharedRuntime.hpp"

    43 #include "runtime/stubRoutines.hpp"

    44 #include "runtime/synchronizer.hpp"

    45 #include "runtime/timer.hpp"

    46 #include "runtime/vframeArray.hpp"

    47 #include "utilities/debug.hpp"

    48 #include "utilities/macros.hpp"

    49 

    50 #ifndef CC_INTERP

    51 #ifndef FAST_DISPATCH

    52 #define FAST_DISPATCH 1

    53 #endif

    54 #undef FAST_DISPATCH

    55 

    56 

    57 // Generation of Interpreter

    58 //

    59 // The InterpreterGenerator generates the interpreter into Interpreter::_code.

    60 

    61 

    62 #define __ _masm->

    63 

    64 

    65 //----------------------------------------------------------------------------------------------------

    66 

    67 

    68 void InterpreterGenerator::save_native_result(void) {

    69   // result potentially in O0/O1: save it across calls

    70   const Address& l_tmp = InterpreterMacroAssembler::l_tmp;

    71 

    72   // result potentially in F0/F1: save it across calls

    73   const Address& d_tmp = InterpreterMacroAssembler::d_tmp;

    74 

    75   // save and restore any potential method result value around the unlocking operation

    76   __ stf(FloatRegisterImpl::D, F0, d_tmp);

    77 #ifdef _LP64

    78   __ stx(O0, l_tmp);

    79 #else

    80   __ std(O0, l_tmp);

    81 #endif

    82 }

    83 

    84 void InterpreterGenerator::restore_native_result(void) {

    85   const Address& l_tmp = InterpreterMacroAssembler::l_tmp;

    86   const Address& d_tmp = InterpreterMacroAssembler::d_tmp;

    87 

    88   // Restore any method result value

    89   __ ldf(FloatRegisterImpl::D, d_tmp, F0);

    90 #ifdef _LP64

    91   __ ldx(l_tmp, O0);

    92 #else

    93   __ ldd(l_tmp, O0);

    94 #endif

    95 }

    96 

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

    98   assert(!pass_oop || message == NULL, "either oop or message but not both");

    99   address entry = __ pc();

   100   // expression stack must be empty before entering the VM if an exception happened

   101   __ empty_expression_stack();

   102   // load exception object

   103   __ set((intptr_t)name, G3_scratch);

   104   if (pass_oop) {

   105     __ call_VM(Oexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_klass_exception), G3_scratch, Otos_i);

   106   } else {

   107     __ set((intptr_t)message, G4_scratch);

   108     __ call_VM(Oexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), G3_scratch, G4_scratch);

   109   }

   110   // throw exception

   111   assert(Interpreter::throw_exception_entry() != NULL, "generate it first");

   112   AddressLiteral thrower(Interpreter::throw_exception_entry());

   113   __ jump_to(thrower, G3_scratch);

   114   __ delayed()->nop();

   115   return entry;

   116 }

   117 

   118 address TemplateInterpreterGenerator::generate_ClassCastException_handler() {

   119   address entry = __ pc();

   120   // expression stack must be empty before entering the VM if an exception

   121   // happened

   122   __ empty_expression_stack();

   123   // load exception object

   124   __ call_VM(Oexception,

   125              CAST_FROM_FN_PTR(address,

   126                               InterpreterRuntime::throw_ClassCastException),

   127              Otos_i);

   128   __ should_not_reach_here();

   129   return entry;

   130 }

   131 

   132 

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

   134   address entry = __ pc();

   135   // expression stack must be empty before entering the VM if an exception happened

   136   __ empty_expression_stack();

   137   // convention: expect aberrant index in register G3_scratch, then shuffle the

   138   // index to G4_scratch for the VM call

   139   __ mov(G3_scratch, G4_scratch);

   140   __ set((intptr_t)name, G3_scratch);

   141   __ call_VM(Oexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ArrayIndexOutOfBoundsException), G3_scratch, G4_scratch);

   142   __ should_not_reach_here();

   143   return entry;

   144 }

   145 

   146 

   147 address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {

   148   address entry = __ pc();

   149   // expression stack must be empty before entering the VM if an exception happened

   150   __ empty_expression_stack();

   151   __ call_VM(Oexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_StackOverflowError));

   152   __ should_not_reach_here();

   153   return entry;

   154 }

   155 

   156 

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

   158   address entry = __ pc();

   159 

   160   if (state == atos) {

   161     __ profile_return_type(O0, G3_scratch, G1_scratch);

   162   }

   163 

   164 #if !defined(_LP64) && defined(COMPILER2)

   165   // All return values are where we want them, except for Longs.  C2 returns

   166   // longs in G1 in the 32-bit build whereas the interpreter wants them in O0/O1.

   167   // Since the interpreter will return longs in G1 and O0/O1 in the 32bit

   168   // build even if we are returning from interpreted we just do a little

   169   // stupid shuffing.

   170   // Note: I tried to make c2 return longs in O0/O1 and G1 so we wouldn't have to

   171   // do this here. Unfortunately if we did a rethrow we'd see an machepilog node

   172   // first which would move g1 -> O0/O1 and destroy the exception we were throwing.

   173 

   174   if (state == ltos) {

   175     __ srl (G1,  0, O1);

   176     __ srlx(G1, 32, O0);

   177   }

   178 #endif // !_LP64 && COMPILER2

   179 

   180   // The callee returns with the stack possibly adjusted by adapter transition

   181   // We remove that possible adjustment here.

   182   // All interpreter local registers are untouched. Any result is passed back

   183   // in the O0/O1 or float registers. Before continuing, the arguments must be

   184   // popped from the java expression stack; i.e., Lesp must be adjusted.

   185 

   186   __ mov(Llast_SP, SP);   // Remove any adapter added stack space.

   187 

   188   const Register cache = G3_scratch;

   189   const Register index  = G1_scratch;

   190   __ get_cache_and_index_at_bcp(cache, index, 1, index_size);

   191 

   192   const Register flags = cache;

   193   __ ld_ptr(cache, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset(), flags);

   194   const Register parameter_size = flags;

   195   __ and3(flags, ConstantPoolCacheEntry::parameter_size_mask, parameter_size);  // argument size in words

   196   __ sll(parameter_size, Interpreter::logStackElementSize, parameter_size);     // each argument size in bytes

   197   __ add(Lesp, parameter_size, Lesp);                                           // pop arguments

   198   __ dispatch_next(state, step);

   199 

   200   return entry;

   201 }

   202 

   203 

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

   205   address entry = __ pc();

   206   __ get_constant_pool_cache(LcpoolCache); // load LcpoolCache

   207 #if INCLUDE_JVMCI

   208   // Check if we need to take lock at entry of synchronized method.

   209   if (UseJVMCICompiler) {

   210     Label L;

   211     Address pending_monitor_enter_addr(G2_thread, JavaThread::pending_monitorenter_offset());

   212     __ ldbool(pending_monitor_enter_addr, Gtemp);  // Load if pending monitor enter

   213     __ cmp_and_br_short(Gtemp, G0, Assembler::equal, Assembler::pn, L);

   214     // Clear flag.

   215     __ stbool(G0, pending_monitor_enter_addr);

   216     // Take lock.

   217     lock_method();

   218     __ bind(L);

   219   }

   220 #endif

   221   { Label L;

   222     Address exception_addr(G2_thread, Thread::pending_exception_offset());

   223     __ ld_ptr(exception_addr, Gtemp);  // Load pending exception.

   224     __ br_null_short(Gtemp, Assembler::pt, L);

   225     __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_pending_exception));

   226     __ should_not_reach_here();

   227     __ bind(L);

   228   }

   229   __ dispatch_next(state, step);

   230   return entry;

   231 }

   232 

   233 // A result handler converts/unboxes a native call result into

   234 // a java interpreter/compiler result. The current frame is an

   235 // interpreter frame. The activation frame unwind code must be

   236 // consistent with that of TemplateTable::_return(...). In the

   237 // case of native methods, the caller's SP was not modified.

   238 address TemplateInterpreterGenerator::generate_result_handler_for(BasicType type) {

   239   address entry = __ pc();

   240   Register Itos_i  = Otos_i ->after_save();

   241   Register Itos_l  = Otos_l ->after_save();

   242   Register Itos_l1 = Otos_l1->after_save();

   243   Register Itos_l2 = Otos_l2->after_save();

   244   switch (type) {

   245     case T_BOOLEAN: __ subcc(G0, O0, G0); __ addc(G0, 0, Itos_i); break; // !0 => true; 0 => false

   246     case T_CHAR   : __ sll(O0, 16, O0); __ srl(O0, 16, Itos_i);   break; // cannot use and3, 0xFFFF too big as immediate value!

   247     case T_BYTE   : __ sll(O0, 24, O0); __ sra(O0, 24, Itos_i);   break;

   248     case T_SHORT  : __ sll(O0, 16, O0); __ sra(O0, 16, Itos_i);   break;

   249     case T_LONG   :

   250 #ifndef _LP64

   251                     __ mov(O1, Itos_l2);  // move other half of long

   252 #endif              // ifdef or no ifdef, fall through to the T_INT case

   253     case T_INT    : __ mov(O0, Itos_i);                         break;

   254     case T_VOID   : /* nothing to do */                         break;

   255     case T_FLOAT  : assert(F0 == Ftos_f, "fix this code" );     break;

   256     case T_DOUBLE : assert(F0 == Ftos_d, "fix this code" );     break;

   257     case T_OBJECT :

   258       __ ld_ptr(FP, (frame::interpreter_frame_oop_temp_offset*wordSize) + STACK_BIAS, Itos_i);

   259       __ verify_oop(Itos_i);

   260       break;

   261     default       : ShouldNotReachHere();

   262   }

   263   __ ret();                           // return from interpreter activation

   264   __ delayed()->restore(I5_savedSP, G0, SP);  // remove interpreter frame

   265   NOT_PRODUCT(__ emit_int32(0);)       // marker for disassembly

   266   return entry;

   267 }

   268 

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

   270   address entry = __ pc();

   271   __ push(state);

   272   __ call_VM(noreg, runtime_entry);

   273   __ dispatch_via(vtos, Interpreter::normal_table(vtos));

   274   return entry;

   275 }

   276 

   277 

   278 address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {

   279   address entry = __ pc();

   280   __ dispatch_next(state);

   281   return entry;

   282 }

   283 

   284 //

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

   286 //

   287 

   288 // increment invocation count & check for overflow

   289 //

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

   291 //       so we have a 'sticky' overflow test

   292 //

   293 // Lmethod: method

   294 // ??: invocation counter

   295 //

   296 void InterpreterGenerator::generate_counter_incr(Label* overflow, Label* profile_method, Label* profile_method_continue) {

   297   // Note: In tiered we increment either counters in MethodCounters* or in

   298   // MDO depending if we're profiling or not.

   299   const Register G3_method_counters = G3_scratch;

   300   Label done;

   301 

   302   if (TieredCompilation) {

   303     const int increment = InvocationCounter::count_increment;

   304     Label no_mdo;

   305     if (ProfileInterpreter) {

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

   307       __ ld_ptr(Lmethod, Method::method_data_offset(), G4_scratch);

   308       __ br_null_short(G4_scratch, Assembler::pn, no_mdo);

   309       // Increment counter

   310       Address mdo_invocation_counter(G4_scratch,

   311                                      in_bytes(MethodData::invocation_counter_offset()) +

   312                                      in_bytes(InvocationCounter::counter_offset()));

   313       Address mask(G4_scratch, in_bytes(MethodData::invoke_mask_offset()));

   314       __ increment_mask_and_jump(mdo_invocation_counter, increment, mask,

   315                                  G3_scratch, Lscratch,

   316                                  Assembler::zero, overflow);

   317       __ ba_short(done);

   318     }

   319 

   320     // Increment counter in MethodCounters*

   321     __ bind(no_mdo);

   322     Address invocation_counter(G3_method_counters,

   323             in_bytes(MethodCounters::invocation_counter_offset()) +

   324             in_bytes(InvocationCounter::counter_offset()));

   325     __ get_method_counters(Lmethod, G3_method_counters, done);

   326     Address mask(G3_method_counters, in_bytes(MethodCounters::invoke_mask_offset()));

   327     __ increment_mask_and_jump(invocation_counter, increment, mask,

   328                                G4_scratch, Lscratch,

   329                                Assembler::zero, overflow);

   330     __ bind(done);

   331   } else { // not TieredCompilation

   332     // Update standard invocation counters

   333     __ get_method_counters(Lmethod, G3_method_counters, done);

   334     __ increment_invocation_counter(G3_method_counters, O0, G4_scratch);

   335     if (ProfileInterpreter) {

   336       Address interpreter_invocation_counter(G3_method_counters,

   337             in_bytes(MethodCounters::interpreter_invocation_counter_offset()));

   338       __ ld(interpreter_invocation_counter, G4_scratch);

   339       __ inc(G4_scratch);

   340       __ st(G4_scratch, interpreter_invocation_counter);

   341     }

   342 

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

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

   345       Address profile_limit(G3_method_counters, in_bytes(MethodCounters::interpreter_profile_limit_offset()));

   346       __ ld(profile_limit, G1_scratch);

   347       __ cmp_and_br_short(O0, G1_scratch, Assembler::lessUnsigned, Assembler::pn, *profile_method_continue);

   348 

   349       // if no method data exists, go to profile_method

   350       __ test_method_data_pointer(*profile_method);

   351     }

   352 

   353     Address invocation_limit(G3_method_counters, in_bytes(MethodCounters::interpreter_invocation_limit_offset()));

   354     __ ld(invocation_limit, G3_scratch);

   355     __ cmp(O0, G3_scratch);

   356     __ br(Assembler::greaterEqualUnsigned, false, Assembler::pn, *overflow); // Far distance

   357     __ delayed()->nop();

   358     __ bind(done);

   359   }

   360 

   361 }

   362 

   363 // Allocate monitor and lock method (asm interpreter)

   364 // ebx - Method*

   365 //

   366 void TemplateInterpreterGenerator::lock_method() {

   367   __ ld(Lmethod, in_bytes(Method::access_flags_offset()), O0);  // Load access flags.

   368 

   369 #ifdef ASSERT

   370  { Label ok;

   371    __ btst(JVM_ACC_SYNCHRONIZED, O0);

   372    __ br( Assembler::notZero, false, Assembler::pt, ok);

   373    __ delayed()->nop();

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

   375    __ bind(ok);

   376   }

   377 #endif // ASSERT

   378 

   379   // get synchronization object to O0

   380   { Label done;

   381     const int mirror_offset = in_bytes(Klass::java_mirror_offset());

   382     __ btst(JVM_ACC_STATIC, O0);

   383     __ br( Assembler::zero, true, Assembler::pt, done);

   384     __ delayed()->ld_ptr(Llocals, Interpreter::local_offset_in_bytes(0), O0); // get receiver for not-static case

   385 

   386     __ ld_ptr( Lmethod, in_bytes(Method::const_offset()), O0);

   387     __ ld_ptr( O0, in_bytes(ConstMethod::constants_offset()), O0);

   388     __ ld_ptr( O0, ConstantPool::pool_holder_offset_in_bytes(), O0);

   389 

   390     // lock the mirror, not the Klass*

   391     __ ld_ptr( O0, mirror_offset, O0);

   392 

   393 #ifdef ASSERT

   394     __ tst(O0);

   395     __ breakpoint_trap(Assembler::zero, Assembler::ptr_cc);

   396 #endif // ASSERT

   397 

   398     __ bind(done);

   399   }

   400 

   401   __ add_monitor_to_stack(true, noreg, noreg);  // allocate monitor elem

   402   __ st_ptr( O0, Lmonitors, BasicObjectLock::obj_offset_in_bytes());   // store object

   403   // __ untested("lock_object from method entry");

   404   __ lock_object(Lmonitors, O0);

   405 }

   406 

   407 

   408 void TemplateInterpreterGenerator::generate_stack_overflow_check(Register Rframe_size,

   409                                                          Register Rscratch,

   410                                                          Register Rscratch2) {

   411   const int page_size = os::vm_page_size();

   412   Label after_frame_check;

   413 

   414   assert_different_registers(Rframe_size, Rscratch, Rscratch2);

   415 

   416   __ set(page_size, Rscratch);

   417   __ cmp_and_br_short(Rframe_size, Rscratch, Assembler::lessEqual, Assembler::pt, after_frame_check);

   418 

   419   // get the stack base, and in debug, verify it is non-zero

   420   __ ld_ptr( G2_thread, Thread::stack_base_offset(), Rscratch );

   421 #ifdef ASSERT

   422   Label base_not_zero;

   423   __ br_notnull_short(Rscratch, Assembler::pn, base_not_zero);

   424   __ stop("stack base is zero in generate_stack_overflow_check");

   425   __ bind(base_not_zero);

   426 #endif

   427 

   428   // get the stack size, and in debug, verify it is non-zero

   429   assert( sizeof(size_t) == sizeof(intptr_t), "wrong load size" );

   430   __ ld_ptr( G2_thread, Thread::stack_size_offset(), Rscratch2 );

   431 #ifdef ASSERT

   432   Label size_not_zero;

   433   __ br_notnull_short(Rscratch2, Assembler::pn, size_not_zero);

   434   __ stop("stack size is zero in generate_stack_overflow_check");

   435   __ bind(size_not_zero);

   436 #endif

   437 

   438   // compute the beginning of the protected zone minus the requested frame size

   439   __ sub( Rscratch, Rscratch2,   Rscratch );

   440   __ set( (StackRedPages+StackYellowPages) * page_size, Rscratch2 );

   441   __ add( Rscratch, Rscratch2,   Rscratch );

   442 

   443   // Add in the size of the frame (which is the same as subtracting it from the

   444   // SP, which would take another register

   445   __ add( Rscratch, Rframe_size, Rscratch );

   446 

   447   // the frame is greater than one page in size, so check against

   448   // the bottom of the stack

   449   __ cmp_and_brx_short(SP, Rscratch, Assembler::greaterUnsigned, Assembler::pt, after_frame_check);

   450 

   451   // the stack will overflow, throw an exception

   452 

   453   // Note that SP is restored to sender's sp (in the delay slot). This

   454   // is necessary if the sender's frame is an extended compiled frame

   455   // (see gen_c2i_adapter()) and safer anyway in case of JSR292

   456   // adaptations.

   457 

   458   // Note also that the restored frame is not necessarily interpreted.

   459   // Use the shared runtime version of the StackOverflowError.

   460   assert(StubRoutines::throw_StackOverflowError_entry() != NULL, "stub not yet generated");

   461   AddressLiteral stub(StubRoutines::throw_StackOverflowError_entry());

   462   __ jump_to(stub, Rscratch);

   463   __ delayed()->mov(O5_savedSP, SP);

   464 

   465   // if you get to here, then there is enough stack space

   466   __ bind( after_frame_check );

   467 }

   468 

   469 

   470 //

   471 // Generate a fixed interpreter frame. This is identical setup for interpreted

   472 // methods and for native methods hence the shared code.

   473 

   474 

   475 //----------------------------------------------------------------------------------------------------

   476 // Stack frame layout

   477 //

   478 // When control flow reaches any of the entry types for the interpreter

   479 // the following holds ->

   480 //

   481 // C2 Calling Conventions:

   482 //

   483 // The entry code below assumes that the following registers are set

   484 // when coming in:

   485 //    G5_method: holds the Method* of the method to call

   486 //    Lesp:    points to the TOS of the callers expression stack

   487 //             after having pushed all the parameters

   488 //

   489 // The entry code does the following to setup an interpreter frame

   490 //   pop parameters from the callers stack by adjusting Lesp

   491 //   set O0 to Lesp

   492 //   compute X = (max_locals - num_parameters)

   493 //   bump SP up by X to accomadate the extra locals

   494 //   compute X = max_expression_stack

   495 //               + vm_local_words

   496 //               + 16 words of register save area

   497 //   save frame doing a save sp, -X, sp growing towards lower addresses

   498 //   set Lbcp, Lmethod, LcpoolCache

   499 //   set Llocals to i0

   500 //   set Lmonitors to FP - rounded_vm_local_words

   501 //   set Lesp to Lmonitors - 4

   502 //

   503 //  The frame has now been setup to do the rest of the entry code

   504 

   505 // Try this optimization:  Most method entries could live in a

   506 // "one size fits all" stack frame without all the dynamic size

   507 // calculations.  It might be profitable to do all this calculation

   508 // statically and approximately for "small enough" methods.

   509 

   510 //-----------------------------------------------------------------------------------------------

   511 

   512 // C1 Calling conventions

   513 //

   514 // Upon method entry, the following registers are setup:

   515 //

   516 // g2 G2_thread: current thread

   517 // g5 G5_method: method to activate

   518 // g4 Gargs  : pointer to last argument

   519 //

   520 //

   521 // Stack:

   522 //

   523 // +---------------+ <--- sp

   524 // |               |

   525 // : reg save area :

   526 // |               |

   527 // +---------------+ <--- sp + 0x40

   528 // |               |

   529 // : extra 7 slots :      note: these slots are not really needed for the interpreter (fix later)

   530 // |               |

   531 // +---------------+ <--- sp + 0x5c

   532 // |               |

   533 // :     free      :

   534 // |               |

   535 // +---------------+ <--- Gargs

   536 // |               |

   537 // :   arguments   :

   538 // |               |

   539 // +---------------+

   540 // |               |

   541 //

   542 //

   543 //

   544 // AFTER FRAME HAS BEEN SETUP for method interpretation the stack looks like:

   545 //

   546 // +---------------+ <--- sp

   547 // |               |

   548 // : reg save area :

   549 // |               |

   550 // +---------------+ <--- sp + 0x40

   551 // |               |

   552 // : extra 7 slots :      note: these slots are not really needed for the interpreter (fix later)

   553 // |               |

   554 // +---------------+ <--- sp + 0x5c

   555 // |               |

   556 // :               :

   557 // |               | <--- Lesp

   558 // +---------------+ <--- Lmonitors (fp - 0x18)

   559 // |   VM locals   |

   560 // +---------------+ <--- fp

   561 // |               |

   562 // : reg save area :

   563 // |               |

   564 // +---------------+ <--- fp + 0x40

   565 // |               |

   566 // : extra 7 slots :      note: these slots are not really needed for the interpreter (fix later)

   567 // |               |

   568 // +---------------+ <--- fp + 0x5c

   569 // |               |

   570 // :     free      :

   571 // |               |

   572 // +---------------+

   573 // |               |

   574 // : nonarg locals :

   575 // |               |

   576 // +---------------+

   577 // |               |

   578 // :   arguments   :

   579 // |               | <--- Llocals

   580 // +---------------+ <--- Gargs

   581 // |               |

   582 

   583 void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) {

   584   //

   585   //

   586   // The entry code sets up a new interpreter frame in 4 steps:

   587   //

   588   // 1) Increase caller's SP by for the extra local space needed:

   589   //    (check for overflow)

   590   //    Efficient implementation of xload/xstore bytecodes requires

   591   //    that arguments and non-argument locals are in a contigously

   592   //    addressable memory block => non-argument locals must be

   593   //    allocated in the caller's frame.

   594   //

   595   // 2) Create a new stack frame and register window:

   596   //    The new stack frame must provide space for the standard

   597   //    register save area, the maximum java expression stack size,

   598   //    the monitor slots (0 slots initially), and some frame local

   599   //    scratch locations.

   600   //

   601   // 3) The following interpreter activation registers must be setup:

   602   //    Lesp       : expression stack pointer

   603   //    Lbcp       : bytecode pointer

   604   //    Lmethod    : method

   605   //    Llocals    : locals pointer

   606   //    Lmonitors  : monitor pointer

   607   //    LcpoolCache: constant pool cache

   608   //

   609   // 4) Initialize the non-argument locals if necessary:

   610   //    Non-argument locals may need to be initialized to NULL

   611   //    for GC to work. If the oop-map information is accurate

   612   //    (in the absence of the JSR problem), no initialization

   613   //    is necessary.

   614   //

   615   // (gri - 2/25/2000)

   616 

   617 

   618   int rounded_vm_local_words = round_to( frame::interpreter_frame_vm_local_words, WordsPerLong );

   619 

   620   const int extra_space =

   621     rounded_vm_local_words +                   // frame local scratch space

   622     Method::extra_stack_entries() +            // extra stack for jsr 292

   623     frame::memory_parameter_word_sp_offset +   // register save area

   624     (native_call ? frame::interpreter_frame_extra_outgoing_argument_words : 0);

   625 

   626   const Register Glocals_size = G3;

   627   const Register RconstMethod = Glocals_size;

   628   const Register Otmp1 = O3;

   629   const Register Otmp2 = O4;

   630   // Lscratch can't be used as a temporary because the call_stub uses

   631   // it to assert that the stack frame was setup correctly.

   632   const Address constMethod       (G5_method, Method::const_offset());

   633   const Address size_of_parameters(RconstMethod, ConstMethod::size_of_parameters_offset());

   634 

   635   __ ld_ptr( constMethod, RconstMethod );

   636   __ lduh( size_of_parameters, Glocals_size);

   637 

   638   // Gargs points to first local + BytesPerWord

   639   // Set the saved SP after the register window save

   640   //

   641   assert_different_registers(Gargs, Glocals_size, Gframe_size, O5_savedSP);

   642   __ sll(Glocals_size, Interpreter::logStackElementSize, Otmp1);

   643   __ add(Gargs, Otmp1, Gargs);

   644 

   645   if (native_call) {

   646     __ calc_mem_param_words( Glocals_size, Gframe_size );

   647     __ add( Gframe_size,  extra_space, Gframe_size);

   648     __ round_to( Gframe_size, WordsPerLong );

   649     __ sll( Gframe_size, LogBytesPerWord, Gframe_size );

   650   } else {

   651 

   652     //

   653     // Compute number of locals in method apart from incoming parameters

   654     //

   655     const Address size_of_locals    (Otmp1, ConstMethod::size_of_locals_offset());

   656     __ ld_ptr( constMethod, Otmp1 );

   657     __ lduh( size_of_locals, Otmp1 );

   658     __ sub( Otmp1, Glocals_size, Glocals_size );

   659     __ round_to( Glocals_size, WordsPerLong );

   660     __ sll( Glocals_size, Interpreter::logStackElementSize, Glocals_size );

   661 

   662     // see if the frame is greater than one page in size. If so,

   663     // then we need to verify there is enough stack space remaining

   664     // Frame_size = (max_stack + extra_space) * BytesPerWord;

   665     __ ld_ptr( constMethod, Gframe_size );

   666     __ lduh( Gframe_size, in_bytes(ConstMethod::max_stack_offset()), Gframe_size );

   667     __ add( Gframe_size, extra_space, Gframe_size );

   668     __ round_to( Gframe_size, WordsPerLong );

   669     __ sll( Gframe_size, Interpreter::logStackElementSize, Gframe_size);

   670 

   671     // Add in java locals size for stack overflow check only

   672     __ add( Gframe_size, Glocals_size, Gframe_size );

   673 

   674     const Register Otmp2 = O4;

   675     assert_different_registers(Otmp1, Otmp2, O5_savedSP);

   676     generate_stack_overflow_check(Gframe_size, Otmp1, Otmp2);

   677 

   678     __ sub( Gframe_size, Glocals_size, Gframe_size);

   679 

   680     //

   681     // bump SP to accomodate the extra locals

   682     //

   683     __ sub( SP, Glocals_size, SP );

   684   }

   685 

   686   //

   687   // now set up a stack frame with the size computed above

   688   //

   689   __ neg( Gframe_size );

   690   __ save( SP, Gframe_size, SP );

   691 

   692   //

   693   // now set up all the local cache registers

   694   //

   695   // NOTE: At this point, Lbyte_code/Lscratch has been modified. Note

   696   // that all present references to Lbyte_code initialize the register

   697   // immediately before use

   698   if (native_call) {

   699     __ mov(G0, Lbcp);

   700   } else {

   701     __ ld_ptr(G5_method, Method::const_offset(), Lbcp);

   702     __ add(Lbcp, in_bytes(ConstMethod::codes_offset()), Lbcp);

   703   }

   704   __ mov( G5_method, Lmethod);                 // set Lmethod

   705   __ get_constant_pool_cache( LcpoolCache );   // set LcpoolCache

   706   __ sub(FP, rounded_vm_local_words * BytesPerWord, Lmonitors ); // set Lmonitors

   707 #ifdef _LP64

   708   __ add( Lmonitors, STACK_BIAS, Lmonitors );   // Account for 64 bit stack bias

   709 #endif

   710   __ sub(Lmonitors, BytesPerWord, Lesp);       // set Lesp

   711 

   712   // setup interpreter activation registers

   713   __ sub(Gargs, BytesPerWord, Llocals);        // set Llocals

   714 

   715   if (ProfileInterpreter) {

   716 #ifdef FAST_DISPATCH

   717     // FAST_DISPATCH and ProfileInterpreter are mutually exclusive since

   718     // they both use I2.

   719     assert(0, "FAST_DISPATCH and +ProfileInterpreter are mutually exclusive");

   720 #endif // FAST_DISPATCH

   721     __ set_method_data_pointer();

   722   }

   723 

   724 }

   725 

   726 // Method entry for java.lang.ref.Reference.get.

   727 address InterpreterGenerator::generate_Reference_get_entry(void) {

   728 #if INCLUDE_ALL_GCS

   729   // Code: _aload_0, _getfield, _areturn

   730   // parameter size = 1

   731   //

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

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

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

   735   //

   736   // Notes:-

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

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

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

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

   741   //   update buffer.

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

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

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

   745   //   will be fine.

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

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

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

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

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

   751   //

   752   // This code is based on generate_accessor_enty.

   753 

   754   address entry = __ pc();

   755 

   756   const int referent_offset = java_lang_ref_Reference::referent_offset;

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

   758 

   759   if (UseG1GC) {

   760      Label slow_path;

   761 

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

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

   764 

   765     // Check if local 0 != NULL

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

   767     __ ld_ptr(Gargs, G0, Otos_i ); // get local 0

   768     // check if local 0 == NULL and go the slow path

   769     __ cmp_and_brx_short(Otos_i, 0, Assembler::equal, Assembler::pn, slow_path);

   770 

   771 

   772     // Load the value of the referent field.

   773     if (Assembler::is_simm13(referent_offset)) {

   774       __ load_heap_oop(Otos_i, referent_offset, Otos_i);

   775     } else {

   776       __ set(referent_offset, G3_scratch);

   777       __ load_heap_oop(Otos_i, G3_scratch, Otos_i);

   778     }

   779 

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

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

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

   783     // the load of the previous value

   784 

   785     __ g1_write_barrier_pre(noreg /* obj */, noreg /* index */, 0 /* offset */,

   786                             Otos_i /* pre_val */,

   787                             G3_scratch /* tmp */,

   788                             true /* preserve_o_regs */);

   789 

   790     // _areturn

   791     __ retl();                      // return from leaf routine

   792     __ delayed()->mov(O5_savedSP, SP);

   793 

   794     // Generate regular method entry

   795     __ bind(slow_path);

   796     __ jump_to_entry(Interpreter::entry_for_kind(Interpreter::zerolocals));

   797     return entry;

   798   }

   799 #endif // INCLUDE_ALL_GCS

   800 

   801   // If G1 is not enabled then attempt to go through the accessor entry point

   802   // Reference.get is an accessor

   803   return NULL;

   804 }

   805 

   806 /**

   807  * Method entry for static native methods:

   808  *   int java.util.zip.CRC32.update(int crc, int b)

   809  */

   810 address InterpreterGenerator::generate_CRC32_update_entry() {

   811 

   812   if (UseCRC32Intrinsics) {

   813     address entry = __ pc();

   814 

   815     Label L_slow_path;

   816     // If we need a safepoint check, generate full interpreter entry.

   817     ExternalAddress state(SafepointSynchronize::address_of_state());

   818     __ set(ExternalAddress(SafepointSynchronize::address_of_state()), O2);

   819     __ set(SafepointSynchronize::_not_synchronized, O3);

   820     __ cmp_and_br_short(O2, O3, Assembler::notEqual, Assembler::pt, L_slow_path);

   821 

   822     // Load parameters

   823     const Register crc   = O0; // initial crc

   824     const Register val   = O1; // byte to update with

   825     const Register table = O2; // address of 256-entry lookup table

   826 

   827     __ ldub(Gargs, 3, val);

   828     __ lduw(Gargs, 8, crc);

   829 

   830     __ set(ExternalAddress(StubRoutines::crc_table_addr()), table);

   831 

   832     __ not1(crc); // ~crc

   833     __ clruwu(crc);

   834     __ update_byte_crc32(crc, val, table);

   835     __ not1(crc); // ~crc

   836 

   837     // result in O0

   838     __ retl();

   839     __ delayed()->nop();

   840 

   841     // generate a vanilla native entry as the slow path

   842     __ bind(L_slow_path);

   843     __ jump_to_entry(Interpreter::entry_for_kind(Interpreter::native));

   844     return entry;

   845   }

   846   return NULL;

   847 }

   848 

   849 /**

   850  * Method entry for static native methods:

   851  *   int java.util.zip.CRC32.updateBytes(int crc, byte[] b, int off, int len)

   852  *   int java.util.zip.CRC32.updateByteBuffer(int crc, long buf, int off, int len)

   853  */

   854 address InterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) {

   855 

   856   if (UseCRC32Intrinsics) {

   857     address entry = __ pc();

   858 

   859     Label L_slow_path;

   860     // If we need a safepoint check, generate full interpreter entry.

   861     ExternalAddress state(SafepointSynchronize::address_of_state());

   862     __ set(ExternalAddress(SafepointSynchronize::address_of_state()), O2);

   863     __ set(SafepointSynchronize::_not_synchronized, O3);

   864     __ cmp_and_br_short(O2, O3, Assembler::notEqual, Assembler::pt, L_slow_path);

   865 

   866     // Load parameters from the stack

   867     const Register crc    = O0; // initial crc

   868     const Register buf    = O1; // source java byte array address

   869     const Register len    = O2; // len

   870     const Register offset = O3; // offset

   871 

   872     // Arguments are reversed on java expression stack

   873     // Calculate address of start element

   874     if (kind == Interpreter::java_util_zip_CRC32_updateByteBuffer) {

   875       __ lduw(Gargs, 0,  len);

   876       __ lduw(Gargs, 8,  offset);

   877       __ ldx( Gargs, 16, buf);

   878       __ lduw(Gargs, 32, crc);

   879       __ add(buf, offset, buf);

   880     } else {

   881       __ lduw(Gargs, 0,  len);

   882       __ lduw(Gargs, 8,  offset);

   883       __ ldx( Gargs, 16, buf);

   884       __ lduw(Gargs, 24, crc);

   885       __ add(buf, arrayOopDesc::base_offset_in_bytes(T_BYTE), buf); // account for the header size

   886       __ add(buf ,offset, buf);

   887     }

   888 

   889     // Call the crc32 kernel

   890     __ MacroAssembler::save_thread(L7_thread_cache);

   891     __ kernel_crc32(crc, buf, len, O3);

   892     __ MacroAssembler::restore_thread(L7_thread_cache);

   893 

   894     // result in O0

   895     __ retl();

   896     __ delayed()->nop();

   897 

   898     // generate a vanilla native entry as the slow path

   899     __ bind(L_slow_path);

   900     __ jump_to_entry(Interpreter::entry_for_kind(Interpreter::native));

   901     return entry;

   902   }

   903   return NULL;

   904 }

   905 

   906 //

   907 // Interpreter stub for calling a native method. (asm interpreter)

   908 // This sets up a somewhat different looking stack for calling the native method

   909 // than the typical interpreter frame setup.

   910 //

   911 

   912 address InterpreterGenerator::generate_native_entry(bool synchronized) {

   913   address entry = __ pc();

   914 

   915   // the following temporary registers are used during frame creation

   916   const Register Gtmp1 = G3_scratch ;

   917   const Register Gtmp2 = G1_scratch;

   918   bool inc_counter  = UseCompiler || CountCompiledCalls || LogTouchedMethods;

   919 

   920   // make sure registers are different!

   921   assert_different_registers(G2_thread, G5_method, Gargs, Gtmp1, Gtmp2);

   922 

   923   const Address Laccess_flags(Lmethod, Method::access_flags_offset());

   924 

   925   const Register Glocals_size = G3;

   926   assert_different_registers(Glocals_size, G4_scratch, Gframe_size);

   927 

   928   // make sure method is native & not abstract

   929   // rethink these assertions - they can be simplified and shared (gri 2/25/2000)

   930 #ifdef ASSERT

   931   __ ld(G5_method, Method::access_flags_offset(), Gtmp1);

   932   {

   933     Label L;

   934     __ btst(JVM_ACC_NATIVE, Gtmp1);

   935     __ br(Assembler::notZero, false, Assembler::pt, L);

   936     __ delayed()->nop();

   937     __ stop("tried to execute non-native method as native");

   938     __ bind(L);

   939   }

   940   { Label L;

   941     __ btst(JVM_ACC_ABSTRACT, Gtmp1);

   942     __ br(Assembler::zero, false, Assembler::pt, L);

   943     __ delayed()->nop();

   944     __ stop("tried to execute abstract method as non-abstract");

   945     __ bind(L);

   946   }

   947 #endif // ASSERT

   948 

   949  // generate the code to allocate the interpreter stack frame

   950   generate_fixed_frame(true);

   951 

   952   //

   953   // No locals to initialize for native method

   954   //

   955 

   956   // this slot will be set later, we initialize it to null here just in

   957   // case we get a GC before the actual value is stored later

   958   __ st_ptr(G0, FP, (frame::interpreter_frame_oop_temp_offset * wordSize) + STACK_BIAS);

   959 

   960   const Address do_not_unlock_if_synchronized(G2_thread,

   961     JavaThread::do_not_unlock_if_synchronized_offset());

   962   // Since at this point in the method invocation the exception handler

   963   // would try to exit the monitor of synchronized methods which hasn't

   964   // been entered yet, we set the thread local variable

   965   // _do_not_unlock_if_synchronized to true. If any exception was thrown by

   966   // runtime, exception handling i.e. unlock_if_synchronized_method will

   967   // check this thread local flag.

   968   // This flag has two effects, one is to force an unwind in the topmost

   969   // interpreter frame and not perform an unlock while doing so.

   970 

   971   __ movbool(true, G3_scratch);

   972   __ stbool(G3_scratch, do_not_unlock_if_synchronized);

   973 

   974   // increment invocation counter and check for overflow

   975   //

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

   977   //       so we have a 'sticky' overflow test (may be of

   978   //       importance as soon as we have true MT/MP)

   979   Label invocation_counter_overflow;

   980   Label Lcontinue;

   981   if (inc_counter) {

   982     generate_counter_incr(&invocation_counter_overflow, NULL, NULL);

   983 

   984   }

   985   __ bind(Lcontinue);

   986 

   987   bang_stack_shadow_pages(true);

   988 

   989   // reset the _do_not_unlock_if_synchronized flag

   990   __ stbool(G0, do_not_unlock_if_synchronized);

   991 

   992   // check for synchronized methods

   993   // Must happen AFTER invocation_counter check and stack overflow check,

   994   // so method is not locked if overflows.

   995 

   996   if (synchronized) {

   997     lock_method();

   998   } else {

   999 #ifdef ASSERT

  1000     { Label ok;

  1001       __ ld(Laccess_flags, O0);

  1002       __ btst(JVM_ACC_SYNCHRONIZED, O0);

  1003       __ br( Assembler::zero, false, Assembler::pt, ok);

  1004       __ delayed()->nop();

  1005       __ stop("method needs synchronization");

  1006       __ bind(ok);

  1007     }

  1008 #endif // ASSERT

  1009   }

  1010 

  1011 

  1012   // start execution

  1013   __ verify_thread();

  1014 

  1015   // JVMTI support

  1016   __ notify_method_entry();

  1017 

  1018   // native call

  1019 

  1020   // (note that O0 is never an oop--at most it is a handle)

  1021   // It is important not to smash any handles created by this call,

  1022   // until any oop handle in O0 is dereferenced.

  1023 

  1024   // (note that the space for outgoing params is preallocated)

  1025 

  1026   // get signature handler

  1027   { Label L;

  1028     Address signature_handler(Lmethod, Method::signature_handler_offset());

  1029     __ ld_ptr(signature_handler, G3_scratch);

  1030     __ br_notnull_short(G3_scratch, Assembler::pt, L);

  1031     __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), Lmethod);

  1032     __ ld_ptr(signature_handler, G3_scratch);

  1033     __ bind(L);

  1034   }

  1035 

  1036   // Push a new frame so that the args will really be stored in

  1037   // Copy a few locals across so the new frame has the variables

  1038   // we need but these values will be dead at the jni call and

  1039   // therefore not gc volatile like the values in the current

  1040   // frame (Lmethod in particular)

  1041 

  1042   // Flush the method pointer to the register save area

  1043   __ st_ptr(Lmethod, SP, (Lmethod->sp_offset_in_saved_window() * wordSize) + STACK_BIAS);

  1044   __ mov(Llocals, O1);

  1045 

  1046   // calculate where the mirror handle body is allocated in the interpreter frame:

  1047   __ add(FP, (frame::interpreter_frame_oop_temp_offset * wordSize) + STACK_BIAS, O2);

  1048 

  1049   // Calculate current frame size

  1050   __ sub(SP, FP, O3);         // Calculate negative of current frame size

  1051   __ save(SP, O3, SP);        // Allocate an identical sized frame

  1052 

  1053   // Note I7 has leftover trash. Slow signature handler will fill it in

  1054   // should we get there. Normal jni call will set reasonable last_Java_pc

  1055   // below (and fix I7 so the stack trace doesn't have a meaningless frame

  1056   // in it).

  1057 

  1058   // Load interpreter frame's Lmethod into same register here

  1059 

  1060   __ ld_ptr(FP, (Lmethod->sp_offset_in_saved_window() * wordSize) + STACK_BIAS, Lmethod);

  1061 

  1062   __ mov(I1, Llocals);

  1063   __ mov(I2, Lscratch2);     // save the address of the mirror

  1064 

  1065 

  1066   // ONLY Lmethod and Llocals are valid here!

  1067 

  1068   // call signature handler, It will move the arg properly since Llocals in current frame

  1069   // matches that in outer frame

  1070 

  1071   __ callr(G3_scratch, 0);

  1072   __ delayed()->nop();

  1073 

  1074   // Result handler is in Lscratch

  1075 

  1076   // Reload interpreter frame's Lmethod since slow signature handler may block

  1077   __ ld_ptr(FP, (Lmethod->sp_offset_in_saved_window() * wordSize) + STACK_BIAS, Lmethod);

  1078 

  1079   { Label not_static;

  1080 

  1081     __ ld(Laccess_flags, O0);

  1082     __ btst(JVM_ACC_STATIC, O0);

  1083     __ br( Assembler::zero, false, Assembler::pt, not_static);

  1084     // get native function entry point(O0 is a good temp until the very end)

  1085     __ delayed()->ld_ptr(Lmethod, in_bytes(Method::native_function_offset()), O0);

  1086     // for static methods insert the mirror argument

  1087     const int mirror_offset = in_bytes(Klass::java_mirror_offset());

  1088 

  1089     __ ld_ptr(Lmethod, Method:: const_offset(), O1);

  1090     __ ld_ptr(O1, ConstMethod::constants_offset(), O1);

  1091     __ ld_ptr(O1, ConstantPool::pool_holder_offset_in_bytes(), O1);

  1092     __ ld_ptr(O1, mirror_offset, O1);

  1093 #ifdef ASSERT

  1094     if (!PrintSignatureHandlers)  // do not dirty the output with this

  1095     { Label L;

  1096       __ br_notnull_short(O1, Assembler::pt, L);

  1097       __ stop("mirror is missing");

  1098       __ bind(L);

  1099     }

  1100 #endif // ASSERT

  1101     __ st_ptr(O1, Lscratch2, 0);

  1102     __ mov(Lscratch2, O1);

  1103     __ bind(not_static);

  1104   }

  1105 

  1106   // At this point, arguments have been copied off of stack into

  1107   // their JNI positions, which are O1..O5 and SP[68..].

  1108   // Oops are boxed in-place on the stack, with handles copied to arguments.

  1109   // The result handler is in Lscratch.  O0 will shortly hold the JNIEnv*.

  1110 

  1111 #ifdef ASSERT

  1112   { Label L;

  1113     __ br_notnull_short(O0, Assembler::pt, L);

  1114     __ stop("native entry point is missing");

  1115     __ bind(L);

  1116   }

  1117 #endif // ASSERT

  1118 

  1119   //

  1120   // setup the frame anchor

  1121   //

  1122   // The scavenge function only needs to know that the PC of this frame is

  1123   // in the interpreter method entry code, it doesn't need to know the exact

  1124   // PC and hence we can use O7 which points to the return address from the

  1125   // previous call in the code stream (signature handler function)

  1126   //

  1127   // The other trick is we set last_Java_sp to FP instead of the usual SP because

  1128   // we have pushed the extra frame in order to protect the volatile register(s)

  1129   // in that frame when we return from the jni call

  1130   //

  1131 

  1132   __ set_last_Java_frame(FP, O7);

  1133   __ mov(O7, I7);  // make dummy interpreter frame look like one above,

  1134                    // not meaningless information that'll confuse me.