/*

 * 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.

 *

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_interpreterRuntime.cpp.incl"

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.

    methodDataOop 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

  constantPoolOop pool = method(thread)->constants();

  int index = wide ? two_byte_index(thread) : one_byte_index(thread);

  constantTag tag = pool->tag_at(index);

  if (tag.is_unresolved_klass() || tag.is_klass()) {

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

    oop java_class = klass->klass_part()->java_mirror();

    thread->set_vm_result(java_class);

  } else {

#ifdef ASSERT

    // If we entered this runtime routine, we believed the tag contained

    // an unresolved string, an unresolved class or a resolved class.

    // However, another thread could have resolved the unresolved string

    // or class by the time we go there.

    assert(tag.is_unresolved_string()|| tag.is_string(), "expected string");

#endif

    oop s_oop = pool->string_at(index, CHECK);

    thread->set_vm_result(s_oop);

  }

IRT_END

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

// Allocation

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

  klassOop 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, constantPoolOopDesc* pool, int index, jint size))

  // Note: no oopHandle for pool & klass needed since they are not used

  //       anymore after new_objArray() and no GC can happen before.

  //       (This may have to change if this code changes!)

  klassOop  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

  constantPoolOop constants = method(thread)->constants();

  int          i = two_byte_index(thread);

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

  int   nof_dims = number_of_dimensions(thread);

  assert(oop(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()->klass_part()->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 = two_byte_index(thread);

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

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

  thread->set_vm_result(klass);

IRT_END

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

// Exceptions

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

  if (trap_method.not_null()) {

    methodDataHandle trap_mdo(thread, trap_method->method_data());

    if (trap_mdo.is_null()) {

      methodOopDesc::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 = methodDataHandle(thread, trap_method->method_data());

      // and fall through...

    }

    if (trap_mdo.not_null()) {

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

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

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

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

    }

  }

}

static Handle get_preinitialized_exception(klassOop 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);

  THROW_HANDLE(exception);

IRT_END

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

  // lookup exception klass

  symbolHandle s = oopFactory::new_symbol_handle(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 = Klass::cast(obj->klass())->external_name();

  // lookup exception klass

  symbolHandle s = oopFactory::new_symbol_handle(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

  symbolHandle s = oopFactory::new_symbol_handle(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, Klass::cast(obj->klass())->external_name());

  if (ProfileTraps) {

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

  }

  // create exception

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

IRT_END

// required can be either a MethodType, or a Class (for a single argument)

// actual (if not null) can be either a MethodHandle, or an arbitrary value (for a single argument)

IRT_ENTRY(void, InterpreterRuntime::throw_WrongMethodTypeException(JavaThread* thread,

                                                                   oopDesc* required,

                                                                   oopDesc* actual)) {

  ResourceMark rm(thread);

  char* message = SharedRuntime::generate_wrong_method_type_message(thread, required, actual);

  if (ProfileTraps) {

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

  }

  // create exception

  THROW_MSG(vmSymbols::java_dyn_WrongMethodTypeException(), 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());

  typeArrayHandle    h_extable  (thread, h_method->exception_table());

  bool               should_repeat;

  int                handler_bci;

  int                current_bci = bcp(thread) - h_method->code_base();

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

      ttyLocker ttyl;

      ResourceMark rm(thread);

      tty->print_cr("Exception <%s> (" INTPTR_FORMAT ")", h_exception->print_value_string(), (address)h_exception());

      tty->print_cr(" thrown in interpreter method <%s>", h_method->print_value_string());

      tty->print_cr(" at bci %d for thread " INTPTR_FORMAT, current_bci, thread);

    }

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

//     else if (h_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

    NOT_PRODUCT(Exceptions::debug_check_abort(h_exception));

    // exception handler lookup

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

    handler_bci = h_method->fast_exception_handler_bci_for(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);

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

    // enough stack space available to reprotect the stack.

#ifndef CC_INTERP

    continuation = Interpreter::remove_activation_entry();

#endif

    // Count this for compilation purposes

    h_method->interpreter_throwout_increment();

  } else {

    // handler in this method => change bci/bcp to handler bci/bcp and continue there

    handler_pc = h_method->code_base() + handler_bci;

#ifndef CC_INTERP

    set_bcp_and_mdp(handler_pc, thread);

    continuation = Interpreter::dispatch_table(vtos)[*handler_pc];

#endif

  }

  // notify debugger of an exception catch

  // (this is good for exceptions caught in native methods as well)

  if (JvmtiExport::can_post_on_exceptions()) {

    JvmtiExport::notice_unwind_due_to_exception(thread, h_method(), handler_pc, h_exception(), (handler_pc != NULL));

  }

  thread->set_vm_result(h_exception());

  return continuation;

IRT_END

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

  assert(thread->has_pending_exception(), "must only ne called if there's an exception pending");

  // nothing to do - eventually we should remove this code entirely (see comments @ call sites)

IRT_END

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

  THROW(vmSymbols::java_lang_AbstractMethodError());

IRT_END

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

  THROW(vmSymbols::java_lang_IncompatibleClassChangeError());

IRT_END

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

// Fields

//

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

  // resolve field

  FieldAccessInfo info;

  constantPoolHandle pool(thread, method(thread)->constants());

  bool is_static = (bytecode == Bytecodes::_getstatic || bytecode == Bytecodes::_putstatic);

  {

    JvmtiHideSingleStepping jhss(thread);

    LinkResolver::resolve_field(info, pool, two_byte_index(thread),

                                bytecode, false, CHECK);

  } // end JvmtiHideSingleStepping

  // check if link resolution caused cpCache to be updated

  if (already_resolved(thread)) return;

  // compute auxiliary field attributes

  TosState state  = as_TosState(info.field_type());

  // We need to delay resolving put instructions on final fields

  // until we actually invoke one. This is required so we throw

  // exceptions at the correct place. If we do not resolve completely

  // in the current pass, leaving the put_code set to zero will

  // cause the next put instruction to reresolve.

  bool is_put = (bytecode == Bytecodes::_putfield ||

                 bytecode == Bytecodes::_putstatic);

  Bytecodes::Code put_code = (Bytecodes::Code)0;

  // We also need to delay resolving getstatic instructions until the

  // class is intitialized.  This is required so that access to the static

  // field will call the initialization function every time until the class

  // is completely initialized ala. in 2.17.5 in JVM Specification.

  instanceKlass *klass = instanceKlass::cast(info.klass()->as_klassOop());

  bool uninitialized_static = ((bytecode == Bytecodes::_getstatic || bytecode == Bytecodes::_putstatic) &&

                               !klass->is_initialized());

  Bytecodes::Code get_code = (Bytecodes::Code)0;

  if (!uninitialized_static) {

    get_code = ((is_static) ? Bytecodes::_getstatic : Bytecodes::_getfield);

    if (is_put || !info.access_flags().is_final()) {

      put_code = ((is_static) ? Bytecodes::_putstatic : Bytecodes::_putfield);

    }

  }

  cache_entry(thread)->set_field(

    get_code,

    put_code,

    info.klass(),

    info.field_index(),

    info.field_offset(),

    state,

    info.access_flags().is_final(),

    info.access_flags().is_volatile()

  );

IRT_END

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

// Synchronization

//

// The interpreter's synchronization code is factored out so that it can

// be shared by method invocation and synchronized blocks.

//%note synchronization_3

static void trace_locking(Handle& h_locking_obj, bool is_locking) {

  ObjectSynchronizer::trace_locking(h_locking_obj, false, true, is_locking);

}