/*

 * 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 "code/compiledIC.hpp"

#include "compiler/compileBroker.hpp"

#include "jvmci/jvmciCodeInstaller.hpp"

#include "jvmci/jvmciCompilerToVM.hpp"

#include "jvmci/jvmciRuntime.hpp"

#include "memory/universe.hpp"

#include "oops/compressedOops.inline.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/jniHandles.inline.hpp"

#include "runtime/sharedRuntime.hpp"

#include "utilities/align.hpp"

// frequently used constants

// Allocate them with new so they are never destroyed (otherwise, a

// forced exit could destroy these objects while they are still in

// use).

ConstantOopWriteValue* CodeInstaller::_oop_null_scope_value = new (ResourceObj::C_HEAP, mtJVMCI) ConstantOopWriteValue(NULL);

ConstantIntValue*      CodeInstaller::_int_m1_scope_value = new (ResourceObj::C_HEAP, mtJVMCI) ConstantIntValue(-1);

ConstantIntValue*      CodeInstaller::_int_0_scope_value =  new (ResourceObj::C_HEAP, mtJVMCI) ConstantIntValue((jint)0);

ConstantIntValue*      CodeInstaller::_int_1_scope_value =  new (ResourceObj::C_HEAP, mtJVMCI) ConstantIntValue(1);

ConstantIntValue*      CodeInstaller::_int_2_scope_value =  new (ResourceObj::C_HEAP, mtJVMCI) ConstantIntValue(2);

LocationValue*         CodeInstaller::_illegal_value = new (ResourceObj::C_HEAP, mtJVMCI) LocationValue(Location());

VMReg CodeInstaller::getVMRegFromLocation(JVMCIObject location, int total_frame_size, JVMCI_TRAPS) {

  if (location.is_null()) {

    JVMCI_THROW_NULL(NullPointerException);

  }

  JVMCIObject reg = jvmci_env()->get_code_Location_reg(location);

  jint offset = jvmci_env()->get_code_Location_offset(location);

  if (reg.is_non_null()) {

    // register

    jint number = jvmci_env()->get_code_Register_number(reg);

    VMReg vmReg = CodeInstaller::get_hotspot_reg(number, JVMCI_CHECK_NULL);

    if (offset % 4 == 0) {

      return vmReg->next(offset / 4);

    } else {

      JVMCI_ERROR_NULL("unaligned subregister offset %d in oop map", offset);

    }

  } else {

    // stack slot

    if (offset % 4 == 0) {

      VMReg vmReg = VMRegImpl::stack2reg(offset / 4);

      if (!OopMapValue::legal_vm_reg_name(vmReg)) {

        // This restriction only applies to VMRegs that are used in OopMap but

        // since that's the only use of VMRegs it's simplest to put this test

        // here.  This test should also be equivalent legal_vm_reg_name but JVMCI

        // clients can use max_oop_map_stack_stack_offset to detect this problem

        // directly.  The asserts just ensure that the tests are in agreement.

        assert(offset > CompilerToVM::Data::max_oop_map_stack_offset(), "illegal VMReg");

        JVMCI_ERROR_NULL("stack offset %d is too large to be encoded in OopMap (max %d)",

                         offset, CompilerToVM::Data::max_oop_map_stack_offset());

      }

      assert(OopMapValue::legal_vm_reg_name(vmReg), "illegal VMReg");

      return vmReg;

    } else {

      JVMCI_ERROR_NULL("unaligned stack offset %d in oop map", offset);

    }

  }

}

// creates a HotSpot oop map out of the byte arrays provided by DebugInfo

OopMap* CodeInstaller::create_oop_map(JVMCIObject debug_info, JVMCI_TRAPS) {

  JVMCIObject reference_map = jvmci_env()->get_DebugInfo_referenceMap(debug_info);

  if (reference_map.is_null()) {

    JVMCI_THROW_NULL(NullPointerException);

  }

  if (!jvmci_env()->isa_HotSpotReferenceMap(reference_map)) {

    JVMCI_ERROR_NULL("unknown reference map: %s", jvmci_env()->klass_name(reference_map));

  }

  if (!_has_wide_vector && SharedRuntime::is_wide_vector(jvmci_env()->get_HotSpotReferenceMap_maxRegisterSize(reference_map))) {

    if (SharedRuntime::polling_page_vectors_safepoint_handler_blob() == NULL) {

      JVMCI_ERROR_NULL("JVMCI is producing code using vectors larger than the runtime supports");

    }

    _has_wide_vector = true;

  }

  OopMap* map = new OopMap(_total_frame_size, _parameter_count);

  JVMCIObjectArray objects = jvmci_env()->get_HotSpotReferenceMap_objects(reference_map);

  JVMCIObjectArray derivedBase = jvmci_env()->get_HotSpotReferenceMap_derivedBase(reference_map);

  JVMCIPrimitiveArray sizeInBytes = jvmci_env()->get_HotSpotReferenceMap_sizeInBytes(reference_map);

  if (objects.is_null() || derivedBase.is_null() || sizeInBytes.is_null()) {

    JVMCI_THROW_NULL(NullPointerException);

  }

  if (JVMCIENV->get_length(objects) != JVMCIENV->get_length(derivedBase) || JVMCIENV->get_length(objects) != JVMCIENV->get_length(sizeInBytes)) {

    JVMCI_ERROR_NULL("arrays in reference map have different sizes: %d %d %d", JVMCIENV->get_length(objects), JVMCIENV->get_length(derivedBase), JVMCIENV->get_length(sizeInBytes));

  }

  for (int i = 0; i < JVMCIENV->get_length(objects); i++) {

    JVMCIObject location = JVMCIENV->get_object_at(objects, i);

    JVMCIObject baseLocation = JVMCIENV->get_object_at(derivedBase, i);

    jint bytes = JVMCIENV->get_int_at(sizeInBytes, i);

    VMReg vmReg = getVMRegFromLocation(location, _total_frame_size, JVMCI_CHECK_NULL);

    if (baseLocation.is_non_null()) {

      // derived oop

#ifdef _LP64

      if (bytes == 8) {

#else

      if (bytes == 4) {

#endif

        VMReg baseReg = getVMRegFromLocation(baseLocation, _total_frame_size, JVMCI_CHECK_NULL);

        map->set_derived_oop(vmReg, baseReg);

      } else {

        JVMCI_ERROR_NULL("invalid derived oop size in ReferenceMap: %d", bytes);

      }

#ifdef _LP64

    } else if (bytes == 8) {

      // wide oop

      map->set_oop(vmReg);

    } else if (bytes == 4) {

      // narrow oop

      map->set_narrowoop(vmReg);

#else

    } else if (bytes == 4) {

      map->set_oop(vmReg);

#endif

    } else {

      JVMCI_ERROR_NULL("invalid oop size in ReferenceMap: %d", bytes);

    }

  }

  JVMCIObject callee_save_info = jvmci_env()->get_DebugInfo_calleeSaveInfo(debug_info);

  if (callee_save_info.is_non_null()) {

    JVMCIObjectArray registers = jvmci_env()->get_RegisterSaveLayout_registers(callee_save_info);

    JVMCIPrimitiveArray slots = jvmci_env()->get_RegisterSaveLayout_slots(callee_save_info);

    for (jint i = 0; i < JVMCIENV->get_length(slots); i++) {

      JVMCIObject jvmci_reg = JVMCIENV->get_object_at(registers, i);

      jint jvmci_reg_number = jvmci_env()->get_code_Register_number(jvmci_reg);

      VMReg hotspot_reg = CodeInstaller::get_hotspot_reg(jvmci_reg_number, JVMCI_CHECK_NULL);

      // HotSpot stack slots are 4 bytes

      jint jvmci_slot = JVMCIENV->get_int_at(slots, i);

      jint hotspot_slot = jvmci_slot * VMRegImpl::slots_per_word;

      VMReg hotspot_slot_as_reg = VMRegImpl::stack2reg(hotspot_slot);

      map->set_callee_saved(hotspot_slot_as_reg, hotspot_reg);

#ifdef _LP64

      // (copied from generate_oop_map() in c1_Runtime1_x86.cpp)

      VMReg hotspot_slot_hi_as_reg = VMRegImpl::stack2reg(hotspot_slot + 1);

      map->set_callee_saved(hotspot_slot_hi_as_reg, hotspot_reg->next());

#endif

    }

  }

  return map;

}

#if INCLUDE_AOT

AOTOopRecorder::AOTOopRecorder(CodeInstaller* code_inst, Arena* arena, bool deduplicate) : OopRecorder(arena, deduplicate) {

  _code_inst = code_inst;

  _meta_refs = new GrowableArray<jobject>();

}

int AOTOopRecorder::nr_meta_refs() const {

  return _meta_refs->length();

}

jobject AOTOopRecorder::meta_element(int pos) const {

  return _meta_refs->at(pos);

}

int AOTOopRecorder::find_index(Metadata* h) {

  JavaThread* THREAD = JavaThread::current();

  JVMCIEnv* JVMCIENV = _code_inst->jvmci_env();

  int oldCount = metadata_count();

  int index =  this->OopRecorder::find_index(h);

  int newCount = metadata_count();

  if (oldCount == newCount) {

    // found a match

    return index;

  }

  vmassert(index + 1 == newCount, "must be last");

  JVMCIKlassHandle klass(THREAD);

  JVMCIObject result;

  guarantee(h != NULL,

            "If DebugInformationRecorder::describe_scope passes NULL oldCount == newCount must hold.");

  if (h->is_klass()) {

    klass = (Klass*) h;

    result = JVMCIENV->get_jvmci_type(klass, JVMCI_CATCH);

  } else if (h->is_method()) {

    Method* method = (Method*) h;

  }

  jobject ref = JVMCIENV->get_jobject(result);

  record_meta_ref(ref, index);

  return index;

}

int AOTOopRecorder::find_index(jobject h) {

  if (h == NULL) {

    return 0;

  }

  oop javaMirror = JNIHandles::resolve(h);

  Klass* klass = java_lang_Class::as_Klass(javaMirror);

  return find_index(klass);

}

void AOTOopRecorder::record_meta_ref(jobject o, int index) {

  assert(index > 0, "must be 1..n");

  index -= 1; // reduce by one to convert to array index

  assert(index == _meta_refs->length(), "must be last");

  _meta_refs->append(o);

}

#endif // INCLUDE_AOT

void* CodeInstaller::record_metadata_reference(CodeSection* section, address dest, JVMCIObject constant, JVMCI_TRAPS) {

  /*

   * This method needs to return a raw (untyped) pointer, since the value of a pointer to the base

   * class is in general not equal to the pointer of the subclass. When patching metaspace pointers,

   * the compiler expects a direct pointer to the subclass (Klass* or Method*), not a pointer to the

   * base class (Metadata* or MetaspaceObj*).

   */

  JVMCIObject obj = jvmci_env()->get_HotSpotMetaspaceConstantImpl_metaspaceObject(constant);

  if (jvmci_env()->isa_HotSpotResolvedObjectTypeImpl(obj)) {

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

    assert(!jvmci_env()->get_HotSpotMetaspaceConstantImpl_compressed(constant), "unexpected compressed klass pointer %s @ " INTPTR_FORMAT, klass->name()->as_C_string(), p2i(klass));

    int index = _oop_recorder->find_index(klass);

    section->relocate(dest, metadata_Relocation::spec(index));

    TRACE_jvmci_3("metadata[%d of %d] = %s", index, _oop_recorder->metadata_count(), klass->name()->as_C_string());

    return klass;

  } else if (jvmci_env()->isa_HotSpotResolvedJavaMethodImpl(obj)) {

    Method* method = jvmci_env()->asMethod(obj);

    assert(!jvmci_env()->get_HotSpotMetaspaceConstantImpl_compressed(constant), "unexpected compressed method pointer %s @ " INTPTR_FORMAT, method->name()->as_C_string(), p2i(method));

    int index = _oop_recorder->find_index(method);

    section->relocate(dest, metadata_Relocation::spec(index));

    TRACE_jvmci_3("metadata[%d of %d] = %s", index, _oop_recorder->metadata_count(), method->name()->as_C_string());

    return method;

  } else {

    JVMCI_ERROR_NULL("unexpected metadata reference for constant of type %s", jvmci_env()->klass_name(obj));

  }

}

#ifdef _LP64

narrowKlass CodeInstaller::record_narrow_metadata_reference(CodeSection* section, address dest, JVMCIObject constant, JVMCI_TRAPS) {

  JVMCIObject obj = jvmci_env()->get_HotSpotMetaspaceConstantImpl_metaspaceObject(constant);

  assert(jvmci_env()->get_HotSpotMetaspaceConstantImpl_compressed(constant), "unexpected uncompressed pointer");

  if (!jvmci_env()->isa_HotSpotResolvedObjectTypeImpl(obj)) {

    JVMCI_ERROR_0("unexpected compressed pointer of type %s", jvmci_env()->klass_name(obj));

  }

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

  int index = _oop_recorder->find_index(klass);

  section->relocate(dest, metadata_Relocation::spec(index));

  TRACE_jvmci_3("narrowKlass[%d of %d] = %s", index, _oop_recorder->metadata_count(), klass->name()->as_C_string());

  return CompressedKlassPointers::encode(klass);

}

#endif

Location::Type CodeInstaller::get_oop_type(JVMCIObject value) {

  JVMCIObject valueKind = jvmci_env()->get_Value_valueKind(value);

  JVMCIObject platformKind = jvmci_env()->get_ValueKind_platformKind(valueKind);

  if (jvmci_env()->equals(platformKind, word_kind())) {

    return Location::oop;

  } else {

    return Location::narrowoop;

  }

}

ScopeValue* CodeInstaller::get_scope_value(JVMCIObject value, BasicType type, GrowableArray<ScopeValue*>* objects, ScopeValue* &second, JVMCI_TRAPS) {

  second = NULL;

  if (value.is_null()) {

    JVMCI_THROW_NULL(NullPointerException);

  } else if (JVMCIENV->equals(value, jvmci_env()->get_Value_ILLEGAL())) {

    if (type != T_ILLEGAL) {

      JVMCI_ERROR_NULL("unexpected illegal value, expected %s", basictype_to_str(type));

    }

    return _illegal_value;

  } else if (jvmci_env()->isa_RegisterValue(value)) {

    JVMCIObject reg = jvmci_env()->get_RegisterValue_reg(value);

    jint number = jvmci_env()->get_code_Register_number(reg);

    VMReg hotspotRegister = get_hotspot_reg(number, JVMCI_CHECK_NULL);

    if (is_general_purpose_reg(hotspotRegister)) {

      Location::Type locationType;

      if (type == T_OBJECT) {

        locationType = get_oop_type(value);

      } else if (type == T_LONG) {

        locationType = Location::lng;

      } else if (type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN) {

        locationType = Location::int_in_long;

      } else {

        JVMCI_ERROR_NULL("unexpected type %s in cpu register", basictype_to_str(type));

      }

      ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister));

      if (type == T_LONG) {

        second = value;

      }

      return value;

    } else {

      Location::Type locationType;

      if (type == T_FLOAT) {

        // this seems weird, but the same value is used in c1_LinearScan

        locationType = Location::normal;

      } else if (type == T_DOUBLE) {

        locationType = Location::dbl;

      } else {

        JVMCI_ERROR_NULL("unexpected type %s in floating point register", basictype_to_str(type));

      }

      ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister));

      if (type == T_DOUBLE) {

        second = value;

      }

      return value;

    }

  } else if (jvmci_env()->isa_StackSlot(value)) {

    jint offset = jvmci_env()->get_StackSlot_offset(value);

    if (jvmci_env()->get_StackSlot_addFrameSize(value)) {

      offset += _total_frame_size;

    }

    Location::Type locationType;

    if (type == T_OBJECT) {

      locationType = get_oop_type(value);

    } else if (type == T_LONG) {

      locationType = Location::lng;

    } else if (type == T_DOUBLE) {

      locationType = Location::dbl;

    } else if (type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN) {

      locationType = Location::normal;

    } else {

      JVMCI_ERROR_NULL("unexpected type %s in stack slot", basictype_to_str(type));

    }

    ScopeValue* value = new LocationValue(Location::new_stk_loc(locationType, offset));

    if (type == T_DOUBLE || type == T_LONG) {

      second = value;

    }

    return value;

  } else if (jvmci_env()->isa_JavaConstant(value)) {

    if (jvmci_env()->isa_PrimitiveConstant(value)) {

      if (jvmci_env()->isa_RawConstant(value)) {

        jlong prim = jvmci_env()->get_PrimitiveConstant_primitive(value);

        return new ConstantLongValue(prim);

      } else {

        BasicType constantType = jvmci_env()->kindToBasicType(jvmci_env()->get_PrimitiveConstant_kind(value), JVMCI_CHECK_NULL);

        if (type != constantType) {

          JVMCI_ERROR_NULL("primitive constant type doesn't match, expected %s but got %s", basictype_to_str(type), basictype_to_str(constantType));

        }

        if (type == T_INT || type == T_FLOAT) {

          jint prim = (jint)jvmci_env()->get_PrimitiveConstant_primitive(value);

          switch (prim) {

            case -1: return _int_m1_scope_value;

            case  0: return _int_0_scope_value;

            case  1: return _int_1_scope_value;

            case  2: return _int_2_scope_value;

            default: return new ConstantIntValue(prim);

          }

        } else if (type == T_LONG || type == T_DOUBLE) {

          jlong prim = jvmci_env()->get_PrimitiveConstant_primitive(value);

          second = _int_1_scope_value;

          return new ConstantLongValue(prim);

        } else {

          JVMCI_ERROR_NULL("unexpected primitive constant type %s", basictype_to_str(type));

        }

      }

    } else if (jvmci_env()->isa_NullConstant(value) || jvmci_env()->isa_HotSpotCompressedNullConstant(value)) {

      if (type == T_OBJECT) {

        return _oop_null_scope_value;

      } else {

        JVMCI_ERROR_NULL("unexpected null constant, expected %s", basictype_to_str(type));

      }

    } else if (jvmci_env()->isa_HotSpotObjectConstantImpl(value)) {

      if (type == T_OBJECT) {

        Handle obj = jvmci_env()->asConstant(value, JVMCI_CHECK_NULL);

        if (obj == NULL) {

          JVMCI_ERROR_NULL("null value must be in NullConstant");

        }

        return new ConstantOopWriteValue(JNIHandles::make_local(obj()));

      } else {

        JVMCI_ERROR_NULL("unexpected object constant, expected %s", basictype_to_str(type));

      }

    }

  } else if (jvmci_env()->isa_VirtualObject(value)) {

    if (type == T_OBJECT) {

      int id = jvmci_env()->get_VirtualObject_id(value);

      if (0 <= id && id < objects->length()) {

        ScopeValue* object = objects->at(id);

        if (object != NULL) {

          return object;

        }

      }

      JVMCI_ERROR_NULL("unknown virtual object id %d", id);

    } else {

      JVMCI_ERROR_NULL("unexpected virtual object, expected %s", basictype_to_str(type));

    }

  }

  JVMCI_ERROR_NULL("unexpected value in scope: %s", jvmci_env()->klass_name(value))

}

void CodeInstaller::record_object_value(ObjectValue* sv, JVMCIObject value, GrowableArray<ScopeValue*>* objects, JVMCI_TRAPS) {

  JVMCIObject type = jvmci_env()->get_VirtualObject_type(value);

  int id = jvmci_env()->get_VirtualObject_id(value);

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

  bool isLongArray = klass == Universe::longArrayKlassObj();

  JVMCIObjectArray values = jvmci_env()->get_VirtualObject_values(value);

  JVMCIObjectArray slotKinds = jvmci_env()->get_VirtualObject_slotKinds(value);

  for (jint i = 0; i < JVMCIENV->get_length(values); i++) {

    ScopeValue* cur_second = NULL;

    JVMCIObject object = JVMCIENV->get_object_at(values, i);

    BasicType type = jvmci_env()->kindToBasicType(JVMCIENV->get_object_at(slotKinds, i), JVMCI_CHECK);

    ScopeValue* value = get_scope_value(object, type, objects, cur_second, JVMCI_CHECK);

    if (isLongArray && cur_second == NULL) {

      // we're trying to put ints into a long array... this isn't really valid, but it's used for some optimizations.

      // add an int 0 constant

      cur_second = _int_0_scope_value;

    }

    if (cur_second != NULL) {

      sv->field_values()->append(cur_second);

    }

    assert(value != NULL, "missing value");

    sv->field_values()->append(value);

  }

}

MonitorValue* CodeInstaller::get_monitor_value(JVMCIObject value, GrowableArray<ScopeValue*>* objects, JVMCI_TRAPS) {

  if (value.is_null()) {

    JVMCI_THROW_NULL(NullPointerException);

  }

  if (!jvmci_env()->isa_StackLockValue(value)) {

    JVMCI_ERROR_NULL("Monitors must be of type StackLockValue, got %s", jvmci_env()->klass_name(value));

  }

  ScopeValue* second = NULL;

  ScopeValue* owner_value = get_scope_value(jvmci_env()->get_StackLockValue_owner(value), T_OBJECT, objects, second, JVMCI_CHECK_NULL);

  assert(second == NULL, "monitor cannot occupy two stack slots");

  ScopeValue* lock_data_value = get_scope_value(jvmci_env()->get_StackLockValue_slot(value), T_LONG, objects, second, JVMCI_CHECK_NULL);

  assert(second == lock_data_value, "monitor is LONG value that occupies two stack slots");

  assert(lock_data_value->is_location(), "invalid monitor location");

  Location lock_data_loc = ((LocationValue*)lock_data_value)->location();

  bool eliminated = false;

  if (jvmci_env()->get_StackLockValue_eliminated(value)) {

    eliminated = true;

  }

  return new MonitorValue(owner_value, lock_data_loc, eliminated);

}

void CodeInstaller::initialize_dependencies(JVMCIObject compiled_code, OopRecorder* oop_recorder, JVMCI_TRAPS) {

  JavaThread* thread = JavaThread::current();

  CompilerThread* compilerThread = thread->is_Compiler_thread() ? thread->as_CompilerThread() : NULL;

  _oop_recorder = oop_recorder;

  _dependencies = new Dependencies(&_arena, _oop_recorder, compilerThread != NULL ? compilerThread->log() : NULL);

  JVMCIObjectArray assumptions = jvmci_env()->get_HotSpotCompiledCode_assumptions(compiled_code);

  if (assumptions.is_non_null()) {

    int length = JVMCIENV->get_length(assumptions);

    for (int i = 0; i < length; ++i) {

      JVMCIObject assumption = JVMCIENV->get_object_at(assumptions, i);

      if (assumption.is_non_null()) {

        if (jvmci_env()->isa_Assumptions_NoFinalizableSubclass(assumption)) {

          assumption_NoFinalizableSubclass(assumption);

        } else if (jvmci_env()->isa_Assumptions_ConcreteSubtype(assumption)) {

          assumption_ConcreteSubtype(assumption);

        } else if (jvmci_env()->isa_Assumptions_LeafType(assumption)) {

          assumption_LeafType(assumption);

        } else if (jvmci_env()->isa_Assumptions_ConcreteMethod(assumption)) {

          assumption_ConcreteMethod(assumption);

        } else if (jvmci_env()->isa_Assumptions_CallSiteTargetValue(assumption)) {

          assumption_CallSiteTargetValue(assumption, JVMCI_CHECK);

        } else {

          JVMCI_ERROR("unexpected Assumption subclass %s", jvmci_env()->klass_name(assumption));

        }