/*

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

#include "memory/oopFactory.hpp"

#include "oops/cpCache.inline.hpp"

#include "oops/generateOopMap.hpp"

#include "oops/method.inline.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/typeArrayOop.inline.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/disassembler.hpp"

#include "jvmci/jvmciCompilerToVM.hpp"

#include "jvmci/jvmciCodeInstaller.hpp"

#include "runtime/timerTrace.hpp"

#include "runtime/vframe_hp.hpp"

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

  }

}

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

  TRACE_jvmci_1("CompilerToVM::" #name); \

  TRACE_CALL(result_type, jvmci_ ## name signature) \

  JVMCI_VM_ENTRY_MARK; \

#define C2V_END }

oop CompilerToVM::get_jvmci_method(const methodHandle& method, TRAPS) {

  if (method() != NULL) {

    JavaValue result(T_OBJECT);

    JavaCallArguments args;

    args.push_long((jlong) (address) method());

    JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedJavaMethodImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::method_fromMetaspace_signature(), &args, CHECK_NULL);

    return (oop)result.get_jobject();

  }

  return NULL;

}

oop CompilerToVM::get_jvmci_type(Klass* klass, TRAPS) {

  if (klass != NULL) {

    JavaValue result(T_OBJECT);

    JavaCallArguments args;

    args.push_oop(Handle(THREAD, klass->java_mirror()));

    JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedObjectTypeImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::klass_fromMetaspace_signature(), &args, CHECK_NULL);

    return (oop)result.get_jobject();

  }

  return NULL;

}

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

C2V_END

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

#define RETURN_BOXED_LONG(value) oop box; jvalue p; p.j = (jlong) (value); box = java_lang_boxing_object::create(T_LONG, &p, CHECK_NULL); return JNIHandles::make_local(THREAD, box);

#define RETURN_BOXED_DOUBLE(value) oop box; jvalue p; p.d = (jdouble) (value); box = java_lang_boxing_object::create(T_DOUBLE, &p, CHECK_NULL); return JNIHandles::make_local(THREAD, box);

  Handle name(THREAD, JNIHandles::resolve(name_handle));

  if (name.is_null()) {

    THROW_0(vmSymbols::java_lang_NullPointerException());

  }

  ResourceMark rm;

  const char* cstring = java_lang_String::as_utf8_string(name());

  Flag* flag = Flag::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();

    oop box = java_lang_boxing_object::create(T_BOOLEAN, &prim, CHECK_NULL);

    return JNIHandles::make_local(THREAD, box);

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

    Handle value = java_lang_String::create_from_str(flag->get_ccstr(), CHECK_NULL);

    return JNIHandles::make_local(THREAD, 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);

  }

C2V_END

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

  methodHandle method = CompilerToVM::asMethod(jvmci_method);

  ResourceMark rm;

  int code_size = method->code_size();

  typeArrayOop reconstituted_code = oopFactory::new_byteArray(code_size, CHECK_NULL);

  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->byte_at_put(bci, (jbyte) (s.is_wide()? Bytecodes::_wide : code));

    if (len > 1) {

      memcpy(reconstituted_code->byte_at_addr(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->byte_at_addr(bci + 1));

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

          break;

        }

        case Bytecodes::_invokedynamic: {

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

          Bytes::put_Java_u4((address) reconstituted_code->byte_at_addr(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->byte_at(bci + 1) & 0xff;

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

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

          reconstituted_code->byte_at_put(bci + 1, (jbyte) cp_index);

          break;

        }

        case Bytecodes::_fast_aldc_w: {

          int cpc_index = Bytes::get_native_u2((address) reconstituted_code->byte_at_addr(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->byte_at_addr(bci + 1), (u2) cp_index);

          break;

        }

        default:

          break;

      }

    }

  }

  return (jbyteArray) JNIHandles::make_local(THREAD, reconstituted_code);

C2V_END

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

  ResourceMark rm;

  methodHandle method = CompilerToVM::asMethod(jvmci_method);

  return method->exception_table_length();

C2V_END

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

  ResourceMark rm;

  methodHandle method = CompilerToVM::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 *, jobject, jobject executable_handle))

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

  oop result = CompilerToVM::get_jvmci_method(method, CHECK_NULL);

  return JNIHandles::make_local(THREAD, result);

}

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

  methodHandle method;

  oop base_object = JNIHandles::resolve(base);

  if (base_object == NULL) {

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

  } else if (base_object->is_a(SystemDictionary::ResolvedMethodName_klass())) {

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

  } else if (base_object->is_a(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass())) {

    method = *((Method**)(HotSpotResolvedJavaMethodImpl::metaspaceMethod(base_object) + offset));

  } else {

    THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),

                err_msg("Unexpected type: %s", base_object->klass()->external_name()));

  }

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

  oop result = CompilerToVM::get_jvmci_method(method, CHECK_NULL);

  return JNIHandles::make_local(THREAD, result);

}

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

  constantPoolHandle cp;

  oop object = JNIHandles::resolve(object_handle);

  if (object == NULL) {

    THROW_0(vmSymbols::java_lang_NullPointerException());

  }

  if (object->is_a(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass())) {

    cp = CompilerToVM::asMethod(object)->constMethod()->constants();

  } else if (object->is_a(SystemDictionary::HotSpotResolvedObjectTypeImpl_klass())) {

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

  } else {

    THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),

                err_msg("Unexpected type: %s", object->klass()->external_name()));

  }

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

  JavaValue method_result(T_OBJECT);

  JavaCallArguments args;

  args.push_long((jlong) (address) cp());

  JavaCalls::call_static(&method_result, SystemDictionary::HotSpotConstantPool_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::constantPool_fromMetaspace_signature(), &args, CHECK_NULL);

  return JNIHandles::make_local(THREAD, (oop)method_result.get_jobject());

}

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

  Klass* klass = NULL;

  oop base_object = JNIHandles::resolve(base);

  jlong base_address = 0;

  if (base_object != NULL && offset == oopDesc::klass_offset_in_bytes()) {

    klass = base_object->klass();

  } else if (!compressed) {

    if (base_object != NULL) {

      if (base_object->is_a(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass())) {

        base_address = HotSpotResolvedJavaMethodImpl::metaspaceMethod(base_object);

      } else if (base_object->is_a(SystemDictionary::HotSpotConstantPool_klass())) {

        base_address = HotSpotConstantPool::metaspaceConstantPool(base_object);

      } else if (base_object->is_a(SystemDictionary::HotSpotResolvedObjectTypeImpl_klass())) {

        base_address = (jlong) CompilerToVM::asKlass(base_object);

      } else if (base_object->is_a(SystemDictionary::Class_klass())) {

        base_address = (jlong) (address) base_object;

      } else {

        THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),

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

      }

    }

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

  } else {

    THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),

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

  }

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

  oop result = CompilerToVM::get_jvmci_type(klass, CHECK_NULL);

  return JNIHandles::make_local(THREAD, result);

}

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

  ResourceMark rm;

  methodHandle method = CompilerToVM::asMethod(jvmci_method);

  Klass* holder = CompilerToVM::asKlass(jvmci_type);

  if (holder->is_interface()) {

    THROW_MSG_0(vmSymbols::java_lang_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());

  }

  oop result = CompilerToVM::get_jvmci_method(ucm, CHECK_NULL);

  return JNIHandles::make_local(THREAD, result);

C2V_END

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

  Klass* klass = CompilerToVM::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);

  oop implementor = CompilerToVM::get_jvmci_type(iklass->implementor(), CHECK_NULL);

  return JNIHandles::make_local(THREAD, implementor);

C2V_END

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

  methodHandle method = CompilerToVM::asMethod(jvmci_method);

  return method->is_ignored_by_security_stack_walk();

C2V_END

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

  methodHandle method = CompilerToVM::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 *, jobject, jobject jvmci_method))

  methodHandle method = CompilerToVM::asMethod(jvmci_method);

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

C2V_END

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

  methodHandle method = CompilerToVM::asMethod(jvmci_method);

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

C2V_END

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

  ResourceMark rm;

  Handle name(THREAD, JNIHandles::resolve(jname));

  Symbol* class_name = java_lang_String::as_symbol(name(), CHECK_0);

  if (java_lang_String::length(name()) <= 1) {

    THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Primitive type %s should be handled in Java code", class_name->as_C_string()));

  }

  Klass* resolved_klass = NULL;

  if (JNIHandles::resolve(accessing_class) == NULL) {

    THROW_0(vmSymbols::java_lang_NullPointerException());

  }

  Klass* accessing_klass = java_lang_Class::as_Klass(JNIHandles::resolve(accessing_class));

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

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

  if (resolve) {

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

  } else {

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

      class_name->byte_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 != NULL) {

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

        }

      } else {

        resolved_klass = Universe::typeArrayKlassObj(t);

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

      }

    }

  }

  oop result = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL);

  return JNIHandles::make_local(THREAD, result);

C2V_END

C2V_VMENTRY(jobject, resolveConstantInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))

  constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);

  oop result = cp->resolve_constant_at(index, CHECK_NULL);

  return JNIHandles::make_local(THREAD, result);

C2V_END

C2V_VMENTRY(jobject, resolvePossiblyCachedConstantInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))

  constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);

  oop result = cp->resolve_possibly_cached_constant_at(index, CHECK_NULL);

  return JNIHandles::make_local(THREAD, result);

C2V_END

C2V_VMENTRY(jint, lookupNameAndTypeRefIndexInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))

  constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);

  return cp->name_and_type_ref_index_at(index);

C2V_END

C2V_VMENTRY(jobject, lookupNameInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint which))

  constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);

  Handle sym = java_lang_String::create_from_symbol(cp->name_ref_at(which), CHECK_NULL);

  return JNIHandles::make_local(THREAD, sym());

C2V_END

C2V_VMENTRY(jobject, lookupSignatureInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint which))

  constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);

  Handle sym = java_lang_String::create_from_symbol(cp->signature_ref_at(which), CHECK_NULL);

  return JNIHandles::make_local(THREAD, sym());

C2V_END

C2V_VMENTRY(jint, lookupKlassRefIndexInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))

  constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);

  return cp->klass_ref_index_at(index);

C2V_END

C2V_VMENTRY(jobject, resolveTypeInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))

  constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);

  Klass* resolved_klass = cp->klass_at(index, CHECK_NULL);

  oop klass = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL);

  return JNIHandles::make_local(THREAD, klass);

C2V_END

C2V_VMENTRY(jobject, lookupKlassInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))

  constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);

  Klass* loading_klass = cp->pool_holder();

  bool is_accessible = false;

  Klass* klass = JVMCIEnv::get_klass_by_index(cp, index, is_accessible, loading_klass);

  Symbol* symbol = NULL;

  if (klass == NULL) {

    symbol = cp->klass_name_at(index);

  }

  oop result_oop;

  if (klass != NULL) {

    result_oop = CompilerToVM::get_jvmci_type(klass, CHECK_NULL);

  } else {

    Handle result = java_lang_String::create_from_symbol(symbol, CHECK_NULL);

    result_oop = result();

  }

  return JNIHandles::make_local(THREAD, result_oop);

C2V_END

C2V_VMENTRY(jobject, lookupAppendixInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))

  constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);

  oop appendix_oop = ConstantPool::appendix_at_if_loaded(cp, index);

  return JNIHandles::make_local(THREAD, appendix_oop);

C2V_END

C2V_VMENTRY(jobject, lookupMethodInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))

  constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);

  InstanceKlass* pool_holder = cp->pool_holder();

  Bytecodes::Code bc = (Bytecodes::Code) (((int) opcode) & 0xFF);

  methodHandle method = JVMCIEnv::get_method_by_index(cp, index, bc, pool_holder);

  oop result = CompilerToVM::get_jvmci_method(method, CHECK_NULL);

  return JNIHandles::make_local(THREAD, result);

C2V_END

C2V_VMENTRY(jint, constantPoolRemapInstructionOperandFromCache, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))