/*

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

#include "oops/constantPool.hpp"

#include "oops/cpCache.inline.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.inline.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/icache.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.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/align.hpp"

#include "utilities/copy.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);

    }

};

// Helper class to access current interpreter state

class LastFrameAccessor : public StackObj {

  frame _last_frame;

public:

  LastFrameAccessor(JavaThread* thread) {

    assert(thread == Thread::current(), "sanity");

    _last_frame = thread->last_frame();

  }

  bool is_interpreted_frame() const              { return _last_frame.is_interpreted_frame(); }

  Method*   method() const                       { return _last_frame.interpreter_frame_method(); }

  address   bcp() const                          { return _last_frame.interpreter_frame_bcp(); }

  int       bci() const                          { return _last_frame.interpreter_frame_bci(); }

  address   mdp() const                          { return _last_frame.interpreter_frame_mdp(); }

  void      set_bcp(address bcp)                 { _last_frame.interpreter_frame_set_bcp(bcp); }

  void      set_mdp(address dp)                  { _last_frame.interpreter_frame_set_mdp(dp); }

  // pass method to avoid calling unsafe bcp_to_method (partial fix 4926272)

  Bytecodes::Code code() const                   { return Bytecodes::code_at(method(), bcp()); }

  Bytecode  bytecode() const                     { return Bytecode(method(), bcp()); }

  int get_index_u1(Bytecodes::Code bc) const     { return bytecode().get_index_u1(bc); }

  int get_index_u2(Bytecodes::Code bc) const     { return bytecode().get_index_u2(bc); }

  int get_index_u2_cpcache(Bytecodes::Code bc) const

                                                 { return bytecode().get_index_u2_cpcache(bc); }

  int get_index_u4(Bytecodes::Code bc) const     { return bytecode().get_index_u4(bc); }

  int number_of_dimensions() const               { return bcp()[3]; }

  ConstantPoolCacheEntry* cache_entry_at(int i) const

                                                 { return method()->constants()->cache()->entry_at(i); }

  ConstantPoolCacheEntry* cache_entry() const    { return cache_entry_at(Bytes::get_native_u2(bcp() + 1)); }

  oop callee_receiver(Symbol* signature) {

    return _last_frame.interpreter_callee_receiver(signature);

  }

  BasicObjectLock* monitor_begin() const {

    return _last_frame.interpreter_frame_monitor_begin();

  }

  BasicObjectLock* monitor_end() const {

    return _last_frame.interpreter_frame_monitor_end();

  }

  BasicObjectLock* next_monitor(BasicObjectLock* current) const {

    return _last_frame.next_monitor_in_interpreter_frame(current);

  }

  frame& get_frame()                             { return _last_frame; }

};

bool InterpreterRuntime::is_breakpoint(JavaThread *thread) {

  return Bytecodes::code_or_bp_at(LastFrameAccessor(thread).bcp()) == Bytecodes::_breakpoint;

}

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

// State accessors

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

  LastFrameAccessor last_frame(thread);

  last_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.method()->method_data();

    if (mdo != NULL) {

      NEEDS_CLEANUP;

      last_frame.set_mdp(mdo->bci_to_dp(last_frame.bci()));

    }

  }

}

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

// Constants

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

  // access constant pool

  LastFrameAccessor last_frame(thread);

  ConstantPool* pool = last_frame.method()->constants();

  int index = wide ? last_frame.get_index_u2(Bytecodes::_ldc_w) : last_frame.get_index_u1(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::_ldc ||

         bytecode == Bytecodes::_ldc_w ||

         bytecode == Bytecodes::_ldc2_w ||

         bytecode == Bytecodes::_fast_aldc ||

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

  ResourceMark rm(thread);

  const bool is_fast_aldc = (bytecode == Bytecodes::_fast_aldc ||

                             bytecode == Bytecodes::_fast_aldc_w);

  LastFrameAccessor last_frame(thread);

  methodHandle m (thread, last_frame.method());

  Bytecode_loadconstant ldc(m, last_frame.bci());

  // Double-check the size.  (Condy can have any type.)

  BasicType type = ldc.result_type();

  switch (type2size[type]) {

  case 2: guarantee(bytecode == Bytecodes::_ldc2_w, ""); break;

  case 1: guarantee(bytecode != Bytecodes::_ldc2_w, ""); break;

  default: ShouldNotReachHere();

  }

  // Resolve the constant.  This does not do unboxing.

  // But it does replace Universe::the_null_sentinel by null.

  oop result = ldc.resolve_constant(CHECK);

  assert(result != NULL || is_fast_aldc, "null result only valid for fast_aldc");

#ifdef ASSERT

  {

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

    Bytecode_loadconstant ldc2(m, last_frame.bci());

    int rindex = ldc2.cache_index();

    if (rindex < 0)

      rindex = m->constants()->cp_to_object_index(ldc2.pool_index());

    if (rindex >= 0) {

      oop coop = m->constants()->resolved_references()->obj_at(rindex);

      oop roop = (result == NULL ? Universe::the_null_sentinel() : result);

      assert(oopDesc::equals(roop, coop), "expected result for assembly code");

    }

  }

#endif

  thread->set_vm_result(result);

  if (!is_fast_aldc) {

    // Tell the interpreter how to unbox the primitive.

    guarantee(java_lang_boxing_object::is_instance(result, type), "");

    int offset = java_lang_boxing_object::value_offset_in_bytes(type);

    intptr_t flags = ((as_TosState(type) << ConstantPoolCacheEntry::tos_state_shift)

                      | (offset & ConstantPoolCacheEntry::field_index_mask));

    thread->set_vm_result_2((Metadata*)flags);

  }

}

IRT_END

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

// Allocation

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

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

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

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

  LastFrameAccessor last_frame(thread);

  ConstantPool* constants = last_frame.method()->constants();

  int          i = last_frame.get_index_u2(Bytecodes::_multianewarray);

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

  int   nof_dims = last_frame.number_of_dimensions();

  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(oopDesc::is_oop(obj), "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

  LastFrameAccessor last_frame(thread);

  int which = last_frame.get_index_u2(Bytecodes::_checkcast);

  ConstantPool* cpool = last_frame.method()->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,

                                         const 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");

  LastFrameAccessor last_frame(thread);

  methodHandle trap_method(thread, last_frame.method());

  int trap_bci = trap_method->bci_from(last_frame.bcp());

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

  // Produce the error message first because note_trap can safepoint

  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, arrayOopDesc* a, jint index))

  // Produce the error message first because note_trap can safepoint

  ResourceMark rm(thread);

  stringStream ss;

  ss.print("Index %d out of bounds for length %d", index, a->length());

  if (ProfileTraps) {

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

  }

  THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), ss.as_string());

IRT_END

IRT_ENTRY(void, InterpreterRuntime::throw_ClassCastException(

  JavaThread* thread, oopDesc* obj))

  // Produce the error message first because note_trap can safepoint

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

  LastFrameAccessor last_frame(thread);

  Handle             h_exception(thread, exception);

  methodHandle       h_method   (thread, last_frame.method());

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

  bool               should_repeat;

  int                handler_bci;

  int                current_bci = last_frame.bci();

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

    // Allocation of scalar replaced object used in this frame

    // failed. Unconditionally pop the frame.