/*

 * 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 "jvmci/vmStructs_jvmci.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;

}

extern "C" {

extern VMStructEntry* jvmciHotSpotVMStructs;

extern uint64_t jvmciHotSpotVMStructEntryTypeNameOffset;

extern uint64_t jvmciHotSpotVMStructEntryFieldNameOffset;

extern uint64_t jvmciHotSpotVMStructEntryTypeStringOffset;

extern uint64_t jvmciHotSpotVMStructEntryIsStaticOffset;

extern uint64_t jvmciHotSpotVMStructEntryOffsetOffset;

extern uint64_t jvmciHotSpotVMStructEntryAddressOffset;

extern uint64_t jvmciHotSpotVMStructEntryArrayStride;

extern VMTypeEntry* jvmciHotSpotVMTypes;

extern uint64_t jvmciHotSpotVMTypeEntryTypeNameOffset;

extern uint64_t jvmciHotSpotVMTypeEntrySuperclassNameOffset;

extern uint64_t jvmciHotSpotVMTypeEntryIsOopTypeOffset;

extern uint64_t jvmciHotSpotVMTypeEntryIsIntegerTypeOffset;

extern uint64_t jvmciHotSpotVMTypeEntryIsUnsignedOffset;

extern uint64_t jvmciHotSpotVMTypeEntrySizeOffset;

extern uint64_t jvmciHotSpotVMTypeEntryArrayStride;

extern VMIntConstantEntry* jvmciHotSpotVMIntConstants;

extern uint64_t jvmciHotSpotVMIntConstantEntryNameOffset;

extern uint64_t jvmciHotSpotVMIntConstantEntryValueOffset;

extern uint64_t jvmciHotSpotVMIntConstantEntryArrayStride;

extern VMLongConstantEntry* jvmciHotSpotVMLongConstants;

extern uint64_t jvmciHotSpotVMLongConstantEntryNameOffset;

extern uint64_t jvmciHotSpotVMLongConstantEntryValueOffset;

extern uint64_t jvmciHotSpotVMLongConstantEntryArrayStride;

extern VMAddressEntry* jvmciHotSpotVMAddresses;

extern uint64_t jvmciHotSpotVMAddressEntryNameOffset;

extern uint64_t jvmciHotSpotVMAddressEntryValueOffset;

extern uint64_t jvmciHotSpotVMAddressEntryArrayStride;

}

int CompilerToVM::Data::InstanceKlass_vtable_start_offset;

int CompilerToVM::Data::InstanceKlass_vtable_length_offset;

int CompilerToVM::Data::Method_extra_stack_entries;

address CompilerToVM::Data::SharedRuntime_ic_miss_stub;

address CompilerToVM::Data::SharedRuntime_handle_wrong_method_stub;

address CompilerToVM::Data::SharedRuntime_deopt_blob_unpack;

address CompilerToVM::Data::SharedRuntime_deopt_blob_uncommon_trap;

size_t CompilerToVM::Data::ThreadLocalAllocBuffer_alignment_reserve;

CollectedHeap* CompilerToVM::Data::Universe_collectedHeap;

int CompilerToVM::Data::Universe_base_vtable_size;

address CompilerToVM::Data::Universe_narrow_oop_base;

int CompilerToVM::Data::Universe_narrow_oop_shift;

address CompilerToVM::Data::Universe_narrow_klass_base;

int CompilerToVM::Data::Universe_narrow_klass_shift;

void* CompilerToVM::Data::Universe_non_oop_bits;

uintptr_t CompilerToVM::Data::Universe_verify_oop_mask;

uintptr_t CompilerToVM::Data::Universe_verify_oop_bits;

bool       CompilerToVM::Data::_supports_inline_contig_alloc;

HeapWord** CompilerToVM::Data::_heap_end_addr;

HeapWord** CompilerToVM::Data::_heap_top_addr;

jbyte* CompilerToVM::Data::cardtable_start_address;

int CompilerToVM::Data::cardtable_shift;

void CompilerToVM::Data::initialize() {

  InstanceKlass_vtable_start_offset = InstanceKlass::vtable_start_offset();

  InstanceKlass_vtable_length_offset = InstanceKlass::vtable_length_offset() * HeapWordSize;

  Method_extra_stack_entries = Method::extra_stack_entries();

  SharedRuntime_ic_miss_stub = SharedRuntime::get_ic_miss_stub();

  SharedRuntime_handle_wrong_method_stub = SharedRuntime::get_handle_wrong_method_stub();

  SharedRuntime_deopt_blob_unpack = SharedRuntime::deopt_blob()->unpack();

  SharedRuntime_deopt_blob_uncommon_trap = SharedRuntime::deopt_blob()->uncommon_trap();

  ThreadLocalAllocBuffer_alignment_reserve = ThreadLocalAllocBuffer::alignment_reserve();

  Universe_collectedHeap = Universe::heap();

  Universe_base_vtable_size = Universe::base_vtable_size();

  Universe_narrow_oop_base = Universe::narrow_oop_base();

  Universe_narrow_oop_shift = Universe::narrow_oop_shift();

  Universe_narrow_klass_base = Universe::narrow_klass_base();

  Universe_narrow_klass_shift = Universe::narrow_klass_shift();

  Universe_non_oop_bits = Universe::non_oop_word();

  Universe_verify_oop_mask = Universe::verify_oop_mask();

  Universe_verify_oop_bits = Universe::verify_oop_bits();

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

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

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

  BarrierSet* bs = Universe::heap()->barrier_set();

  switch (bs->kind()) {

  case BarrierSet::CardTableModRef:

  case BarrierSet::CardTableForRS:

  case BarrierSet::CardTableExtension:

  case BarrierSet::G1SATBCT:

  case BarrierSet::G1SATBCTLogging: {

    jbyte* base = barrier_set_cast<CardTableModRefBS>(bs)->byte_map_base;

    assert(base != 0, "unexpected byte_map_base");

    cardtable_start_address = base;

    cardtable_shift = CardTableModRefBS::card_shift;

    break;

  }

  case BarrierSet::ModRef:

    cardtable_start_address = 0;

    cardtable_shift = 0;

    // No post barriers

    break;

  default:

    ShouldNotReachHere();

    break;

  }

}

/**

 * We put all jvmciHotSpotVM 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) jvmciHotSpotVMStructs;

  ciHotSpotVMData[1] = jvmciHotSpotVMStructEntryTypeNameOffset;

  ciHotSpotVMData[2] = jvmciHotSpotVMStructEntryFieldNameOffset;

  ciHotSpotVMData[3] = jvmciHotSpotVMStructEntryTypeStringOffset;

  ciHotSpotVMData[4] = jvmciHotSpotVMStructEntryIsStaticOffset;

  ciHotSpotVMData[5] = jvmciHotSpotVMStructEntryOffsetOffset;

  ciHotSpotVMData[6] = jvmciHotSpotVMStructEntryAddressOffset;

  ciHotSpotVMData[7] = jvmciHotSpotVMStructEntryArrayStride;

  ciHotSpotVMData[8] = (uintptr_t) jvmciHotSpotVMTypes;

  ciHotSpotVMData[9] = jvmciHotSpotVMTypeEntryTypeNameOffset;

  ciHotSpotVMData[10] = jvmciHotSpotVMTypeEntrySuperclassNameOffset;

  ciHotSpotVMData[11] = jvmciHotSpotVMTypeEntryIsOopTypeOffset;

  ciHotSpotVMData[12] = jvmciHotSpotVMTypeEntryIsIntegerTypeOffset;

  ciHotSpotVMData[13] = jvmciHotSpotVMTypeEntryIsUnsignedOffset;

  ciHotSpotVMData[14] = jvmciHotSpotVMTypeEntrySizeOffset;

  ciHotSpotVMData[15] = jvmciHotSpotVMTypeEntryArrayStride;

  ciHotSpotVMData[16] = (uintptr_t) jvmciHotSpotVMIntConstants;

  ciHotSpotVMData[17] = jvmciHotSpotVMIntConstantEntryNameOffset;

  ciHotSpotVMData[18] = jvmciHotSpotVMIntConstantEntryValueOffset;

  ciHotSpotVMData[19] = jvmciHotSpotVMIntConstantEntryArrayStride;

  ciHotSpotVMData[20] = (uintptr_t) jvmciHotSpotVMLongConstants;

  ciHotSpotVMData[21] = jvmciHotSpotVMLongConstantEntryNameOffset;

  ciHotSpotVMData[22] = jvmciHotSpotVMLongConstantEntryValueOffset;

  ciHotSpotVMData[23] = jvmciHotSpotVMLongConstantEntryArrayStride;

  ciHotSpotVMData[24] = (uintptr_t) jvmciHotSpotVMAddresses;

  ciHotSpotVMData[25] = jvmciHotSpotVMAddressEntryNameOffset;

  ciHotSpotVMData[26] = jvmciHotSpotVMAddressEntryValueOffset;

  ciHotSpotVMData[27] = jvmciHotSpotVMAddressEntryArrayStride;

  CompilerToVM::Data::initialize();

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