1 /*

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

     3  * Copyright (c) 2015 SAP AG. All rights reserved.

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

     5  *

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

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

     8  * published by the Free Software Foundation.

     9  *

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

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

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

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

    14  * accompanied this code).

    15  *

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

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

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

    19  *

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

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

    22  * questions.

    23  *

    24  */

    25 

    26 #include "precompiled.hpp"

    27 #ifndef CC_INTERP

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

    29 #include "interpreter/bytecodeHistogram.hpp"

    30 #include "interpreter/interpreter.hpp"

    31 #include "interpreter/interpreterGenerator.hpp"

    32 #include "interpreter/interpreterRuntime.hpp"

    33 #include "interpreter/interp_masm.hpp"

    34 #include "interpreter/templateTable.hpp"

    35 #include "oops/arrayOop.hpp"

    36 #include "oops/methodData.hpp"

    37 #include "oops/method.hpp"

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

    39 #include "prims/jvmtiExport.hpp"

    40 #include "prims/jvmtiThreadState.hpp"

    41 #include "runtime/arguments.hpp"

    42 #include "runtime/deoptimization.hpp"

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

    44 #include "runtime/sharedRuntime.hpp"

    45 #include "runtime/stubRoutines.hpp"

    46 #include "runtime/synchronizer.hpp"

    47 #include "runtime/timer.hpp"

    48 #include "runtime/vframeArray.hpp"

    49 #include "utilities/debug.hpp"

    50 #include "utilities/macros.hpp"

    51 

    52 #undef __

    53 #define __ _masm->

    54 

    55 #ifdef PRODUCT

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

    57 #else

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

    59 #endif

    60 

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

    62 

    63 //-----------------------------------------------------------------------------

    64 

    65 // Actually we should never reach here since we do stack overflow checks before pushing any frame.

    66 address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {

    67   address entry = __ pc();

    68   __ unimplemented("generate_StackOverflowError_handler");

    69   return entry;

    70 }

    71 

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

    73   address entry = __ pc();

    74   __ empty_expression_stack();

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

    76   // Index is in R17_tos.

    77   __ mr(R5_ARG3, R17_tos);

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

    79   return entry;

    80 }

    81 

    82 #if 0

    83 // Call special ClassCastException constructor taking object to cast

    84 // and target class as arguments.

    85 address TemplateInterpreterGenerator::generate_ClassCastException_verbose_handler() {

    86   address entry = __ pc();

    87 

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

    89   // exception happened.

    90   __ empty_expression_stack();

    91 

    92   // Thread will be loaded to R3_ARG1.

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

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

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

    96   DEBUG_ONLY(__ should_not_reach_here();)

    97   return entry;

    98 }

    99 #endif

   100 

   101 address TemplateInterpreterGenerator::generate_ClassCastException_handler() {

   102   address entry = __ pc();

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

   104   // exception happened.

   105   __ empty_expression_stack();

   106 

   107   // Load exception object.

   108   // Thread will be loaded to R3_ARG1.

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

   110 #ifdef ASSERT

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

   112   __ should_not_reach_here();

   113 #endif

   114   return entry;

   115 }

   116 

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

   118   address entry = __ pc();

   119   //__ untested("generate_exception_handler_common");

   120   Register Rexception = R17_tos;

   121 

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

   123   __ empty_expression_stack();

   124 

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

   126   if (pass_oop) {

   127     __ mr(R5_ARG3, Rexception);

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

   129   } else {

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

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

   132   }

   133 

   134   // Throw exception.

   135   __ mr(R3_ARG1, Rexception);

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

   137   __ mtctr(R11_scratch1);

   138   __ bctr();

   139 

   140   return entry;

   141 }

   142 

   143 address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {

   144   address entry = __ pc();

   145   __ unimplemented("generate_continuation_for");

   146   return entry;

   147 }

   148 

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

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

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

   152   address entry = __ pc();

   153 

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

   155   switch (state) {

   156     case ltos:

   157     case btos:

   158     case ctos:

   159     case stos:

   160     case atos:

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

   162     case ftos:

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

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

   165     default  : ShouldNotReachHere();

   166   }

   167 

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

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

   170   __ resize_frame_absolute(R12_scratch2, R11_scratch1, R0);

   171 

   172   // Compiled code destroys templateTableBase, reload.

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

   174 

   175   if (state == atos) {

   176     __ profile_return_type(R3_RET, R11_scratch1, R12_scratch2);

   177   }

   178 

   179   const Register cache = R11_scratch1;

   180   const Register size  = R12_scratch2;

   181   __ get_cache_and_index_at_bcp(cache, 1, index_size);

   182 

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

   184 #if defined(VM_LITTLE_ENDIAN)

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

   186 #else

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

   188 #endif

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

   190   __ add(R15_esp, R15_esp, size);

   191   __ dispatch_next(state, step);

   192   return entry;

   193 }

   194 

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

   196   address entry = __ pc();

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

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

   199   // to the TOS cache of current frame.

   200 

   201   switch (state) {

   202     case ltos:

   203     case btos:

   204     case ctos:

   205     case stos:

   206     case atos:

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

   208     case ftos:

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

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

   211     default  : ShouldNotReachHere();

   212   }

   213 

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

   215   __ get_constant_pool_cache(R27_constPoolCache);

   216 

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

   218   __ check_and_forward_exception(R11_scratch1, R12_scratch2);

   219 

   220   // Start executing bytecodes.

   221   __ dispatch_next(state, step);

   222 

   223   return entry;

   224 }

   225 

   226 // A result handler converts the native result into java format.

   227 // Use the shared code between c++ and template interpreter.

   228 address TemplateInterpreterGenerator::generate_result_handler_for(BasicType type) {

   229   return AbstractInterpreterGenerator::generate_result_handler_for(type);

   230 }

   231 

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

   233   address entry = __ pc();

   234 

   235   __ push(state);

   236   __ call_VM(noreg, runtime_entry);

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

   238 

   239   return entry;

   240 }

   241 

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

   243 

   244 // Increment invocation count & check for overflow.

   245 //

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

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

   248 //

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

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

   251   Register Rscratch1   = R11_scratch1;

   252   Register Rscratch2   = R12_scratch2;

   253   Register R3_counters = R3_ARG1;

   254   Label done;

   255 

   256   if (TieredCompilation) {

   257     const int increment = InvocationCounter::count_increment;

   258     const int mask = ((1 << Tier0InvokeNotifyFreqLog) - 1) << InvocationCounter::count_shift;

   259     Label no_mdo;

   260     if (ProfileInterpreter) {

   261       const Register Rmdo = Rscratch1;

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

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

   264       __ cmpdi(CCR0, Rmdo, 0);

   265       __ beq(CCR0, no_mdo);

   266 

   267       // Increment backedge counter in the MDO.

   268       const int mdo_bc_offs = in_bytes(MethodData::backedge_counter_offset()) + in_bytes(InvocationCounter::counter_offset());

   269       __ lwz(Rscratch2, mdo_bc_offs, Rmdo);

   270       __ addi(Rscratch2, Rscratch2, increment);

   271       __ stw(Rscratch2, mdo_bc_offs, Rmdo);

   272       __ load_const_optimized(Rscratch1, mask, R0);

   273       __ and_(Rscratch1, Rscratch2, Rscratch1);

   274       __ bne(CCR0, done);

   275       __ b(*overflow);

   276     }

   277 

   278     // Increment counter in MethodCounters*.

   279     const int mo_bc_offs = in_bytes(MethodCounters::backedge_counter_offset()) + in_bytes(InvocationCounter::counter_offset());

   280     __ bind(no_mdo);

   281     __ get_method_counters(R19_method, R3_counters, done);

   282     __ lwz(Rscratch2, mo_bc_offs, R3_counters);

   283     __ addi(Rscratch2, Rscratch2, increment);

   284     __ stw(Rscratch2, mo_bc_offs, R3_counters);

   285     __ load_const_optimized(Rscratch1, mask, R0);

   286     __ and_(Rscratch1, Rscratch2, Rscratch1);

   287     __ beq(CCR0, *overflow);

   288 

   289     __ bind(done);

   290 

   291   } else {

   292 

   293     // Update standard invocation counters.

   294     Register Rsum_ivc_bec = R4_ARG2;

   295     __ get_method_counters(R19_method, R3_counters, done);

   296     __ increment_invocation_counter(R3_counters, Rsum_ivc_bec, R12_scratch2);

   297     // Increment interpreter invocation counter.

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

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

   300       __ addi(R12_scratch2, R12_scratch2, 1);

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

   302     }

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

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

   305       const Register profile_limit = Rscratch1;

   306       int pl_offs = __ load_const_optimized(profile_limit, &InvocationCounter::InterpreterProfileLimit, R0, true);

   307       __ lwz(profile_limit, pl_offs, profile_limit);

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

   309       __ cmpw(CCR0, Rsum_ivc_bec, profile_limit);

   310       __ blt(CCR0, *profile_method_continue);

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

   312       __ test_method_data_pointer(*profile_method);

   313     }

   314     // Finally check for counter overflow.

   315     if (overflow) {

   316       const Register invocation_limit = Rscratch1;

   317       int il_offs = __ load_const_optimized(invocation_limit, &InvocationCounter::InterpreterInvocationLimit, R0, true);

   318       __ lwz(invocation_limit, il_offs, invocation_limit);

   319       assert(4 == sizeof(InvocationCounter::InterpreterInvocationLimit), "unexpected field size");

   320       __ cmpw(CCR0, Rsum_ivc_bec, invocation_limit);

   321       __ bge(CCR0, *overflow);

   322     }

   323 

   324     __ bind(done);

   325   }

   326 }

   327 

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

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

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

   331 

   332   // InterpreterRuntime::frequency_counter_overflow takes one arguments,

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

   334   // We pass zero in.

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

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

   337   //

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

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

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

   341 

   342   __ li(R4_ARG2, 0);

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

   344 

   345   // Returns verified_entry_point or NULL.

   346   // We ignore it in any case.

   347   __ b(continue_entry);

   348 }

   349 

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

   351   assert_different_registers(Rmem_frame_size, Rscratch1);

   352   __ generate_stack_overflow_check_with_compare_and_throw(Rmem_frame_size, Rscratch1);

   353 }

   354 

   355 void TemplateInterpreterGenerator::unlock_method(bool check_exceptions) {

   356   __ unlock_object(R26_monitor, check_exceptions);

   357 }

   358 

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

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

   361   const Register Robj_to_lock = Rscratch2;

   362 

   363   {

   364     if (!flags_preloaded) {

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

   366     }

   367 

   368 #ifdef ASSERT

   369     // Check if methods needs synchronization.

   370     {

   371       Label Lok;

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

   373       __ btrue(CCR0,Lok);

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

   375       __ bind(Lok);

   376     }

   377 #endif // ASSERT

   378   }

   379 

   380   // Get synchronization object to Rscratch2.

   381   {

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

   383     Label Lstatic;

   384     Label Ldone;

   385 

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

   387     __ btrue(CCR0, Lstatic);

   388 

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

   390     __ ld(Robj_to_lock, R18_locals);

   391     __ b(Ldone);

   392 

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

   394     __ ld(Robj_to_lock, in_bytes(Method::const_offset()), R19_method);

   395     __ ld(Robj_to_lock, in_bytes(ConstMethod::constants_offset()), Robj_to_lock);

   396     __ ld(Robj_to_lock, ConstantPool::pool_holder_offset_in_bytes(), Robj_to_lock);

   397     __ ld(Robj_to_lock, mirror_offset, Robj_to_lock);

   398 

   399     __ bind(Ldone);

   400     __ verify_oop(Robj_to_lock);

   401   }

   402 

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

   404   __ add_monitor_to_stack(true, Rscratch1, R0);

   405 

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

   407   __ lock_object(R26_monitor, Robj_to_lock);

   408 }

   409 

   410 // Generate a fixed interpreter frame for pure interpreter

   411 // and I2N native transition frames.

   412 //

   413 // Before (stack grows downwards):

   414 //

   415 //         |  ...         |

   416 //         |------------- |

   417 //         |  java arg0   |

   418 //         |  ...         |

   419 //         |  java argn   |

   420 //         |              |   <-   R15_esp

   421 //         |              |

   422 //         |--------------|

   423 //         | abi_112      |

   424 //         |              |   <-   R1_SP

   425 //         |==============|

   426 //

   427 //

   428 // After:

   429 //

   430 //         |  ...         |

   431 //         |  java arg0   |<-   R18_locals

   432 //         |  ...         |

   433 //         |  java argn   |

   434 //         |--------------|

   435 //         |              |

   436 //         |  java locals |

   437 //         |              |

   438 //         |--------------|

   439 //         |  abi_48      |

   440 //         |==============|

   441 //         |              |

   442 //         |   istate     |

   443 //         |              |

   444 //         |--------------|

   445 //         |   monitor    |<-   R26_monitor

   446 //         |--------------|

   447 //         |              |<-   R15_esp

   448 //         | expression   |

   449 //         | stack        |

   450 //         |              |

   451 //         |--------------|

   452 //         |              |

   453 //         | abi_112      |<-   R1_SP

   454 //         |==============|

   455 //

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

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

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

   459 // space on the stack, we resize the caller. However, java local reside in

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

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

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

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

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

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

   466 //          + (R1_SP - R15_esp) + 48

   467 //

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

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

   470 //

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

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

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

   474 //

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

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

   477            top_frame_size      = R7_ARG5,

   478            Rconst_method       = R8_ARG6;

   479 

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

   481 

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

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

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

   485   if (native_call) {

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

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

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

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

   490     Label skip_native_calculate_max_stack;

   491     __ addi(top_frame_size, Rsize_of_parameters, 2);

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

   493     __ bge(CCR0, skip_native_calculate_max_stack);

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

   495     __ bind(skip_native_calculate_max_stack);

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

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

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

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

   500   } else {

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

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

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

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

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

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

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

   508     __ add(parent_frame_resize, parent_frame_resize, R11_scratch1);

   509   }

   510 

   511   // Compute top frame size.

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

   513 

   514   // Cut back area between esp and max_stack.

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

   516 

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

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

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

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

   521 

   522   {

   523     // --------------------------------------------------------------------------

   524     // Stack overflow check

   525 

   526     Label cont;

   527     __ add(R11_scratch1, parent_frame_resize, top_frame_size);

   528     generate_stack_overflow_check(R11_scratch1, R12_scratch2);

   529   }

   530 

   531   // Set up interpreter state registers.

   532 

   533   __ add(R18_locals, R15_esp, Rsize_of_parameters);

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

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

   536 

   537   // Set method data pointer.

   538   if (ProfileInterpreter) {

   539     Label zero_continue;

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

   541     __ cmpdi(CCR0, R28_mdx, 0);

   542     __ beq(CCR0, zero_continue);

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

   544     __ bind(zero_continue);

   545   }

   546 

   547   if (native_call) {

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

   549   } else {

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

   551   }

   552 

   553   // Resize parent frame.

   554   __ mflr(R12_scratch2);

   555   __ neg(parent_frame_resize, parent_frame_resize);

   556   __ resize_frame(parent_frame_resize, R11_scratch1);

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

   558 

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

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

   561 

   562   // Store values.

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

   564   // in InterpreterMacroAssembler::call_from_interpreter.

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

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

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

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

   569 

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

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

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

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

   574   // (Enhanced Stack Trace).

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

   576   __ li(R0, 0);

   577 #ifdef ASSERT

   578   // Fill remaining slots with constants.

   579   __ load_const_optimized(R11_scratch1, 0x5afe);

   580   __ load_const_optimized(R12_scratch2, 0xdead);

   581 #endif

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

   583   if (native_call) {

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

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

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

   587   }

   588 #ifdef ASSERT

   589   else {

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

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

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

   593   }

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

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

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

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

   598 #endif

   599   __ subf(R12_scratch2, top_frame_size, R1_SP);

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

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

   602 

   603   // Push top frame.

   604   __ push_frame(top_frame_size, R11_scratch1);

   605 }

   606 

   607 // End of helpers

   608 

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

   610   if (!TemplateInterpreter::math_entry_available(kind)) {

   611     NOT_PRODUCT(__ should_not_reach_here();)

   612     return NULL;

   613   }

   614 

   615   address entry = __ pc();

   616 

   617   __ lfd(F1_RET, Interpreter::stackElementSize, R15_esp);

   618 

   619   // Pop c2i arguments (if any) off when we return.

   620 #ifdef ASSERT

   621   __ ld(R9_ARG7, 0, R1_SP);

   622   __ ld(R10_ARG8, 0, R21_sender_SP);

   623   __ cmpd(CCR0, R9_ARG7, R10_ARG8);

   624   __ asm_assert_eq("backlink", 0x545);

   625 #endif // ASSERT

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

   627 

   628   if (kind == Interpreter::java_lang_math_sqrt) {

   629     __ fsqrt(F1_RET, F1_RET);

   630   } else if (kind == Interpreter::java_lang_math_abs) {

   631     __ fabs(F1_RET, F1_RET);

   632   } else {

   633     ShouldNotReachHere();

   634   }

   635 

   636   // And we're done.

   637   __ blr();

   638 

   639   __ flush();

   640 

   641   return entry;

   642 }

   643 

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

   645 // This sets up a somewhat different looking stack for calling the

   646 // native method than the typical interpreter frame setup.

   647 //

   648 // On entry:

   649 //   R19_method    - method

   650 //   R16_thread    - JavaThread*

   651 //   R15_esp       - intptr_t* sender tos

   652 //

   653 //   abstract stack (grows up)

   654 //     [  IJava (caller of JNI callee)  ]  <-- ASP

   655 //        ...

   656 address TemplateInterpreterGenerator::generate_native_entry(bool synchronized) {

   657 

   658   address entry = __ pc();

   659 

   660   const bool inc_counter = UseCompiler || CountCompiledCalls || LogTouchedMethods;

   661 

   662   // -----------------------------------------------------------------------------

   663   // Allocate a new frame that represents the native callee (i2n frame).

   664   // This is not a full-blown interpreter frame, but in particular, the

   665   // following registers are valid after this:

   666   // - R19_method

   667   // - R18_local (points to start of argumuments to native function)

   668   //

   669   //   abstract stack (grows up)

   670   //     [  IJava (caller of JNI callee)  ]  <-- ASP

   671   //        ...

   672 

   673   const Register signature_handler_fd = R11_scratch1;

   674   const Register pending_exception    = R0;

   675   const Register result_handler_addr  = R31;

   676   const Register native_method_fd     = R11_scratch1;

   677   const Register access_flags         = R22_tmp2;

   678   const Register active_handles       = R11_scratch1; // R26_monitor saved to state.

   679   const Register sync_state           = R12_scratch2;

   680   const Register sync_state_addr      = sync_state;   // Address is dead after use.

   681   const Register suspend_flags        = R11_scratch1;

   682 

   683   //=============================================================================

   684   // Allocate new frame and initialize interpreter state.

   685 

   686   Label exception_return;

   687   Label exception_return_sync_check;

   688   Label stack_overflow_return;

   689 

   690   // Generate new interpreter state and jump to stack_overflow_return in case of

   691   // a stack overflow.

   692   //generate_compute_interpreter_state(stack_overflow_return);

   693 

   694   Register size_of_parameters = R22_tmp2;

   695 

   696   generate_fixed_frame(true, size_of_parameters, noreg /* unused */);

   697 

   698   //=============================================================================

   699   // Increment invocation counter. On overflow, entry to JNI method

   700   // will be compiled.

   701   Label invocation_counter_overflow, continue_after_compile;

   702   if (inc_counter) {

   703     if (synchronized) {

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

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

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

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

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

   709       // check this thread local flag.

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

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

   712       __ li(R0, 1);

   713       __ stb(R0, in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()), R16_thread);

   714     }

   715     generate_counter_incr(&invocation_counter_overflow, NULL, NULL);

   716 

   717     BIND(continue_after_compile);

   718     // Reset the _do_not_unlock_if_synchronized flag.

   719     if (synchronized) {

   720       __ li(R0, 0);

   721       __ stb(R0, in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()), R16_thread);

   722     }

   723   }

   724 

   725   // access_flags = method->access_flags();

   726   // Load access flags.

   727   assert(access_flags->is_nonvolatile(),

   728          "access_flags must be in a non-volatile register");

   729   // Type check.

   730   assert(4 == sizeof(AccessFlags), "unexpected field size");

   731   __ lwz(access_flags, method_(access_flags));

   732 

   733   // We don't want to reload R19_method and access_flags after calls

   734   // to some helper functions.

   735   assert(R19_method->is_nonvolatile(),

   736          "R19_method must be a non-volatile register");

   737 

   738   // Check for synchronized methods. Must happen AFTER invocation counter

   739   // check, so method is not locked if counter overflows.

   740 

   741   if (synchronized) {

   742     lock_method(access_flags, R11_scratch1, R12_scratch2, true);

   743 

   744     // Update monitor in state.

   745     __ ld(R11_scratch1, 0, R1_SP);

   746     __ std(R26_monitor, _ijava_state_neg(monitors), R11_scratch1);

   747   }

   748 

   749   // jvmti/jvmpi support

   750   __ notify_method_entry();

   751 

   752   //=============================================================================

   753   // Get and call the signature handler.

   754 

   755   __ ld(signature_handler_fd, method_(signature_handler));

   756   Label call_signature_handler;

   757 

   758   __ cmpdi(CCR0, signature_handler_fd, 0);

   759   __ bne(CCR0, call_signature_handler);

   760 

   761   // Method has never been called. Either generate a specialized

   762   // handler or point to the slow one.

   763   //

   764   // Pass parameter 'false' to avoid exception check in call_VM.

   765   __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), R19_method, false);

   766 

   767   // Check for an exception while looking up the target method. If we

   768   // incurred one, bail.

   769   __ ld(pending_exception, thread_(pending_exception));

   770   __ cmpdi(CCR0, pending_exception, 0);

   771   __ bne(CCR0, exception_return_sync_check); // Has pending exception.

   772 

   773   // Reload signature handler, it may have been created/assigned in the meanwhile.

   774   __ ld(signature_handler_fd, method_(signature_handler));

   775   __ twi_0(signature_handler_fd); // Order wrt. load of klass mirror and entry point (isync is below).

   776 

   777   BIND(call_signature_handler);

   778 

   779   // Before we call the signature handler we push a new frame to

   780   // protect the interpreter frame volatile registers when we return

   781   // from jni but before we can get back to Java.

   782 

   783   // First set the frame anchor while the SP/FP registers are

   784   // convenient and the slow signature handler can use this same frame

   785   // anchor.

   786 

   787   // We have a TOP_IJAVA_FRAME here, which belongs to us.

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

   789 

   790   // Now the interpreter frame (and its call chain) have been

   791   // invalidated and flushed. We are now protected against eager

   792   // being enabled in native code. Even if it goes eager the

   793   // registers will be reloaded as clean and we will invalidate after

   794   // the call so no spurious flush should be possible.

   795 

   796   // Call signature handler and pass locals address.

   797   //

   798   // Our signature handlers copy required arguments to the C stack

   799   // (outgoing C args), R3_ARG1 to R10_ARG8, and FARG1 to FARG13.

   800   __ mr(R3_ARG1, R18_locals);

   801 #if !defined(ABI_ELFv2)

   802   __ ld(signature_handler_fd, 0, signature_handler_fd);

   803 #endif

   804 

   805   __ call_stub(signature_handler_fd);

   806 

   807   // Remove the register parameter varargs slots we allocated in

   808   // compute_interpreter_state. SP+16 ends up pointing to the ABI

   809   // outgoing argument area.

   810   //

   811   // Not needed on PPC64.

   812   //__ add(SP, SP, Argument::n_register_parameters*BytesPerWord);

   813 

   814   assert(result_handler_addr->is_nonvolatile(), "result_handler_addr must be in a non-volatile register");

   815   // Save across call to native method.

   816   __ mr(result_handler_addr, R3_RET);

   817 

   818   __ isync(); // Acquire signature handler before trying to fetch the native entry point and klass mirror.

   819 

   820   // Set up fixed parameters and call the native method.

   821   // If the method is static, get mirror into R4_ARG2.

   822   {

   823     Label method_is_not_static;

   824     // Access_flags is non-volatile and still, no need to restore it.

   825 

   826     // Restore access flags.

   827     __ testbitdi(CCR0, R0, access_flags, JVM_ACC_STATIC_BIT);

   828     __ bfalse(CCR0, method_is_not_static);

   829 

   830     // constants = method->constants();

   831     __ ld(R11_scratch1, in_bytes(Method::const_offset()), R19_method);

   832     __ ld(R11_scratch1, in_bytes(ConstMethod::constants_offset()), R11_scratch1);

   833     // pool_holder = method->constants()->pool_holder();

   834     __ ld(R11_scratch1/*pool_holder*/, ConstantPool::pool_holder_offset_in_bytes(),

   835           R11_scratch1/*constants*/);

   836 

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

   838 

   839     // mirror = pool_holder->klass_part()->java_mirror();

   840     __ ld(R0/*mirror*/, mirror_offset, R11_scratch1/*pool_holder*/);

   841     // state->_native_mirror = mirror;

   842 

   843     __ ld(R11_scratch1, 0, R1_SP);

   844     __ std(R0/*mirror*/, _ijava_state_neg(oop_tmp), R11_scratch1);

   845     // R4_ARG2 = &state->_oop_temp;

   846     __ addi(R4_ARG2, R11_scratch1, _ijava_state_neg(oop_tmp));

   847     BIND(method_is_not_static);

   848   }

   849 

   850   // At this point, arguments have been copied off the stack into

   851   // their JNI positions. Oops are boxed in-place on the stack, with

   852   // handles copied to arguments. The result handler address is in a

   853   // register.

   854 

   855   // Pass JNIEnv address as first parameter.

   856   __ addir(R3_ARG1, thread_(jni_environment));

   857 

   858   // Load the native_method entry before we change the thread state.

   859   __ ld(native_method_fd, method_(native_function));

   860 

   861   //=============================================================================

   862   // Transition from _thread_in_Java to _thread_in_native. As soon as

   863   // we make this change the safepoint code needs to be certain that

   864   // the last Java frame we established is good. The pc in that frame

   865   // just needs to be near here not an actual return address.

   866 

   867   // We use release_store_fence to update values like the thread state, where

   868   // we don't want the current thread to continue until all our prior memory

   869   // accesses (including the new thread state) are visible to other threads.

   870   __ li(R0, _thread_in_native);

   871   __ release();

   872 

   873   // TODO PPC port assert(4 == JavaThread::sz_thread_state(), "unexpected field size");

   874   __ stw(R0, thread_(thread_state));

   875 

   876   if (UseMembar) {

   877     __ fence();

   878   }

   879 

   880   //=============================================================================

   881   // Call the native method. Argument registers must not have been

   882   // overwritten since "__ call_stub(signature_handler);" (except for

   883   // ARG1 and ARG2 for static methods).

   884   __ call_c(native_method_fd);

   885 

   886   __ li(R0, 0);

   887   __ ld(R11_scratch1, 0, R1_SP);

   888   __ std(R3_RET, _ijava_state_neg(lresult), R11_scratch1);

   889   __ stfd(F1_RET, _ijava_state_neg(fresult), R11_scratch1);

   890   __ std(R0/*mirror*/, _ijava_state_neg(oop_tmp), R11_scratch1); // reset

   891 

   892   // Note: C++ interpreter needs the following here:

   893   // The frame_manager_lr field, which we use for setting the last

   894   // java frame, gets overwritten by the signature handler. Restore

   895   // it now.

   896   //__ get_PC_trash_LR(R11_scratch1);

   897   //__ std(R11_scratch1, _top_ijava_frame_abi(frame_manager_lr), R1_SP);

   898 

   899   // Because of GC R19_method may no longer be valid.

   900 

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

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

   903   // blocking.

   904 

   905   //=============================================================================

   906   // Switch thread to "native transition" state before reading the

   907   // synchronization state. This additional state is necessary

   908   // because reading and testing the synchronization state is not

   909   // atomic w.r.t. GC, as this scenario demonstrates: Java thread A,

   910   // in _thread_in_native state, loads _not_synchronized and is

   911   // preempted. VM thread changes sync state to synchronizing and

   912   // suspends threads for GC. Thread A is resumed to finish this

   913   // native method, but doesn't block here since it didn't see any

   914   // synchronization in progress, and escapes.

   915 

   916   // We use release_store_fence to update values like the thread state, where

   917   // we don't want the current thread to continue until all our prior memory

   918   // accesses (including the new thread state) are visible to other threads.

   919   __ li(R0/*thread_state*/, _thread_in_native_trans);

   920   __ release();

   921   __ stw(R0/*thread_state*/, thread_(thread_state));

   922   if (UseMembar) {

   923     __ fence();

   924   }

   925   // Write serialization page so that the VM thread can do a pseudo remote

   926   // membar. We use the current thread pointer to calculate a thread

   927   // specific offset to write to within the page. This minimizes bus

   928   // traffic due to cache line collision.

   929   else {

   930     __ serialize_memory(R16_thread, R11_scratch1, R12_scratch2);

   931   }

   932 

   933   // Now before we return to java we must look for a current safepoint

   934   // (a new safepoint can not start since we entered native_trans).

   935   // We must check here because a current safepoint could be modifying

   936   // the callers registers right this moment.

   937 

   938   // Acquire isn't strictly necessary here because of the fence, but

   939   // sync_state is declared to be volatile, so we do it anyway

   940   // (cmp-br-isync on one path, release (same as acquire on PPC64) on the other path).

   941   int sync_state_offs = __ load_const_optimized(sync_state_addr, SafepointSynchronize::address_of_state(), /*temp*/R0, true);

   942 

   943   // TODO PPC port assert(4 == SafepointSynchronize::sz_state(), "unexpected field size");

   944   __ lwz(sync_state, sync_state_offs, sync_state_addr);

   945 

   946   // TODO PPC port assert(4 == Thread::sz_suspend_flags(), "unexpected field size");

   947   __ lwz(suspend_flags, thread_(suspend_flags));

   948 

   949   Label sync_check_done;

   950   Label do_safepoint;

   951   // No synchronization in progress nor yet synchronized.

   952   __ cmpwi(CCR0, sync_state, SafepointSynchronize::_not_synchronized);

   953   // Not suspended.

   954   __ cmpwi(CCR1, suspend_flags, 0);

   955 

   956   __ bne(CCR0, do_safepoint);

   957   __ beq(CCR1, sync_check_done);

   958   __ bind(do_safepoint);

   959   __ isync();

   960   // Block. We do the call directly and leave the current

   961   // last_Java_frame setup undisturbed. We must save any possible

   962   // native result across the call. No oop is present.

   963 

   964   __ mr(R3_ARG1, R16_thread);

   965 #if defined(ABI_ELFv2)

   966   __ call_c(CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans),

   967             relocInfo::none);

   968 #else

   969   __ call_c(CAST_FROM_FN_PTR(FunctionDescriptor*, JavaThread::check_special_condition_for_native_trans),

   970             relocInfo::none);

   971 #endif

   972 

   973   __ bind(sync_check_done);

   974 

   975   //=============================================================================

   976   // <<<<<< Back in Interpreter Frame >>>>>

   977 

   978   // We are in thread_in_native_trans here and back in the normal

   979   // interpreter frame. We don't have to do anything special about

   980   // safepoints and we can switch to Java mode anytime we are ready.

   981 

   982   // Note: frame::interpreter_frame_result has a dependency on how the

   983   // method result is saved across the call to post_method_exit. For

   984   // native methods it assumes that the non-FPU/non-void result is

   985   // saved in _native_lresult and a FPU result in _native_fresult. If

   986   // this changes then the interpreter_frame_result implementation

   987   // will need to be updated too.

   988 

   989   // On PPC64, we have stored the result directly after the native call.

   990 

   991   //=============================================================================

   992   // Back in Java

   993 

   994   // We use release_store_fence to update values like the thread state, where

   995   // we don't want the current thread to continue until all our prior memory

   996   // accesses (including the new thread state) are visible to other threads.

   997   __ li(R0/*thread_state*/, _thread_in_Java);

   998   __ release();

   999   __ stw(R0/*thread_state*/, thread_(thread_state));

  1000   if (UseMembar) {

  1001     __ fence();

  1002   }

  1003 

  1004   __ reset_last_Java_frame();

  1005 

  1006   // Jvmdi/jvmpi support. Whether we've got an exception pending or

  1007   // not, and whether unlocking throws an exception or not, we notify

  1008   // on native method exit. If we do have an exception, we'll end up

  1009   // in the caller's context to handle it, so if we don't do the

  1010   // notify here, we'll drop it on the floor.

  1011   __ notify_method_exit(true/*native method*/,

  1012                         ilgl /*illegal state (not used for native methods)*/,

  1013                         InterpreterMacroAssembler::NotifyJVMTI,

  1014                         false /*check_exceptions*/);

  1015 

  1016   //=============================================================================

  1017   // Handle exceptions

  1018 

  1019   if (synchronized) {

  1020     // Don't check for exceptions since we're still in the i2n frame. Do that

  1021     // manually afterwards.

  1022     unlock_method(false);

  1023   }

  1024 

  1025   // Reset active handles after returning from native.

  1026   // thread->active_handles()->clear();

  1027   __ ld(active_handles, thread_(active_handles));

  1028   // TODO PPC port assert(4 == JNIHandleBlock::top_size_in_bytes(), "unexpected field size");

  1029   __ li(R0, 0);

  1030   __ stw(R0, JNIHandleBlock::top_offset_in_bytes(), active_handles);

  1031 

  1032   Label exception_return_sync_check_already_unlocked;

  1033   __ ld(R0/*pending_exception*/, thread_(pending_exception));

  1034   __ cmpdi(CCR0, R0/*pending_exception*/, 0);

  1035   __ bne(CCR0, exception_return_sync_check_already_unlocked);

  1036 

  1037   //-----------------------------------------------------------------------------

  1038   // No exception pending.

  1039 

  1040   // Move native method result back into proper registers and return.

  1041   // Invoke result handler (may unbox/promote).

  1042   __ ld(R11_scratch1, 0, R1_SP);

  1043   __ ld(R3_RET, _ijava_state_neg(lresult), R11_scratch1);

  1044   __ lfd(F1_RET, _ijava_state_neg(fresult), R11_scratch1);

  1045   __ call_stub(result_handler_addr);

  1046 

  1047   __ merge_frames(/*top_frame_sp*/ R21_sender_SP, /*return_pc*/ R0, R11_scratch1, R12_scratch2);

  1048 

  1049   // Must use the return pc which was loaded from the caller's frame

  1050   // as the VM uses return-pc-patching for deoptimization.

  1051   __ mtlr(R0);

  1052   __ blr();

  1053 

  1054   //-----------------------------------------------------------------------------

  1055   // An exception is pending. We call into the runtime only if the

  1056   // caller was not interpreted. If it was interpreted the

  1057   // interpreter will do the correct thing. If it isn't interpreted

  1058   // (call stub/compiled code) we will change our return and continue.

  1059 

  1060   BIND(exception_return_sync_check);

  1061 

  1062   if (synchronized) {

  1063     // Don't check for exceptions since we're still in the i2n frame. Do that

  1064     // manually afterwards.

  1065     unlock_method(false);

  1066   }

  1067   BIND(exception_return_sync_check_already_unlocked);

  1068 

  1069   const Register return_pc = R31;

  1070 

  1071   __ ld(return_pc, 0, R1_SP);

  1072   __ ld(return_pc, _abi(lr), return_pc);

  1073 

  1074   // Get the address of the exception handler.

  1075   __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address),

  1076                   R16_thread,

  1077                   return_pc /* return pc */);

  1078   __ merge_frames(/*top_frame_sp*/ R21_sender_SP, noreg, R11_scratch1, R12_scratch2);

  1079 

  1080   // Load the PC of the the exception handler into LR.

  1081   __ mtlr(R3_RET);

  1082 

  1083   // Load exception into R3_ARG1 and clear pending exception in thread.

  1084   __ ld(R3_ARG1/*exception*/, thread_(pending_exception));

  1085   __ li(R4_ARG2, 0);

  1086   __ std(R4_ARG2, thread_(pending_exception));

  1087 

  1088   // Load the original return pc into R4_ARG2.

  1089   __ mr(R4_ARG2/*issuing_pc*/, return_pc);

  1090 

  1091   // Return to exception handler.

  1092   __ blr();

  1093 

  1094   //=============================================================================

  1095   // Counter overflow.

  1096 

  1097   if (inc_counter) {

  1098     // Handle invocation counter overflow.

  1099     __ bind(invocation_counter_overflow);

  1100 

  1101     generate_counter_overflow(continue_after_compile);

  1102   }

  1103 

  1104   return entry;

  1105 }

  1106 

  1107 // Generic interpreted method entry to (asm) interpreter.

  1108 //

  1109 address TemplateInterpreterGenerator::generate_normal_entry(bool synchronized) {

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

  1111   address entry = __ pc();

  1112   // Generate the code to allocate the interpreter stack frame.

  1113   Register Rsize_of_parameters = R4_ARG2, // Written by generate_fixed_frame.

  1114            Rsize_of_locals     = R5_ARG3; // Written by generate_fixed_frame.

  1115 

  1116   generate_fixed_frame(false, Rsize_of_parameters, Rsize_of_locals);

  1117 

  1118   // --------------------------------------------------------------------------

  1119   // Zero out non-parameter locals.

  1120   // Note: *Always* zero out non-parameter locals as Sparc does. It's not

  1121   // worth to ask the flag, just do it.

  1122   Register Rslot_addr = R6_ARG4,

  1123            Rnum       = R7_ARG5;

  1124   Label Lno_locals, Lzero_loop;

  1125 

  1126   // Set up the zeroing loop.

  1127   __ subf(Rnum, Rsize_of_parameters, Rsize_of_locals);

  1128   __ subf(Rslot_addr, Rsize_of_parameters, R18_locals);

  1129   __ srdi_(Rnum, Rnum, Interpreter::logStackElementSize);

  1130   __ beq(CCR0, Lno_locals);

  1131   __ li(R0, 0);

  1132   __ mtctr(Rnum);

  1133 

  1134   // The zero locals loop.