1 /*

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

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

     4  *

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

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

     7  * published by the Free Software Foundation.

     8  *

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

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

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

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

    13  * accompanied this code).

    14  *

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

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

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

    18  *

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

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

    21  * questions.

    22  *

    23  */

    24 

    25 #include "precompiled.hpp"

    26 #include "asm/macroAssembler.hpp"

    27 #include "interpreter/bytecodeHistogram.hpp"

    28 #include "interpreter/interpreter.hpp"

    29 #include "interpreter/interpreterGenerator.hpp"

    30 #include "interpreter/interpreterRuntime.hpp"

    31 #include "interpreter/interp_masm.hpp"

    32 #include "interpreter/templateTable.hpp"

    33 #include "oops/arrayOop.hpp"

    34 #include "oops/methodData.hpp"

    35 #include "oops/method.hpp"

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

    37 #include "prims/jvmtiExport.hpp"

    38 #include "prims/jvmtiThreadState.hpp"

    39 #include "runtime/arguments.hpp"

    40 #include "runtime/deoptimization.hpp"

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

    42 #include "runtime/sharedRuntime.hpp"

    43 #include "runtime/stubRoutines.hpp"

    44 #include "runtime/synchronizer.hpp"

    45 #include "runtime/timer.hpp"

    46 #include "runtime/vframeArray.hpp"

    47 #include "utilities/debug.hpp"

    48 #include "utilities/macros.hpp"

    49 

    50 #define __ _masm->

    51 

    52 #ifndef CC_INTERP

    53 

    54 const int method_offset = frame::interpreter_frame_method_offset * wordSize;

    55 const int bcp_offset    = frame::interpreter_frame_bcp_offset    * wordSize;

    56 const int locals_offset = frame::interpreter_frame_locals_offset * wordSize;

    57 

    58 //-----------------------------------------------------------------------------

    59 

    60 address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {

    61   address entry = __ pc();

    62 

    63 #ifdef ASSERT

    64   {

    65     Label L;

    66     __ lea(rax, Address(rbp,

    67                         frame::interpreter_frame_monitor_block_top_offset *

    68                         wordSize));

    69     __ cmpptr(rax, rsp); // rax = maximal rsp for current rbp (stack

    70                          // grows negative)

    71     __ jcc(Assembler::aboveEqual, L); // check if frame is complete

    72     __ stop ("interpreter frame not set up");

    73     __ bind(L);

    74   }

    75 #endif // ASSERT

    76   // Restore bcp under the assumption that the current frame is still

    77   // interpreted

    78   __ restore_bcp();

    79 

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

    81   // exception happened

    82   __ empty_expression_stack();

    83   // throw exception

    84   __ call_VM(noreg,

    85              CAST_FROM_FN_PTR(address,

    86                               InterpreterRuntime::throw_StackOverflowError));

    87   return entry;

    88 }

    89 

    90 address TemplateInterpreterGenerator::generate_ArrayIndexOutOfBounds_handler(

    91         const char* name) {

    92   address entry = __ pc();

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

    94   // exception happened

    95   __ empty_expression_stack();

    96   // setup parameters

    97   // ??? convention: expect aberrant index in register ebx

    98   __ lea(c_rarg1, ExternalAddress((address)name));

    99   __ call_VM(noreg,

   100              CAST_FROM_FN_PTR(address,

   101                               InterpreterRuntime::

   102                               throw_ArrayIndexOutOfBoundsException),

   103              c_rarg1, rbx);

   104   return entry;

   105 }

   106 

   107 address TemplateInterpreterGenerator::generate_ClassCastException_handler() {

   108   address entry = __ pc();

   109 

   110   // object is at TOS

   111   __ pop(c_rarg1);

   112 

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

   114   // exception happened

   115   __ empty_expression_stack();

   116 

   117   __ call_VM(noreg,

   118              CAST_FROM_FN_PTR(address,

   119                               InterpreterRuntime::

   120                               throw_ClassCastException),

   121              c_rarg1);

   122   return entry;

   123 }

   124 

   125 address TemplateInterpreterGenerator::generate_exception_handler_common(

   126         const char* name, const char* message, bool pass_oop) {

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

   128   address entry = __ pc();

   129   if (pass_oop) {

   130     // object is at TOS

   131     __ pop(c_rarg2);

   132   }

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

   134   // exception happened

   135   __ empty_expression_stack();

   136   // setup parameters

   137   __ lea(c_rarg1, ExternalAddress((address)name));

   138   if (pass_oop) {

   139     __ call_VM(rax, CAST_FROM_FN_PTR(address,

   140                                      InterpreterRuntime::

   141                                      create_klass_exception),

   142                c_rarg1, c_rarg2);

   143   } else {

   144     // kind of lame ExternalAddress can't take NULL because

   145     // external_word_Relocation will assert.

   146     if (message != NULL) {

   147       __ lea(c_rarg2, ExternalAddress((address)message));

   148     } else {

   149       __ movptr(c_rarg2, NULL_WORD);

   150     }

   151     __ call_VM(rax,

   152                CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception),

   153                c_rarg1, c_rarg2);

   154   }

   155   // throw exception

   156   __ jump(ExternalAddress(Interpreter::throw_exception_entry()));

   157   return entry;

   158 }

   159 

   160 

   161 address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {

   162   address entry = __ pc();

   163   // NULL last_sp until next java call

   164   __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);

   165   __ dispatch_next(state);

   166   return entry;

   167 }

   168 

   169 

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

   171   address entry = __ pc();

   172 

   173   // Restore stack bottom in case i2c adjusted stack

   174   __ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));

   175   // and NULL it as marker that esp is now tos until next java call

   176   __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);

   177 

   178   __ restore_bcp();

   179   __ restore_locals();

   180 

   181   if (state == atos) {

   182     Register mdp = rbx;

   183     Register tmp = rcx;

   184     __ profile_return_type(mdp, rax, tmp);

   185   }

   186 

   187   const Register cache = rbx;

   188   const Register index = rcx;

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

   190 

   191   const Register flags = cache;

   192   __ movl(flags, Address(cache, index, Address::times_ptr, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset()));

   193   __ andl(flags, ConstantPoolCacheEntry::parameter_size_mask);

   194   __ lea(rsp, Address(rsp, flags, Interpreter::stackElementScale()));

   195   __ dispatch_next(state, step);

   196 

   197   return entry;

   198 }

   199 

   200 

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

   202   address entry = __ pc();

   203   // NULL last_sp until next java call

   204   __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);

   205   __ restore_bcp();

   206   __ restore_locals();

   207 #if INCLUDE_JVMCI

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

   209   if (UseJVMCICompiler) {

   210     Label L;

   211     __ cmpb(Address(r15_thread, JavaThread::pending_monitorenter_offset()), 0);

   212     __ jcc(Assembler::zero, L);

   213     // Clear flag.

   214     __ movb(Address(r15_thread, JavaThread::pending_monitorenter_offset()), 0);

   215     // Satisfy calling convention for lock_method().

   216     __ get_method(rbx);

   217     // Take lock.

   218     lock_method();

   219     __ bind(L);

   220   }

   221 #endif

   222   // handle exceptions

   223   {

   224     Label L;

   225     __ cmpptr(Address(r15_thread, Thread::pending_exception_offset()), (int32_t) NULL_WORD);

   226     __ jcc(Assembler::zero, L);

   227     __ call_VM(noreg,

   228                CAST_FROM_FN_PTR(address,

   229                                 InterpreterRuntime::throw_pending_exception));

   230     __ should_not_reach_here();

   231     __ bind(L);

   232   }

   233   __ dispatch_next(state, step);

   234   return entry;

   235 }

   236 

   237 int AbstractInterpreter::BasicType_as_index(BasicType type) {

   238   int i = 0;

   239   switch (type) {

   240     case T_BOOLEAN: i = 0; break;

   241     case T_CHAR   : i = 1; break;

   242     case T_BYTE   : i = 2; break;

   243     case T_SHORT  : i = 3; break;

   244     case T_INT    : i = 4; break;

   245     case T_LONG   : i = 5; break;

   246     case T_VOID   : i = 6; break;

   247     case T_FLOAT  : i = 7; break;

   248     case T_DOUBLE : i = 8; break;

   249     case T_OBJECT : i = 9; break;

   250     case T_ARRAY  : i = 9; break;

   251     default       : ShouldNotReachHere();

   252   }

   253   assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers,

   254          "index out of bounds");

   255   return i;

   256 }

   257 

   258 

   259 address TemplateInterpreterGenerator::generate_result_handler_for(

   260         BasicType type) {

   261   address entry = __ pc();

   262   switch (type) {

   263   case T_BOOLEAN: __ c2bool(rax);            break;

   264   case T_CHAR   : __ movzwl(rax, rax);       break;

   265   case T_BYTE   : __ sign_extend_byte(rax);  break;

   266   case T_SHORT  : __ sign_extend_short(rax); break;

   267   case T_INT    : /* nothing to do */        break;

   268   case T_LONG   : /* nothing to do */        break;

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

   270   case T_FLOAT  : /* nothing to do */        break;

   271   case T_DOUBLE : /* nothing to do */        break;

   272   case T_OBJECT :

   273     // retrieve result from frame

   274     __ movptr(rax, Address(rbp, frame::interpreter_frame_oop_temp_offset*wordSize));

   275     // and verify it

   276     __ verify_oop(rax);

   277     break;

   278   default       : ShouldNotReachHere();

   279   }

   280   __ ret(0);                                   // return from result handler

   281   return entry;

   282 }

   283 

   284 address TemplateInterpreterGenerator::generate_safept_entry_for(

   285         TosState state,

   286         address runtime_entry) {

   287   address entry = __ pc();

   288   __ push(state);

   289   __ call_VM(noreg, runtime_entry);

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

   291   return entry;

   292 }

   293 

   294 

   295 

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

   297 //

   298 

   299 

   300 // increment invocation count & check for overflow

   301 //

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

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

   304 //

   305 // rbx: method

   306 // ecx: invocation counter

   307 //

   308 void InterpreterGenerator::generate_counter_incr(

   309         Label* overflow,

   310         Label* profile_method,

   311         Label* profile_method_continue) {

   312   Label done;

   313   // Note: In tiered we increment either counters in Method* or in MDO depending if we're profiling or not.

   314   if (TieredCompilation) {

   315     int increment = InvocationCounter::count_increment;

   316     Label no_mdo;

   317     if (ProfileInterpreter) {

   318       // Are we profiling?

   319       __ movptr(rax, Address(rbx, Method::method_data_offset()));

   320       __ testptr(rax, rax);

   321       __ jccb(Assembler::zero, no_mdo);

   322       // Increment counter in the MDO

   323       const Address mdo_invocation_counter(rax, in_bytes(MethodData::invocation_counter_offset()) +

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

   325       const Address mask(rax, in_bytes(MethodData::invoke_mask_offset()));

   326       __ increment_mask_and_jump(mdo_invocation_counter, increment, mask, rcx, false, Assembler::zero, overflow);

   327       __ jmp(done);

   328     }

   329     __ bind(no_mdo);

   330     // Increment counter in MethodCounters

   331     const Address invocation_counter(rax,

   332                   MethodCounters::invocation_counter_offset() +

   333                   InvocationCounter::counter_offset());

   334     __ get_method_counters(rbx, rax, done);

   335     const Address mask(rax, in_bytes(MethodCounters::invoke_mask_offset()));

   336     __ increment_mask_and_jump(invocation_counter, increment, mask, rcx,

   337                                false, Assembler::zero, overflow);

   338     __ bind(done);

   339   } else { // not TieredCompilation

   340     const Address backedge_counter(rax,

   341                   MethodCounters::backedge_counter_offset() +

   342                   InvocationCounter::counter_offset());

   343     const Address invocation_counter(rax,

   344                   MethodCounters::invocation_counter_offset() +

   345                   InvocationCounter::counter_offset());

   346 

   347     __ get_method_counters(rbx, rax, done);

   348 

   349     if (ProfileInterpreter) {

   350       __ incrementl(Address(rax,

   351               MethodCounters::interpreter_invocation_counter_offset()));

   352     }

   353     // Update standard invocation counters

   354     __ movl(rcx, invocation_counter);

   355     __ incrementl(rcx, InvocationCounter::count_increment);

   356     __ movl(invocation_counter, rcx); // save invocation count

   357 

   358     __ movl(rax, backedge_counter);   // load backedge counter

   359     __ andl(rax, InvocationCounter::count_mask_value); // mask out the status bits

   360 

   361     __ addl(rcx, rax);                // add both counters

   362 

   363     // profile_method is non-null only for interpreted method so

   364     // profile_method != NULL == !native_call

   365 

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

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

   368       __ movptr(rax, Address(rbx, Method::method_counters_offset()));

   369       __ cmp32(rcx, Address(rax, in_bytes(MethodCounters::interpreter_profile_limit_offset())));

   370       __ jcc(Assembler::less, *profile_method_continue);

   371 

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

   373       __ test_method_data_pointer(rax, *profile_method);

   374     }

   375 

   376     __ movptr(rax, Address(rbx, Method::method_counters_offset()));

   377     __ cmp32(rcx, Address(rax, in_bytes(MethodCounters::interpreter_invocation_limit_offset())));

   378     __ jcc(Assembler::aboveEqual, *overflow);

   379     __ bind(done);

   380   }

   381 }

   382 

   383 void InterpreterGenerator::generate_counter_overflow(Label* do_continue) {

   384 

   385   // Asm interpreter on entry

   386   // r14 - locals

   387   // r13 - bcp

   388   // rbx - method

   389   // edx - cpool --- DOES NOT APPEAR TO BE TRUE

   390   // rbp - interpreter frame

   391 

   392   // On return (i.e. jump to entry_point) [ back to invocation of interpreter ]

   393   // Everything as it was on entry

   394   // rdx is not restored. Doesn't appear to really be set.

   395 

   396   // InterpreterRuntime::frequency_counter_overflow takes two

   397   // arguments, the first (thread) is passed by call_VM, the second

   398   // indicates if the counter overflow occurs at a backwards branch

   399   // (NULL bcp).  We pass zero for it.  The call returns the address

   400   // of the verified entry point for the method or NULL if the

   401   // compilation did not complete (either went background or bailed

   402   // out).

   403   __ movl(c_rarg1, 0);

   404   __ call_VM(noreg,

   405              CAST_FROM_FN_PTR(address,

   406                               InterpreterRuntime::frequency_counter_overflow),

   407              c_rarg1);

   408 

   409   __ movptr(rbx, Address(rbp, method_offset));   // restore Method*

   410   // Preserve invariant that r13/r14 contain bcp/locals of sender frame

   411   // and jump to the interpreted entry.

   412   __ jmp(*do_continue, relocInfo::none);

   413 }

   414 

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

   416 // The expression stack grows down incrementally, so the normal guard

   417 // page mechanism will work for that.

   418 //

   419 // NOTE: Since the additional locals are also always pushed (wasn't

   420 // obvious in generate_fixed_frame) so the guard should work for them

   421 // too.

   422 //

   423 // Args:

   424 //      rdx: number of additional locals this frame needs (what we must check)

   425 //      rbx: Method*

   426 //

   427 // Kills:

   428 //      rax

   429 void InterpreterGenerator::generate_stack_overflow_check(void) {

   430 

   431   // monitor entry size: see picture of stack in frame_x86.hpp

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

   433 

   434   // total overhead size: entry_size + (saved rbp through expr stack

   435   // bottom).  be sure to change this if you add/subtract anything

   436   // to/from the overhead area

   437   const int overhead_size =

   438     -(frame::interpreter_frame_initial_sp_offset * wordSize) + entry_size;

   439 

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

   441 

   442   Label after_frame_check;

   443 

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

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

   446   // for the additional locals.

   447   __ cmpl(rdx, (page_size - overhead_size) / Interpreter::stackElementSize);

   448   __ jcc(Assembler::belowEqual, after_frame_check);

   449 

   450   // compute rsp as if this were going to be the last frame on

   451   // the stack before the red zone

   452 

   453   const Address stack_base(r15_thread, Thread::stack_base_offset());

   454   const Address stack_size(r15_thread, Thread::stack_size_offset());

   455 

   456   // locals + overhead, in bytes

   457   __ mov(rax, rdx);

   458   __ shlptr(rax, Interpreter::logStackElementSize);  // 2 slots per parameter.

   459   __ addptr(rax, overhead_size);

   460 

   461 #ifdef ASSERT

   462   Label stack_base_okay, stack_size_okay;

   463   // verify that thread stack base is non-zero

   464   __ cmpptr(stack_base, (int32_t)NULL_WORD);

   465   __ jcc(Assembler::notEqual, stack_base_okay);

   466   __ stop("stack base is zero");

   467   __ bind(stack_base_okay);

   468   // verify that thread stack size is non-zero

   469   __ cmpptr(stack_size, 0);

   470   __ jcc(Assembler::notEqual, stack_size_okay);

   471   __ stop("stack size is zero");

   472   __ bind(stack_size_okay);

   473 #endif

   474 

   475   // Add stack base to locals and subtract stack size

   476   __ addptr(rax, stack_base);

   477   __ subptr(rax, stack_size);

   478 

   479   // Use the maximum number of pages we might bang.

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

   481                                                                               (StackRedPages+StackYellowPages);

   482 

   483   // add in the red and yellow zone sizes

   484   __ addptr(rax, max_pages * page_size);

   485 

   486   // check against the current stack bottom

   487   __ cmpptr(rsp, rax);

   488   __ jcc(Assembler::above, after_frame_check);

   489 

   490   // Restore sender's sp as SP. This is necessary if the sender's

   491   // frame is an extended compiled frame (see gen_c2i_adapter())

   492   // and safer anyway in case of JSR292 adaptations.

   493 

   494   __ pop(rax); // return address must be moved if SP is changed

   495   __ mov(rsp, r13);

   496   __ push(rax);

   497 

   498   // Note: the restored frame is not necessarily interpreted.

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

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

   501   __ jump(ExternalAddress(StubRoutines::throw_StackOverflowError_entry()));

   502 

   503   // all done with frame size check

   504   __ bind(after_frame_check);

   505 }

   506 

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

   508 //

   509 // Args:

   510 //      rbx: Method*

   511 //      r14: locals

   512 //

   513 // Kills:

   514 //      rax

   515 //      c_rarg0, c_rarg1, c_rarg2, c_rarg3, ...(param regs)

   516 //      rscratch1, rscratch2 (scratch regs)

   517 void TemplateInterpreterGenerator::lock_method() {

   518   // synchronize method

   519   const Address access_flags(rbx, Method::access_flags_offset());

   520   const Address monitor_block_top(

   521         rbp,

   522         frame::interpreter_frame_monitor_block_top_offset * wordSize);

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

   524 

   525 #ifdef ASSERT

   526   {

   527     Label L;

   528     __ movl(rax, access_flags);

   529     __ testl(rax, JVM_ACC_SYNCHRONIZED);

   530     __ jcc(Assembler::notZero, L);

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

   532     __ bind(L);

   533   }

   534 #endif // ASSERT

   535 

   536   // get synchronization object

   537   {

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

   539     Label done;

   540     __ movl(rax, access_flags);

   541     __ testl(rax, JVM_ACC_STATIC);

   542     // get receiver (assume this is frequent case)

   543     __ movptr(rax, Address(r14, Interpreter::local_offset_in_bytes(0)));

   544     __ jcc(Assembler::zero, done);

   545     __ movptr(rax, Address(rbx, Method::const_offset()));

   546     __ movptr(rax, Address(rax, ConstMethod::constants_offset()));

   547     __ movptr(rax, Address(rax,

   548                            ConstantPool::pool_holder_offset_in_bytes()));

   549     __ movptr(rax, Address(rax, mirror_offset));

   550 

   551 #ifdef ASSERT

   552     {

   553       Label L;

   554       __ testptr(rax, rax);

   555       __ jcc(Assembler::notZero, L);

   556       __ stop("synchronization object is NULL");

   557       __ bind(L);

   558     }

   559 #endif // ASSERT

   560 

   561     __ bind(done);

   562   }

   563 

   564   // add space for monitor & lock

   565   __ subptr(rsp, entry_size); // add space for a monitor entry

   566   __ movptr(monitor_block_top, rsp);  // set new monitor block top

   567   // store object

   568   __ movptr(Address(rsp, BasicObjectLock::obj_offset_in_bytes()), rax);

   569   __ movptr(c_rarg1, rsp); // object address

   570   __ lock_object(c_rarg1);

   571 }

   572 

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

   574 // interpreted methods and for native methods hence the shared code.

   575 //

   576 // Args:

   577 //      rax: return address

   578 //      rbx: Method*

   579 //      r14: pointer to locals

   580 //      r13: sender sp

   581 //      rdx: cp cache

   582 void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) {

   583   // initialize fixed part of activation frame

   584   __ push(rax);        // save return address

   585   __ enter();          // save old & set new rbp

   586   __ push(r13);        // set sender sp

   587   __ push((int)NULL_WORD); // leave last_sp as null

   588   __ movptr(r13, Address(rbx, Method::const_offset()));      // get ConstMethod*

   589   __ lea(r13, Address(r13, ConstMethod::codes_offset())); // get codebase

   590   __ push(rbx);        // save Method*

   591   if (ProfileInterpreter) {

   592     Label method_data_continue;

   593     __ movptr(rdx, Address(rbx, in_bytes(Method::method_data_offset())));

   594     __ testptr(rdx, rdx);

   595     __ jcc(Assembler::zero, method_data_continue);

   596     __ addptr(rdx, in_bytes(MethodData::data_offset()));

   597     __ bind(method_data_continue);

   598     __ push(rdx);      // set the mdp (method data pointer)

   599   } else {

   600     __ push(0);

   601   }

   602 

   603   __ movptr(rdx, Address(rbx, Method::const_offset()));

   604   __ movptr(rdx, Address(rdx, ConstMethod::constants_offset()));

   605   __ movptr(rdx, Address(rdx, ConstantPool::cache_offset_in_bytes()));

   606   __ push(rdx); // set constant pool cache

   607   __ push(r14); // set locals pointer

   608   if (native_call) {

   609     __ push(0); // no bcp

   610   } else {

   611     __ push(r13); // set bcp

   612   }

   613   __ push(0); // reserve word for pointer to expression stack bottom

   614   __ movptr(Address(rsp, 0), rsp); // set expression stack bottom

   615 }

   616 

   617 // End of helpers

   618 

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

   620 address InterpreterGenerator::generate_Reference_get_entry(void) {

   621 #if INCLUDE_ALL_GCS

   622   // Code: _aload_0, _getfield, _areturn

   623   // parameter size = 1

   624   //

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

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

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

   628   //

   629   // Notes:-

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

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

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

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

   634   //   update buffer.

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

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

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

   638   //   will be fine.

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

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

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

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

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

   644   //

   645   // rbx: Method*

   646 

   647   // r13: senderSP must preserve for slow path, set SP to it on fast path

   648 

   649   address entry = __ pc();

   650 

   651   const int referent_offset = java_lang_ref_Reference::referent_offset;

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

   653 

   654   if (UseG1GC) {

   655     Label slow_path;

   656     // rbx: method

   657 

   658     // Check if local 0 != NULL

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

   660     __ movptr(rax, Address(rsp, wordSize));

   661 

   662     __ testptr(rax, rax);

   663     __ jcc(Assembler::zero, slow_path);

   664 

   665     // rax: local 0

   666     // rbx: method (but can be used as scratch now)

   667     // rdx: scratch

   668     // rdi: scratch

   669 

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

   671     // the referent field in an SATB buffer.

   672 

   673     // Load the value of the referent field.

   674     const Address field_address(rax, referent_offset);

   675     __ load_heap_oop(rax, field_address);

   676 

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

   678     // the referent field in an SATB buffer.

   679     __ g1_write_barrier_pre(noreg /* obj */,

   680                             rax /* pre_val */,

   681                             r15_thread /* thread */,

   682                             rbx /* tmp */,

   683                             true /* tosca_live */,

   684                             true /* expand_call */);

   685 

   686     // _areturn

   687     __ pop(rdi);                // get return address

   688     __ mov(rsp, r13);           // set sp to sender sp

   689     __ jmp(rdi);

   690     __ ret(0);

   691 

   692     // generate a vanilla interpreter entry as the slow path

   693     __ bind(slow_path);

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

   695     return entry;

   696   }

   697 #endif // INCLUDE_ALL_GCS

   698 

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

   700   // Reference.get is an accessor

   701   return NULL;

   702 }

   703 

   704 /**

   705  * Method entry for static native methods:

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

   707  */

   708 address InterpreterGenerator::generate_CRC32_update_entry() {

   709   if (UseCRC32Intrinsics) {

   710     address entry = __ pc();

   711 

   712     // rbx,: Method*

   713     // r13: senderSP must preserved for slow path, set SP to it on fast path

   714     // c_rarg0: scratch (rdi on non-Win64, rcx on Win64)

   715     // c_rarg1: scratch (rsi on non-Win64, rdx on Win64)

   716 

   717     Label slow_path;

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

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

   720     __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()),

   721              SafepointSynchronize::_not_synchronized);

   722     __ jcc(Assembler::notEqual, slow_path);

   723 

   724     // We don't generate local frame and don't align stack because

   725     // we call stub code and there is no safepoint on this path.

   726 

   727     // Load parameters

   728     const Register crc = rax;  // crc

   729     const Register val = c_rarg0;  // source java byte value

   730     const Register tbl = c_rarg1;  // scratch

   731 

   732     // Arguments are reversed on java expression stack

   733     __ movl(val, Address(rsp,   wordSize)); // byte value

   734     __ movl(crc, Address(rsp, 2*wordSize)); // Initial CRC

   735 

   736     __ lea(tbl, ExternalAddress(StubRoutines::crc_table_addr()));

   737     __ notl(crc); // ~crc

   738     __ update_byte_crc32(crc, val, tbl);

   739     __ notl(crc); // ~crc

   740     // result in rax

   741 

   742     // _areturn

   743     __ pop(rdi);                // get return address

   744     __ mov(rsp, r13);           // set sp to sender sp

   745     __ jmp(rdi);

   746 

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

   748     __ bind(slow_path);

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

   750     return entry;

   751   }

   752   return NULL;

   753 }

   754 

   755 /**

   756  * Method entry for static native methods:

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

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

   759  */

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

   761   if (UseCRC32Intrinsics) {

   762     address entry = __ pc();

   763 

   764     // rbx,: Method*

   765     // r13: senderSP must preserved for slow path, set SP to it on fast path

   766 

   767     Label slow_path;

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

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

   770     __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()),

   771              SafepointSynchronize::_not_synchronized);

   772     __ jcc(Assembler::notEqual, slow_path);

   773 

   774     // We don't generate local frame and don't align stack because

   775     // we call stub code and there is no safepoint on this path.

   776 

   777     // Load parameters

   778     const Register crc = c_rarg0;  // crc

   779     const Register buf = c_rarg1;  // source java byte array address

   780     const Register len = c_rarg2;  // length

   781     const Register off = len;      // offset (never overlaps with 'len')

   782 

   783     // Arguments are reversed on java expression stack

   784     // Calculate address of start element

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

   786       __ movptr(buf, Address(rsp, 3*wordSize)); // long buf

   787       __ movl2ptr(off, Address(rsp, 2*wordSize)); // offset

   788       __ addq(buf, off); // + offset

   789       __ movl(crc,   Address(rsp, 5*wordSize)); // Initial CRC

   790     } else {

   791       __ movptr(buf, Address(rsp, 3*wordSize)); // byte[] array

   792       __ addptr(buf, arrayOopDesc::base_offset_in_bytes(T_BYTE)); // + header size

   793       __ movl2ptr(off, Address(rsp, 2*wordSize)); // offset

   794       __ addq(buf, off); // + offset

   795       __ movl(crc,   Address(rsp, 4*wordSize)); // Initial CRC

   796     }

   797     // Can now load 'len' since we're finished with 'off'

   798     __ movl(len, Address(rsp, wordSize)); // Length

   799 

   800     __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, StubRoutines::updateBytesCRC32()), crc, buf, len);

   801     // result in rax

   802 

   803     // _areturn

   804     __ pop(rdi);                // get return address

   805     __ mov(rsp, r13);           // set sp to sender sp

   806     __ jmp(rdi);

   807 

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

   809     __ bind(slow_path);

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

   811     return entry;

   812   }

   813   return NULL;

   814 }

   815 

   816 /**

   817 * Method entry for static native methods:

   818 *   int java.util.zip.CRC32C.updateBytes(int crc, byte[] b, int off, int end)

   819 *   int java.util.zip.CRC32C.updateByteBuffer(int crc, long address, int off, int end)

   820 */

   821 address InterpreterGenerator::generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind) {

   822   if (UseCRC32CIntrinsics) {

   823     address entry = __ pc();

   824     // Load parameters

   825     const Register crc = c_rarg0;  // crc

   826     const Register buf = c_rarg1;  // source java byte array address

   827     const Register len = c_rarg2;

   828     const Register off = c_rarg3;  // offset

   829     const Register end = len;

   830 

   831     // Arguments are reversed on java expression stack

   832     // Calculate address of start element

   833     if (kind == Interpreter::java_util_zip_CRC32C_updateDirectByteBuffer) {

   834       __ movptr(buf, Address(rsp, 3 * wordSize)); // long buf

   835       __ movl2ptr(off, Address(rsp, 2 * wordSize)); // offset

   836       __ addq(buf, off); // + offset

   837       __ movl(crc, Address(rsp, 5 * wordSize)); // Initial CRC

   838       // Note on 5 * wordSize vs. 4 * wordSize:

   839       // *   int java.util.zip.CRC32C.updateByteBuffer(int crc, long address, int off, int end)

   840       //                                                   4         2,3          1        0

   841       // end starts at SP + 8

   842       // The Java(R) Virtual Machine Specification Java SE 7 Edition

   843       // 4.10.2.3. Values of Types long and double

   844       //    "When calculating operand stack length, values of type long and double have length two."

   845     } else {

   846       __ movptr(buf, Address(rsp, 3 * wordSize)); // byte[] array

   847       __ addptr(buf, arrayOopDesc::base_offset_in_bytes(T_BYTE)); // + header size

   848       __ movl2ptr(off, Address(rsp, 2 * wordSize)); // offset

   849       __ addq(buf, off); // + offset

   850       __ movl(crc, Address(rsp, 4 * wordSize)); // Initial CRC

   851     }

   852     __ movl(end, Address(rsp, wordSize)); // end

   853     __ subl(end, off); // end - off

   854     __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, StubRoutines::updateBytesCRC32C()), crc, buf, len);

   855     // result in rax

   856     // _areturn

   857     __ pop(rdi);                // get return address

   858     __ mov(rsp, r13);           // set sp to sender sp

   859     __ jmp(rdi);

   860 

   861     return entry;

   862   }

   863 

   864   return NULL;

   865 }

   866 

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

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

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

   870 address InterpreterGenerator::generate_native_entry(bool synchronized) {

   871   // determine code generation flags

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

   873 

   874   // rbx: Method*

   875   // r13: sender sp

   876 

   877   address entry_point = __ pc();

   878 

   879   const Address constMethod       (rbx, Method::const_offset());

   880   const Address access_flags      (rbx, Method::access_flags_offset());

   881   const Address size_of_parameters(rcx, ConstMethod::

   882                                         size_of_parameters_offset());

   883 

   884 

   885   // get parameter size (always needed)

   886   __ movptr(rcx, constMethod);

   887   __ load_unsigned_short(rcx, size_of_parameters);

   888 

   889   // native calls don't need the stack size check since they have no

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

   891   // we only add a handful of words to the stack

   892 

   893   // rbx: Method*

   894   // rcx: size of parameters

   895   // r13: sender sp

   896   __ pop(rax);                                       // get return address

   897 

   898   // for natives the size of locals is zero

   899 

   900   // compute beginning of parameters (r14)

   901   __ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize));

   902 

   903   // add 2 zero-initialized slots for native calls

   904   // initialize result_handler slot

   905   __ push((int) NULL_WORD);

   906   // slot for oop temp

   907   // (static native method holder mirror/jni oop result)

   908   __ push((int) NULL_WORD);

   909 

   910   // initialize fixed part of activation frame

   911   generate_fixed_frame(true);

   912 

   913   // make sure method is native & not abstract

   914 #ifdef ASSERT

   915   __ movl(rax, access_flags);

   916   {

   917     Label L;

   918     __ testl(rax, JVM_ACC_NATIVE);

   919     __ jcc(Assembler::notZero, L);

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

   921     __ bind(L);

   922   }

   923   {

   924     Label L;

   925     __ testl(rax, JVM_ACC_ABSTRACT);

   926     __ jcc(Assembler::zero, L);

   927     __ stop("tried to execute abstract method in interpreter");

   928     __ bind(L);

   929   }

   930 #endif

   931 

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

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

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

   935   // _do_not_unlock_if_synchronized to true. The remove_activation will

   936   // check this flag.

   937 

   938   const Address do_not_unlock_if_synchronized(r15_thread,

   939         in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));

   940   __ movbool(do_not_unlock_if_synchronized, true);

   941 

   942   // increment invocation count & check for overflow

   943   Label invocation_counter_overflow;

   944   if (inc_counter) {

   945     generate_counter_incr(&invocation_counter_overflow, NULL, NULL);

   946   }

   947 

   948   Label continue_after_compile;

   949   __ bind(continue_after_compile);

   950 

   951   bang_stack_shadow_pages(true);

   952 

   953   // reset the _do_not_unlock_if_synchronized flag

   954   __ movbool(do_not_unlock_if_synchronized, false);

   955 

   956   // check for synchronized methods

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

   958   // so method is not locked if overflows.

   959   if (synchronized) {

   960     lock_method();

   961   } else {

   962     // no synchronization necessary

   963 #ifdef ASSERT

   964     {

   965       Label L;

   966       __ movl(rax, access_flags);

   967       __ testl(rax, JVM_ACC_SYNCHRONIZED);

   968       __ jcc(Assembler::zero, L);

   969       __ stop("method needs synchronization");

   970       __ bind(L);

   971     }

   972 #endif

   973   }

   974 

   975   // start execution

   976 #ifdef ASSERT

   977   {

   978     Label L;

   979     const Address monitor_block_top(rbp,

   980                  frame::interpreter_frame_monitor_block_top_offset * wordSize);

   981     __ movptr(rax, monitor_block_top);

   982     __ cmpptr(rax, rsp);

   983     __ jcc(Assembler::equal, L);

   984     __ stop("broken stack frame setup in interpreter");

   985     __ bind(L);

   986   }

   987 #endif

   988 

   989   // jvmti support

   990   __ notify_method_entry();

   991 

   992   // work registers

   993   const Register method = rbx;

   994   const Register t      = r11;

   995 

   996   // allocate space for parameters

   997   __ get_method(method);

   998   __ movptr(t, Address(method, Method::const_offset()));

   999   __ load_unsigned_short(t, Address(t, ConstMethod::size_of_parameters_offset()));

  1000   __ shll(t, Interpreter::logStackElementSize);

  1001 

  1002   __ subptr(rsp, t);

  1003   __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows

  1004   __ andptr(rsp, -16); // must be 16 byte boundary (see amd64 ABI)

  1005 

  1006   // get signature handler

  1007   {

  1008     Label L;

  1009     __ movptr(t, Address(method, Method::signature_handler_offset()));

  1010     __ testptr(t, t);

  1011     __ jcc(Assembler::notZero, L);

  1012     __ call_VM(noreg,

  1013                CAST_FROM_FN_PTR(address,

  1014                                 InterpreterRuntime::prepare_native_call),

  1015                method);

  1016     __ get_method(method);

  1017     __ movptr(t, Address(method, Method::signature_handler_offset()));

  1018     __ bind(L);

  1019   }

  1020 

  1021   // call signature handler

  1022   assert(InterpreterRuntime::SignatureHandlerGenerator::from() == r14,

  1023          "adjust this code");

  1024   assert(InterpreterRuntime::SignatureHandlerGenerator::to() == rsp,

  1025          "adjust this code");

  1026   assert(InterpreterRuntime::SignatureHandlerGenerator::temp() == rscratch1,

  1027           "adjust this code");

  1028 

  1029   // The generated handlers do not touch RBX (the method oop).

  1030   // However, large signatures cannot be cached and are generated

  1031   // each time here.  The slow-path generator can do a GC on return,

  1032   // so we must reload it after the call.

  1033   __ call(t);

  1034   __ get_method(method);        // slow path can do a GC, reload RBX

  1035 

  1036 

  1037   // result handler is in rax

  1038   // set result handler

  1039   __ movptr(Address(rbp,

  1040                     (frame::interpreter_frame_result_handler_offset) * wordSize),

  1041             rax);

  1042 

  1043   // pass mirror handle if static call

  1044   {

  1045     Label L;

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

  1047     __ movl(t, Address(method, Method::access_flags_offset()));

  1048     __ testl(t, JVM_ACC_STATIC);

  1049     __ jcc(Assembler::zero, L);

  1050     // get mirror

  1051     __ movptr(t, Address(method, Method::const_offset()));

  1052     __ movptr(t, Address(t, ConstMethod::constants_offset()));

  1053     __ movptr(t, Address(t, ConstantPool::pool_holder_offset_in_bytes()));

  1054     __ movptr(t, Address(t, mirror_offset));

  1055     // copy mirror into activation frame

  1056     __ movptr(Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize),

  1057             t);

  1058     // pass handle to mirror

  1059     __ lea(c_rarg1,

  1060            Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize));

  1061     __ bind(L);

  1062   }

  1063 

  1064   // get native function entry point

  1065   {

  1066     Label L;

  1067     __ movptr(rax, Address(method, Method::native_function_offset()));

  1068     ExternalAddress unsatisfied(SharedRuntime::native_method_throw_unsatisfied_link_error_entry());

  1069     __ movptr(rscratch2, unsatisfied.addr());

  1070     __ cmpptr(rax, rscratch2);

  1071     __ jcc(Assembler::notEqual, L);

  1072     __ call_VM(noreg,

  1073                CAST_FROM_FN_PTR(address,

  1074                                 InterpreterRuntime::prepare_native_call),

  1075                method);

  1076     __ get_method(method);

  1077     __ movptr(rax, Address(method, Method::native_function_offset()));

  1078     __ bind(L);

  1079   }

  1080 

  1081   // pass JNIEnv

  1082   __ lea(c_rarg0, Address(r15_thread, JavaThread::jni_environment_offset()));

  1083 

  1084   // It is enough that the pc() points into the right code

  1085   // segment. It does not have to be the correct return pc.

  1086   __ set_last_Java_frame(rsp, rbp, (address) __ pc());

  1087 

  1088   // change thread state

  1089 #ifdef ASSERT

  1090   {

  1091     Label L;

  1092     __ movl(t, Address(r15_thread, JavaThread::thread_state_offset()));

  1093     __ cmpl(t, _thread_in_Java);

  1094     __ jcc(Assembler::equal, L);

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

  1096     __ bind(L);

  1097   }

  1098 #endif

  1099 

  1100   // Change state to native

  1101 

  1102   __ movl(Address(r15_thread, JavaThread::thread_state_offset()),

  1103           _thread_in_native);

  1104 

  1105   // Call the native method.

  1106   __ call(rax);

  1107   // result potentially in rax or xmm0

  1108 

  1109   // Verify or restore cpu control state after JNI call

  1110   __ restore_cpu_control_state_after_jni();

  1111 

  1112   // NOTE: The order of these pushes is known to frame::interpreter_frame_result

  1113   // in order to extract the result of a method call. If the order of these

  1114   // pushes change or anything else is added to the stack then the code in

  1115   // interpreter_frame_result must also change.

  1116 

  1117   __ push(dtos);

  1118   __ push(ltos);

  1119 

  1120   // change thread state

  1121   __ movl(Address(r15_thread, JavaThread::thread_state_offset()),

  1122           _thread_in_native_trans);

  1123 

  1124   if (os::is_MP()) {

  1125     if (UseMembar) {

  1126       // Force this write out before the read below

  1127       __ membar(Assembler::Membar_mask_bits(

  1128            Assembler::LoadLoad | Assembler::LoadStore |

  1129            Assembler::StoreLoad | Assembler::StoreStore));

  1130     } else {

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

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

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

  1134       // due to cache line collision.