/*

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

 *

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

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

 * published by the Free Software Foundation.

 *

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

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

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

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

 * accompanied this code).

 *

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

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

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

 *

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

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

 * questions.

 *

 */

// no precompiled headers

#include "classfile/vmSymbols.hpp"

#include "gc_interface/collectedHeap.hpp"

#include "interpreter/bytecodeHistogram.hpp"

#include "interpreter/bytecodeInterpreter.hpp"

#include "interpreter/bytecodeInterpreter.inline.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/interpreterRuntime.hpp"

#include "memory/cardTableModRefBS.hpp"

#include "memory/resourceArea.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiExport.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/threadCritical.hpp"

#include "utilities/exceptions.hpp"

#ifdef TARGET_OS_ARCH_linux_x86

# include "orderAccess_linux_x86.inline.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_sparc

# include "orderAccess_linux_sparc.inline.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_zero

# include "orderAccess_linux_zero.inline.hpp"

#endif

#ifdef TARGET_OS_ARCH_solaris_x86

# include "orderAccess_solaris_x86.inline.hpp"

#endif

#ifdef TARGET_OS_ARCH_solaris_sparc

# include "orderAccess_solaris_sparc.inline.hpp"

#endif

#ifdef TARGET_OS_ARCH_windows_x86

# include "orderAccess_windows_x86.inline.hpp"

#endif

// no precompiled headers

#ifdef CC_INTERP

/*

 * USELABELS - If using GCC, then use labels for the opcode dispatching

 * rather -then a switch statement. This improves performance because it

 * gives us the oportunity to have the instructions that calculate the

 * next opcode to jump to be intermixed with the rest of the instructions

 * that implement the opcode (see UPDATE_PC_AND_TOS_AND_CONTINUE macro).

 */

#undef USELABELS

#ifdef __GNUC__

/*

   ASSERT signifies debugging. It is much easier to step thru bytecodes if we

   don't use the computed goto approach.

*/

#ifndef ASSERT

#define USELABELS

#endif

#endif

#undef CASE

#ifdef USELABELS

#define CASE(opcode) opc ## opcode

#define DEFAULT opc_default

#else

#define CASE(opcode) case Bytecodes:: opcode

#define DEFAULT default

#endif

/*

 * PREFETCH_OPCCODE - Some compilers do better if you prefetch the next

 * opcode before going back to the top of the while loop, rather then having

 * the top of the while loop handle it. This provides a better opportunity

 * for instruction scheduling. Some compilers just do this prefetch

 * automatically. Some actually end up with worse performance if you

 * force the prefetch. Solaris gcc seems to do better, but cc does worse.

 */

#undef PREFETCH_OPCCODE

#define PREFETCH_OPCCODE

/*

  Interpreter safepoint: it is expected that the interpreter will have no live

  handles of its own creation live at an interpreter safepoint. Therefore we

  run a HandleMarkCleaner and trash all handles allocated in the call chain

  since the JavaCalls::call_helper invocation that initiated the chain.

  There really shouldn't be any handles remaining to trash but this is cheap

  in relation to a safepoint.

*/

#define SAFEPOINT                                                                 \

    if ( SafepointSynchronize::is_synchronizing()) {                              \

        {                                                                         \

          /* zap freed handles rather than GC'ing them */                         \

          HandleMarkCleaner __hmc(THREAD);                                        \

        }                                                                         \

        CALL_VM(SafepointSynchronize::block(THREAD), handle_exception);           \

    }

/*

 * VM_JAVA_ERROR - Macro for throwing a java exception from

 * the interpreter loop. Should really be a CALL_VM but there

 * is no entry point to do the transition to vm so we just

 * do it by hand here.

 */

#define VM_JAVA_ERROR_NO_JUMP(name, msg)                                          \

    DECACHE_STATE();                                                              \

    SET_LAST_JAVA_FRAME();                                                        \

    {                                                                             \

       ThreadInVMfromJava trans(THREAD);                                          \

       Exceptions::_throw_msg(THREAD, __FILE__, __LINE__, name, msg);             \

    }                                                                             \

    RESET_LAST_JAVA_FRAME();                                                      \

    CACHE_STATE();

// Normal throw of a java error

#define VM_JAVA_ERROR(name, msg)                                                  \

    VM_JAVA_ERROR_NO_JUMP(name, msg)                                              \

    goto handle_exception;

#ifdef PRODUCT

#define DO_UPDATE_INSTRUCTION_COUNT(opcode)

#else

#define DO_UPDATE_INSTRUCTION_COUNT(opcode)                                                          \

{                                                                                                    \

    BytecodeCounter::_counter_value++;                                                               \

    BytecodeHistogram::_counters[(Bytecodes::Code)opcode]++;                                         \

    if (StopInterpreterAt && StopInterpreterAt == BytecodeCounter::_counter_value) os::breakpoint(); \

    if (TraceBytecodes) {                                                                            \

      CALL_VM((void)SharedRuntime::trace_bytecode(THREAD, 0,               \

                                   topOfStack[Interpreter::expr_index_at(1)],   \

                                   topOfStack[Interpreter::expr_index_at(2)]),  \

                                   handle_exception);                      \

    }                                                                      \

}

#endif

#undef DEBUGGER_SINGLE_STEP_NOTIFY

#ifdef VM_JVMTI

/* NOTE: (kbr) This macro must be called AFTER the PC has been

   incremented. JvmtiExport::at_single_stepping_point() may cause a

   breakpoint opcode to get inserted at the current PC to allow the

   debugger to coalesce single-step events.

   As a result if we call at_single_stepping_point() we refetch opcode

   to get the current opcode. This will override any other prefetching

   that might have occurred.

*/

#define DEBUGGER_SINGLE_STEP_NOTIFY()                                            \

{                                                                                \

      if (_jvmti_interp_events) {                                                \

        if (JvmtiExport::should_post_single_step()) {                            \

          DECACHE_STATE();                                                       \

          SET_LAST_JAVA_FRAME();                                                 \

          ThreadInVMfromJava trans(THREAD);                                      \

          JvmtiExport::at_single_stepping_point(THREAD,                          \

                                          istate->method(),                      \

                                          pc);                                   \

          RESET_LAST_JAVA_FRAME();                                               \

          CACHE_STATE();                                                         \

          if (THREAD->pop_frame_pending() &&                                     \

              !THREAD->pop_frame_in_process()) {                                 \

            goto handle_Pop_Frame;                                               \

          }                                                                      \

          opcode = *pc;                                                          \

        }                                                                        \

      }                                                                          \

}

#else

#define DEBUGGER_SINGLE_STEP_NOTIFY()

#endif

/*

 * CONTINUE - Macro for executing the next opcode.

 */

#undef CONTINUE

#ifdef USELABELS

// Have to do this dispatch this way in C++ because otherwise gcc complains about crossing an

// initialization (which is is the initialization of the table pointer...)

#define DISPATCH(opcode) goto *(void*)dispatch_table[opcode]

#define CONTINUE {                              \

        opcode = *pc;                           \

        DO_UPDATE_INSTRUCTION_COUNT(opcode);    \

        DEBUGGER_SINGLE_STEP_NOTIFY();          \

        DISPATCH(opcode);                       \

    }

#else

#ifdef PREFETCH_OPCCODE

#define CONTINUE {                              \

        opcode = *pc;                           \

        DO_UPDATE_INSTRUCTION_COUNT(opcode);    \

        DEBUGGER_SINGLE_STEP_NOTIFY();          \

        continue;                               \

    }

#else

#define CONTINUE {                              \

        DO_UPDATE_INSTRUCTION_COUNT(opcode);    \

        DEBUGGER_SINGLE_STEP_NOTIFY();          \

        continue;                               \

    }

#endif

#endif

// JavaStack Implementation

#define MORE_STACK(count)  \

    (topOfStack -= ((count) * Interpreter::stackElementWords))

#define UPDATE_PC(opsize) {pc += opsize; }

/*

 * UPDATE_PC_AND_TOS - Macro for updating the pc and topOfStack.

 */

#undef UPDATE_PC_AND_TOS

#define UPDATE_PC_AND_TOS(opsize, stack) \

    {pc += opsize; MORE_STACK(stack); }

/*

 * UPDATE_PC_AND_TOS_AND_CONTINUE - Macro for updating the pc and topOfStack,

 * and executing the next opcode. It's somewhat similar to the combination

 * of UPDATE_PC_AND_TOS and CONTINUE, but with some minor optimizations.

 */

#undef UPDATE_PC_AND_TOS_AND_CONTINUE

#ifdef USELABELS

#define UPDATE_PC_AND_TOS_AND_CONTINUE(opsize, stack) {         \

        pc += opsize; opcode = *pc; MORE_STACK(stack);          \

        DO_UPDATE_INSTRUCTION_COUNT(opcode);                    \

        DEBUGGER_SINGLE_STEP_NOTIFY();                          \

        DISPATCH(opcode);                                       \

    }

#define UPDATE_PC_AND_CONTINUE(opsize) {                        \

        pc += opsize; opcode = *pc;                             \

        DO_UPDATE_INSTRUCTION_COUNT(opcode);                    \

        DEBUGGER_SINGLE_STEP_NOTIFY();                          \

        DISPATCH(opcode);                                       \

    }

#else

#ifdef PREFETCH_OPCCODE

#define UPDATE_PC_AND_TOS_AND_CONTINUE(opsize, stack) {         \

        pc += opsize; opcode = *pc; MORE_STACK(stack);          \

        DO_UPDATE_INSTRUCTION_COUNT(opcode);                    \

        DEBUGGER_SINGLE_STEP_NOTIFY();                          \

        goto do_continue;                                       \

    }

#define UPDATE_PC_AND_CONTINUE(opsize) {                        \

        pc += opsize; opcode = *pc;                             \

        DO_UPDATE_INSTRUCTION_COUNT(opcode);                    \

        DEBUGGER_SINGLE_STEP_NOTIFY();                          \

        goto do_continue;                                       \

    }

#else

#define UPDATE_PC_AND_TOS_AND_CONTINUE(opsize, stack) { \

        pc += opsize; MORE_STACK(stack);                \

        DO_UPDATE_INSTRUCTION_COUNT(opcode);            \

        DEBUGGER_SINGLE_STEP_NOTIFY();                  \

        goto do_continue;                               \

    }

#define UPDATE_PC_AND_CONTINUE(opsize) {                \

        pc += opsize;                                   \

        DO_UPDATE_INSTRUCTION_COUNT(opcode);            \

        DEBUGGER_SINGLE_STEP_NOTIFY();                  \

        goto do_continue;                               \

    }

#endif /* PREFETCH_OPCCODE */

#endif /* USELABELS */

// About to call a new method, update the save the adjusted pc and return to frame manager

#define UPDATE_PC_AND_RETURN(opsize)  \

   DECACHE_TOS();                     \

   istate->set_bcp(pc+opsize);        \

   return;

#define METHOD istate->method()

#define INVOCATION_COUNT METHOD->invocation_counter()

#define BACKEDGE_COUNT METHOD->backedge_counter()

#define INCR_INVOCATION_COUNT INVOCATION_COUNT->increment()

#define OSR_REQUEST(res, branch_pc) \

            CALL_VM(res=InterpreterRuntime::frequency_counter_overflow(THREAD, branch_pc), handle_exception);

/*

 * For those opcodes that need to have a GC point on a backwards branch

 */

// Backedge counting is kind of strange. The asm interpreter will increment

// the backedge counter as a separate counter but it does it's comparisons

// to the sum (scaled) of invocation counter and backedge count to make

// a decision. Seems kind of odd to sum them together like that

// skip is delta from current bcp/bci for target, branch_pc is pre-branch bcp

#define DO_BACKEDGE_CHECKS(skip, branch_pc)                                                         \

    if ((skip) <= 0) {                                                                              \

      if (UseLoopCounter) {                                                                         \

        bool do_OSR = UseOnStackReplacement;                                                        \

        BACKEDGE_COUNT->increment();                                                                \

        if (do_OSR) do_OSR = BACKEDGE_COUNT->reached_InvocationLimit();                             \

        if (do_OSR) {                                                                               \

          nmethod*  osr_nmethod;                                                                    \

          OSR_REQUEST(osr_nmethod, branch_pc);                                                      \

          if (osr_nmethod != NULL && osr_nmethod->osr_entry_bci() != InvalidOSREntryBci) {          \

            intptr_t* buf = SharedRuntime::OSR_migration_begin(THREAD);                             \

            istate->set_msg(do_osr);                                                                \

            istate->set_osr_buf((address)buf);                                                      \

            istate->set_osr_entry(osr_nmethod->osr_entry());                                        \

            return;                                                                                 \

          }                                                                                         \

        }                                                                                           \

      }  /* UseCompiler ... */                                                                      \

      INCR_INVOCATION_COUNT;                                                                        \

      SAFEPOINT;                                                                                    \

    }

/*

 * For those opcodes that need to have a GC point on a backwards branch

 */

/*

 * Macros for caching and flushing the interpreter state. Some local

 * variables need to be flushed out to the frame before we do certain

 * things (like pushing frames or becomming gc safe) and some need to

 * be recached later (like after popping a frame). We could use one

 * macro to cache or decache everything, but this would be less then

 * optimal because we don't always need to cache or decache everything

 * because some things we know are already cached or decached.

 */

#undef DECACHE_TOS

#undef CACHE_TOS

#undef CACHE_PREV_TOS

#define DECACHE_TOS()    istate->set_stack(topOfStack);

#define CACHE_TOS()      topOfStack = (intptr_t *)istate->stack();

#undef DECACHE_PC

#undef CACHE_PC

#define DECACHE_PC()    istate->set_bcp(pc);

#define CACHE_PC()      pc = istate->bcp();

#define CACHE_CP()      cp = istate->constants();

#define CACHE_LOCALS()  locals = istate->locals();

#undef CACHE_FRAME

#define CACHE_FRAME()

/*

 * CHECK_NULL - Macro for throwing a NullPointerException if the object

 * passed is a null ref.

 * On some architectures/platforms it should be possible to do this implicitly

 */

#undef CHECK_NULL

#define CHECK_NULL(obj_)                                                 \

    if ((obj_) == NULL) {                                                \

        VM_JAVA_ERROR(vmSymbols::java_lang_NullPointerException(), "");  \

    }                                                                    \

    VERIFY_OOP(obj_)

#define VMdoubleConstZero() 0.0

#define VMdoubleConstOne() 1.0

#define VMlongConstZero() (max_jlong-max_jlong)

#define VMlongConstOne() ((max_jlong-max_jlong)+1)

/*

 * Alignment

 */

#define VMalignWordUp(val)          (((uintptr_t)(val) + 3) & ~3)

// Decache the interpreter state that interpreter modifies directly (i.e. GC is indirect mod)

#define DECACHE_STATE() DECACHE_PC(); DECACHE_TOS();

// Reload interpreter state after calling the VM or a possible GC

#define CACHE_STATE()   \

        CACHE_TOS();    \

        CACHE_PC();     \

        CACHE_CP();     \

        CACHE_LOCALS();

// Call the VM don't check for pending exceptions

#define CALL_VM_NOCHECK(func)                                     \

          DECACHE_STATE();                                        \

          SET_LAST_JAVA_FRAME();                                  \

          func;                                                   \

          RESET_LAST_JAVA_FRAME();                                \

          CACHE_STATE();                                          \

          if (THREAD->pop_frame_pending() &&                      \

              !THREAD->pop_frame_in_process()) {                  \

            goto handle_Pop_Frame;                                \

          }

// Call the VM and check for pending exceptions

#define CALL_VM(func, label) {                                    \

          CALL_VM_NOCHECK(func);                                  \

          if (THREAD->has_pending_exception()) goto label;        \

        }

/*

 * BytecodeInterpreter::run(interpreterState istate)

 * BytecodeInterpreter::runWithChecks(interpreterState istate)

 *

 * The real deal. This is where byte codes actually get interpreted.

 * Basically it's a big while loop that iterates until we return from

 * the method passed in.

 *

 * The runWithChecks is used if JVMTI is enabled.

 *

 */

#if defined(VM_JVMTI)

void

BytecodeInterpreter::runWithChecks(interpreterState istate) {

#else

void

BytecodeInterpreter::run(interpreterState istate) {

#endif

  // In order to simplify some tests based on switches set at runtime

  // we invoke the interpreter a single time after switches are enabled

  // and set simpler to to test variables rather than method calls or complex

  // boolean expressions.

  static int initialized = 0;

  static int checkit = 0;

  static intptr_t* c_addr = NULL;

  static intptr_t  c_value;

  if (checkit && *c_addr != c_value) {

    os::breakpoint();

  }

#ifdef VM_JVMTI

  static bool _jvmti_interp_events = 0;

#endif

  static int _compiling;  // (UseCompiler || CountCompiledCalls)

#ifdef ASSERT

  if (istate->_msg != initialize) {

    assert(abs(istate->_stack_base - istate->_stack_limit) == (istate->_method->max_stack() + 1), "bad stack limit");

#ifndef SHARK

    IA32_ONLY(assert(istate->_stack_limit == istate->_thread->last_Java_sp() + 1, "wrong"));

#endif // !SHARK

  }

  // Verify linkages.

  interpreterState l = istate;

  do {

    assert(l == l->_self_link, "bad link");

    l = l->_prev_link;

  } while (l != NULL);

  // Screwups with stack management usually cause us to overwrite istate

  // save a copy so we can verify it.

  interpreterState orig = istate;

#endif

  static volatile jbyte* _byte_map_base; // adjusted card table base for oop store barrier

  register intptr_t*        topOfStack = (intptr_t *)istate->stack(); /* access with STACK macros */

  register address          pc = istate->bcp();

  register jubyte opcode;

  register intptr_t*        locals = istate->locals();

  register constantPoolCacheOop  cp = istate->constants(); // method()->constants()->cache()

#ifdef LOTS_OF_REGS

  register JavaThread*      THREAD = istate->thread();

  register volatile jbyte*  BYTE_MAP_BASE = _byte_map_base;

#else

#undef THREAD

#define THREAD istate->thread()

#undef BYTE_MAP_BASE

#define BYTE_MAP_BASE _byte_map_base

#endif

#ifdef USELABELS

  const static void* const opclabels_data[256] = {

/* 0x00 */ &&opc_nop,     &&opc_aconst_null,&&opc_iconst_m1,&&opc_iconst_0,

/* 0x04 */ &&opc_iconst_1,&&opc_iconst_2,   &&opc_iconst_3, &&opc_iconst_4,

/* 0x08 */ &&opc_iconst_5,&&opc_lconst_0,   &&opc_lconst_1, &&opc_fconst_0,

/* 0x0C */ &&opc_fconst_1,&&opc_fconst_2,   &&opc_dconst_0, &&opc_dconst_1,

/* 0x10 */ &&opc_bipush, &&opc_sipush, &&opc_ldc,    &&opc_ldc_w,

/* 0x14 */ &&opc_ldc2_w, &&opc_iload,  &&opc_lload,  &&opc_fload,

/* 0x18 */ &&opc_dload,  &&opc_aload,  &&opc_iload_0,&&opc_iload_1,

/* 0x1C */ &&opc_iload_2,&&opc_iload_3,&&opc_lload_0,&&opc_lload_1,

/* 0x20 */ &&opc_lload_2,&&opc_lload_3,&&opc_fload_0,&&opc_fload_1,

/* 0x24 */ &&opc_fload_2,&&opc_fload_3,&&opc_dload_0,&&opc_dload_1,

/* 0x28 */ &&opc_dload_2,&&opc_dload_3,&&opc_aload_0,&&opc_aload_1,

/* 0x2C */ &&opc_aload_2,&&opc_aload_3,&&opc_iaload, &&opc_laload,

/* 0x30 */ &&opc_faload,  &&opc_daload,  &&opc_aaload,  &&opc_baload,

/* 0x34 */ &&opc_caload,  &&opc_saload,  &&opc_istore,  &&opc_lstore,

/* 0x38 */ &&opc_fstore,  &&opc_dstore,  &&opc_astore,  &&opc_istore_0,

/* 0x3C */ &&opc_istore_1,&&opc_istore_2,&&opc_istore_3,&&opc_lstore_0,

/* 0x40 */ &&opc_lstore_1,&&opc_lstore_2,&&opc_lstore_3,&&opc_fstore_0,

/* 0x44 */ &&opc_fstore_1,&&opc_fstore_2,&&opc_fstore_3,&&opc_dstore_0,

/* 0x48 */ &&opc_dstore_1,&&opc_dstore_2,&&opc_dstore_3,&&opc_astore_0,

/* 0x4C */ &&opc_astore_1,&&opc_astore_2,&&opc_astore_3,&&opc_iastore,

/* 0x50 */ &&opc_lastore,&&opc_fastore,&&opc_dastore,&&opc_aastore,

/* 0x54 */ &&opc_bastore,&&opc_castore,&&opc_sastore,&&opc_pop,

/* 0x58 */ &&opc_pop2,   &&opc_dup,    &&opc_dup_x1, &&opc_dup_x2,

/* 0x5C */ &&opc_dup2,   &&opc_dup2_x1,&&opc_dup2_x2,&&opc_swap,