/*

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

#include "code/scopeDesc.hpp"

#include "interpreter/linkResolver.hpp"

#include "memory/oopFactory.hpp"

#include "oops/generateOopMap.hpp"

#include "oops/fieldStreams.hpp"

#include "oops/oop.inline.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "runtime/fieldDescriptor.hpp"

#include "runtime/javaCalls.hpp"

#include "jvmci/jvmciRuntime.hpp"

#include "compiler/abstractCompiler.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/compilerOracle.hpp"

#include "compiler/disassembler.hpp"

#include "compiler/oopMap.hpp"

#include "jvmci/jvmciCompilerToVM.hpp"

#include "jvmci/jvmciCompiler.hpp"

#include "jvmci/jvmciEnv.hpp"

#include "jvmci/jvmciJavaClasses.hpp"

#include "jvmci/jvmciCodeInstaller.hpp"

#include "gc/g1/heapRegion.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/vframe.hpp"

#include "runtime/vframe_hp.hpp"

#include "runtime/vmStructs.hpp"

// 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(KlassHandle klass, TRAPS) {

  if (klass() != NULL) {

    JavaValue result(T_OBJECT);

    JavaCallArguments args;

    args.push_oop(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;

}

void CompilerToVM::invalidate_installed_code(Handle installedCode, TRAPS) {

  if (installedCode() == NULL) {

    THROW(vmSymbols::java_lang_NullPointerException());

  }

  jlong nativeMethod = InstalledCode::address(installedCode);

  nmethod* nm = (nmethod*)nativeMethod;

  assert(nm == NULL || nm->jvmci_installed_code() == installedCode(), "sanity check");

  if (nm != NULL && nm->is_alive()) {

    // The nmethod state machinery maintains the link between the

    // HotSpotInstalledCode and nmethod* so as long as the nmethod appears to be

    // alive assume there is work to do and deoptimize the nmethod.

    nm->mark_for_deoptimization();

    VM_Deoptimize op;

    VMThread::execute(&op);

  }

  InstalledCode::set_address(installedCode, 0);

}

extern "C" {

extern VMStructEntry* gHotSpotVMStructs;

extern uint64_t gHotSpotVMStructEntryTypeNameOffset;

extern uint64_t gHotSpotVMStructEntryFieldNameOffset;

extern uint64_t gHotSpotVMStructEntryTypeStringOffset;

extern uint64_t gHotSpotVMStructEntryIsStaticOffset;

extern uint64_t gHotSpotVMStructEntryOffsetOffset;

extern uint64_t gHotSpotVMStructEntryAddressOffset;

extern uint64_t gHotSpotVMStructEntryArrayStride;

extern VMTypeEntry* gHotSpotVMTypes;

extern uint64_t gHotSpotVMTypeEntryTypeNameOffset;

extern uint64_t gHotSpotVMTypeEntrySuperclassNameOffset;

extern uint64_t gHotSpotVMTypeEntryIsOopTypeOffset;

extern uint64_t gHotSpotVMTypeEntryIsIntegerTypeOffset;

extern uint64_t gHotSpotVMTypeEntryIsUnsignedOffset;

extern uint64_t gHotSpotVMTypeEntrySizeOffset;

extern uint64_t gHotSpotVMTypeEntryArrayStride;

extern VMIntConstantEntry* gHotSpotVMIntConstants;

extern uint64_t gHotSpotVMIntConstantEntryNameOffset;

extern uint64_t gHotSpotVMIntConstantEntryValueOffset;

extern uint64_t gHotSpotVMIntConstantEntryArrayStride;

extern VMLongConstantEntry* gHotSpotVMLongConstants;

extern uint64_t gHotSpotVMLongConstantEntryNameOffset;

extern uint64_t gHotSpotVMLongConstantEntryValueOffset;

extern uint64_t gHotSpotVMLongConstantEntryArrayStride;

extern VMAddressEntry* gHotSpotVMAddresses;

extern uint64_t gHotSpotVMAddressEntryNameOffset;

extern uint64_t gHotSpotVMAddressEntryValueOffset;

extern uint64_t gHotSpotVMAddressEntryArrayStride;

}

// FIXME This is only temporary until the GC code is changed.

bool       CompilerToVM::_supports_inline_contig_alloc;

HeapWord** CompilerToVM::_heap_end_addr;

HeapWord** CompilerToVM::_heap_top_addr;

/**

 * We put all gHotSpotVM values in an array so we can read them easily from Java.

 */

static uintptr_t ciHotSpotVMData[28];

C2V_VMENTRY(jlong, initializeConfiguration, (JNIEnv *env, jobject))

  ciHotSpotVMData[0] = (uintptr_t) gHotSpotVMStructs;

  ciHotSpotVMData[1] = gHotSpotVMStructEntryTypeNameOffset;

  ciHotSpotVMData[2] = gHotSpotVMStructEntryFieldNameOffset;

  ciHotSpotVMData[3] = gHotSpotVMStructEntryTypeStringOffset;

  ciHotSpotVMData[4] = gHotSpotVMStructEntryIsStaticOffset;

  ciHotSpotVMData[5] = gHotSpotVMStructEntryOffsetOffset;

  ciHotSpotVMData[6] = gHotSpotVMStructEntryAddressOffset;

  ciHotSpotVMData[7] = gHotSpotVMStructEntryArrayStride;

  ciHotSpotVMData[8] = (uintptr_t) gHotSpotVMTypes;

  ciHotSpotVMData[9] = gHotSpotVMTypeEntryTypeNameOffset;

  ciHotSpotVMData[10] = gHotSpotVMTypeEntrySuperclassNameOffset;

  ciHotSpotVMData[11] = gHotSpotVMTypeEntryIsOopTypeOffset;

  ciHotSpotVMData[12] = gHotSpotVMTypeEntryIsIntegerTypeOffset;

  ciHotSpotVMData[13] = gHotSpotVMTypeEntryIsUnsignedOffset;

  ciHotSpotVMData[14] = gHotSpotVMTypeEntrySizeOffset;

  ciHotSpotVMData[15] = gHotSpotVMTypeEntryArrayStride;

  ciHotSpotVMData[16] = (uintptr_t) gHotSpotVMIntConstants;

  ciHotSpotVMData[17] = gHotSpotVMIntConstantEntryNameOffset;

  ciHotSpotVMData[18] = gHotSpotVMIntConstantEntryValueOffset;

  ciHotSpotVMData[19] = gHotSpotVMIntConstantEntryArrayStride;

  ciHotSpotVMData[20] = (uintptr_t) gHotSpotVMLongConstants;

  ciHotSpotVMData[21] = gHotSpotVMLongConstantEntryNameOffset;

  ciHotSpotVMData[22] = gHotSpotVMLongConstantEntryValueOffset;

  ciHotSpotVMData[23] = gHotSpotVMLongConstantEntryArrayStride;

  ciHotSpotVMData[24] = (uintptr_t) gHotSpotVMAddresses;

  ciHotSpotVMData[25] = gHotSpotVMAddressEntryNameOffset;

  ciHotSpotVMData[26] = gHotSpotVMAddressEntryValueOffset;

  ciHotSpotVMData[27] = gHotSpotVMAddressEntryArrayStride;

  // FIXME This is only temporary until the GC code is changed.

  CompilerToVM::_supports_inline_contig_alloc = Universe::heap()->supports_inline_contig_alloc();

  CompilerToVM::_heap_end_addr = CompilerToVM::_supports_inline_contig_alloc ? Universe::heap()->end_addr() : (HeapWord**) -1;

  CompilerToVM::_heap_top_addr = CompilerToVM::_supports_inline_contig_alloc ? Universe::heap()->top_addr() : (HeapWord**) -1;

  return (jlong) (address) &ciHotSpotVMData;

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;

      }

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

        }

      }

    }

  }

  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, getResolvedJavaMethodAtSlot, (JNIEnv *, jobject, jclass holder_handle, jint slot))

  oop java_class = JNIHandles::resolve(holder_handle);

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

  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::MemberName_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 base, jlong offset))

  constantPoolHandle cp;

  oop base_object = JNIHandles::resolve(base);

  jlong base_address = 0;

  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 {

      THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),

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

    }

  }

  cp = *((ConstantPool**) (intptr_t) (base_address + offset));

  if (!cp.is_null()) {

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

  }

  return NULL;

}

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

  KlassHandle klass;

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

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

  InstanceKlass* klass = (InstanceKlass*) CompilerToVM::asKlass(jvmci_type);

  oop implementor = CompilerToVM::get_jvmci_type(klass->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, canInlineMethod,(JNIEnv *, jobject, jobject jvmci_method))

  methodHandle method = CompilerToVM::asMethod(jvmci_method);

  return !method->is_not_compilable() && !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 = 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;

  Handle class_loader;

  Handle protection_domain;

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

    THROW_0(vmSymbols::java_lang_NullPointerException());

  }

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

  class_loader = accessing_klass->class_loader();

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

      }

    }

  }

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

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

  KlassHandle loading_klass(cp->pool_holder());

  bool is_accessible = false;

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

  Symbol* symbol = NULL;

  if (klass.is_null()) {

    symbol = cp->klass_name_at(index);

  }

  Handle result;

  if (!klass.is_null()) {

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

  } else {

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

  }

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

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

  instanceKlassHandle 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