/*

 * Copyright (c) 1997, 2016, 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.

 *

 */

#include "precompiled.hpp"

#include "classfile/javaClasses.inline.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/codeCache.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/disassembler.hpp"

#include "gc/shared/collectedHeap.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/interpreterRuntime.hpp"

#include "interpreter/linkResolver.hpp"

#include "interpreter/templateTable.hpp"

#include "logging/log.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.inline.hpp"

#include "oops/constantPool.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/methodData.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/nativeLookup.hpp"

#include "runtime/atomic.hpp"

#include "runtime/biasedLocking.hpp"

#include "runtime/compilationPolicy.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/fieldDescriptor.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/icache.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/java.hpp"

#include "runtime/jfieldIDWorkaround.hpp"

#include "runtime/osThread.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/synchronizer.hpp"

#include "runtime/threadCritical.hpp"

#include "utilities/events.hpp"

#ifdef COMPILER2

#include "opto/runtime.hpp"

#endif

class UnlockFlagSaver {

  private:

    JavaThread* _thread;

    bool _do_not_unlock;

  public:

    UnlockFlagSaver(JavaThread* t) {

      _thread = t;

      _do_not_unlock = t->do_not_unlock_if_synchronized();

      t->set_do_not_unlock_if_synchronized(false);

    }

    ~UnlockFlagSaver() {

      _thread->set_do_not_unlock_if_synchronized(_do_not_unlock);

    }

};

//------------------------------------------------------------------------------------------------------------------------

// State accessors

void InterpreterRuntime::set_bcp_and_mdp(address bcp, JavaThread *thread) {

  last_frame(thread).interpreter_frame_set_bcp(bcp);

  if (ProfileInterpreter) {

    // ProfileTraps uses MDOs independently of ProfileInterpreter.

    // That is why we must check both ProfileInterpreter and mdo != NULL.

    MethodData* mdo = last_frame(thread).interpreter_frame_method()->method_data();

    if (mdo != NULL) {

      NEEDS_CLEANUP;

      last_frame(thread).interpreter_frame_set_mdp(mdo->bci_to_dp(last_frame(thread).interpreter_frame_bci()));

    }

  }

}

//------------------------------------------------------------------------------------------------------------------------

// Constants

IRT_ENTRY(void, InterpreterRuntime::ldc(JavaThread* thread, bool wide))

  // access constant pool

  ConstantPool* pool = method(thread)->constants();

  int index = wide ? get_index_u2(thread, Bytecodes::_ldc_w) : get_index_u1(thread, Bytecodes::_ldc);

  constantTag tag = pool->tag_at(index);

  assert (tag.is_unresolved_klass() || tag.is_klass(), "wrong ldc call");

  Klass* klass = pool->klass_at(index, CHECK);

    oop java_class = klass->java_mirror();

    thread->set_vm_result(java_class);

IRT_END

IRT_ENTRY(void, InterpreterRuntime::resolve_ldc(JavaThread* thread, Bytecodes::Code bytecode)) {

  assert(bytecode == Bytecodes::_fast_aldc ||

         bytecode == Bytecodes::_fast_aldc_w, "wrong bc");

  ResourceMark rm(thread);

  methodHandle m (thread, method(thread));

  Bytecode_loadconstant ldc(m, bci(thread));

  oop result = ldc.resolve_constant(CHECK);

#ifdef ASSERT

  {

    // The bytecode wrappers aren't GC-safe so construct a new one

    Bytecode_loadconstant ldc2(m, bci(thread));

    oop coop = m->constants()->resolved_references()->obj_at(ldc2.cache_index());

    assert(result == coop, "expected result for assembly code");

  }

#endif

  thread->set_vm_result(result);

}

IRT_END

//------------------------------------------------------------------------------------------------------------------------

// Allocation

IRT_ENTRY(void, InterpreterRuntime::_new(JavaThread* thread, ConstantPool* pool, int index))

  Klass* k_oop = pool->klass_at(index, CHECK);

  instanceKlassHandle klass (THREAD, k_oop);

  // Make sure we are not instantiating an abstract klass

  klass->check_valid_for_instantiation(true, CHECK);

  // Make sure klass is initialized

  klass->initialize(CHECK);

  // At this point the class may not be fully initialized

  // because of recursive initialization. If it is fully

  // initialized & has_finalized is not set, we rewrite

  // it into its fast version (Note: no locking is needed

  // here since this is an atomic byte write and can be

  // done more than once).

  //

  // Note: In case of classes with has_finalized we don't

  //       rewrite since that saves us an extra check in

  //       the fast version which then would call the

  //       slow version anyway (and do a call back into

  //       Java).

  //       If we have a breakpoint, then we don't rewrite

  //       because the _breakpoint bytecode would be lost.

  oop obj = klass->allocate_instance(CHECK);

  thread->set_vm_result(obj);

IRT_END

IRT_ENTRY(void, InterpreterRuntime::newarray(JavaThread* thread, BasicType type, jint size))

  oop obj = oopFactory::new_typeArray(type, size, CHECK);

  thread->set_vm_result(obj);

IRT_END

IRT_ENTRY(void, InterpreterRuntime::anewarray(JavaThread* thread, ConstantPool* pool, int index, jint size))

  Klass*    klass = pool->klass_at(index, CHECK);

  objArrayOop obj = oopFactory::new_objArray(klass, size, CHECK);

  thread->set_vm_result(obj);

IRT_END

IRT_ENTRY(void, InterpreterRuntime::multianewarray(JavaThread* thread, jint* first_size_address))

  // We may want to pass in more arguments - could make this slightly faster

  ConstantPool* constants = method(thread)->constants();

  int          i = get_index_u2(thread, Bytecodes::_multianewarray);

  Klass* klass = constants->klass_at(i, CHECK);

  int   nof_dims = number_of_dimensions(thread);

  assert(klass->is_klass(), "not a class");

  assert(nof_dims >= 1, "multianewarray rank must be nonzero");

  // We must create an array of jints to pass to multi_allocate.

  ResourceMark rm(thread);

  const int small_dims = 10;

  jint dim_array[small_dims];

  jint *dims = &dim_array[0];

  if (nof_dims > small_dims) {

    dims = (jint*) NEW_RESOURCE_ARRAY(jint, nof_dims);

  }

  for (int index = 0; index < nof_dims; index++) {

    // offset from first_size_address is addressed as local[index]

    int n = Interpreter::local_offset_in_bytes(index)/jintSize;

    dims[index] = first_size_address[n];

  }

  oop obj = ArrayKlass::cast(klass)->multi_allocate(nof_dims, dims, CHECK);

  thread->set_vm_result(obj);

IRT_END

IRT_ENTRY(void, InterpreterRuntime::register_finalizer(JavaThread* thread, oopDesc* obj))

  assert(obj->is_oop(), "must be a valid oop");

  assert(obj->klass()->has_finalizer(), "shouldn't be here otherwise");

  InstanceKlass::register_finalizer(instanceOop(obj), CHECK);

IRT_END

// Quicken instance-of and check-cast bytecodes

IRT_ENTRY(void, InterpreterRuntime::quicken_io_cc(JavaThread* thread))

  // Force resolving; quicken the bytecode

  int which = get_index_u2(thread, Bytecodes::_checkcast);

  ConstantPool* cpool = method(thread)->constants();

  // We'd expect to assert that we're only here to quicken bytecodes, but in a multithreaded

  // program we might have seen an unquick'd bytecode in the interpreter but have another

  // thread quicken the bytecode before we get here.

  // assert( cpool->tag_at(which).is_unresolved_klass(), "should only come here to quicken bytecodes" );

  Klass* klass = cpool->klass_at(which, CHECK);

  thread->set_vm_result_2(klass);

IRT_END

//------------------------------------------------------------------------------------------------------------------------

// Exceptions

void InterpreterRuntime::note_trap_inner(JavaThread* thread, int reason,

                                         methodHandle trap_method, int trap_bci, TRAPS) {

  if (trap_method.not_null()) {

    MethodData* trap_mdo = trap_method->method_data();

    if (trap_mdo == NULL) {

      Method::build_interpreter_method_data(trap_method, THREAD);

      if (HAS_PENDING_EXCEPTION) {

        assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())),

               "we expect only an OOM error here");

        CLEAR_PENDING_EXCEPTION;

      }

      trap_mdo = trap_method->method_data();

      // and fall through...

    }

    if (trap_mdo != NULL) {

      // Update per-method count of trap events.  The interpreter

      // is updating the MDO to simulate the effect of compiler traps.

      Deoptimization::update_method_data_from_interpreter(trap_mdo, trap_bci, reason);

    }

  }

}

// Assume the compiler is (or will be) interested in this event.

// If necessary, create an MDO to hold the information, and record it.

void InterpreterRuntime::note_trap(JavaThread* thread, int reason, TRAPS) {

  assert(ProfileTraps, "call me only if profiling");

  methodHandle trap_method(thread, method(thread));

  int trap_bci = trap_method->bci_from(bcp(thread));

  note_trap_inner(thread, reason, trap_method, trap_bci, THREAD);

}

#ifdef CC_INTERP

// As legacy note_trap, but we have more arguments.

IRT_ENTRY(void, InterpreterRuntime::note_trap(JavaThread* thread, int reason, Method *method, int trap_bci))

  methodHandle trap_method(method);

  note_trap_inner(thread, reason, trap_method, trap_bci, THREAD);

IRT_END

// Class Deoptimization is not visible in BytecodeInterpreter, so we need a wrapper

// for each exception.

void InterpreterRuntime::note_nullCheck_trap(JavaThread* thread, Method *method, int trap_bci)

  { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_null_check, method, trap_bci); }

void InterpreterRuntime::note_div0Check_trap(JavaThread* thread, Method *method, int trap_bci)

  { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_div0_check, method, trap_bci); }

void InterpreterRuntime::note_rangeCheck_trap(JavaThread* thread, Method *method, int trap_bci)

  { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_range_check, method, trap_bci); }

void InterpreterRuntime::note_classCheck_trap(JavaThread* thread, Method *method, int trap_bci)

  { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_class_check, method, trap_bci); }

void InterpreterRuntime::note_arrayCheck_trap(JavaThread* thread, Method *method, int trap_bci)

  { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_array_check, method, trap_bci); }

#endif // CC_INTERP

static Handle get_preinitialized_exception(Klass* k, TRAPS) {

  // get klass

  InstanceKlass* klass = InstanceKlass::cast(k);

  assert(klass->is_initialized(),

         "this klass should have been initialized during VM initialization");

  // create instance - do not call constructor since we may have no

  // (java) stack space left (should assert constructor is empty)

  Handle exception;

  oop exception_oop = klass->allocate_instance(CHECK_(exception));

  exception = Handle(THREAD, exception_oop);

  if (StackTraceInThrowable) {

    java_lang_Throwable::fill_in_stack_trace(exception);

  }

  return exception;

}

// Special handling for stack overflow: since we don't have any (java) stack

// space left we use the pre-allocated & pre-initialized StackOverflowError

// klass to create an stack overflow error instance.  We do not call its

// constructor for the same reason (it is empty, anyway).

IRT_ENTRY(void, InterpreterRuntime::throw_StackOverflowError(JavaThread* thread))

  Handle exception = get_preinitialized_exception(

                                 SystemDictionary::StackOverflowError_klass(),

                                 CHECK);

  // Increment counter for hs_err file reporting

  Atomic::inc(&Exceptions::_stack_overflow_errors);

  THROW_HANDLE(exception);

IRT_END

IRT_ENTRY(void, InterpreterRuntime::throw_delayed_StackOverflowError(JavaThread* thread))

  Handle exception = get_preinitialized_exception(

                                 SystemDictionary::StackOverflowError_klass(),

                                 CHECK);

  java_lang_Throwable::set_message(exception(),

          Universe::delayed_stack_overflow_error_message());

  // Increment counter for hs_err file reporting

  Atomic::inc(&Exceptions::_stack_overflow_errors);

  THROW_HANDLE(exception);

IRT_END

IRT_ENTRY(void, InterpreterRuntime::create_exception(JavaThread* thread, char* name, char* message))

  // lookup exception klass

  TempNewSymbol s = SymbolTable::new_symbol(name, CHECK);

  if (ProfileTraps) {

    if (s == vmSymbols::java_lang_ArithmeticException()) {

      note_trap(thread, Deoptimization::Reason_div0_check, CHECK);

    } else if (s == vmSymbols::java_lang_NullPointerException()) {

      note_trap(thread, Deoptimization::Reason_null_check, CHECK);

    }

  }

  // create exception

  Handle exception = Exceptions::new_exception(thread, s, message);

  thread->set_vm_result(exception());

IRT_END

IRT_ENTRY(void, InterpreterRuntime::create_klass_exception(JavaThread* thread, char* name, oopDesc* obj))

  ResourceMark rm(thread);

  const char* klass_name = obj->klass()->external_name();

  // lookup exception klass

  TempNewSymbol s = SymbolTable::new_symbol(name, CHECK);

  if (ProfileTraps) {

    note_trap(thread, Deoptimization::Reason_class_check, CHECK);

  }

  // create exception, with klass name as detail message

  Handle exception = Exceptions::new_exception(thread, s, klass_name);

  thread->set_vm_result(exception());

IRT_END

IRT_ENTRY(void, InterpreterRuntime::throw_ArrayIndexOutOfBoundsException(JavaThread* thread, char* name, jint index))

  char message[jintAsStringSize];

  // lookup exception klass

  TempNewSymbol s = SymbolTable::new_symbol(name, CHECK);

  if (ProfileTraps) {

    note_trap(thread, Deoptimization::Reason_range_check, CHECK);

  }

  // create exception

  sprintf(message, "%d", index);

  THROW_MSG(s, message);

IRT_END

IRT_ENTRY(void, InterpreterRuntime::throw_ClassCastException(

  JavaThread* thread, oopDesc* obj))

  ResourceMark rm(thread);

  char* message = SharedRuntime::generate_class_cast_message(

    thread, obj->klass());

  if (ProfileTraps) {

    note_trap(thread, Deoptimization::Reason_class_check, CHECK);

  }

  // create exception

  THROW_MSG(vmSymbols::java_lang_ClassCastException(), message);

IRT_END

// exception_handler_for_exception(...) returns the continuation address,

// the exception oop (via TLS) and sets the bci/bcp for the continuation.

// The exception oop is returned to make sure it is preserved over GC (it

// is only on the stack if the exception was thrown explicitly via athrow).

// During this operation, the expression stack contains the values for the

// bci where the exception happened. If the exception was propagated back

// from a call, the expression stack contains the values for the bci at the

// invoke w/o arguments (i.e., as if one were inside the call).

IRT_ENTRY(address, InterpreterRuntime::exception_handler_for_exception(JavaThread* thread, oopDesc* exception))

  Handle             h_exception(thread, exception);

  methodHandle       h_method   (thread, method(thread));

  constantPoolHandle h_constants(thread, h_method->constants());

  bool               should_repeat;

  int                handler_bci;

  int                current_bci = bci(thread);

  if (thread->frames_to_pop_failed_realloc() > 0) {

    // Allocation of scalar replaced object used in this frame

    // failed. Unconditionally pop the frame.

    thread->dec_frames_to_pop_failed_realloc();

    thread->set_vm_result(h_exception());

    // If the method is synchronized we already unlocked the monitor

    // during deoptimization so the interpreter needs to skip it when

    // the frame is popped.

    thread->set_do_not_unlock_if_synchronized(true);

#ifdef CC_INTERP

    return (address) -1;

#else

    return Interpreter::remove_activation_entry();

#endif

  }

  // Need to do this check first since when _do_not_unlock_if_synchronized

  // is set, we don't want to trigger any classloading which may make calls

  // into java, or surprisingly find a matching exception handler for bci 0

  // since at this moment the method hasn't been "officially" entered yet.

  if (thread->do_not_unlock_if_synchronized()) {

    ResourceMark rm;

    assert(current_bci == 0,  "bci isn't zero for do_not_unlock_if_synchronized");

    thread->set_vm_result(exception);

#ifdef CC_INTERP

    return (address) -1;

#else

    return Interpreter::remove_activation_entry();

#endif

  }

  do {

    should_repeat = false;

    // assertions

#ifdef ASSERT

    assert(h_exception.not_null(), "NULL exceptions should be handled by athrow");

    assert(h_exception->is_oop(), "just checking");

    // Check that exception is a subclass of Throwable, otherwise we have a VerifyError

    if (!(h_exception->is_a(SystemDictionary::Throwable_klass()))) {

      if (ExitVMOnVerifyError) vm_exit(-1);

      ShouldNotReachHere();

    }

#endif

    // tracing

    if (log_is_enabled(Info, exceptions)) {

      ResourceMark rm(thread);

      stringStream tempst;

      tempst.print("interpreter method <%s>\n"

                   " at bci %d for thread " INTPTR_FORMAT,

                   h_method->print_value_string(), current_bci, p2i(thread));

      Exceptions::log_exception(h_exception, tempst);

    }

// Don't go paging in something which won't be used.

//     else if (extable->length() == 0) {

//       // disabled for now - interpreter is not using shortcut yet

//       // (shortcut is not to call runtime if we have no exception handlers)

//       // warning("performance bug: should not call runtime if method has no exception handlers");

//     }

    // for AbortVMOnException flag

    Exceptions::debug_check_abort(h_exception);

    // exception handler lookup

    KlassHandle h_klass(THREAD, h_exception->klass());

    handler_bci = Method::fast_exception_handler_bci_for(h_method, h_klass, current_bci, THREAD);

    if (HAS_PENDING_EXCEPTION) {

      // We threw an exception while trying to find the exception handler.

      // Transfer the new exception to the exception handle which will

      // be set into thread local storage, and do another lookup for an

      // exception handler for this exception, this time starting at the

      // BCI of the exception handler which caused the exception to be

      // thrown (bug 4307310).

      h_exception = Handle(THREAD, PENDING_EXCEPTION);

      CLEAR_PENDING_EXCEPTION;

      if (handler_bci >= 0) {

        current_bci = handler_bci;

        should_repeat = true;

      }

    }

  } while (should_repeat == true);

#if INCLUDE_JVMCI

  if (EnableJVMCI && h_method->method_data() != NULL) {

    ResourceMark rm(thread);

    ProfileData* pdata = h_method->method_data()->allocate_bci_to_data(current_bci, NULL);

    if (pdata != NULL && pdata->is_BitData()) {

      BitData* bit_data = (BitData*) pdata;

      bit_data->set_exception_seen();

    }

  }

#endif

  // notify JVMTI of an exception throw; JVMTI will detect if this is a first

  // time throw or a stack unwinding throw and accordingly notify the debugger

  if (JvmtiExport::can_post_on_exceptions()) {

    JvmtiExport::post_exception_throw(thread, h_method(), bcp(thread), h_exception());

  }

#ifdef CC_INTERP

  address continuation = (address)(intptr_t) handler_bci;

#else

  address continuation = NULL;

#endif

  address handler_pc = NULL;

  if (handler_bci < 0 || !thread->reguard_stack((address) &continuation)) {

    // Forward exception to callee (leaving bci/bcp untouched) because (a) no

    // handler in this method, or (b) after a stack overflow there is not yet