1 /*

     2  * Copyright (c) 2007, 2014, 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/assembler.hpp"

    27 #include "interpreter/bytecodeHistogram.hpp"

    28 #include "interpreter/cppInterpreter.hpp"

    29 #include "interpreter/interpreter.hpp"

    30 #include "interpreter/interpreterGenerator.hpp"

    31 #include "interpreter/interpreterRuntime.hpp"

    32 #include "interpreter/interp_masm.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/interfaceSupport.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 #ifdef SHARK

    51 #include "shark/shark_globals.hpp"

    52 #endif

    53 

    54 #ifdef CC_INTERP

    55 

    56 // Routine exists to make tracebacks look decent in debugger

    57 // while "shadow" interpreter frames are on stack. It is also

    58 // used to distinguish interpreter frames.

    59 

    60 extern "C" void RecursiveInterpreterActivation(interpreterState istate) {

    61   ShouldNotReachHere();

    62 }

    63 

    64 bool CppInterpreter::contains(address pc) {

    65   return ( _code->contains(pc) ||

    66          ( pc == (CAST_FROM_FN_PTR(address, RecursiveInterpreterActivation) + frame::pc_return_offset)));

    67 }

    68 

    69 #define STATE(field_name) Lstate, in_bytes(byte_offset_of(BytecodeInterpreter, field_name))

    70 #define __ _masm->

    71 

    72 Label frame_manager_entry; // c++ interpreter entry point this holds that entry point label.

    73 

    74 static address unctrap_frame_manager_entry  = NULL;

    75 

    76 static address interpreter_return_address  = NULL;

    77 static address deopt_frame_manager_return_atos  = NULL;

    78 static address deopt_frame_manager_return_btos  = NULL;

    79 static address deopt_frame_manager_return_itos  = NULL;

    80 static address deopt_frame_manager_return_ltos  = NULL;

    81 static address deopt_frame_manager_return_ftos  = NULL;

    82 static address deopt_frame_manager_return_dtos  = NULL;

    83 static address deopt_frame_manager_return_vtos  = NULL;

    84 

    85 const Register prevState = G1_scratch;

    86 

    87 void InterpreterGenerator::save_native_result(void) {

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

    89   __ stf(FloatRegisterImpl::D, F0, STATE(_native_fresult));

    90 #ifdef _LP64

    91   __ stx(O0, STATE(_native_lresult));

    92 #else

    93   __ std(O0, STATE(_native_lresult));

    94 #endif

    95 }

    96 

    97 void InterpreterGenerator::restore_native_result(void) {

    98 

    99   // Restore any method result value

   100   __ ldf(FloatRegisterImpl::D, STATE(_native_fresult), F0);

   101 #ifdef _LP64

   102   __ ldx(STATE(_native_lresult), O0);

   103 #else

   104   __ ldd(STATE(_native_lresult), O0);

   105 #endif

   106 }

   107 

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

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

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

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

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

   113 address CppInterpreterGenerator::generate_result_handler_for(BasicType type) {

   114   address entry = __ pc();

   115   Register Itos_i  = Otos_i ->after_save();

   116   Register Itos_l  = Otos_l ->after_save();

   117   Register Itos_l1 = Otos_l1->after_save();

   118   Register Itos_l2 = Otos_l2->after_save();

   119   switch (type) {

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

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

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

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

   124     case T_LONG   :

   125 #ifndef _LP64

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

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

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

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

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

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

   132     case T_OBJECT :

   133       __ ld_ptr(STATE(_oop_temp), Itos_i);

   134       __ verify_oop(Itos_i);

   135       break;

   136     default       : ShouldNotReachHere();

   137   }

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

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

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

   141   return entry;

   142 }

   143 

   144 // tosca based result to c++ interpreter stack based result.

   145 // Result goes to address in L1_scratch

   146 

   147 address CppInterpreterGenerator::generate_tosca_to_stack_converter(BasicType type) {

   148   // A result is in the native abi result register from a native method call.

   149   // We need to return this result to the interpreter by pushing the result on the interpreter's

   150   // stack. This is relatively simple the destination is in L1_scratch

   151   // i.e. L1_scratch is the first free element on the stack. If we "push" a return value we must

   152   // adjust L1_scratch

   153   address entry = __ pc();

   154   switch (type) {

   155     case T_BOOLEAN:

   156       // !0 => true; 0 => false

   157       __ subcc(G0, O0, G0);

   158       __ addc(G0, 0, O0);

   159       __ st(O0, L1_scratch, 0);

   160       __ sub(L1_scratch, wordSize, L1_scratch);

   161       break;

   162 

   163     // cannot use and3, 0xFFFF too big as immediate value!

   164     case T_CHAR   :

   165       __ sll(O0, 16, O0);

   166       __ srl(O0, 16, O0);

   167       __ st(O0, L1_scratch, 0);

   168       __ sub(L1_scratch, wordSize, L1_scratch);

   169       break;

   170 

   171     case T_BYTE   :

   172       __ sll(O0, 24, O0);

   173       __ sra(O0, 24, O0);

   174       __ st(O0, L1_scratch, 0);

   175       __ sub(L1_scratch, wordSize, L1_scratch);

   176       break;

   177 

   178     case T_SHORT  :

   179       __ sll(O0, 16, O0);

   180       __ sra(O0, 16, O0);

   181       __ st(O0, L1_scratch, 0);

   182       __ sub(L1_scratch, wordSize, L1_scratch);

   183       break;

   184     case T_LONG   :

   185 #ifndef _LP64

   186 #if defined(COMPILER2)

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

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

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

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

   191   // stupid shuffing.

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

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

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

   195       __ stx(G1, L1_scratch, -wordSize);

   196 #else

   197       // native result is in O0, O1

   198       __ st(O1, L1_scratch, 0);                      // Low order

   199       __ st(O0, L1_scratch, -wordSize);              // High order

   200 #endif /* COMPILER2 */

   201 #else

   202       __ stx(O0, L1_scratch, -wordSize);

   203 #endif

   204       __ sub(L1_scratch, 2*wordSize, L1_scratch);

   205       break;

   206 

   207     case T_INT    :

   208       __ st(O0, L1_scratch, 0);

   209       __ sub(L1_scratch, wordSize, L1_scratch);

   210       break;

   211 

   212     case T_VOID   : /* nothing to do */

   213       break;

   214 

   215     case T_FLOAT  :

   216       __ stf(FloatRegisterImpl::S, F0, L1_scratch, 0);

   217       __ sub(L1_scratch, wordSize, L1_scratch);

   218       break;

   219 

   220     case T_DOUBLE :

   221       // Every stack slot is aligned on 64 bit, However is this

   222       // the correct stack slot on 64bit?? QQQ

   223       __ stf(FloatRegisterImpl::D, F0, L1_scratch, -wordSize);

   224       __ sub(L1_scratch, 2*wordSize, L1_scratch);

   225       break;

   226     case T_OBJECT :

   227       __ verify_oop(O0);

   228       __ st_ptr(O0, L1_scratch, 0);

   229       __ sub(L1_scratch, wordSize, L1_scratch);

   230       break;

   231     default       : ShouldNotReachHere();

   232   }

   233   __ retl();                          // return from interpreter activation

   234   __ delayed()->nop();                // schedule this better

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

   236   return entry;

   237 }

   238 

   239 address CppInterpreterGenerator::generate_stack_to_stack_converter(BasicType type) {

   240   // A result is in the java expression stack of the interpreted method that has just

   241   // returned. Place this result on the java expression stack of the caller.

   242   //

   243   // The current interpreter activation in Lstate is for the method just returning its

   244   // result. So we know that the result of this method is on the top of the current

   245   // execution stack (which is pre-pushed) and will be return to the top of the caller

   246   // stack. The top of the callers stack is the bottom of the locals of the current

   247   // activation.

   248   // Because of the way activation are managed by the frame manager the value of esp is

   249   // below both the stack top of the current activation and naturally the stack top

   250   // of the calling activation. This enable this routine to leave the return address

   251   // to the frame manager on the stack and do a vanilla return.

   252   //

   253   // On entry: O0 - points to source (callee stack top)

   254   //           O1 - points to destination (caller stack top [i.e. free location])

   255   // destroys O2, O3

   256   //

   257 

   258   address entry = __ pc();

   259   switch (type) {

   260     case T_VOID:  break;

   261       break;

   262     case T_FLOAT  :

   263     case T_BOOLEAN:

   264     case T_CHAR   :

   265     case T_BYTE   :

   266     case T_SHORT  :

   267     case T_INT    :

   268       // 1 word result

   269       __ ld(O0, 0, O2);

   270       __ st(O2, O1, 0);

   271       __ sub(O1, wordSize, O1);

   272       break;

   273     case T_DOUBLE  :

   274     case T_LONG    :

   275       // return top two words on current expression stack to caller's expression stack

   276       // The caller's expression stack is adjacent to the current frame manager's intepretState

   277       // except we allocated one extra word for this intepretState so we won't overwrite it

   278       // when we return a two word result.

   279 #ifdef _LP64

   280       __ ld_ptr(O0, 0, O2);

   281       __ st_ptr(O2, O1, -wordSize);

   282 #else

   283       __ ld(O0, 0, O2);

   284       __ ld(O0, wordSize, O3);

   285       __ st(O3, O1, 0);

   286       __ st(O2, O1, -wordSize);

   287 #endif

   288       __ sub(O1, 2*wordSize, O1);

   289       break;

   290     case T_OBJECT :

   291       __ ld_ptr(O0, 0, O2);

   292       __ verify_oop(O2);                                               // verify it

   293       __ st_ptr(O2, O1, 0);

   294       __ sub(O1, wordSize, O1);

   295       break;

   296     default       : ShouldNotReachHere();

   297   }

   298   __ retl();

   299   __ delayed()->nop(); // QQ schedule this better

   300   return entry;

   301 }

   302 

   303 address CppInterpreterGenerator::generate_stack_to_native_abi_converter(BasicType type) {

   304   // A result is in the java expression stack of the interpreted method that has just

   305   // returned. Place this result in the native abi that the caller expects.

   306   // We are in a new frame registers we set must be in caller (i.e. callstub) frame.

   307   //

   308   // Similar to generate_stack_to_stack_converter above. Called at a similar time from the

   309   // frame manager execept in this situation the caller is native code (c1/c2/call_stub)

   310   // and so rather than return result onto caller's java expression stack we return the

   311   // result in the expected location based on the native abi.

   312   // On entry: O0 - source (stack top)

   313   // On exit result in expected output register

   314   // QQQ schedule this better

   315 

   316   address entry = __ pc();

   317   switch (type) {

   318     case T_VOID:  break;

   319       break;

   320     case T_FLOAT  :

   321       __ ldf(FloatRegisterImpl::S, O0, 0, F0);

   322       break;

   323     case T_BOOLEAN:

   324     case T_CHAR   :

   325     case T_BYTE   :

   326     case T_SHORT  :

   327     case T_INT    :

   328       // 1 word result

   329       __ ld(O0, 0, O0->after_save());

   330       break;

   331     case T_DOUBLE  :

   332       __ ldf(FloatRegisterImpl::D, O0, 0, F0);

   333       break;

   334     case T_LONG    :

   335       // return top two words on current expression stack to caller's expression stack

   336       // The caller's expression stack is adjacent to the current frame manager's interpretState

   337       // except we allocated one extra word for this intepretState so we won't overwrite it

   338       // when we return a two word result.

   339 #ifdef _LP64

   340       __ ld_ptr(O0, 0, O0->after_save());

   341 #else

   342       __ ld(O0, wordSize, O1->after_save());

   343       __ ld(O0, 0, O0->after_save());

   344 #endif

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

   346       // C2 expects long results in G1 we can't tell if we're returning to interpreted

   347       // or compiled so just be safe use G1 and O0/O1

   348 

   349       // Shift bits into high (msb) of G1

   350       __ sllx(Otos_l1->after_save(), 32, G1);

   351       // Zero extend low bits

   352       __ srl (Otos_l2->after_save(), 0, Otos_l2->after_save());

   353       __ or3 (Otos_l2->after_save(), G1, G1);

   354 #endif /* COMPILER2 */

   355       break;

   356     case T_OBJECT :

   357       __ ld_ptr(O0, 0, O0->after_save());

   358       __ verify_oop(O0->after_save());                                               // verify it

   359       break;

   360     default       : ShouldNotReachHere();

   361   }

   362   __ retl();

   363   __ delayed()->nop();

   364   return entry;

   365 }

   366 

   367 address CppInterpreter::return_entry(TosState state, int length, Bytecodes::Code code) {

   368   // make it look good in the debugger

   369   return CAST_FROM_FN_PTR(address, RecursiveInterpreterActivation) + frame::pc_return_offset;

   370 }

   371 

   372 address CppInterpreter::deopt_entry(TosState state, int length) {

   373   address ret = NULL;

   374   if (length != 0) {

   375     switch (state) {

   376       case atos: ret = deopt_frame_manager_return_atos; break;

   377       case btos: ret = deopt_frame_manager_return_btos; break;

   378       case ctos:

   379       case stos:

   380       case itos: ret = deopt_frame_manager_return_itos; break;

   381       case ltos: ret = deopt_frame_manager_return_ltos; break;

   382       case ftos: ret = deopt_frame_manager_return_ftos; break;

   383       case dtos: ret = deopt_frame_manager_return_dtos; break;

   384       case vtos: ret = deopt_frame_manager_return_vtos; break;

   385     }

   386   } else {

   387     ret = unctrap_frame_manager_entry;  // re-execute the bytecode ( e.g. uncommon trap)

   388   }

   389   assert(ret != NULL, "Not initialized");

   390   return ret;

   391 }

   392 

   393 //

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

   395 //

   396 

   397 // increment invocation count & check for overflow

   398 //

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

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

   401 //

   402 // Lmethod: method

   403 // ??: invocation counter

   404 //

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

   406   Label done;

   407   const Register Rcounters = G3_scratch;

   408 

   409   __ ld_ptr(STATE(_method), G5_method);

   410   __ get_method_counters(G5_method, Rcounters, done);

   411 

   412   // Update standard invocation counters

   413   __ increment_invocation_counter(Rcounters, O0, G4_scratch);

   414   if (ProfileInterpreter) {

   415     Address interpreter_invocation_counter(Rcounters,

   416             in_bytes(MethodCounters::interpreter_invocation_counter_offset()));

   417     __ ld(interpreter_invocation_counter, G4_scratch);

   418     __ inc(G4_scratch);

   419     __ st(G4_scratch, interpreter_invocation_counter);

   420   }

   421 

   422   AddressLiteral invocation_limit((address)&InvocationCounter::InterpreterInvocationLimit);

   423   __ load_contents(invocation_limit, G3_scratch);

   424   __ cmp(O0, G3_scratch);

   425   __ br(Assembler::greaterEqualUnsigned, false, Assembler::pn, *overflow);

   426   __ delayed()->nop();

   427   __ bind(done);

   428 }

   429 

   430 address InterpreterGenerator::generate_empty_entry(void) {

   431 

   432   // A method that does nothing but return...

   433 

   434   address entry = __ pc();

   435   Label slow_path;

   436 

   437   // do nothing for empty methods (do not even increment invocation counter)

   438   if ( UseFastEmptyMethods) {

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

   440     AddressLiteral sync_state(SafepointSynchronize::address_of_state());

   441     __ load_contents(sync_state, G3_scratch);

   442     __ cmp(G3_scratch, SafepointSynchronize::_not_synchronized);

   443     __ br(Assembler::notEqual, false, Assembler::pn, frame_manager_entry);

   444     __ delayed()->nop();

   445 

   446     // Code: _return

   447     __ retl();

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

   449     return entry;

   450   }

   451   return NULL;

   452 }

   453 

   454 address InterpreterGenerator::generate_Reference_get_entry(void) {

   455 #if INCLUDE_ALL_GCS

   456   if (UseG1GC) {

   457     // We need to generate have a routine that generates code to:

   458     //   * load the value in the referent field

   459     //   * passes that value to the pre-barrier.

   460     //

   461     // In the case of G1 this will record the value of the

   462     // referent in an SATB buffer if marking is active.

   463     // This will cause concurrent marking to mark the referent

   464     // field as live.

   465     Unimplemented();

   466   }

   467 #endif // INCLUDE_ALL_GCS

   468 

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

   470   // Reference.get is an accessor

   471   return NULL;

   472 }

   473 

   474 //

   475 // Interpreter stub for calling a native method. (C++ interpreter)

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

   477 // than the typical interpreter frame setup.

   478 //

   479 

   480 address InterpreterGenerator::generate_native_entry(bool synchronized) {

   481   address entry = __ pc();

   482 

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

   484   const Register Gtmp1 = G3_scratch ;

   485   const Register Gtmp2 = G1_scratch;

   486   const Register RconstMethod = Gtmp1;

   487   const Address constMethod(G5_method, in_bytes(Method::const_offset()));

   488   const Address size_of_parameters(RconstMethod, in_bytes(ConstMethod::size_of_parameters_offset()));

   489 

   490   bool inc_counter  = UseCompiler || CountCompiledCalls;

   491 

   492   // make sure registers are different!

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

   494 

   495   const Address access_flags      (G5_method, in_bytes(Method::access_flags_offset()));

   496 

   497   Label Lentry;

   498   __ bind(Lentry);

   499 

   500   const Register Glocals_size = G3;

   501   assert_different_registers(Glocals_size, G4_scratch, Gframe_size);

   502 

   503   // make sure method is native & not abstract

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

   505 #ifdef ASSERT

   506   __ ld(access_flags, Gtmp1);

   507   {

   508     Label L;

   509     __ btst(JVM_ACC_NATIVE, Gtmp1);

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

   511     __ delayed()->nop();

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

   513     __ bind(L);

   514   }

   515   { Label L;

   516     __ btst(JVM_ACC_ABSTRACT, Gtmp1);

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

   518     __ delayed()->nop();

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

   520     __ bind(L);

   521   }

   522 #endif // ASSERT

   523 

   524   __ ld_ptr(constMethod, RconstMethod);

   525   __ lduh(size_of_parameters, Gtmp1);

   526   __ sll(Gtmp1, LogBytesPerWord, Gtmp2);       // parameter size in bytes

   527   __ add(Gargs, Gtmp2, Gargs);                 // points to first local + BytesPerWord

   528   // NEW

   529   __ add(Gargs, -wordSize, Gargs);             // points to first local[0]

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

   531   // NEW FRAME ALLOCATED HERE

   532   // save callers original sp

   533   // __ mov(SP, I5_savedSP->after_restore());

   534 

   535   generate_compute_interpreter_state(Lstate, G0, true);

   536 

   537   // At this point Lstate points to new interpreter state

   538   //

   539 

   540   const Address do_not_unlock_if_synchronized(G2_thread,

   541       in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));

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

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

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

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

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

   547   // check this thread local flag.

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

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

   550 

   551   __ movbool(true, G3_scratch);

   552   __ stbool(G3_scratch, do_not_unlock_if_synchronized);

   553 

   554 

   555   // increment invocation counter and check for overflow

   556   //

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

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

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

   560   Label invocation_counter_overflow;

   561   if (inc_counter) {

   562     generate_counter_incr(&invocation_counter_overflow, NULL, NULL);

   563   }

   564   Label Lcontinue;

   565   __ bind(Lcontinue);

   566 

   567   bang_stack_shadow_pages(true);

   568   // reset the _do_not_unlock_if_synchronized flag

   569   __ stbool(G0, do_not_unlock_if_synchronized);

   570 

   571   // check for synchronized methods

   572   // Must happen AFTER invocation_counter check, so method is not locked

   573   // if counter overflows.

   574 

   575   if (synchronized) {

   576     lock_method();

   577     // Don't see how G2_thread is preserved here...

   578     // __ verify_thread(); QQQ destroys L0,L1 can't use

   579   } else {

   580 #ifdef ASSERT

   581     { Label ok;

   582       __ ld_ptr(STATE(_method), G5_method);

   583       __ ld(access_flags, O0);

   584       __ btst(JVM_ACC_SYNCHRONIZED, O0);

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

   586       __ delayed()->nop();

   587       __ stop("method needs synchronization");

   588       __ bind(ok);

   589     }

   590 #endif // ASSERT

   591   }

   592 

   593   // start execution

   594 

   595 //   __ verify_thread(); kills L1,L2 can't  use at the moment

   596 

   597   // jvmti/jvmpi support

   598   __ notify_method_entry();

   599 

   600   // native call

   601 

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

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

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

   605 

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

   607 

   608   // get signature handler

   609 

   610   Label pending_exception_present;

   611 

   612   { Label L;

   613     __ ld_ptr(STATE(_method), G5_method);

   614     __ ld_ptr(Address(G5_method, in_bytes(Method::signature_handler_offset())), G3_scratch);

   615     __ tst(G3_scratch);

   616     __ brx(Assembler::notZero, false, Assembler::pt, L);

   617     __ delayed()->nop();

   618     __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), G5_method, false);

   619     __ ld_ptr(STATE(_method), G5_method);

   620 

   621     Address exception_addr(G2_thread, in_bytes(Thread::pending_exception_offset()));

   622     __ ld_ptr(exception_addr, G3_scratch);

   623     __ br_notnull_short(G3_scratch, Assembler::pn, pending_exception_present);

   624     __ ld_ptr(Address(G5_method, in_bytes(Method::signature_handler_offset())), G3_scratch);

   625     __ bind(L);

   626   }

   627 

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

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

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

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

   632   // frame (Lstate in particular)

   633 

   634   // Flush the state pointer to the register save area

   635   // Which is the only register we need for a stack walk.

   636   __ st_ptr(Lstate, SP, (Lstate->sp_offset_in_saved_window() * wordSize) + STACK_BIAS);

   637 

   638   __ mov(Lstate, O1);         // Need to pass the state pointer across the frame

   639 

   640   // Calculate current frame size

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

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

   643 

   644   __ mov(I1, Lstate);          // In the "natural" register.

   645 

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

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

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

   649   // in it).

   650 

   651 

   652   // call signature handler

   653   __ ld_ptr(STATE(_method), Lmethod);

   654   __ ld_ptr(STATE(_locals), Llocals);

   655 

   656   __ callr(G3_scratch, 0);

   657   __ delayed()->nop();

   658   __ ld_ptr(STATE(_thread), G2_thread);        // restore thread (shouldn't be needed)

   659 

   660   { Label not_static;

   661 

   662     __ ld_ptr(STATE(_method), G5_method);

   663     __ ld(access_flags, O0);

   664     __ btst(JVM_ACC_STATIC, O0);

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

   666     __ delayed()->

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

   668        ld_ptr(Address(G5_method, in_bytes(Method::native_function_offset())), O0);

   669     // for static methods insert the mirror argument

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

   671 

   672     __ ld_ptr(Address(G5_method, in_bytes(Method:: const_offset())), O1);

   673     __ ld_ptr(Address(O1, in_bytes(ConstMethod::constants_offset())), O1);

   674     __ ld_ptr(Address(O1, ConstantPool::pool_holder_offset_in_bytes()), O1);

   675     __ ld_ptr(O1, mirror_offset, O1);

   676     // where the mirror handle body is allocated:

   677 #ifdef ASSERT

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

   679     { Label L;

   680       __ tst(O1);

   681       __ brx(Assembler::notZero, false, Assembler::pt, L);

   682       __ delayed()->nop();

   683       __ stop("mirror is missing");

   684       __ bind(L);

   685     }

   686 #endif // ASSERT

   687     __ st_ptr(O1, STATE(_oop_temp));

   688     __ add(STATE(_oop_temp), O1);            // this is really an LEA not an add

   689     __ bind(not_static);

   690   }

   691 

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

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

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

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

   696 

   697 #ifdef ASSERT

   698   { Label L;

   699     __ tst(O0);

   700     __ brx(Assembler::notZero, false, Assembler::pt, L);

   701     __ delayed()->nop();

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

   703     __ bind(L);

   704   }

   705 #endif // ASSERT

   706 

   707   //

   708   // setup the java frame anchor

   709   //

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

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

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

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

   714   //

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

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

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

   718   //

   719 

   720 

   721   __ set_last_Java_frame(FP, O7);

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

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

   724 

   725   // flush the windows now. We don't care about the current (protection) frame

   726   // only the outer frames

   727 

   728   __ flushw();

   729 

   730   // mark windows as flushed

   731   Address flags(G2_thread,

   732                 in_bytes(JavaThread::frame_anchor_offset()) + in_bytes(JavaFrameAnchor::flags_offset()));

   733   __ set(JavaFrameAnchor::flushed, G3_scratch);

   734   __ st(G3_scratch, flags);

   735 

   736   // Transition from _thread_in_Java to _thread_in_native. We are already safepoint ready.

   737 

   738   Address thread_state(G2_thread, in_bytes(JavaThread::thread_state_offset()));

   739 #ifdef ASSERT

   740   { Label L;

   741     __ ld(thread_state, G3_scratch);

   742     __ cmp(G3_scratch, _thread_in_Java);

   743     __ br(Assembler::equal, false, Assembler::pt, L);

   744     __ delayed()->nop();

   745     __ stop("Wrong thread state in native stub");

   746     __ bind(L);

   747   }

   748 #endif // ASSERT

   749   __ set(_thread_in_native, G3_scratch);

   750   __ st(G3_scratch, thread_state);

   751 

   752   // Call the jni method, using the delay slot to set the JNIEnv* argument.

   753   __ callr(O0, 0);

   754   __ delayed()->

   755      add(G2_thread, in_bytes(JavaThread::jni_environment_offset()), O0);

   756   __ ld_ptr(STATE(_thread), G2_thread);  // restore thread

   757 

   758   // must we block?

   759 

   760   // Block, if necessary, before resuming in _thread_in_Java state.

   761   // In order for GC to work, don't clear the last_Java_sp until after blocking.

   762   { Label no_block;

   763     AddressLiteral sync_state(SafepointSynchronize::address_of_state());

   764 

   765     // Switch thread to "native transition" state before reading the synchronization state.

   766     // This additional state is necessary because reading and testing the synchronization

   767     // state is not atomic w.r.t. GC, as this scenario demonstrates:

   768     //     Java thread A, in _thread_in_native state, loads _not_synchronized and is preempted.

   769     //     VM thread changes sync state to synchronizing and suspends threads for GC.

   770     //     Thread A is resumed to finish this native method, but doesn't block here since it

   771     //     didn't see any synchronization is progress, and escapes.

   772     __ set(_thread_in_native_trans, G3_scratch);

   773     __ st(G3_scratch, thread_state);

   774     if(os::is_MP()) {

   775       // Write serialization page so VM thread can do a pseudo remote membar.

   776       // We use the current thread pointer to calculate a thread specific

   777       // offset to write to within the page. This minimizes bus traffic

   778       // due to cache line collision.

   779       __ serialize_memory(G2_thread, G1_scratch, G3_scratch);

   780     }

   781     __ load_contents(sync_state, G3_scratch);

   782     __ cmp(G3_scratch, SafepointSynchronize::_not_synchronized);

   783 

   784 

   785     Label L;

   786     Address suspend_state(G2_thread, in_bytes(JavaThread::suspend_flags_offset()));

   787     __ br(Assembler::notEqual, false, Assembler::pn, L);

   788     __ delayed()->

   789       ld(suspend_state, G3_scratch);

   790     __ cmp(G3_scratch, 0);

   791     __ br(Assembler::equal, false, Assembler::pt, no_block);

   792     __ delayed()->nop();

   793     __ bind(L);

   794 

   795     // Block.  Save any potential method result value before the operation and

   796     // use a leaf call to leave the last_Java_frame setup undisturbed.

   797     save_native_result();

   798     __ call_VM_leaf(noreg,

   799                     CAST_FROM_FN_PTR(address, JavaThread::check_safepoint_and_suspend_for_native_trans),

   800                     G2_thread);

   801     __ ld_ptr(STATE(_thread), G2_thread);  // restore thread

   802     // Restore any method result value

   803     restore_native_result();

   804     __ bind(no_block);

   805   }

   806 

   807   // Clear the frame anchor now

   808 

   809   __ reset_last_Java_frame();

   810 

   811   // Move the result handler address

   812   __ mov(Lscratch, G3_scratch);

   813   // return possible result to the outer frame

   814 #ifndef __LP64

   815   __ mov(O0, I0);

   816   __ restore(O1, G0, O1);

   817 #else

   818   __ restore(O0, G0, O0);

   819 #endif /* __LP64 */

   820 

   821   // Move result handler to expected register

   822   __ mov(G3_scratch, Lscratch);

   823 

   824 

   825   // thread state is thread_in_native_trans. Any safepoint blocking has

   826   // happened in the trampoline we are ready to switch to thread_in_Java.

   827 

   828   __ set(_thread_in_Java, G3_scratch);

   829   __ st(G3_scratch, thread_state);

   830 

   831   // If we have an oop result store it where it will be safe for any further gc

   832   // until we return now that we've released the handle it might be protected by

   833 

   834   {

   835     Label no_oop, store_result;

   836 

   837     __ set((intptr_t)AbstractInterpreter::result_handler(T_OBJECT), G3_scratch);

   838     __ cmp(G3_scratch, Lscratch);

   839     __ brx(Assembler::notEqual, false, Assembler::pt, no_oop);

   840     __ delayed()->nop();

   841     __ addcc(G0, O0, O0);

   842     __ brx(Assembler::notZero, true, Assembler::pt, store_result);     // if result is not NULL:

   843     __ delayed()->ld_ptr(O0, 0, O0);                                   // unbox it

   844     __ mov(G0, O0);

   845 

   846     __ bind(store_result);

   847     // Store it where gc will look for it and result handler expects it.

   848     __ st_ptr(O0, STATE(_oop_temp));

   849 

   850     __ bind(no_oop);

   851 

   852   }

   853 

   854   // reset handle block

   855   __ ld_ptr(G2_thread, in_bytes(JavaThread::active_handles_offset()), G3_scratch);

   856   __ st(G0, G3_scratch, JNIHandleBlock::top_offset_in_bytes());

   857 

   858 

   859   // handle exceptions (exception handling will handle unlocking!)

   860   { Label L;

   861     Address exception_addr (G2_thread, in_bytes(Thread::pending_exception_offset()));

   862 

   863     __ ld_ptr(exception_addr, Gtemp);

   864     __ tst(Gtemp);

   865     __ brx(Assembler::equal, false, Assembler::pt, L);

   866     __ delayed()->nop();

   867     __ bind(pending_exception_present);

   868     // With c++ interpreter we just leave it pending caller will do the correct thing. However...

   869     // Like x86 we ignore the result of the native call and leave the method locked. This

   870     // seems wrong to leave things locked.

   871 

   872     __ br(Assembler::always, false, Assembler::pt, StubRoutines::forward_exception_entry(), relocInfo::runtime_call_type);

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

   874 

   875     __ bind(L);

   876   }

   877 

   878   // jvmdi/jvmpi support (preserves thread register)

   879   __ notify_method_exit(true, ilgl, InterpreterMacroAssembler::NotifyJVMTI);

   880 

   881   if (synchronized) {

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

   883     save_native_result();

   884 

   885     const int entry_size            = frame::interpreter_frame_monitor_size() * wordSize;

   886     // Get the initial monitor we allocated

   887     __ sub(Lstate, entry_size, O1);                        // initial monitor

   888     __ unlock_object(O1);

   889     restore_native_result();

   890   }

   891 

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

   893 

   894   // C2 expects long results in G1 we can't tell if we're returning to interpreted

   895   // or compiled so just be safe.

   896 

   897   __ sllx(O0, 32, G1);          // Shift bits into high G1

   898   __ srl (O1, 0, O1);           // Zero extend O1

   899   __ or3 (O1, G1, G1);          // OR 64 bits into G1

   900 

   901 #endif /* COMPILER2 && !_LP64 */

   902 

   903 #ifdef ASSERT

   904   {

   905     Label ok;

   906     __ cmp(I5_savedSP, FP);

   907     __ brx(Assembler::greaterEqualUnsigned, false, Assembler::pt, ok);

   908     __ delayed()->nop();

   909     __ stop("bad I5_savedSP value");

   910     __ should_not_reach_here();

   911     __ bind(ok);

   912   }

   913 #endif

   914   // Calls result handler which POPS FRAME

   915   if (TraceJumps) {

   916     // Move target to register that is recordable

   917     __ mov(Lscratch, G3_scratch);

   918     __ JMP(G3_scratch, 0);

   919   } else {

   920     __ jmp(Lscratch, 0);

   921   }

   922   __ delayed()->nop();

   923 

   924   if (inc_counter) {

   925     // handle invocation counter overflow

   926     __ bind(invocation_counter_overflow);

   927     generate_counter_overflow(Lcontinue);

   928   }

   929 

   930 

   931   return entry;

   932 }

   933 

   934 void CppInterpreterGenerator::generate_compute_interpreter_state(const Register state,

   935                                                               const Register prev_state,

   936                                                               bool native) {

   937 

   938   // On entry

   939   // G5_method - caller's method

   940   // Gargs - points to initial parameters (i.e. locals[0])

   941   // G2_thread - valid? (C1 only??)

   942   // "prev_state" - contains any previous frame manager state which we must save a link

   943   //

   944   // On return

   945   // "state" is a pointer to the newly allocated  state object. We must allocate and initialize

   946   // a new interpretState object and the method expression stack.

   947 

   948   assert_different_registers(state, prev_state);

   949   assert_different_registers(prev_state, G3_scratch);

   950   const Register Gtmp = G3_scratch;

   951   const Address constMethod       (G5_method, in_bytes(Method::const_offset()));

   952   const Address access_flags      (G5_method, in_bytes(Method::access_flags_offset()));

   953 

   954   // slop factor is two extra slots on the expression stack so that

   955   // we always have room to store a result when returning from a call without parameters

   956   // that returns a result.

   957 

   958   const int slop_factor = 2*wordSize;

   959 

   960   const int fixed_size = ((sizeof(BytecodeInterpreter) + slop_factor) >> LogBytesPerWord) + // what is the slop factor?

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

   962                          frame::memory_parameter_word_sp_offset +  // register save area + param window

   963                          (native ?  frame::interpreter_frame_extra_outgoing_argument_words : 0); // JNI, class

   964 

   965   // XXX G5_method valid

   966 

   967   // Now compute new frame size

   968 

   969   if (native) {

   970     const Register RconstMethod = Gtmp;

   971     const Address size_of_parameters(RconstMethod, in_bytes(ConstMethod::size_of_parameters_offset()));

   972     __ ld_ptr(constMethod, RconstMethod);

   973     __ lduh( size_of_parameters, Gtmp );

   974     __ calc_mem_param_words(Gtmp, Gtmp);     // space for native call parameters passed on the stack in words

   975   } else {

   976     // Full size expression stack

   977     __ ld_ptr(constMethod, Gtmp);

   978     __ lduh(Gtmp, in_bytes(ConstMethod::max_stack_offset()), Gtmp);

   979   }

   980   __ add(Gtmp, fixed_size, Gtmp);           // plus the fixed portion

   981 

   982   __ neg(Gtmp);                               // negative space for stack/parameters in words

   983   __ and3(Gtmp, -WordsPerLong, Gtmp);        // make multiple of 2 (SP must be 2-word aligned)

   984   __ sll(Gtmp, LogBytesPerWord, Gtmp);       // negative space for frame in bytes

   985 

   986   // Need to do stack size check here before we fault on large frames

   987 

   988   Label stack_ok;

   989 

   990   const int max_pages = StackShadowPages > (StackRedPages+StackYellowPages) ? StackShadowPages :

   991                                                                               (StackRedPages+StackYellowPages);

   992 

   993 

   994   __ ld_ptr(G2_thread, in_bytes(Thread::stack_base_offset()), O0);

   995   __ ld_ptr(G2_thread, in_bytes(Thread::stack_size_offset()), O1);

   996   // compute stack bottom

   997   __ sub(O0, O1, O0);

   998 

   999   // Avoid touching the guard pages

  1000   // Also a fudge for frame size of BytecodeInterpreter::run

  1001   // It varies from 1k->4k depending on build type

  1002   const int fudge = 6 * K;

  1003 

  1004   __ set(fudge + (max_pages * os::vm_page_size()), O1);

  1005 

  1006   __ add(O0, O1, O0);

  1007   __ sub(O0, Gtmp, O0);

  1008   __ cmp(SP, O0);

  1009   __ brx(Assembler::greaterUnsigned, false, Assembler::pt, stack_ok);

  1010   __ delayed()->nop();

  1011 

  1012      // throw exception return address becomes throwing pc

  1013 

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

  1015   __ stop("never reached");

  1016 

  1017   __ bind(stack_ok);

  1018 

  1019   __ save(SP, Gtmp, SP);                      // setup new frame and register window

  1020 

  1021   // New window I7 call_stub or previous activation

  1022   // O6 - register save area, BytecodeInterpreter just below it, args/locals just above that

  1023   //

  1024   __ sub(FP, sizeof(BytecodeInterpreter), state);        // Point to new Interpreter state

  1025   __ add(state, STACK_BIAS, state );         // Account for 64bit bias

  1026 

  1027 #define XXX_STATE(field_name) state, in_bytes(byte_offset_of(BytecodeInterpreter, field_name))

  1028 

  1029   // Initialize a new Interpreter state

  1030   // orig_sp - caller's original sp

  1031   // G2_thread - thread

  1032   // Gargs - &locals[0] (unbiased?)

  1033   // G5_method - method

  1034   // SP (biased) - accounts for full size java stack, BytecodeInterpreter object, register save area, and register parameter save window

  1035 

  1036 

  1037   __ set(0xdead0004, O1);

  1038 

  1039 

  1040   __ st_ptr(Gargs, XXX_STATE(_locals));

  1041   __ st_ptr(G0, XXX_STATE(_oop_temp));

  1042 

  1043   __ st_ptr(state, XXX_STATE(_self_link));                // point to self

  1044   __ st_ptr(prev_state->after_save(), XXX_STATE(_prev_link)); // Chain interpreter states

  1045   __ st_ptr(G2_thread, XXX_STATE(_thread));               // Store javathread

  1046 

  1047   if (native) {

  1048     __ st_ptr(G0, XXX_STATE(_bcp));

  1049   } else {

  1050     __ ld_ptr(G5_method, in_bytes(Method::const_offset()), O2); // get ConstMethod*

  1051     __ add(O2, in_bytes(ConstMethod::codes_offset()), O2);        // get bcp

  1052     __ st_ptr(O2, XXX_STATE(_bcp));

  1053   }

  1054 

  1055   __ st_ptr(G0, XXX_STATE(_mdx));

  1056   __ st_ptr(G5_method, XXX_STATE(_method));

  1057 

  1058   __ set((int) BytecodeInterpreter::method_entry, O1);

  1059   __ st(O1, XXX_STATE(_msg));

  1060 

  1061   __ ld_ptr(constMethod, O3);

  1062   __ ld_ptr(O3, in_bytes(ConstMethod::constants_offset()), O3);

  1063   __ ld_ptr(O3, ConstantPool::cache_offset_in_bytes(), O2);

  1064   __ st_ptr(O2, XXX_STATE(_constants));

  1065 

  1066   __ st_ptr(G0, XXX_STATE(_result._to_call._callee));

  1067 

  1068   // Monitor base is just start of BytecodeInterpreter object;

  1069   __ mov(state, O2);

  1070   __ st_ptr(O2, XXX_STATE(_monitor_base));

  1071 

  1072   // Do we need a monitor for synchonized method?

  1073   {

  1074     __ ld(access_flags, O1);

  1075     Label done;

  1076     Label got_obj;

  1077     __ btst(JVM_ACC_SYNCHRONIZED, O1);

  1078     __ br( Assembler::zero, false, Assembler::pt, done);

  1079 

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

  1081     __ delayed()->btst(JVM_ACC_STATIC, O1);

  1082     __ ld_ptr(XXX_STATE(_locals), O1);

  1083     __ br( Assembler::zero, true, Assembler::pt, got_obj);

  1084     __ delayed()->ld_ptr(O1, 0, O1);                  // get receiver for not-static case

  1085     __ ld_ptr(constMethod, O1);

  1086     __ ld_ptr( O1, in_bytes(ConstMethod::constants_offset()), O1);

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

  1088     // lock the mirror, not the Klass*

  1089     __ ld_ptr( O1, mirror_offset, O1);

  1090 

  1091     __ bind(got_obj);

  1092 

  1093   #ifdef ASSERT

  1094     __ tst(O1);

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

  1096   #endif // ASSERT

  1097 

  1098     const int entry_size            = frame::interpreter_frame_monitor_size() * wordSize;

  1099     __ sub(SP, entry_size, SP);                         // account for initial monitor

  1100     __ sub(O2, entry_size, O2);                        // initial monitor

  1101     __ st_ptr(O1, O2, BasicObjectLock::obj_offset_in_bytes()); // and allocate it for interpreter use

  1102     __ bind(done);

  1103   }

  1104 

  1105   // Remember initial frame bottom

  1106 

  1107   __ st_ptr(SP, XXX_STATE(_frame_bottom));

  1108 

  1109   __ st_ptr(O2, XXX_STATE(_stack_base));

  1110 

  1111   __ sub(O2, wordSize, O2);                    // prepush

  1112   __ st_ptr(O2, XXX_STATE(_stack));                // PREPUSH

  1113 

  1114   // Full size expression stack

  1115   __ ld_ptr(constMethod, O3);

  1116   __ lduh(O3, in_bytes(ConstMethod::max_stack_offset()), O3);

  1117   __ inc(O3, Method::extra_stack_entries());

  1118   __ sll(O3, LogBytesPerWord, O3);

  1119   __ sub(O2, O3, O3);

  1120 //  __ sub(O3, wordSize, O3);                    // so prepush doesn't look out of bounds

  1121   __ st_ptr(O3, XXX_STATE(_stack_limit));

  1122 

  1123   if (!native) {

  1124     //

  1125     // Code to initialize locals

  1126     //

  1127     Register init_value = noreg;    // will be G0 if we must clear locals

  1128     // Now zero locals

  1129     if (true /* zerolocals */ || ClearInterpreterLocals) {

  1130       // explicitly initialize locals

  1131       init_value = G0;

  1132     } else {

  1133     #ifdef ASSERT

  1134       // initialize locals to a garbage pattern for better debugging

  1135       init_value = O3;