/*

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

 * 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/resourceArea.hpp"

#include "oops/methodCounters.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiThreadState.hpp"

#include "runtime/biasedLocking.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

#ifdef TARGET_OS_ARCH_linux_arm

# include "orderAccess_linux_arm.inline.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_ppc

# include "orderAccess_linux_ppc.inline.hpp"

#endif

#ifdef TARGET_OS_ARCH_aix_ppc

# include "orderAccess_aix_ppc.inline.hpp"

#endif

#ifdef TARGET_OS_ARCH_bsd_x86

# include "orderAccess_bsd_x86.inline.hpp"

#endif

#ifdef TARGET_OS_ARCH_bsd_zero

# include "orderAccess_bsd_zero.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;                                               \

          }                                                                      \

          if (THREAD->jvmti_thread_state() &&                                    \

              THREAD->jvmti_thread_state()->is_earlyret_pending()) {             \

            goto handle_Early_Return;                                            \

          }                                                                      \

          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

#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 GET_METHOD_COUNTERS(res)    \

  res = METHOD->method_counters();  \

  if (res == NULL) {                \

    CALL_VM(res = InterpreterRuntime::build_method_counters(THREAD, METHOD), handle_exception); \

  }

#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) {                                                                              \

      MethodCounters* mcs;                                                                          \

      GET_METHOD_COUNTERS(mcs);                                                                     \

      if (UseLoopCounter) {                                                                         \

        bool do_OSR = UseOnStackReplacement;                                                        \

        mcs->backedge_counter()->increment();                                                       \

        if (do_OSR) do_OSR = mcs->backedge_counter()->reached_InvocationLimit();                    \

        if (do_OSR) {                                                                               \

          nmethod*  osr_nmethod;                                                                    \

          OSR_REQUEST(osr_nmethod, branch_pc);                                                      \

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

            istate->set_msg(do_osr);                                                                \

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

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

            return;                                                                                 \

          }                                                                                         \

        }                                                                                           \

      }  /* UseCompiler ... */                                                                      \

      mcs->invocation_counter()->increment();                                                       \

      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();

        DECACHE_STATE();                                           \

        SET_LAST_JAVA_FRAME();                                     \

        func;                                                      \

        RESET_LAST_JAVA_FRAME();                                   \

        if (THREAD->pop_frame_pending() &&                         \

            !THREAD->pop_frame_in_process()) {                     \

          goto handle_Pop_Frame;                                   \

        }                                                          \

        if (THREAD->jvmti_thread_state() &&                        \

            THREAD->jvmti_thread_state()->is_earlyret_pending()) { \

          goto handle_Early_Return;                                \

        }

// 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) {

    // We have a problem here if we are running with a pre-hsx24 JDK (for example during bootstrap)

    // because in that case, EnableInvokeDynamic is true by default but will be later switched off

    // if java_lang_invoke_MethodHandle::compute_offsets() detects that the JDK only has the classes

    // for the old JSR292 implementation.

    // This leads to a situation where 'istate->_stack_limit' always accounts for

    // methodOopDesc::extra_stack_entries() because it is computed in

    // CppInterpreterGenerator::generate_compute_interpreter_state() which was generated while

    // EnableInvokeDynamic was still true. On the other hand, istate->_method->max_stack() doesn't

    // account for extra_stack_entries() anymore because at the time when it is called

    // EnableInvokeDynamic was already set to false.

    // So we have a second version of the assertion which handles the case where EnableInvokeDynamic was

    // switched off because of the wrong classes.

    if (EnableInvokeDynamic || FLAG_IS_CMDLINE(EnableInvokeDynamic)) {

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

    } else {

      const int extra_stack_entries = Method::extra_stack_entries_for_jsr292;

      assert(labs(istate->_stack_base - istate->_stack_limit) == (istate->_method->max_stack() + extra_stack_entries

                                                                                               + 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);