/*

 * Copyright (c) 2011, 2019, 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/stringTable.hpp"

#include "classfile/symbolTable.hpp"

#include "code/scopeDesc.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/disassembler.hpp"

#include "interpreter/linkResolver.hpp"

#include "interpreter/bytecodeStream.hpp"

#include "jvmci/jvmciCompilerToVM.hpp"

#include "jvmci/jvmciCodeInstaller.hpp"

#include "jvmci/jvmciRuntime.hpp"

#include "memory/oopFactory.hpp"

#include "oops/constantPool.inline.hpp"

#include "oops/method.inline.hpp"

#include "oops/typeArrayOop.inline.hpp"

#include "prims/nativeLookup.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/fieldDescriptor.inline.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/jniHandles.inline.hpp"

#include "runtime/timerTrace.hpp"

#include "runtime/vframe_hp.hpp"

JVMCIKlassHandle::JVMCIKlassHandle(Thread* thread, Klass* klass) {

  _thread = thread;

  _klass = klass;

  if (klass != NULL) {

    _holder = Handle(_thread, klass->klass_holder());

  }

}

JVMCIKlassHandle& JVMCIKlassHandle::operator=(Klass* klass) {

  _klass = klass;

  if (klass != NULL) {

    _holder = Handle(_thread, klass->klass_holder());

  }

  return *this;

}

void JNIHandleMark::push_jni_handle_block() {

  JavaThread* thread = JavaThread::current();

  if (thread != NULL) {

    // Allocate a new block for JNI handles.

    // Inlined code from jni_PushLocalFrame()

    JNIHandleBlock* java_handles = ((JavaThread*)thread)->active_handles();

    JNIHandleBlock* compile_handles = JNIHandleBlock::allocate_block(thread);

    assert(compile_handles != NULL && java_handles != NULL, "should not be NULL");

    compile_handles->set_pop_frame_link(java_handles);

    thread->set_active_handles(compile_handles);

  }

}

void JNIHandleMark::pop_jni_handle_block() {

  JavaThread* thread = JavaThread::current();

  if (thread != NULL) {

    // Release our JNI handle block

    JNIHandleBlock* compile_handles = thread->active_handles();

    JNIHandleBlock* java_handles = compile_handles->pop_frame_link();

    thread->set_active_handles(java_handles);

    compile_handles->set_pop_frame_link(NULL);

    JNIHandleBlock::release_block(compile_handles, thread); // may block

  }

}

class JVMCITraceMark : public StackObj {

  const char* _msg;

 public:

  JVMCITraceMark(const char* msg) {

    _msg = msg;

    if (JVMCITraceLevel >= 1) {

      tty->print_cr(PTR_FORMAT " JVMCITrace-1: Enter %s", p2i(JavaThread::current()), _msg);

    }

  }

  ~JVMCITraceMark() {

    if (JVMCITraceLevel >= 1) {

      tty->print_cr(PTR_FORMAT " JVMCITrace-1: Exit %s", p2i(JavaThread::current()), _msg);

    }

  }

};

Handle JavaArgumentUnboxer::next_arg(BasicType expectedType) {

  assert(_index < _args->length(), "out of bounds");

  oop arg=((objArrayOop) (_args))->obj_at(_index++);

  assert(expectedType == T_OBJECT || java_lang_boxing_object::is_instance(arg, expectedType), "arg type mismatch");

  return Handle(Thread::current(), arg);

}

// Entry to native method implementation that transitions current thread to '_thread_in_vm'.

#define C2V_VMENTRY(result_type, name, signature)        \

  JNIEXPORT result_type JNICALL c2v_ ## name signature { \

  JVMCITraceMark jtm("CompilerToVM::" #name);            \

  TRACE_CALL(result_type, jvmci_ ## name signature)      \

  JVMCI_VM_ENTRY_MARK;                                   \

  ResourceMark rm;                                       \

  JNI_JVMCIENV(env);

#define C2V_END }

jobjectArray readConfiguration0(JNIEnv *env, JVMCI_TRAPS);

C2V_VMENTRY(jobjectArray, readConfiguration, (JNIEnv* env))

  jobjectArray config = readConfiguration0(env, JVMCI_CHECK_NULL);

  return config;

}

C2V_VMENTRY(jobject, getFlagValue, (JNIEnv* env, jobject c2vm, jobject name_handle))

#define RETURN_BOXED_LONG(value) jvalue p; p.j = (jlong) (value); JVMCIObject box = JVMCIENV->create_box(T_LONG, &p, JVMCI_CHECK_NULL); return box.as_jobject();

#define RETURN_BOXED_DOUBLE(value) jvalue p; p.d = (jdouble) (value); JVMCIObject box = JVMCIENV->create_box(T_DOUBLE, &p, JVMCI_CHECK_NULL); return box.as_jobject();

  JVMCIObject name = JVMCIENV->wrap(name_handle);

  if (name.is_null()) {

    JVMCI_THROW_NULL(NullPointerException);

  }

  const char* cstring = JVMCIENV->as_utf8_string(name);

  JVMFlag* flag = JVMFlag::find_flag(cstring, strlen(cstring), /* allow_locked */ true, /* return_flag */ true);

  if (flag == NULL) {

    return c2vm;

  }

  if (flag->is_bool()) {

    jvalue prim;

    prim.z = flag->get_bool();

    JVMCIObject box = JVMCIENV->create_box(T_BOOLEAN, &prim, JVMCI_CHECK_NULL);

    return JVMCIENV->get_jobject(box);

  } else if (flag->is_ccstr()) {

    JVMCIObject value = JVMCIENV->create_string(flag->get_ccstr(), JVMCI_CHECK_NULL);

    return JVMCIENV->get_jobject(value);

  } else if (flag->is_intx()) {

    RETURN_BOXED_LONG(flag->get_intx());

  } else if (flag->is_int()) {

    RETURN_BOXED_LONG(flag->get_int());

  } else if (flag->is_uint()) {

    RETURN_BOXED_LONG(flag->get_uint());

  } else if (flag->is_uint64_t()) {

    RETURN_BOXED_LONG(flag->get_uint64_t());

  } else if (flag->is_size_t()) {

    RETURN_BOXED_LONG(flag->get_size_t());

  } else if (flag->is_uintx()) {

    RETURN_BOXED_LONG(flag->get_uintx());

  } else if (flag->is_double()) {

    RETURN_BOXED_DOUBLE(flag->get_double());

  } else {

    JVMCI_ERROR_NULL("VM flag %s has unsupported type %s", flag->_name, flag->_type);

  }

#undef RETURN_BOXED_LONG

#undef RETURN_BOXED_DOUBLE

C2V_END

C2V_VMENTRY(jobject, getObjectAtAddress, (JNIEnv* env, jobject c2vm, jlong oop_address))

  if (env != JavaThread::current()->jni_environment()) {

    JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot");

  }

  if (oop_address == 0) {

    JVMCI_THROW_MSG_NULL(InternalError, "Handle must be non-zero");

  }

  oop obj = *((oopDesc**) oop_address);

  if (obj != NULL) {

    oopDesc::verify(obj);

  }

  return JNIHandles::make_local(obj);

C2V_END

C2V_VMENTRY(jbyteArray, getBytecode, (JNIEnv* env, jobject, jobject jvmci_method))

  methodHandle method = JVMCIENV->asMethod(jvmci_method);

  int code_size = method->code_size();

  jbyte* reconstituted_code = NEW_RESOURCE_ARRAY(jbyte, code_size);

  guarantee(method->method_holder()->is_rewritten(), "Method's holder should be rewritten");

  // iterate over all bytecodes and replace non-Java bytecodes

  for (BytecodeStream s(method); s.next() != Bytecodes::_illegal; ) {

    Bytecodes::Code code = s.code();

    Bytecodes::Code raw_code = s.raw_code();

    int bci = s.bci();

    int len = s.instruction_size();

    // Restore original byte code.

    reconstituted_code[bci] =  (jbyte) (s.is_wide()? Bytecodes::_wide : code);

    if (len > 1) {

      memcpy(reconstituted_code + (bci + 1), s.bcp()+1, len-1);

    }

    if (len > 1) {

      // Restore the big-endian constant pool indexes.

      // Cf. Rewriter::scan_method

      switch (code) {

        case Bytecodes::_getstatic:

        case Bytecodes::_putstatic:

        case Bytecodes::_getfield:

        case Bytecodes::_putfield:

        case Bytecodes::_invokevirtual:

        case Bytecodes::_invokespecial:

        case Bytecodes::_invokestatic:

        case Bytecodes::_invokeinterface:

        case Bytecodes::_invokehandle: {

          int cp_index = Bytes::get_native_u2((address) reconstituted_code + (bci + 1));

          Bytes::put_Java_u2((address) reconstituted_code + (bci + 1), (u2) cp_index);

          break;

        }

        case Bytecodes::_invokedynamic: {

          int cp_index = Bytes::get_native_u4((address) reconstituted_code + (bci + 1));

          Bytes::put_Java_u4((address) reconstituted_code + (bci + 1), (u4) cp_index);

          break;

        }

        default:

          break;

      }

      // Not all ldc byte code are rewritten.

      switch (raw_code) {

        case Bytecodes::_fast_aldc: {

          int cpc_index = reconstituted_code[bci + 1] & 0xff;

          int cp_index = method->constants()->object_to_cp_index(cpc_index);

          assert(cp_index < method->constants()->length(), "sanity check");

          reconstituted_code[bci + 1] = (jbyte) cp_index;

          break;

        }

        case Bytecodes::_fast_aldc_w: {

          int cpc_index = Bytes::get_native_u2((address) reconstituted_code + (bci + 1));

          int cp_index = method->constants()->object_to_cp_index(cpc_index);

          assert(cp_index < method->constants()->length(), "sanity check");

          Bytes::put_Java_u2((address) reconstituted_code + (bci + 1), (u2) cp_index);

          break;

        }

        default:

          break;

      }

    }

  }

  JVMCIPrimitiveArray result = JVMCIENV->new_byteArray(code_size, JVMCI_CHECK_NULL);

  JVMCIENV->copy_bytes_from(reconstituted_code, result, 0, code_size);

  return JVMCIENV->get_jbyteArray(result);

C2V_END

C2V_VMENTRY(jint, getExceptionTableLength, (JNIEnv* env, jobject, jobject jvmci_method))

  methodHandle method = JVMCIENV->asMethod(jvmci_method);

  return method->exception_table_length();

C2V_END

C2V_VMENTRY(jlong, getExceptionTableStart, (JNIEnv* env, jobject, jobject jvmci_method))

  methodHandle method = JVMCIENV->asMethod(jvmci_method);

  if (method->exception_table_length() == 0) {

    return 0L;

  }

  return (jlong) (address) method->exception_table_start();

C2V_END

C2V_VMENTRY(jobject, asResolvedJavaMethod, (JNIEnv* env, jobject, jobject executable_handle))

  if (env != JavaThread::current()->jni_environment()) {

    JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot");

  }

  oop executable = JNIHandles::resolve(executable_handle);

  oop mirror = NULL;

  int slot = 0;

  if (executable->klass() == SystemDictionary::reflect_Constructor_klass()) {

    mirror = java_lang_reflect_Constructor::clazz(executable);

    slot = java_lang_reflect_Constructor::slot(executable);

  } else {

    assert(executable->klass() == SystemDictionary::reflect_Method_klass(), "wrong type");

    mirror = java_lang_reflect_Method::clazz(executable);

    slot = java_lang_reflect_Method::slot(executable);

  }

  Klass* holder = java_lang_Class::as_Klass(mirror);

  methodHandle method = InstanceKlass::cast(holder)->method_with_idnum(slot);

  JVMCIObject result = JVMCIENV->get_jvmci_method(method, JVMCI_CHECK_NULL);

  return JVMCIENV->get_jobject(result);

}

C2V_VMENTRY(jobject, getResolvedJavaMethod, (JNIEnv* env, jobject, jobject base, jlong offset))

  methodHandle method;

  JVMCIObject base_object = JVMCIENV->wrap(base);

  if (base_object.is_null()) {

    method = *((Method**)(offset));

  } else if (JVMCIENV->isa_HotSpotObjectConstantImpl(base_object)) {

    Handle obj = JVMCIENV->asConstant(base_object, JVMCI_CHECK_NULL);

    if (obj->is_a(SystemDictionary::ResolvedMethodName_klass())) {

      method = (Method*) (intptr_t) obj->long_field(offset);

    } else {

      JVMCI_THROW_MSG_NULL(IllegalArgumentException, err_msg("Unexpected type: %s", obj->klass()->external_name()));

    }

  } else if (JVMCIENV->isa_HotSpotResolvedJavaMethodImpl(base_object)) {

    method = JVMCIENV->asMethod(base_object);

  }

  if (method.is_null()) {

    JVMCI_THROW_MSG_NULL(IllegalArgumentException, err_msg("Unexpected type: %s", JVMCIENV->klass_name(base_object)));

  }

  assert (method.is_null() || method->is_method(), "invalid read");

  JVMCIObject result = JVMCIENV->get_jvmci_method(method, JVMCI_CHECK_NULL);

  return JVMCIENV->get_jobject(result);

}

C2V_VMENTRY(jobject, getConstantPool, (JNIEnv* env, jobject, jobject object_handle))

  constantPoolHandle cp;

  JVMCIObject object = JVMCIENV->wrap(object_handle);

  if (object.is_null()) {

    JVMCI_THROW_NULL(NullPointerException);

  }

  if (JVMCIENV->isa_HotSpotResolvedJavaMethodImpl(object)) {

    cp = JVMCIENV->asMethod(object)->constMethod()->constants();

  } else if (JVMCIENV->isa_HotSpotResolvedObjectTypeImpl(object)) {

    cp = InstanceKlass::cast(JVMCIENV->asKlass(object))->constants();

  } else {

    JVMCI_THROW_MSG_NULL(IllegalArgumentException,

                err_msg("Unexpected type: %s", JVMCIENV->klass_name(object)));

  }

  assert(!cp.is_null(), "npe");

  JVMCIObject result = JVMCIENV->get_jvmci_constant_pool(cp, JVMCI_CHECK_NULL);

  return JVMCIENV->get_jobject(result);

}

C2V_VMENTRY(jobject, getResolvedJavaType0, (JNIEnv* env, jobject, jobject base, jlong offset, jboolean compressed))

  JVMCIKlassHandle klass(THREAD);

  JVMCIObject base_object = JVMCIENV->wrap(base);

  jlong base_address = 0;

  if (base_object.is_non_null() && offset == oopDesc::klass_offset_in_bytes()) {

    // klass = JVMCIENV->unhandle(base_object)->klass();

    if (JVMCIENV->isa_HotSpotObjectConstantImpl(base_object)) {

      Handle base_oop = JVMCIENV->asConstant(base_object, JVMCI_CHECK_NULL);

      klass = base_oop->klass();

    } else {

      assert(false, "What types are we actually expecting here?");

    }

  } else if (!compressed) {

    if (base_object.is_non_null()) {

      if (JVMCIENV->isa_HotSpotResolvedJavaMethodImpl(base_object)) {

        base_address = (intptr_t) JVMCIENV->asMethod(base_object);

      } else if (JVMCIENV->isa_HotSpotConstantPool(base_object)) {

        base_address = (intptr_t) JVMCIENV->asConstantPool(base_object);

      } else if (JVMCIENV->isa_HotSpotResolvedObjectTypeImpl(base_object)) {

        base_address = (intptr_t) JVMCIENV->asKlass(base_object);

      } else if (JVMCIENV->isa_HotSpotObjectConstantImpl(base_object)) {

        Handle base_oop = JVMCIENV->asConstant(base_object, JVMCI_CHECK_NULL);

        if (base_oop->is_a(SystemDictionary::Class_klass())) {

          base_address = (jlong) (address) base_oop();

        }

      }

      if (base_address == 0) {

        JVMCI_THROW_MSG_NULL(IllegalArgumentException,

                    err_msg("Unexpected arguments: %s " JLONG_FORMAT " %s", JVMCIENV->klass_name(base_object), offset, compressed ? "true" : "false"));

      }

    }

    klass = *((Klass**) (intptr_t) (base_address + offset));

  } else {

    JVMCI_THROW_MSG_NULL(IllegalArgumentException,

                err_msg("Unexpected arguments: %s " JLONG_FORMAT " %s",

                        base_object.is_non_null() ? JVMCIENV->klass_name(base_object) : "null",

                        offset, compressed ? "true" : "false"));

  }

  assert (klass == NULL || klass->is_klass(), "invalid read");

  JVMCIObject result = JVMCIENV->get_jvmci_type(klass, JVMCI_CHECK_NULL);

  return JVMCIENV->get_jobject(result);

}

C2V_VMENTRY(jobject, findUniqueConcreteMethod, (JNIEnv* env, jobject, jobject jvmci_type, jobject jvmci_method))

  methodHandle method = JVMCIENV->asMethod(jvmci_method);

  Klass* holder = JVMCIENV->asKlass(jvmci_type);

  if (holder->is_interface()) {

    JVMCI_THROW_MSG_NULL(InternalError, err_msg("Interface %s should be handled in Java code", holder->external_name()));

  }

  methodHandle ucm;

  {

    MutexLocker locker(Compile_lock);

    ucm = Dependencies::find_unique_concrete_method(holder, method());

  }

  JVMCIObject result = JVMCIENV->get_jvmci_method(ucm, JVMCI_CHECK_NULL);

  return JVMCIENV->get_jobject(result);

C2V_END

C2V_VMENTRY(jobject, getImplementor, (JNIEnv* env, jobject, jobject jvmci_type))

  Klass* klass = JVMCIENV->asKlass(jvmci_type);

  if (!klass->is_interface()) {

    THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),

        err_msg("Expected interface type, got %s", klass->external_name()));

  }

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

  JVMCIKlassHandle handle(THREAD);

  {

    // Need Compile_lock around implementor()

    MutexLocker locker(Compile_lock);

    handle = iklass->implementor();

  }

  JVMCIObject implementor = JVMCIENV->get_jvmci_type(handle, JVMCI_CHECK_NULL);

  return JVMCIENV->get_jobject(implementor);

C2V_END

C2V_VMENTRY(jboolean, methodIsIgnoredBySecurityStackWalk,(JNIEnv* env, jobject, jobject jvmci_method))

  methodHandle method = JVMCIENV->asMethod(jvmci_method);

  return method->is_ignored_by_security_stack_walk();

C2V_END

C2V_VMENTRY(jboolean, isCompilable,(JNIEnv* env, jobject, jobject jvmci_method))

  methodHandle method = JVMCIENV->asMethod(jvmci_method);

  constantPoolHandle cp = method->constMethod()->constants();

  assert(!cp.is_null(), "npe");

  // don't inline method when constant pool contains a CONSTANT_Dynamic

  return !method->is_not_compilable(CompLevel_full_optimization) && !cp->has_dynamic_constant();

C2V_END

C2V_VMENTRY(jboolean, hasNeverInlineDirective,(JNIEnv* env, jobject, jobject jvmci_method))

  methodHandle method = JVMCIENV->asMethod(jvmci_method);

  return !Inline || CompilerOracle::should_not_inline(method) || method->dont_inline();

C2V_END

C2V_VMENTRY(jboolean, shouldInlineMethod,(JNIEnv* env, jobject, jobject jvmci_method))

  methodHandle method = JVMCIENV->asMethod(jvmci_method);

  return CompilerOracle::should_inline(method) || method->force_inline();

C2V_END

C2V_VMENTRY(jobject, lookupType, (JNIEnv* env, jobject, jstring jname, jclass accessing_class, jboolean resolve))

  JVMCIObject name = JVMCIENV->wrap(jname);

  const char* str = JVMCIENV->as_utf8_string(name);

  TempNewSymbol class_name = SymbolTable::new_symbol(str, CHECK_NULL);

  if (class_name->utf8_length() <= 1) {

    JVMCI_THROW_MSG_0(InternalError, err_msg("Primitive type %s should be handled in Java code", class_name->as_C_string()));

  }

  JVMCIKlassHandle resolved_klass(THREAD);

  Klass* accessing_klass = NULL;

  Handle class_loader;

  Handle protection_domain;

  if (accessing_class != NULL) {

    accessing_klass = JVMCIENV->asKlass(accessing_class);

    class_loader = Handle(THREAD, accessing_klass->class_loader());

    protection_domain = Handle(THREAD, accessing_klass->protection_domain());

  } else {

    // Use the System class loader

    class_loader = Handle(THREAD, SystemDictionary::java_system_loader());

    JVMCIENV->runtime()->initialize(JVMCIENV);

  }

  if (resolve) {

    resolved_klass = SystemDictionary::resolve_or_null(class_name, class_loader, protection_domain, CHECK_0);

  } else {

    if (class_name->char_at(0) == 'L' &&

      class_name->char_at(class_name->utf8_length()-1) == ';') {

      // This is a name from a signature.  Strip off the trimmings.

      // Call recursive to keep scope of strippedsym.

      TempNewSymbol strippedsym = SymbolTable::new_symbol(class_name->as_utf8()+1,

                                                          class_name->utf8_length()-2,

                                                          CHECK_0);

      resolved_klass = SystemDictionary::find(strippedsym, class_loader, protection_domain, CHECK_0);

    } else if (FieldType::is_array(class_name)) {

      FieldArrayInfo fd;

      // dimension and object_key in FieldArrayInfo are assigned as a side-effect

      // of this call

      BasicType t = FieldType::get_array_info(class_name, fd, CHECK_0);

      if (t == T_OBJECT) {

        TempNewSymbol strippedsym = SymbolTable::new_symbol(class_name->as_utf8()+1+fd.dimension(),

                                                            class_name->utf8_length()-2-fd.dimension(),

                                                            CHECK_0);

        // naked oop "k" is OK here -- we assign back into it

        resolved_klass = SystemDictionary::find(strippedsym,

                                                             class_loader,

                                                             protection_domain,

                                                             CHECK_0);

        if (!resolved_klass.is_null()) {

          resolved_klass = resolved_klass->array_klass(fd.dimension(), CHECK_0);

        }

      } else {

        resolved_klass = TypeArrayKlass::cast(Universe::typeArrayKlassObj(t))->array_klass(fd.dimension(), CHECK_0);

      }

    } else {