2554 lines
128 KiB
Rust
2554 lines
128 KiB
Rust
|
|
use crate::stackframe::StackFrame;
|
|
use crate::heap_area::ObjectReference;
|
|
use crate::heap_area::FieldValue;
|
|
use crate::jvm::wrap_stackframe_error;
|
|
use crate::stackframe::StackValue;
|
|
use crate::classfile::{ AbstractTypeDescription, AbstractTypeKind, MethodDescriptor };
|
|
use crate::native_registry::NativeMethodCallable;
|
|
use crate::jvm::JVM;
|
|
use crate::jvm::Error;
|
|
use crate::jvm::JVMCallbackOperation;
|
|
|
|
pub fn ignore_call(_: &mut JVM) -> Result<JVMCallbackOperation, Error> {
|
|
Ok(JVMCallbackOperation::PopFrame())
|
|
}
|
|
|
|
pub fn todo_call(_: &mut JVM) -> Result<JVMCallbackOperation, Error> {
|
|
todo!()
|
|
}
|
|
|
|
pub struct EntryPoint {}
|
|
|
|
impl EntryPoint {
|
|
pub fn populate_unsafe_constants(jvm: &mut JVM) -> Result<JVMCallbackOperation, Error> {
|
|
jvm.heap_area.static_area.set(&String::from("jdk/internal/misc/UnsafeConstants"), &String::from("ADDRESS_SIZE0"), FieldValue::Int(4))?; // objectreference use u32
|
|
|
|
jvm.heap_area.static_area.set(&String::from("jdk/internal/misc/UnsafeConstants"), &String::from("PAGE_SIZE"), FieldValue::Int(4096))?;
|
|
// TODO: Get actual page size
|
|
|
|
jvm.heap_area.static_area.set(&String::from("jdk/internal/misc/UnsafeConstants"), &String::from("BIG_ENDIAN"), FieldValue::Boolean(cfg!(target_endian = "big")))?;
|
|
|
|
// This is the safe version, TODO: Change it to the actual value
|
|
jvm.heap_area.static_area.set(&String::from("jdk/internal/misc/UnsafeConstants"), &String::from("UNALIGNED_ACCESS"), FieldValue::Boolean(false))?;
|
|
|
|
// This is the safe version, TODO: Change it to the actual value
|
|
jvm.heap_area.static_area.set(&String::from("jdk/internal/misc/UnsafeConstants"), &String::from("DATA_CACHE_LINE_FLUSH_SIZE"), FieldValue::Int(0))?;
|
|
|
|
Ok(JVMCallbackOperation::PopFrame())
|
|
}
|
|
}
|
|
|
|
struct JavaLangClass {}
|
|
|
|
impl JavaLangClass {
|
|
pub fn get_primitive_class(jvm: &mut JVM) -> Result<JVMCallbackOperation, Error> {
|
|
let frame = {
|
|
let frame_index = jvm.stack_frames.len() - 1;
|
|
&mut jvm.stack_frames[frame_index]
|
|
};
|
|
// max_locals: 1
|
|
// max_stack: 1
|
|
let class = jvm.class_store.class_file_from_idx(frame.class_index).unwrap();
|
|
let method = &class.methods[frame.method_index as usize];
|
|
let class_class_index = jvm.class_store.class_idx_from_name(&String::from("java/lang/Class")).unwrap();
|
|
let (string_class_file, string_class_index) = jvm.class_store.get_class(&String::from("java/lang/String")).unwrap();
|
|
let string_equals_index = string_class_file.find_method_index(&String::from("equals")).unwrap();
|
|
let passed_wanted_string = match frame.locals[0] {
|
|
StackValue::Reference(r) => r,
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
frame.instruction_pointer += 1;
|
|
|
|
match frame.instruction_pointer - 1 {
|
|
0 => {
|
|
let boolean_class_ref = jvm.class_store.primitive_classes.boolean_class;
|
|
let boolean_class_name_ref = match jvm.heap_area.object_area.get_object_field(
|
|
boolean_class_ref,
|
|
"name",
|
|
class_class_index,
|
|
&jvm.class_store
|
|
).unwrap() {
|
|
FieldValue::Reference(r) => r,
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
let string_compare_frame = StackFrame::new(
|
|
string_class_file,
|
|
string_class_index,
|
|
string_equals_index as u16,
|
|
&[StackValue::Reference(boolean_class_name_ref), StackValue::Reference(passed_wanted_string)],
|
|
);
|
|
|
|
Ok(JVMCallbackOperation::PushFrame(string_compare_frame))
|
|
}
|
|
|
|
1 => {
|
|
if wrap_stackframe_error(class, method, frame.operand_stack.pop_int(0))? == 1 {
|
|
let boolean_class_ref = jvm.class_store.primitive_classes.boolean_class;
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Reference(boolean_class_ref)))
|
|
} else {
|
|
let byte_class_ref = jvm.class_store.primitive_classes.byte_class;
|
|
let byte_class_name_ref = match jvm.heap_area.object_area.get_object_field(
|
|
byte_class_ref,
|
|
"name",
|
|
class_class_index,
|
|
&jvm.class_store
|
|
).unwrap() {
|
|
FieldValue::Reference(r) => r,
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
let string_compare_frame = StackFrame::new(
|
|
string_class_file,
|
|
string_class_index,
|
|
string_equals_index as u16,
|
|
&[StackValue::Reference(byte_class_name_ref), StackValue::Reference(passed_wanted_string)],
|
|
);
|
|
|
|
Ok(JVMCallbackOperation::PushFrame(string_compare_frame))
|
|
}
|
|
}
|
|
|
|
2 => {
|
|
if wrap_stackframe_error(class, method, frame.operand_stack.pop_int(0))? == 1 {
|
|
let char_class_ref = jvm.class_store.primitive_classes.char_class;
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Reference(char_class_ref)))
|
|
} else {
|
|
let char_class_ref = jvm.class_store.primitive_classes.char_class;
|
|
let char_class_name_ref = match jvm.heap_area.object_area.get_object_field(
|
|
char_class_ref,
|
|
"name",
|
|
class_class_index,
|
|
&jvm.class_store
|
|
).unwrap() {
|
|
FieldValue::Reference(r) => r,
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
let string_compare_frame = StackFrame::new(
|
|
string_class_file,
|
|
string_class_index,
|
|
string_equals_index as u16,
|
|
&[StackValue::Reference(char_class_name_ref), StackValue::Reference(passed_wanted_string)],
|
|
);
|
|
|
|
Ok(JVMCallbackOperation::PushFrame(string_compare_frame))
|
|
}
|
|
}
|
|
|
|
3 => {
|
|
if wrap_stackframe_error(class, method, frame.operand_stack.pop_int(0))? == 1 {
|
|
let short_class_ref = jvm.class_store.primitive_classes.short_class;
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Reference(short_class_ref)))
|
|
} else {
|
|
let short_class_ref = jvm.class_store.primitive_classes.short_class;
|
|
let short_class_name_ref = match jvm.heap_area.object_area.get_object_field(
|
|
short_class_ref,
|
|
"name",
|
|
class_class_index,
|
|
&jvm.class_store
|
|
).unwrap() {
|
|
FieldValue::Reference(r) => r,
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
let string_compare_frame = StackFrame::new(
|
|
string_class_file,
|
|
string_class_index,
|
|
string_equals_index as u16,
|
|
&[StackValue::Reference(short_class_name_ref), StackValue::Reference(passed_wanted_string)],
|
|
);
|
|
|
|
Ok(JVMCallbackOperation::PushFrame(string_compare_frame))
|
|
}
|
|
}
|
|
|
|
4 => {
|
|
if wrap_stackframe_error(class, method, frame.operand_stack.pop_int(0))? == 1 {
|
|
let int_class_ref = jvm.class_store.primitive_classes.int_class;
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Reference(int_class_ref)))
|
|
} else {
|
|
let int_class_ref = jvm.class_store.primitive_classes.int_class;
|
|
let int_class_name_ref = match jvm.heap_area.object_area.get_object_field(
|
|
int_class_ref,
|
|
"name",
|
|
class_class_index,
|
|
&jvm.class_store
|
|
).unwrap() {
|
|
FieldValue::Reference(r) => r,
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
let string_compare_frame = StackFrame::new(
|
|
string_class_file,
|
|
string_class_index,
|
|
string_equals_index as u16,
|
|
&[StackValue::Reference(int_class_name_ref), StackValue::Reference(passed_wanted_string)],
|
|
);
|
|
|
|
Ok(JVMCallbackOperation::PushFrame(string_compare_frame))
|
|
}
|
|
}
|
|
|
|
5 => {
|
|
if wrap_stackframe_error(class, method, frame.operand_stack.pop_int(0))? == 1 {
|
|
let float_class_ref = jvm.class_store.primitive_classes.float_class;
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Reference(float_class_ref)))
|
|
} else {
|
|
let float_class_ref = jvm.class_store.primitive_classes.float_class;
|
|
let float_class_name_ref = match jvm.heap_area.object_area.get_object_field(
|
|
float_class_ref,
|
|
"name",
|
|
class_class_index,
|
|
&jvm.class_store
|
|
).unwrap() {
|
|
FieldValue::Reference(r) => r,
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
let string_compare_frame = StackFrame::new(
|
|
string_class_file,
|
|
string_class_index,
|
|
string_equals_index as u16,
|
|
&[StackValue::Reference(float_class_name_ref), StackValue::Reference(passed_wanted_string)],
|
|
);
|
|
|
|
Ok(JVMCallbackOperation::PushFrame(string_compare_frame))
|
|
}
|
|
}
|
|
|
|
6 => {
|
|
if wrap_stackframe_error(class, method, frame.operand_stack.pop_int(0))? == 1 {
|
|
let double_class_ref = jvm.class_store.primitive_classes.double_class;
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Reference(double_class_ref)))
|
|
} else {
|
|
let double_class_ref = jvm.class_store.primitive_classes.double_class;
|
|
let double_class_name_ref = match jvm.heap_area.object_area.get_object_field(
|
|
double_class_ref,
|
|
"name",
|
|
class_class_index,
|
|
&jvm.class_store
|
|
).unwrap() {
|
|
FieldValue::Reference(r) => r,
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
let string_compare_frame = StackFrame::new(
|
|
string_class_file,
|
|
string_class_index,
|
|
string_equals_index as u16,
|
|
&[StackValue::Reference(double_class_name_ref), StackValue::Reference(passed_wanted_string)],
|
|
);
|
|
|
|
Ok(JVMCallbackOperation::PushFrame(string_compare_frame))
|
|
}
|
|
}
|
|
|
|
7 => {
|
|
if wrap_stackframe_error(class, method, frame.operand_stack.pop_int(0))? == 1 {
|
|
let long_class_ref = jvm.class_store.primitive_classes.long_class;
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Reference(long_class_ref)))
|
|
} else {
|
|
let long_class_ref = jvm.class_store.primitive_classes.long_class;
|
|
let long_class_name_ref = match jvm.heap_area.object_area.get_object_field(
|
|
long_class_ref,
|
|
"name",
|
|
class_class_index,
|
|
&jvm.class_store
|
|
).unwrap() {
|
|
FieldValue::Reference(r) => r,
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
let string_compare_frame = StackFrame::new(
|
|
string_class_file,
|
|
string_class_index,
|
|
string_equals_index as u16,
|
|
&[StackValue::Reference(long_class_name_ref), StackValue::Reference(passed_wanted_string)],
|
|
);
|
|
|
|
Ok(JVMCallbackOperation::PushFrame(string_compare_frame))
|
|
}
|
|
}
|
|
|
|
8 => {
|
|
if wrap_stackframe_error(class, method, frame.operand_stack.pop_int(0))? == 1 {
|
|
let long_class_ref = jvm.class_store.primitive_classes.long_class;
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Reference(long_class_ref)))
|
|
} else {
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Reference(ObjectReference::NULL)))
|
|
}
|
|
}
|
|
_ => Ok(JVMCallbackOperation::ReturnFrame(StackValue::Reference(ObjectReference::NULL)))
|
|
}
|
|
}
|
|
|
|
pub fn desired_assertion_status_0(_: &mut JVM) -> Result<JVMCallbackOperation, Error> {
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Int(1)))
|
|
}
|
|
}
|
|
|
|
struct JavaLangStringUTF16 {}
|
|
|
|
impl JavaLangStringUTF16 {
|
|
pub fn is_big_endian(_jvm: &mut JVM) -> Result<JVMCallbackOperation, Error> {
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Int(if cfg!(target_endian = "big") {1} else {0})))
|
|
}
|
|
}
|
|
|
|
struct JdkInternalMiscUnsafe {}
|
|
|
|
impl JdkInternalMiscUnsafe {
|
|
pub fn array_index_scale_0(jvm: &mut JVM) -> Result<JVMCallbackOperation, Error> {
|
|
let frame = {
|
|
let frame_index = jvm.stack_frames.len() - 1;
|
|
&mut jvm.stack_frames[frame_index]
|
|
};
|
|
let class = jvm.class_store.class_file_from_idx(frame.class_index).unwrap();
|
|
let method = & class.methods[frame.method_index as usize];
|
|
let class_class_index = jvm.class_store.class_idx_from_name(&String::from("java/lang/Class")).unwrap();
|
|
|
|
let class_reference = wrap_stackframe_error(class, method, frame.load_local_reference(1))?;
|
|
let component_class_reference = match jvm.heap_area.object_area.get_object_field(class_reference, "componentType", class_class_index, &jvm.class_store).unwrap() {
|
|
FieldValue::Reference(r) => r,
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
let index_scale: i32 = if component_class_reference == jvm.class_store.primitive_classes.boolean_class {
|
|
1
|
|
} else if component_class_reference == jvm.class_store.primitive_classes.byte_class {
|
|
1
|
|
} else if component_class_reference == jvm.class_store.primitive_classes.short_class {
|
|
2
|
|
} else if component_class_reference == jvm.class_store.primitive_classes.char_class {
|
|
2
|
|
} else if component_class_reference == jvm.class_store.primitive_classes.int_class {
|
|
4
|
|
} else if component_class_reference == jvm.class_store.primitive_classes.float_class {
|
|
4
|
|
} else if component_class_reference == jvm.class_store.primitive_classes.double_class {
|
|
8
|
|
} else if component_class_reference == jvm.class_store.primitive_classes.long_class {
|
|
8
|
|
} else {
|
|
std::mem::size_of::<usize>() as i32
|
|
};
|
|
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Int(index_scale)))
|
|
}
|
|
|
|
pub fn array_base_offset_0(jvm: &mut JVM) -> Result<JVMCallbackOperation, Error> {
|
|
// TODO: Check passed class
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Int(0)))
|
|
}
|
|
}
|
|
|
|
pub struct JdkInternalUtilSystemPropsRaw {}
|
|
|
|
impl JdkInternalUtilSystemPropsRaw {
|
|
pub fn platform_properties(jvm: &mut JVM) -> Result<JVMCallbackOperation, Error> {
|
|
let array_length = jvm.heap_area.static_area.
|
|
get(
|
|
&String::from("jdk/internal/util/SystemProps$Raw"),
|
|
&String::from("FIXED_LENGTH"),
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() })
|
|
.unwrap();
|
|
let array_length = match array_length {
|
|
FieldValue::Int(i) => i as usize,
|
|
_ => unreachable!()
|
|
};
|
|
|
|
let array_reference = jvm.heap_area.make_empty_array(&jvm.class_store, AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/String".into()) }, array_length);
|
|
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Reference(array_reference)))
|
|
}
|
|
|
|
// command-line configured properties, should return at least java.home
|
|
pub fn vm_properties(jvm: &mut JVM) -> Result<JVMCallbackOperation, Error> {
|
|
let array_length = 4;
|
|
let array_reference = jvm.heap_area.make_empty_array(&jvm.class_store, AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/String".into()) }, array_length);
|
|
|
|
{
|
|
// TODO: Actual java home path
|
|
let java_home_key_reference = jvm.heap_area.make_handmade_string(&String::from("java.home"), &jvm.class_store);
|
|
let java_home_value_reference = jvm.heap_area.make_handmade_string(&String::from("./"), &jvm.class_store);
|
|
|
|
jvm.heap_area.object_area.set_array_element(array_reference, 0, java_home_key_reference.into());
|
|
jvm.heap_area.object_area.set_array_element(array_reference, 1, java_home_value_reference.into());
|
|
}
|
|
|
|
Ok(JVMCallbackOperation::ReturnFrame(StackValue::Reference(array_reference)))
|
|
}
|
|
}
|
|
|
|
|
|
pub fn function_for(class_name: &str, m: &crate::classfile::MethodInfo) -> Result<NativeMethodCallable, Error> {
|
|
let method_name: &str = &m.name;
|
|
match (class_name, method_name) {
|
|
|
|
("java/lang/Class", "forName0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/String".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/ClassLoader".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname(String::from("java/lang/Class"))},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "desiredAssertionStatus0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(JavaLangClass::desired_assertion_status_0)
|
|
}
|
|
|
|
("java/lang/Class", "getClassAccessFlagsRaw0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getClassFileVersion0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getConstantPool") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("jdk/internal/reflect/ConstantPool".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getDeclaredClasses0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getDeclaredConstructors0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Classname("java/lang/reflect/Constructor".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getDeclaredFields0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Classname("java/lang/reflect/Field".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getDeclaredMethods0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Classname("java/lang/reflect/Method".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getDeclaringClass0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getEnclosingMethod0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getGenericSignature0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/String".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getInterfaces0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getNestMembers0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getModifiers") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getNestHost0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getPermittedSubclasses0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getPrimitiveClass") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/String".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(JavaLangClass::get_primitive_class)
|
|
}
|
|
|
|
("java/lang/Class", "getProtectionDomain0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/security/ProtectionDomain".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getRawAnnotations") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Byte() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getRawTypeAnnotations") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Byte() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getRecordComponents0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Classname("java/lang/reflect/RecordComponent".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getSimpleBinaryName0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/String".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getSigners") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "getSuperclass") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "isAssignableFrom") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "initClassName") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/String".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "isArray") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "isHidden") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "isInstance") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "isInterface") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "isPrimitive") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "isRecord0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Class", "registerNatives") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(ignore_call)
|
|
}
|
|
|
|
("java/lang/Class", "setSigners") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) }
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Float", "intBitsToFloat") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() }
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Float() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Float", "floatToRawIntBits") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Float() }
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/String", "intern") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname(String::from("java/lang/String"))},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/StringUTF16", "isBigEndian") => {
|
|
// until JDK 23
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(JavaLangStringUTF16::is_big_endian)
|
|
}
|
|
|
|
("java/lang/Object", "clone") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname(String::from("java/lang/Object"))},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Object", "getClass") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname(String::from("java/lang/Class"))},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Object", "hashCode") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Object", "notifyAll") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Object", "notify") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/Object", "wait0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/System", "arraycopy") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/System", "currentTimeMillis") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/System", "identityHashCode") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/System", "mapLibraryName") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/String".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/String".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/System", "nanoTime") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/System", "registerNatives") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(ignore_call)
|
|
}
|
|
|
|
("java/lang/System", "setIn0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/io/InputStream".to_string()) }
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/System", "setOut0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/io/PrintStream".to_string()) }
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("java/lang/System", "setErr0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/io/PrintStream".to_string()) }
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "arrayBaseOffset0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(JdkInternalMiscUnsafe::array_base_offset_0)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "arrayIndexScale0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(JdkInternalMiscUnsafe::array_index_scale_0)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "allocateInstance") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname(String::from("java/lang/Object"))},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "allocateMemory0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "copyMemory0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "copySwapMemory0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "freeMemory0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "reallocateMemory0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "setMemory0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Byte() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndSetBoolean") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndSetByte") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Byte() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Byte() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndSetChar") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Char() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Char() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndSetDouble") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Double() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Double() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndSetFloat") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Float() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Float() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndSetInt") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndSetLong") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndSetReference") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndSetShort") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Short() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Short() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndExchangeBoolean") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndExchangeByte") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Byte() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Byte() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Byte() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndExchangeChar") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Char() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Char() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Char() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndExchangeDouble") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Double() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Double() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Double() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndExchangeFloat") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Float() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Float() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Float() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndExchangeInt") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndExchangeLong") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndExchangeShort") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Short() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Short() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Short() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "compareAndExchangeReference") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname(String::from("java/lang/Object"))},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "defineClass0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/String".to_string()) },
|
|
AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Byte() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/ClassLoader".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/security/ProtectionDomain".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname(String::from("java/lang/Class"))},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "ensureClassInitialized0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "fullFence") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "getBooleanVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "getByteVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Byte()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "getCharVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Char()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "getFloatVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Float()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "getDoubleVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Double()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "getIntVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "getLongVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "getShortVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Short()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "getReferenceVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname(String::from("java/lang/Object"))},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "getBoolean") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "getByte") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Byte()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "getChar") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Char()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "getDouble") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Double()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "getFloat") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Float()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "getInt") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "getLoadAverage0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Double() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "getLong") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "getReference") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname(String::from("java/lang/Object"))},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "getShort") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Short()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "getUncompressedObject") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname(String::from("java/lang/Object"))},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "objectFieldOffset0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/reflect/Field".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "objectFieldOffset1") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/String".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "registerNatives") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(ignore_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "park") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "putBoolean") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putByte") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Byte() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putChar") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Char() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putDouble") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Double() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putFloat") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Float() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putInt") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putLong") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "putReference") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "putShort") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Short() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "putBooleanVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putByteVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Byte() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putCharVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Char() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putFloatVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Float() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putDoubleVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Double() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putIntVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Int() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putLongVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putShortVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Short() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
|
|
("jdk/internal/misc/Unsafe", "putReferenceVolatile") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "shouldBeInitialized0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Boolean() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "staticFieldOffset0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/reflect/Field".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "staticFieldOffset1") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Class".to_string()) },
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/String".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "staticFieldBase0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/reflect/Field".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
// This will require some changes in the future
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "unpark") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Object".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void() },
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "throwException") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Classname("java/lang/Throwable".to_string()) },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "writeback0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Long() },
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "writebackPostSync0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/misc/Unsafe", "writebackPreSync0") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 0, kind: AbstractTypeKind::Void()},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(todo_call)
|
|
}
|
|
|
|
("jdk/internal/util/SystemProps$Raw", "platformProperties") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Classname("java/lang/String".to_string())},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(JdkInternalUtilSystemPropsRaw::platform_properties)
|
|
}
|
|
|
|
("jdk/internal/util/SystemProps$Raw", "vmProperties") => {
|
|
let expected_descriptor = MethodDescriptor {
|
|
argument_types: Box::new([
|
|
]),
|
|
return_type: AbstractTypeDescription { array_level: 1, kind: AbstractTypeKind::Classname("java/lang/String".to_string())},
|
|
};
|
|
|
|
if m.descriptor != expected_descriptor {
|
|
return Err(Error::RunTimeError(format!("Native descriptor mismatch for method '{class_name}.{method_name}': found '{}' but expected '{}'", m.descriptor.source_string(), expected_descriptor.source_string())));
|
|
}
|
|
|
|
Ok(JdkInternalUtilSystemPropsRaw::vm_properties)
|
|
}
|
|
|
|
|
|
_ => Err(Error::RunTimeError(format!("Failed to find native implementation for method '{class_name}.{method_name}'"))),
|
|
}
|
|
}
|