1 /*

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

     3  * Copyright 2013, 2014 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/templateTable.hpp"

    34 #include "oops/arrayOop.hpp"

    35 #include "oops/methodData.hpp"

    36 #include "oops/method.hpp"

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

    38 #include "prims/jvmtiExport.hpp"

    39 #include "prims/jvmtiThreadState.hpp"

    40 #include "runtime/arguments.hpp"

    41 #include "runtime/deoptimization.hpp"

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

    43 #include "runtime/sharedRuntime.hpp"

    44 #include "runtime/stubRoutines.hpp"

    45 #include "runtime/synchronizer.hpp"

    46 #include "runtime/timer.hpp"

    47 #include "runtime/vframeArray.hpp"

    48 #include "utilities/debug.hpp"

    49 #include "utilities/macros.hpp"

    50 

    51 #undef __

    52 #define __ _masm->

    53 

    54 #ifdef PRODUCT

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

    56 #else

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

    58 #endif

    59 

    60 #define BIND(label) bind(label); BLOCK_COMMENT(#label ":")

    61 

    62 //-----------------------------------------------------------------------------

    63 

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

    65 address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {

    66   address entry = __ pc();

    67   __ unimplemented("generate_StackOverflowError_handler");

    68   return entry;

    69 }

    70 

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

    72   address entry = __ pc();

    73   __ empty_expression_stack();

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

    75   // Index is in R17_tos.

    76   __ mr(R5_ARG3, R17_tos);

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

    78   return entry;

    79 }

    80 

    81 #if 0

    82 // Call special ClassCastException constructor taking object to cast

    83 // and target class as arguments.

    84 address TemplateInterpreterGenerator::generate_ClassCastException_verbose_handler(const char* name) {

    85   address entry = __ pc();

    86 

    87   // Target class oop is in register R6_ARG4 by convention!

    88 

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

    90   // exception happened.

    91   __ empty_expression_stack();

    92   // Setup parameters.

    93   // Thread will be loaded to R3_ARG1.

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

    95   __ mr(R5_ARG3, R17_tos);

    96   // R6_ARG4 contains specified class.

    97   __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ClassCastException_verbose));

    98 #ifdef ASSERT

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

   100   __ should_not_reach_here();

   101 #endif

   102   return entry;

   103 }

   104 #endif

   105 

   106 address TemplateInterpreterGenerator::generate_ClassCastException_handler() {

   107   address entry = __ pc();

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

   109   // exception happened.

   110   __ empty_expression_stack();

   111 

   112   // Load exception object.

   113   // Thread will be loaded to R3_ARG1.

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

   115 #ifdef ASSERT

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

   117   __ should_not_reach_here();

   118 #endif

   119   return entry;

   120 }

   121 

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

   123   address entry = __ pc();

   124   //__ untested("generate_exception_handler_common");

   125   Register Rexception = R17_tos;

   126 

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

   128   __ empty_expression_stack();

   129 

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

   131   if (pass_oop) {

   132     __ mr(R5_ARG3, Rexception);

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

   134   } else {

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

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

   137   }

   138 

   139   // Throw exception.

   140   __ mr(R3_ARG1, Rexception);

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

   142   __ mtctr(R11_scratch1);

   143   __ bctr();

   144 

   145   return entry;

   146 }

   147 

   148 address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {

   149   address entry = __ pc();

   150   __ unimplemented("generate_continuation_for");

   151   return entry;

   152 }

   153 

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

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

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

   157   address entry = __ pc();

   158 

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

   160   switch (state) {

   161     case ltos:

   162     case btos:

   163     case ctos:

   164     case stos:

   165     case atos:

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

   167     case ftos:

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

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

   170     default  : ShouldNotReachHere();

   171   }

   172 

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

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

   175   __ resize_frame_absolute(R12_scratch2, R11_scratch1, R0);

   176 

   177   // Compiled code destroys templateTableBase, reload.

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

   179 

   180   const Register cache = R11_scratch1;

   181   const Register size  = R12_scratch2;

   182   __ get_cache_and_index_at_bcp(cache, 1, index_size);

   183 

   184   // Big Endian (get least significant byte of 64 bit value):

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

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

   187   __ add(R15_esp, R15_esp, size);

   188   __ dispatch_next(state, step);

   189   return entry;

   190 }

   191 

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

   193   address entry = __ pc();

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

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

   196   // to the TOS cache of current frame.

   197 

   198   switch (state) {

   199     case ltos:

   200     case btos:

   201     case ctos:

   202     case stos:

   203     case atos:

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

   205     case ftos:

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

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

   208     default  : ShouldNotReachHere();

   209   }

   210 

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

   212   __ get_constant_pool_cache(R27_constPoolCache);

   213 

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

   215   __ check_and_forward_exception(R11_scratch1, R12_scratch2);

   216 

   217   // Start executing bytecodes.

   218   __ dispatch_next(state, step);

   219 

   220   return entry;

   221 }

   222 

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

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

   225 address TemplateInterpreterGenerator::generate_result_handler_for(BasicType type) {

   226   return AbstractInterpreterGenerator::generate_result_handler_for(type);

   227 }

   228 

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

   230   address entry = __ pc();

   231 

   232   __ push(state);

   233   __ call_VM(noreg, runtime_entry);

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

   235 

   236   return entry;

   237 }

   238 

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

   240 

   241 // Increment invocation count & check for overflow.

   242 //

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

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

   245 //

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

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

   248   Register Rscratch1   = R11_scratch1;

   249   Register Rscratch2   = R12_scratch2;

   250   Register R3_counters = R3_ARG1;

   251   Label done;

   252 

   253   if (TieredCompilation) {

   254     const int increment = InvocationCounter::count_increment;

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

   256     Label no_mdo;

   257     if (ProfileInterpreter) {

   258       const Register Rmdo = Rscratch1;

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

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

   261       __ cmpdi(CCR0, Rmdo, 0);

   262       __ beq(CCR0, no_mdo);

   263 

   264       // Increment backedge counter in the MDO.

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

   266       __ lwz(Rscratch2, mdo_bc_offs, Rmdo);

   267       __ addi(Rscratch2, Rscratch2, increment);

   268       __ stw(Rscratch2, mdo_bc_offs, Rmdo);

   269       __ load_const_optimized(Rscratch1, mask, R0);

   270       __ and_(Rscratch1, Rscratch2, Rscratch1);

   271       __ bne(CCR0, done);

   272       __ b(*overflow);

   273     }

   274 

   275     // Increment counter in MethodCounters*.

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

   277     __ bind(no_mdo);

   278     __ get_method_counters(R19_method, R3_counters, done);

   279     __ lwz(Rscratch2, mo_bc_offs, R3_counters);

   280     __ addi(Rscratch2, Rscratch2, increment);

   281     __ stw(Rscratch2, mo_bc_offs, R3_counters);

   282     __ load_const_optimized(Rscratch1, mask, R0);

   283     __ and_(Rscratch1, Rscratch2, Rscratch1);

   284     __ beq(CCR0, *overflow);

   285 

   286     __ bind(done);

   287 

   288   } else {

   289 

   290     // Update standard invocation counters.

   291     Register Rsum_ivc_bec = R4_ARG2;

   292     __ get_method_counters(R19_method, R3_counters, done);

   293     __ increment_invocation_counter(R3_counters, Rsum_ivc_bec, R12_scratch2);

   294     // Increment interpreter invocation counter.

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

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

   297       __ addi(R12_scratch2, R12_scratch2, 1);

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

   299     }

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

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

   302       const Register profile_limit = Rscratch1;

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

   304       __ lwz(profile_limit, pl_offs, profile_limit);

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

   306       __ cmpw(CCR0, Rsum_ivc_bec, profile_limit);

   307       __ blt(CCR0, *profile_method_continue);

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

   309       __ test_method_data_pointer(*profile_method);

   310     }

   311     // Finally check for counter overflow.

   312     if (overflow) {

   313       const Register invocation_limit = Rscratch1;

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

   315       __ lwz(invocation_limit, il_offs, invocation_limit);

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

   317       __ cmpw(CCR0, Rsum_ivc_bec, invocation_limit);

   318       __ bge(CCR0, *overflow);

   319     }

   320 

   321     __ bind(done);

   322   }

   323 }

   324 

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

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

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

   328 

   329   // InterpreterRuntime::frequency_counter_overflow takes one arguments,

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

   331   // We pass zero in.

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

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

   334   //

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

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

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

   338 

   339   __ li(R4_ARG2, 0);

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

   341 

   342   // Returns verified_entry_point or NULL.

   343   // We ignore it in any case.

   344   __ b(continue_entry);

   345 }

   346 

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

   348   assert_different_registers(Rmem_frame_size, Rscratch1);

   349   __ generate_stack_overflow_check_with_compare_and_throw(Rmem_frame_size, Rscratch1);

   350 }

   351 

   352 void TemplateInterpreterGenerator::unlock_method(bool check_exceptions) {

   353   __ unlock_object(R26_monitor, check_exceptions);

   354 }

   355 

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

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

   358   const Register Robj_to_lock = Rscratch2;

   359 

   360   {

   361     if (!flags_preloaded) {

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

   363     }

   364 

   365 #ifdef ASSERT

   366     // Check if methods needs synchronization.

   367     {

   368       Label Lok;

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

   370       __ btrue(CCR0,Lok);

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

   372       __ bind(Lok);

   373     }

   374 #endif // ASSERT

   375   }

   376 

   377   // Get synchronization object to Rscratch2.

   378   {

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

   380     Label Lstatic;

   381     Label Ldone;

   382 

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

   384     __ btrue(CCR0, Lstatic);

   385 

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

   387     __ ld(Robj_to_lock, R18_locals);

   388     __ b(Ldone);

   389 

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

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

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

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

   394     __ ld(Robj_to_lock, mirror_offset, Robj_to_lock);

   395 

   396     __ bind(Ldone);

   397     __ verify_oop(Robj_to_lock);

   398   }

   399 

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

   401   __ add_monitor_to_stack(true, Rscratch1, R0);

   402 

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

   404   __ lock_object(R26_monitor, Robj_to_lock);

   405 }

   406 

   407 // Generate a fixed interpreter frame for pure interpreter

   408 // and I2N native transition frames.

   409 //

   410 // Before (stack grows downwards):

   411 //

   412 //         |  ...         |

   413 //         |------------- |

   414 //         |  java arg0   |

   415 //         |  ...         |

   416 //         |  java argn   |

   417 //         |              |   <-   R15_esp

   418 //         |              |

   419 //         |--------------|

   420 //         | abi_112      |

   421 //         |              |   <-   R1_SP

   422 //         |==============|

   423 //

   424 //

   425 // After:

   426 //

   427 //         |  ...         |

   428 //         |  java arg0   |<-   R18_locals

   429 //         |  ...         |

   430 //         |  java argn   |

   431 //         |--------------|

   432 //         |              |

   433 //         |  java locals |

   434 //         |              |

   435 //         |--------------|

   436 //         |  abi_48      |

   437 //         |==============|

   438 //         |              |

   439 //         |   istate     |

   440 //         |              |

   441 //         |--------------|

   442 //         |   monitor    |<-   R26_monitor

   443 //         |--------------|

   444 //         |              |<-   R15_esp

   445 //         | expression   |

   446 //         | stack        |

   447 //         |              |

   448 //         |--------------|

   449 //         |              |

   450 //         | abi_112      |<-   R1_SP

   451 //         |==============|

   452 //

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

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

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

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

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

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

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

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

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

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

   463 //          + (R1_SP - R15_esp) + 48

   464 //

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

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

   467 //

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

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

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

   471 //

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

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

   474            top_frame_size      = R7_ARG5,

   475            Rconst_method       = R8_ARG6;

   476 

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

   478 

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

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

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

   482   if (native_call) {

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

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

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

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

   487     Label skip_native_calculate_max_stack;

   488     __ addi(top_frame_size, Rsize_of_parameters, 2);

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

   490     __ bge(CCR0, skip_native_calculate_max_stack);

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

   492     __ bind(skip_native_calculate_max_stack);

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

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

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

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

   497   } else {

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

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

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

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

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

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

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

   505     __ add(parent_frame_resize, parent_frame_resize, R11_scratch1);

   506   }

   507 

   508   // Compute top frame size.

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

   510 

   511   // Cut back area between esp and max_stack.

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

   513 

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

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

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

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

   518 

   519   {

   520     // --------------------------------------------------------------------------

   521     // Stack overflow check

   522 

   523     Label cont;

   524     __ add(R11_scratch1, parent_frame_resize, top_frame_size);

   525     generate_stack_overflow_check(R11_scratch1, R12_scratch2);

   526   }

   527 

   528   // Set up interpreter state registers.

   529 

   530   __ add(R18_locals, R15_esp, Rsize_of_parameters);

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

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

   533 

   534   // Set method data pointer.

   535   if (ProfileInterpreter) {

   536     Label zero_continue;

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

   538     __ cmpdi(CCR0, R28_mdx, 0);

   539     __ beq(CCR0, zero_continue);

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

   541     __ bind(zero_continue);

   542   }

   543 

   544   if (native_call) {

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

   546   } else {

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

   548   }

   549 

   550   // Resize parent frame.

   551   __ mflr(R12_scratch2);

   552   __ neg(parent_frame_resize, parent_frame_resize);

   553   __ resize_frame(parent_frame_resize, R11_scratch1);

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

   555 

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

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

   558 

   559   // Store values.

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

   561   // in InterpreterMacroAssembler::call_from_interpreter.

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

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

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

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

   566 

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

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

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

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

   571   // (Enhanced Stack Trace).

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

   573   __ li(R0, 0);

   574 #ifdef ASSERT

   575   // Fill remaining slots with constants.

   576   __ load_const_optimized(R11_scratch1, 0x5afe);

   577   __ load_const_optimized(R12_scratch2, 0xdead);

   578 #endif

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

   580   if (native_call) {

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

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

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

   584   }

   585 #ifdef ASSERT

   586   else {

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

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

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

   590   }

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

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

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

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

   595 #endif

   596   __ subf(R12_scratch2, top_frame_size, R1_SP);

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

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

   599 

   600   // Push top frame.

   601   __ push_frame(top_frame_size, R11_scratch1);

   602 }

   603 

   604 // End of helpers

   605 

   606 // ============================================================================

   607 // Various method entries

   608 //

   609 

   610 // Empty method, generate a very fast return. We must skip this entry if

   611 // someone's debugging, indicated by the flag

   612 // "interp_mode" in the Thread obj.

   613 // Note: empty methods are generated mostly methods that do assertions, which are

   614 // disabled in the "java opt build".

   615 address TemplateInterpreterGenerator::generate_empty_entry(void) {

   616   if (!UseFastEmptyMethods) {

   617     NOT_PRODUCT(__ should_not_reach_here();)

   618     return Interpreter::entry_for_kind(Interpreter::zerolocals);

   619   }

   620 

   621   Label Lslow_path;

   622   const Register Rjvmti_mode = R11_scratch1;

   623   address entry = __ pc();

   624 

   625   __ lwz(Rjvmti_mode, thread_(interp_only_mode));

   626   __ cmpwi(CCR0, Rjvmti_mode, 0);

   627   __ bne(CCR0, Lslow_path); // jvmti_mode!=0

   628 

   629   // Noone's debuggin: Simply return.

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

   631 #ifdef ASSERT

   632     __ ld(R9_ARG7, 0, R1_SP);

   633     __ ld(R10_ARG8, 0, R21_sender_SP);

   634     __ cmpd(CCR0, R9_ARG7, R10_ARG8);

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

   636 #endif // ASSERT

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

   638 

   639   // And we're done.

   640   __ blr();

   641 

   642   __ bind(Lslow_path);

   643   __ branch_to_entry(Interpreter::entry_for_kind(Interpreter::zerolocals), R11_scratch1);

   644   __ flush();

   645 

   646   return entry;

   647 }

   648 

   649 // Support abs and sqrt like in compiler.

   650 // For others we can use a normal (native) entry.

   651 

   652 inline bool math_entry_available(AbstractInterpreter::MethodKind kind) {

   653   // Provide math entry with debugging on demand.

   654   // Note: Debugging changes which code will get executed:

   655   // Debugging or disabled InlineIntrinsics: java method will get interpreted and performs a native call.

   656   // Not debugging and enabled InlineIntrinics: processor instruction will get used.

   657   // Result might differ slightly due to rounding etc.

   658   if (!InlineIntrinsics && (!FLAG_IS_ERGO(InlineIntrinsics))) return false; // Generate a vanilla entry.

   659 

   660   return ((kind==Interpreter::java_lang_math_sqrt && VM_Version::has_fsqrt()) ||

   661           (kind==Interpreter::java_lang_math_abs));

   662 }

   663 

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

   665   if (!math_entry_available(kind)) {

   666     NOT_PRODUCT(__ should_not_reach_here();)

   667     return Interpreter::entry_for_kind(Interpreter::zerolocals);

   668   }

   669 

   670   Label Lslow_path;

   671   const Register Rjvmti_mode = R11_scratch1;

   672   address entry = __ pc();

   673 

   674   // Provide math entry with debugging on demand.

   675   __ lwz(Rjvmti_mode, thread_(interp_only_mode));

   676   __ cmpwi(CCR0, Rjvmti_mode, 0);

   677   __ bne(CCR0, Lslow_path); // jvmti_mode!=0

   678 

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

   680 

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

   682 #ifdef ASSERT

   683   __ ld(R9_ARG7, 0, R1_SP);

   684   __ ld(R10_ARG8, 0, R21_sender_SP);

   685   __ cmpd(CCR0, R9_ARG7, R10_ARG8);

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

   687 #endif // ASSERT

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

   689 

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

   691     __ fsqrt(F1_RET, F1_RET);

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

   693     __ fabs(F1_RET, F1_RET);

   694   } else {

   695     ShouldNotReachHere();

   696   }

   697 

   698   // And we're done.

   699   __ blr();

   700 

   701   // Provide slow path for JVMTI case.

   702   __ bind(Lslow_path);

   703   __ branch_to_entry(Interpreter::entry_for_kind(Interpreter::zerolocals), R12_scratch2);

   704   __ flush();

   705 

   706   return entry;

   707 }

   708 

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

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

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

   712 //

   713 // On entry:

   714 //   R19_method    - method

   715 //   R16_thread    - JavaThread*

   716 //   R15_esp       - intptr_t* sender tos

   717 //

   718 //   abstract stack (grows up)

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

   720 //        ...

   721 address TemplateInterpreterGenerator::generate_native_entry(bool synchronized) {

   722 

   723   address entry = __ pc();

   724 

   725   const bool inc_counter = UseCompiler || CountCompiledCalls;

   726 

   727   // -----------------------------------------------------------------------------

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

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

   730   // following registers are valid after this:

   731   // - R19_method

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

   733   //

   734   //   abstract stack (grows up)

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

   736   //        ...

   737 

   738   const Register signature_handler_fd = R11_scratch1;

   739   const Register pending_exception    = R0;

   740   const Register result_handler_addr  = R31;

   741   const Register native_method_fd     = R11_scratch1;

   742   const Register access_flags         = R22_tmp2;

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

   744   const Register sync_state           = R12_scratch2;

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

   746   const Register suspend_flags        = R11_scratch1;

   747 

   748   //=============================================================================

   749   // Allocate new frame and initialize interpreter state.

   750 

   751   Label exception_return;

   752   Label exception_return_sync_check;

   753   Label stack_overflow_return;

   754 

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

   756   // a stack overflow.

   757   //generate_compute_interpreter_state(stack_overflow_return);

   758 

   759   Register size_of_parameters = R22_tmp2;

   760 

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

   762 

   763   //=============================================================================

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

   765   // will be compiled.

   766   Label invocation_counter_overflow, continue_after_compile;

   767   if (inc_counter) {

   768     if (synchronized) {

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

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

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

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

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

   774       // check this thread local flag.

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

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

   777       __ li(R0, 1);

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

   779     }

   780     generate_counter_incr(&invocation_counter_overflow, NULL, NULL);

   781 

   782     __ BIND(continue_after_compile);

   783     // Reset the _do_not_unlock_if_synchronized flag.

   784     if (synchronized) {

   785       __ li(R0, 0);

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

   787     }

   788   }

   789 

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

   791   // Load access flags.

   792   assert(access_flags->is_nonvolatile(),

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

   794   // Type check.

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

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

   797 

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

   799   // to some helper functions.

   800   assert(R19_method->is_nonvolatile(),

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

   802 

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

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

   805 

   806   if (synchronized) {

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

   808 

   809     // Update monitor in state.

   810     __ ld(R11_scratch1, 0, R1_SP);

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

   812   }

   813 

   814   // jvmti/jvmpi support

   815   __ notify_method_entry();

   816 

   817   //=============================================================================

   818   // Get and call the signature handler.

   819 

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

   821   Label call_signature_handler;

   822 

   823   __ cmpdi(CCR0, signature_handler_fd, 0);

   824   __ bne(CCR0, call_signature_handler);

   825 

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

   827   // handler or point to the slow one.

   828   //

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

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

   831 

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

   833   // incurred one, bail.

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

   835   __ cmpdi(CCR0, pending_exception, 0);

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

   837 

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

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

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

   841 

   842   __ BIND(call_signature_handler);

   843 

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

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

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

   847 

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

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

   850   // anchor.

   851 

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

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

   854 

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

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

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

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

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

   860 

   861   // Call signature handler and pass locals address.

   862   //

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

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

   865   __ mr(R3_ARG1, R18_locals);

   866   __ ld(signature_handler_fd, 0, signature_handler_fd);

   867 

   868   __ call_stub(signature_handler_fd);

   869 

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

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

   872   // outgoing argument area.

   873   //

   874   // Not needed on PPC64.

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

   876 

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

   878   // Save across call to native method.

   879   __ mr(result_handler_addr, R3_RET);

   880 

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

   882 

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

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

   885   {

   886     Label method_is_not_static;

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

   888 

   889     // Restore access flags.

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

   891     __ bfalse(CCR0, method_is_not_static);

   892 

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

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

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

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

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

   898           R11_scratch1/*constants*/);

   899 

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

   901 

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

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

   904     // state->_native_mirror = mirror;

   905 

   906     __ ld(R11_scratch1, 0, R1_SP);

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

   908     // R4_ARG2 = &state->_oop_temp;

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

   910     __ BIND(method_is_not_static);

   911   }

   912 

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

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

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

   916   // register.

   917 

   918   // Pass JNIEnv address as first parameter.

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

   920 

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

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

   923 

   924   //=============================================================================

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

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

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

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

   929 

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

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

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

   933   __ li(R0, _thread_in_native);

   934   __ release();

   935 

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

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

   938 

   939   if (UseMembar) {

   940     __ fence();

   941   }

   942 

   943   //=============================================================================

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

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

   946   // ARG1 and ARG2 for static methods).

   947   __ call_c(native_method_fd);

   948 

   949   __ li(R0, 0);

   950   __ ld(R11_scratch1, 0, R1_SP);

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

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

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

   954 

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

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

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

   958   // it now.

   959   //__ get_PC_trash_LR(R11_scratch1);

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

   961 

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

   963 

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

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

   966   // blocking.

   967 

   968   //=============================================================================

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

   970   // synchronization state. This additional state is necessary

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

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

   973   // in _thread_in_native state, loads _not_synchronized and is

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

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

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

   977   // synchronization in progress, and escapes.

   978 

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

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

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

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

   983   __ release();

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

   985   if (UseMembar) {

   986     __ fence();

   987   }

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

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

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

   991   // traffic due to cache line collision.

   992   else {

   993     __ serialize_memory(R16_thread, R11_scratch1, R12_scratch2);

   994   }

   995 

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

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

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

   999   // the callers registers right this moment.

  1000 

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

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

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

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

  1005 

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

  1007   __ lwz(sync_state, sync_state_offs, sync_state_addr);

  1008 

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

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

  1011 

  1012   Label sync_check_done;

  1013   Label do_safepoint;

  1014   // No synchronization in progress nor yet synchronized.

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

  1016   // Not suspended.

  1017   __ cmpwi(CCR1, suspend_flags, 0);

  1018 

  1019   __ bne(CCR0, do_safepoint);

  1020   __ beq(CCR1, sync_check_done);

  1021   __ bind(do_safepoint);

  1022   __ isync();

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

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

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

  1026 

  1027   __ mr(R3_ARG1, R16_thread);

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

  1029             relocInfo::none);

  1030 

  1031   __ bind(sync_check_done);

  1032 

  1033   //=============================================================================

  1034   // <<<<<< Back in Interpreter Frame >>>>>

  1035 

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

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

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

  1039 

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

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

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

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

  1044   // this changes then the interpreter_frame_result implementation

  1045   // will need to be updated too.

  1046 

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

  1048 

  1049   //=============================================================================

  1050   // Back in Java

  1051 

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

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

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

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

  1056   __ release();

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

  1058   if (UseMembar) {

  1059     __ fence();

  1060   }

  1061 

  1062   __ reset_last_Java_frame();

  1063 

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

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

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

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

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

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

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

  1071                         InterpreterMacroAssembler::NotifyJVMTI,

  1072                         false /*check_exceptions*/);

  1073 

  1074   //=============================================================================

  1075   // Handle exceptions

  1076 

  1077   if (synchronized) {

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

  1079     // manually afterwards.

  1080     unlock_method(false);

  1081   }

  1082 

  1083   // Reset active handles after returning from native.

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

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

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

  1087   __ li(R0, 0);

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

  1089 

  1090   Label exception_return_sync_check_already_unlocked;

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

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

  1093   __ bne(CCR0, exception_return_sync_check_already_unlocked);

  1094 

  1095   //-----------------------------------------------------------------------------

  1096   // No exception pending.

  1097 

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

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

  1100   __ ld(R11_scratch1, 0, R1_SP);

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

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

  1103   __ call_stub(result_handler_addr);

  1104 

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

  1106 

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

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

  1109   __ mtlr(R0);

  1110   __ blr();

  1111 

  1112   //-----------------------------------------------------------------------------

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

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

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

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

  1117 

  1118   __ BIND(exception_return_sync_check);

  1119 

  1120   if (synchronized) {

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

  1122     // manually afterwards.

  1123     unlock_method(false);

  1124   }

  1125   __ BIND(exception_return_sync_check_already_unlocked);

  1126 

  1127   const Register return_pc = R31;

  1128 

  1129   __ ld(return_pc, 0, R1_SP);

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

  1131 

  1132   // Get the address of the exception handler.

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

  1134                   R16_thread,

  1135                   return_pc /* return pc */);