mirror of
https://github.com/openjdk/jdk.git
synced 2025-08-27 14:54:52 +02:00
8258625: [JVMCI] refactor and unify JVMCI readFieldValue path
Reviewed-by: kvn
This commit is contained in:
Tom Rodriguez
parent
b5c6351315
commit
852a41d718
17 changed files with 288 additions and 647 deletions
|
|
@ -44,6 +44,7 @@
|
|||
#include "memory/oopFactory.hpp"
|
||||
#include "memory/universe.hpp"
|
||||
#include "oops/constantPool.inline.hpp"
|
||||
#include "oops/instanceMirrorKlass.hpp"
|
||||
#include "oops/instanceKlass.inline.hpp"
|
||||
#include "oops/method.inline.hpp"
|
||||
#include "oops/typeArrayOop.inline.hpp"
|
||||
|
|
@ -249,18 +250,6 @@ C2V_VMENTRY_NULL(jobject, getFlagValue, (JNIEnv* env, jobject c2vm, jobject name
|
|||
#undef RETURN_BOXED_DOUBLE
|
||||
C2V_END
|
||||
|
||||
C2V_VMENTRY_NULL(jobject, getObjectAtAddress, (JNIEnv* env, jobject c2vm, jlong oop_address))
|
||||
requireInHotSpot("getObjectAtAddress", JVMCI_CHECK_NULL);
|
||||
if (oop_address == 0) {
|
||||
JVMCI_THROW_MSG_NULL(InternalError, "Handle must be non-zero");
|
||||
}
|
||||
oop obj = *((oopDesc**) oop_address);
|
||||
if (obj != NULL) {
|
||||
oopDesc::verify(obj);
|
||||
}
|
||||
return JNIHandles::make_local(THREAD, obj);
|
||||
C2V_END
|
||||
|
||||
C2V_VMENTRY_NULL(jbyteArray, getBytecode, (JNIEnv* env, jobject, jobject jvmci_method))
|
||||
methodHandle method(THREAD, JVMCIENV->asMethod(jvmci_method));
|
||||
|
||||
|
|
@ -640,29 +629,22 @@ C2V_VMENTRY_NULL(jobject, resolvePossiblyCachedConstantInPool, (JNIEnv* env, job
|
|||
// Convert standard box (e.g. java.lang.Integer) to JVMCI box (e.g. jdk.vm.ci.meta.PrimitiveConstant)
|
||||
jvalue value;
|
||||
jlong raw_value;
|
||||
JVMCIObject kind;
|
||||
BasicType bt2 = java_lang_boxing_object::get_value(obj, &value);
|
||||
assert(bt2 == bt, "");
|
||||
switch (bt2) {
|
||||
case T_BOOLEAN: raw_value = value.z; break;
|
||||
case T_BYTE: raw_value = value.b; break;
|
||||
case T_SHORT: raw_value = value.s; break;
|
||||
case T_CHAR: raw_value = value.c; break;
|
||||
case T_INT: raw_value = value.i; break;
|
||||
case T_LONG: raw_value = value.j; break;
|
||||
case T_FLOAT: {
|
||||
JVMCIObject result = JVMCIENV->call_JavaConstant_forFloat(value.f, JVMCI_CHECK_NULL);
|
||||
return JVMCIENV->get_jobject(result);
|
||||
}
|
||||
case T_DOUBLE: {
|
||||
JVMCIObject result = JVMCIENV->call_JavaConstant_forDouble(value.d, JVMCI_CHECK_NULL);
|
||||
return JVMCIENV->get_jobject(result);
|
||||
}
|
||||
default: {
|
||||
return JVMCIENV->get_jobject(JVMCIENV->get_JavaConstant_ILLEGAL());
|
||||
}
|
||||
case T_LONG: kind = JVMCIENV->get_JavaKind_Long(); raw_value = value.j; break;
|
||||
case T_DOUBLE: kind = JVMCIENV->get_JavaKind_Double(); raw_value = value.j; break;
|
||||
case T_FLOAT: kind = JVMCIENV->get_JavaKind_Float(); raw_value = value.i; break;
|
||||
case T_INT: kind = JVMCIENV->get_JavaKind_Int(); raw_value = value.i; break;
|
||||
case T_SHORT: kind = JVMCIENV->get_JavaKind_Short(); raw_value = value.s; break;
|
||||
case T_BYTE: kind = JVMCIENV->get_JavaKind_Byte(); raw_value = value.b; break;
|
||||
case T_CHAR: kind = JVMCIENV->get_JavaKind_Char(); raw_value = value.c; break;
|
||||
case T_BOOLEAN: kind = JVMCIENV->get_JavaKind_Boolean(); raw_value = value.z; break;
|
||||
default: return JVMCIENV->get_jobject(JVMCIENV->get_JavaConstant_ILLEGAL());
|
||||
}
|
||||
|
||||
JVMCIObject result = JVMCIENV->call_PrimitiveConstant_forTypeChar(type2char(bt2), raw_value, JVMCI_CHECK_NULL);
|
||||
JVMCIObject result = JVMCIENV->call_JavaConstant_forPrimitive(kind, raw_value, JVMCI_CHECK_NULL);
|
||||
return JVMCIENV->get_jobject(result);
|
||||
}
|
||||
}
|
||||
|
|
@ -1191,11 +1173,6 @@ C2V_VMENTRY(void, invalidateHotSpotNmethod, (JNIEnv* env, jobject, jobject hs_nm
|
|||
JVMCIENV->invalidate_nmethod_mirror(nmethod_mirror, JVMCI_CHECK);
|
||||
C2V_END
|
||||
|
||||
C2V_VMENTRY_NULL(jobject, readUncompressedOop, (JNIEnv* env, jobject, jlong addr))
|
||||
oop ret = RawAccess<>::oop_load((oop*)(address)addr);
|
||||
return JVMCIENV->get_jobject(JVMCIENV->get_object_constant(ret));
|
||||
C2V_END
|
||||
|
||||
C2V_VMENTRY_NULL(jlongArray, collectCounters, (JNIEnv* env, jobject))
|
||||
// Returns a zero length array if counters aren't enabled
|
||||
JVMCIPrimitiveArray array = JVMCIENV->new_longArray(JVMCICounterSize, JVMCI_CHECK_NULL);
|
||||
|
|
@ -1949,79 +1926,130 @@ C2V_VMENTRY_NULL(jobjectArray, getDeclaredMethods, (JNIEnv* env, jobject, jobjec
|
|||
return JVMCIENV->get_jobjectArray(methods);
|
||||
C2V_END
|
||||
|
||||
C2V_VMENTRY_NULL(jobject, readFieldValue, (JNIEnv* env, jobject, jobject object, jobject field, jboolean is_volatile))
|
||||
if (object == NULL || field == NULL) {
|
||||
C2V_VMENTRY_NULL(jobject, readFieldValue, (JNIEnv* env, jobject, jobject object, jobject expected_type, long displacement, jboolean is_volatile, jobject kind_object))
|
||||
if (object == NULL || kind_object == NULL) {
|
||||
JVMCI_THROW_0(NullPointerException);
|
||||
}
|
||||
JVMCIObject field_object = JVMCIENV->wrap(field);
|
||||
JVMCIObject java_type = JVMCIENV->get_HotSpotResolvedJavaFieldImpl_type(field_object);
|
||||
int modifiers = JVMCIENV->get_HotSpotResolvedJavaFieldImpl_modifiers(field_object);
|
||||
Klass* holder = JVMCIENV->asKlass(JVMCIENV->get_HotSpotResolvedJavaFieldImpl_holder(field_object));
|
||||
if (!holder->is_instance_klass()) {
|
||||
JVMCI_THROW_MSG_0(InternalError, err_msg("Holder %s must be instance klass", holder->external_name()));
|
||||
}
|
||||
InstanceKlass* ik = InstanceKlass::cast(holder);
|
||||
BasicType constant_type;
|
||||
if (JVMCIENV->isa_HotSpotResolvedPrimitiveType(java_type)) {
|
||||
constant_type = JVMCIENV->kindToBasicType(JVMCIENV->get_HotSpotResolvedPrimitiveType_kind(java_type), JVMCI_CHECK_NULL);
|
||||
} else {
|
||||
constant_type = T_OBJECT;
|
||||
}
|
||||
int displacement = JVMCIENV->get_HotSpotResolvedJavaFieldImpl_offset(field_object);
|
||||
fieldDescriptor fd;
|
||||
if (!ik->find_local_field_from_offset(displacement, (modifiers & JVM_ACC_STATIC) != 0, &fd)) {
|
||||
JVMCI_THROW_MSG_0(InternalError, err_msg("Can't find field with displacement %d", displacement));
|
||||
}
|
||||
JVMCIObject base = JVMCIENV->wrap(object);
|
||||
Handle obj;
|
||||
if (JVMCIENV->isa_HotSpotObjectConstantImpl(base)) {
|
||||
obj = JVMCIENV->asConstant(base, JVMCI_CHECK_NULL);
|
||||
} else if (JVMCIENV->isa_HotSpotResolvedObjectTypeImpl(base)) {
|
||||
Klass* klass = JVMCIENV->asKlass(base);
|
||||
obj = Handle(THREAD, klass->java_mirror());
|
||||
} else {
|
||||
JVMCI_THROW_MSG_NULL(IllegalArgumentException,
|
||||
err_msg("Unexpected type: %s", JVMCIENV->klass_name(base)));
|
||||
|
||||
JVMCIObject kind = JVMCIENV->wrap(kind_object);
|
||||
BasicType basic_type = JVMCIENV->kindToBasicType(kind, JVMCI_CHECK_NULL);
|
||||
|
||||
InstanceKlass* holder = NULL;
|
||||
if (expected_type != NULL) {
|
||||
holder = InstanceKlass::cast(JVMCIENV->asKlass(JVMCIENV->wrap(expected_type)));
|
||||
}
|
||||
|
||||
if (displacement == java_lang_Class::component_mirror_offset() && java_lang_Class::is_instance(obj()) &&
|
||||
!java_lang_Class::as_Klass(obj())->is_array_klass()) {
|
||||
// Class.componentType for non-array classes can transiently contain an int[] that's
|
||||
// used for locking so always return null to mimic Class.getComponentType()
|
||||
return JVMCIENV->get_jobject(JVMCIENV->get_JavaConstant_NULL_POINTER());
|
||||
bool is_static = false;
|
||||
Handle obj;
|
||||
JVMCIObject base = JVMCIENV->wrap(object);
|
||||
if (JVMCIENV->isa_HotSpotObjectConstantImpl(base)) {
|
||||
obj = JVMCIENV->asConstant(base, JVMCI_CHECK_NULL);
|
||||
// asConstant will throw an NPE if a constant contains NULL
|
||||
|
||||
if (holder != NULL && !obj->is_a(holder)) {
|
||||
// Not a subtype of field holder
|
||||
return NULL;
|
||||
}
|
||||
is_static = false;
|
||||
if (holder == NULL && java_lang_Class::is_instance(obj()) && displacement >= InstanceMirrorKlass::offset_of_static_fields()) {
|
||||
is_static = true;
|
||||
}
|
||||
} else if (JVMCIENV->isa_HotSpotResolvedObjectTypeImpl(base)) {
|
||||
is_static = true;
|
||||
Klass* klass = JVMCIENV->asKlass(base);
|
||||
if (holder != NULL && holder != klass) {
|
||||
return NULL;
|
||||
}
|
||||
obj = Handle(THREAD, klass->java_mirror());
|
||||
} else {
|
||||
// The Java code is expected to guard against this path
|
||||
ShouldNotReachHere();
|
||||
}
|
||||
|
||||
if (displacement < 0 || ((long) displacement + type2aelembytes(basic_type) > HeapWordSize * obj->size())) {
|
||||
// Reading outside of the object bounds
|
||||
JVMCI_THROW_MSG_NULL(IllegalArgumentException, "reading outside object bounds");
|
||||
}
|
||||
|
||||
// Perform basic sanity checks on the read. Primitive reads are permitted to read outside the
|
||||
// bounds of their fields but object reads must map exactly onto the underlying oop slot.
|
||||
if (basic_type == T_OBJECT) {
|
||||
if (obj->is_objArray()) {
|
||||
if (displacement < arrayOopDesc::base_offset_in_bytes(T_OBJECT)) {
|
||||
JVMCI_THROW_MSG_NULL(IllegalArgumentException, "reading from array header");
|
||||
}
|
||||
if (displacement + heapOopSize > arrayOopDesc::base_offset_in_bytes(T_OBJECT) + arrayOop(obj())->length() * heapOopSize) {
|
||||
JVMCI_THROW_MSG_NULL(IllegalArgumentException, "reading after last array element");
|
||||
}
|
||||
if (((displacement - arrayOopDesc::base_offset_in_bytes(T_OBJECT)) % heapOopSize) != 0) {
|
||||
JVMCI_THROW_MSG_NULL(IllegalArgumentException, "misaligned object read from array");
|
||||
}
|
||||
} else if (obj->is_instance()) {
|
||||
InstanceKlass* klass = InstanceKlass::cast(is_static ? java_lang_Class::as_Klass(obj()) : obj->klass());
|
||||
fieldDescriptor fd;
|
||||
if (!klass->find_field_from_offset(displacement, is_static, &fd)) {
|
||||
JVMCI_THROW_MSG_NULL(IllegalArgumentException, err_msg("Can't find field at displacement %d in object of type %s", (int) displacement, klass->external_name()));
|
||||
}
|
||||
if (fd.field_type() != T_OBJECT && fd.field_type() != T_ARRAY) {
|
||||
JVMCI_THROW_MSG_NULL(IllegalArgumentException, err_msg("Field at displacement %d in object of type %s is %s but expected %s", (int) displacement,
|
||||
klass->external_name(), type2name(fd.field_type()), type2name(basic_type)));
|
||||
}
|
||||
} else if (obj->is_typeArray()) {
|
||||
JVMCI_THROW_MSG_NULL(IllegalArgumentException, "Can't read objects from primitive array");
|
||||
} else {
|
||||
ShouldNotReachHere();
|
||||
}
|
||||
} else {
|
||||
if (obj->is_objArray()) {
|
||||
JVMCI_THROW_MSG_NULL(IllegalArgumentException, "Reading primitive from object array");
|
||||
} else if (obj->is_typeArray()) {
|
||||
if (displacement < arrayOopDesc::base_offset_in_bytes(ArrayKlass::cast(obj->klass())->element_type())) {
|
||||
JVMCI_THROW_MSG_NULL(IllegalArgumentException, "reading from array header");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
jlong value = 0;
|
||||
JVMCIObject kind;
|
||||
switch (constant_type) {
|
||||
switch (basic_type) {
|
||||
case T_BOOLEAN: value = is_volatile ? obj->bool_field_acquire(displacement) : obj->bool_field(displacement); break;
|
||||
case T_BYTE: value = is_volatile ? obj->byte_field_acquire(displacement) : obj->byte_field(displacement); break;
|
||||
case T_SHORT: value = is_volatile ? obj->short_field_acquire(displacement) : obj->short_field(displacement); break;
|
||||
case T_CHAR: value = is_volatile ? obj->char_field_acquire(displacement) : obj->char_field(displacement); break;
|
||||
case T_FLOAT:
|
||||
case T_INT: value = is_volatile ? obj->int_field_acquire(displacement) : obj->int_field(displacement); break;
|
||||
case T_DOUBLE:
|
||||
case T_LONG: value = is_volatile ? obj->long_field_acquire(displacement) : obj->long_field(displacement); break;
|
||||
|
||||
case T_OBJECT: {
|
||||
oop object = is_volatile ? obj->obj_field_acquire(displacement) : obj->obj_field(displacement);
|
||||
JVMCIObject result = JVMCIENV->get_object_constant(object);
|
||||
if (result.is_null()) {
|
||||
if (displacement == java_lang_Class::component_mirror_offset() && java_lang_Class::is_instance(obj()) &&
|
||||
(java_lang_Class::as_Klass(obj()) == NULL || !java_lang_Class::as_Klass(obj())->is_array_klass())) {
|
||||
// Class.componentType for non-array classes can transiently contain an int[] that's
|
||||
// used for locking so always return null to mimic Class.getComponentType()
|
||||
return JVMCIENV->get_jobject(JVMCIENV->get_JavaConstant_NULL_POINTER());
|
||||
}
|
||||
return JVMCIENV->get_jobject(result);
|
||||
|
||||
oop value = is_volatile ? obj->obj_field_acquire(displacement) : obj->obj_field(displacement);
|
||||
if (value == NULL) {
|
||||
return JVMCIENV->get_jobject(JVMCIENV->get_JavaConstant_NULL_POINTER());
|
||||
} else {
|
||||
if (value != NULL && !oopDesc::is_oop(value)) {
|
||||
// Throw an exception to improve debuggability. This check isn't totally reliable because
|
||||
// is_oop doesn't try to be completety safe but for most invalid values it provides a good
|
||||
// enough answer. It possible to crash in the is_oop call but that just means the crash happens
|
||||
// closer to where things went wrong.
|
||||
JVMCI_THROW_MSG_NULL(InternalError, err_msg("Read bad oop " INTPTR_FORMAT " at offset " JLONG_FORMAT " in object " INTPTR_FORMAT " of type %s",
|
||||
p2i(value), displacement, p2i(obj()), obj->klass()->external_name()));
|
||||
}
|
||||
|
||||
JVMCIObject result = JVMCIENV->get_object_constant(value);
|
||||
return JVMCIENV->get_jobject(result);
|
||||
}
|
||||
}
|
||||
case T_FLOAT: {
|
||||
float f = is_volatile ? obj->float_field_acquire(displacement) : obj->float_field(displacement);
|
||||
JVMCIObject result = JVMCIENV->call_JavaConstant_forFloat(f, JVMCI_CHECK_NULL);
|
||||
return JVMCIENV->get_jobject(result);
|
||||
}
|
||||
case T_DOUBLE: {
|
||||
double f = is_volatile ? obj->double_field_acquire(displacement) : obj->double_field(displacement);
|
||||
JVMCIObject result = JVMCIENV->call_JavaConstant_forDouble(f, JVMCI_CHECK_NULL);
|
||||
return JVMCIENV->get_jobject(result);
|
||||
}
|
||||
case T_BOOLEAN: value = is_volatile ? obj->bool_field_acquire(displacement) : obj->bool_field(displacement); break;
|
||||
case T_BYTE: value = is_volatile ? obj->byte_field_acquire(displacement) : obj->byte_field(displacement); break;
|
||||
case T_SHORT: value = is_volatile ? obj->short_field_acquire(displacement) : obj->short_field(displacement); break;
|
||||
case T_CHAR: value = is_volatile ? obj->char_field_acquire(displacement) : obj->char_field(displacement); break;
|
||||
case T_INT: value = is_volatile ? obj->int_field_acquire(displacement) : obj->int_field(displacement); break;
|
||||
case T_LONG: value = is_volatile ? obj->long_field_acquire(displacement) : obj->long_field(displacement); break;
|
||||
|
||||
default:
|
||||
ShouldNotReachHere();
|
||||
}
|
||||
JVMCIObject result = JVMCIENV->call_PrimitiveConstant_forTypeChar(type2char(constant_type), value, JVMCI_CHECK_NULL);
|
||||
JVMCIObject result = JVMCIENV->call_JavaConstant_forPrimitive(kind, value, JVMCI_CHECK_NULL);
|
||||
return JVMCIENV->get_jobject(result);
|
||||
C2V_END
|
||||
|
||||
|
|
@ -2179,55 +2207,6 @@ C2V_VMENTRY_0(jint, arrayIndexScale, (JNIEnv* env, jobject, jobject kind))
|
|||
return type2aelembytes(type);
|
||||
C2V_END
|
||||
|
||||
C2V_VMENTRY_0(jbyte, getByte, (JNIEnv* env, jobject, jobject x, long displacement))
|
||||
if (x == NULL) {
|
||||
JVMCI_THROW_0(NullPointerException);
|
||||
}
|
||||
Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
|
||||
return xobj->byte_field(displacement);
|
||||
}
|
||||
|
||||
C2V_VMENTRY_0(jshort, getShort, (JNIEnv* env, jobject, jobject x, long displacement))
|
||||
if (x == NULL) {
|
||||
JVMCI_THROW_0(NullPointerException);
|
||||
}
|
||||
Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
|
||||
return xobj->short_field(displacement);
|
||||
}
|
||||
|
||||
C2V_VMENTRY_0(jint, getInt, (JNIEnv* env, jobject, jobject x, long displacement))
|
||||
if (x == NULL) {
|
||||
JVMCI_THROW_0(NullPointerException);
|
||||
}
|
||||
Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
|
||||
return xobj->int_field(displacement);
|
||||
}
|
||||
|
||||
C2V_VMENTRY_0(jlong, getLong, (JNIEnv* env, jobject, jobject x, long displacement))
|
||||
if (x == NULL) {
|
||||
JVMCI_THROW_0(NullPointerException);
|
||||
}
|
||||
Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
|
||||
return xobj->long_field(displacement);
|
||||
}
|
||||
|
||||
C2V_VMENTRY_NULL(jobject, getObject, (JNIEnv* env, jobject, jobject x, long displacement))
|
||||
if (x == NULL) {
|
||||
JVMCI_THROW_0(NullPointerException);
|
||||
}
|
||||
Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
|
||||
if (displacement == java_lang_Class::component_mirror_offset() && java_lang_Class::is_instance(xobj()) &&
|
||||
!java_lang_Class::as_Klass(xobj())->is_array_klass()) {
|
||||
// Class.componentType for non-array classes can transiently contain an int[] that's
|
||||
// used for locking so always return null to mimic Class.getComponentType()
|
||||
return JVMCIENV->get_jobject(JVMCIENV->get_JavaConstant_NULL_POINTER());
|
||||
}
|
||||
|
||||
oop res = xobj->obj_field(displacement);
|
||||
JVMCIObject result = JVMCIENV->get_object_constant(res);
|
||||
return JVMCIENV->get_jobject(result);
|
||||
}
|
||||
|
||||
C2V_VMENTRY(void, deleteGlobalHandle, (JNIEnv* env, jobject, jlong h))
|
||||
jobject handle = (jobject)(address)h;
|
||||
if (handle != NULL) {
|
||||
|
|
@ -2768,7 +2747,6 @@ JNINativeMethod CompilerToVM::methods[] = {
|
|||
{CC "getLocalVariableTableLength", CC "(" HS_RESOLVED_METHOD ")I", FN_PTR(getLocalVariableTableLength)},
|
||||
{CC "reprofile", CC "(" HS_RESOLVED_METHOD ")V", FN_PTR(reprofile)},
|
||||
{CC "invalidateHotSpotNmethod", CC "(" HS_NMETHOD ")V", FN_PTR(invalidateHotSpotNmethod)},
|
||||
{CC "readUncompressedOop", CC "(J)" OBJECTCONSTANT, FN_PTR(readUncompressedOop)},
|
||||
{CC "collectCounters", CC "()[J", FN_PTR(collectCounters)},
|
||||
{CC "getCountersSize", CC "()I", FN_PTR(getCountersSize)},
|
||||
{CC "setCountersSize", CC "(I)Z", FN_PTR(setCountersSize)},
|
||||
|
|
@ -2787,7 +2765,6 @@ JNINativeMethod CompilerToVM::methods[] = {
|
|||
{CC "interpreterFrameSize", CC "(" BYTECODE_FRAME ")I", FN_PTR(interpreterFrameSize)},
|
||||
{CC "compileToBytecode", CC "(" OBJECTCONSTANT ")V", FN_PTR(compileToBytecode)},
|
||||
{CC "getFlagValue", CC "(" STRING ")" OBJECT, FN_PTR(getFlagValue)},
|
||||
{CC "getObjectAtAddress", CC "(J)" OBJECT, FN_PTR(getObjectAtAddress)},
|
||||
{CC "getInterfaces", CC "(" HS_RESOLVED_KLASS ")[" HS_RESOLVED_KLASS, FN_PTR(getInterfaces)},
|
||||
{CC "getComponentType", CC "(" HS_RESOLVED_KLASS ")" HS_RESOLVED_TYPE, FN_PTR(getComponentType)},
|
||||
{CC "ensureInitialized", CC "(" HS_RESOLVED_KLASS ")V", FN_PTR(ensureInitialized)},
|
||||
|
|
@ -2798,8 +2775,8 @@ JNINativeMethod CompilerToVM::methods[] = {
|
|||
{CC "boxPrimitive", CC "(" OBJECT ")" OBJECTCONSTANT, FN_PTR(boxPrimitive)},
|
||||
{CC "getDeclaredConstructors", CC "(" HS_RESOLVED_KLASS ")[" RESOLVED_METHOD, FN_PTR(getDeclaredConstructors)},
|
||||
{CC "getDeclaredMethods", CC "(" HS_RESOLVED_KLASS ")[" RESOLVED_METHOD, FN_PTR(getDeclaredMethods)},
|
||||
{CC "readFieldValue", CC "(" HS_RESOLVED_KLASS HS_RESOLVED_FIELD "Z)" JAVACONSTANT, FN_PTR(readFieldValue)},
|
||||
{CC "readFieldValue", CC "(" OBJECTCONSTANT HS_RESOLVED_FIELD "Z)" JAVACONSTANT, FN_PTR(readFieldValue)},
|
||||
{CC "readFieldValue", CC "(" HS_RESOLVED_KLASS HS_RESOLVED_KLASS "JZLjdk/vm/ci/meta/JavaKind;)" JAVACONSTANT, FN_PTR(readFieldValue)},
|
||||
{CC "readFieldValue", CC "(" OBJECTCONSTANT HS_RESOLVED_KLASS "JZLjdk/vm/ci/meta/JavaKind;)" JAVACONSTANT, FN_PTR(readFieldValue)},
|
||||
{CC "isInstance", CC "(" HS_RESOLVED_KLASS OBJECTCONSTANT ")Z", FN_PTR(isInstance)},
|
||||
{CC "isAssignableFrom", CC "(" HS_RESOLVED_KLASS HS_RESOLVED_KLASS ")Z", FN_PTR(isAssignableFrom)},
|
||||
{CC "isTrustedForIntrinsics", CC "(" HS_RESOLVED_KLASS ")Z", FN_PTR(isTrustedForIntrinsics)},
|
||||
|
|
@ -2811,11 +2788,6 @@ JNINativeMethod CompilerToVM::methods[] = {
|
|||
{CC "readArrayElement", CC "(" OBJECTCONSTANT "I)Ljava/lang/Object;", FN_PTR(readArrayElement)},
|
||||
{CC "arrayBaseOffset", CC "(Ljdk/vm/ci/meta/JavaKind;)I", FN_PTR(arrayBaseOffset)},
|
||||
{CC "arrayIndexScale", CC "(Ljdk/vm/ci/meta/JavaKind;)I", FN_PTR(arrayIndexScale)},
|
||||
{CC "getByte", CC "(" OBJECTCONSTANT "J)B", FN_PTR(getByte)},
|
||||
{CC "getShort", CC "(" OBJECTCONSTANT "J)S", FN_PTR(getShort)},
|
||||
{CC "getInt", CC "(" OBJECTCONSTANT "J)I", FN_PTR(getInt)},
|
||||
{CC "getLong", CC "(" OBJECTCONSTANT "J)J", FN_PTR(getLong)},
|
||||
{CC "getObject", CC "(" OBJECTCONSTANT "J)" OBJECTCONSTANT, FN_PTR(getObject)},
|
||||
{CC "deleteGlobalHandle", CC "(J)V", FN_PTR(deleteGlobalHandle)},
|
||||
{CC "registerNativeMethods", CC "(" CLASS ")[J", FN_PTR(registerNativeMethods)},
|
||||
{CC "isCurrentThreadAttached", CC "()Z", FN_PTR(isCurrentThreadAttached)},
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue