VegOwOtenks/jvm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

I can't even describe my disappointment at interfaces

Browse source
This commit is contained in:
VegOwOtenks 2024-09-11 00:02:48 +02:00
parent d7d159d115
commit 9190d3f7e7
4 changed files with 116 additions and 15 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/bytecode.rs
View file

@ -207,6 +207,7 @@ impl Bytecode {
0xB6 => (Instruction::InvokeVirtual((self.bytes[offset+1] as u16) << 8 | self.bytes[offset+2] as u16), 3),
0xB7 => (Instruction::InvokeSpecial((self.bytes[offset+1] as u16) << 8 | self.bytes[offset+2] as u16), 3),
0xB8 => (Instruction::InvokeStatic((self.bytes[offset+1] as u16) << 8 | self.bytes[offset+2] as u16), 3),
0xB9 => (Instruction::InvokeInterface((self.bytes[offset+1] as u16) << 8 | self.bytes[offset+2] as u16), 3),
0xBA => (Instruction::InvokeDynamic((self.bytes[offset+1] as u16) << 8 | self.bytes[offset+2] as u16, (self.bytes[offset+3] as u16) << 8 | self.bytes[offset+4] as u16), 5),
0xBB => (Instruction::NewObject((self.bytes[offset+1] as u16) << 8 | self.bytes[offset+2] as u16), 3),
0xBC => (Instruction::NewPrimitiveArray(self.bytes[offset+1]), 2),
@ -363,6 +364,7 @@ pub enum Instruction {
InvokeVirtual(u16) = 0xB6, // invoke function on a class
InvokeSpecial(u16) = 0xB7, // invoke instance method
InvokeStatic(u16) = 0xB8, // invoke static function
InvokeInterface(u16) = 0xB9, // invoke interface function
InvokeDynamic(u16, u16) = 0xBA, // invoke dynamic function
NewObject(u16) = 0xBB, // Create a new object from a constant-pool class reference
NewPrimitiveArray(u8) = 0xBC, // make a primitive array

33
src/classfile.rs
View file

@ -5,7 +5,7 @@ use core::str::Utf8Error;
use crate::accessmasks::*;
use crate::bytecode::Bytecode;
use crate::constantpool::{ ConstantFieldRefInfo, ConstantPoolInfo, ConstantUtf8Info, ConstantStringInfo, ConstantMethodRefInfo, ConstantFloatInfo, ConstantClassInfo, ConstantNameAndTypeInfo, ConstantIntegerInfo, ConstantLongInfo };
use crate::constantpool::{ ConstantFieldRefInfo, ConstantPoolInfo, ConstantUtf8Info, ConstantInterfaceMethodRefInfo, ConstantStringInfo, ConstantMethodRefInfo, ConstantFloatInfo, ConstantClassInfo, ConstantNameAndTypeInfo, ConstantIntegerInfo, ConstantLongInfo };
#[derive(Debug)]
pub enum Error {
@ -206,6 +206,17 @@ impl JavaClassFile {
return pool_entry(&self.constant_pool, index);
}
pub fn pool_interfacemethodref_entry(&self, index: u16) -> Result<&ConstantInterfaceMethodRefInfo, Error> {
let pool_entry = self.pool_entry(index)?;
let methodref_entry = match pool_entry {
ConstantPoolInfo::InterfaceMethodRef(data) => data,
_ => unreachable!(),
};
return Ok(methodref_entry);
}
pub fn pool_methodref_entry(&self, index: u16) -> Result<&ConstantMethodRefInfo, Error> {
let pool_entry = self.pool_entry(index)?;
@ -329,6 +340,19 @@ impl JavaClassFile {
Ok(class_name)
}
pub fn gather_interfacemethodref(&self, index: u16) -> Result<(&String, &String, &String), Error> {
let methodref = self.pool_interfacemethodref_entry(index)?;
let class_entry = self.pool_class_entry(methodref.class_index)?;
let class_name_entry = self.pool_utf8_entry(class_entry.name_index)?;
let name_and_type_entry = self.pool_nameandtype_entry(methodref.name_and_type_index)?;
let class_name = &class_name_entry.utf8;
let method_name = &self.pool_utf8_entry(name_and_type_entry.name_index)?.utf8;
let method_descriptor = &self.pool_utf8_entry(name_and_type_entry.descriptor_index)?.utf8;
return Ok((class_name, method_name, method_descriptor));
}
pub fn gather_methodref(&self, index: u16) -> Result<(&String, &String, &String), Error> {
let methodref = self.pool_methodref_entry(index)?;
let class_entry = self.pool_class_entry(methodref.class_index)?;
@ -886,6 +910,13 @@ impl AbstractTypeDescription {
return Ok((offset, AbstractTypeDescription { array_level, kind }))
}
pub fn for_class_name(name: &str) -> Self {
AbstractTypeDescription {
array_level: 0,
kind: AbstractTypeKind::Classname(name.to_string()),
}
}
}
#[derive(Debug, Eq, PartialEq)]

1
src/heap_area.rs
View file

@ -256,6 +256,7 @@ impl ObjectArea {
match self.get_entry(reference) {
CompartmentEntry::Object(o) => class_store.get_class_objectref_from_index(o.class_index),
CompartmentEntry::ReferenceArray(a) => a.class_ref,
CompartmentEntry::ByteArray(a) => a.class_ref,
_ => unreachable!(),
}
}

79
src/jvm.rs
View file

@ -841,16 +841,22 @@ impl JVM {
Instruction::CheckCast(classref_index) => {
// TODO: Class loading checks
let class_name = class.gather_class(classref_index)?;
let object = wrap_stackframe_error(class, method, frame.operand_stack.pop_reference(0))?;
let native_class_name = self.heap_area.object_area.get_reference_native_class_name(object, &self.class_store);
let instruction_result = if class_name == native_class_name {
1
} else {
let class_index = self.class_store.class_idx_from_name(class_name).unwrap();
let class_object_ref = self.class_store.get_class_objectref_from_index(class_index);
let native_class_description = self.heap_area.object_area.get_class_ref_native_class_name(class_object_ref, &self.class_store);
let class_description = AbstractTypeDescription::parse_full(native_class_description)?;
let object = wrap_stackframe_error(class, method, frame.operand_stack.pop_reference(0))?;
let native_class_name = self.heap_area.object_area.get_reference_native_class_name(object, &self.class_store);
let object_description = AbstractTypeDescription::parse_full(native_class_name)?;
if self.class_store.are_types_compatible(&object_description, &class_description) { 1 } else { 0 }
};
if ! self.class_store.are_types_compatible(&object_description, &class_description) {
if instruction_result == 0 {
// TODO: Throw Exception
return Err(Error::RunTimeError(format!("Trying to cast an object of type {native_class_name} to {class_name}")))
}
@ -979,20 +985,81 @@ impl JVM {
Instruction::InstanceOf(classref_index) => {
// TODO: Class loading checks
let class_name = class.gather_class(classref_index)?;
let object = wrap_stackframe_error(class, method, frame.operand_stack.pop_reference(0))?;
let native_class_name = self.heap_area.object_area.get_reference_native_class_name(object, &self.class_store);
let instruction_result = if class_name == native_class_name {
1
} else {
let class_index = self.class_store.class_idx_from_name(class_name).unwrap();
let class_object_ref = self.class_store.get_class_objectref_from_index(class_index);
let native_class_description = self.heap_area.object_area.get_class_ref_native_class_name(class_object_ref, &self.class_store);
let class_description = AbstractTypeDescription::parse_full(native_class_description)?;
let object = wrap_stackframe_error(class, method, frame.operand_stack.pop_reference(0))?;
let native_class_name = self.heap_area.object_area.get_reference_native_class_name(object, &self.class_store);
let object_description = AbstractTypeDescription::parse_full(native_class_name)?;
if self.class_store.are_types_compatible(&object_description, &class_description) { 1 } else { 0 }
};
let instruction_result = if self.class_store.are_types_compatible(&object_description, &class_description) { 1 } else { 0 };
wrap_stackframe_error(class, method, frame.operand_stack.push(StackValue::Int(instruction_result)))?;
}
Instruction::InvokeInterface(methodref_index) => {
let (supplied_interface_name, supplied_method_name, supplied_descriptor_string) = class.gather_interfacemethodref(methodref_index)?;
if ! self.class_store.have_class(supplied_interface_name) {
frame.instruction_pointer -= offset as u32;
return Ok(JVMCallbackOperation::LoadClass(supplied_interface_name.to_string()));
}
if ! self.class_store.was_init(supplied_interface_name).unwrap() {
frame.instruction_pointer -= offset as u32;
return Ok(JVMCallbackOperation::InitClass(supplied_interface_name.to_string()));
}
let target_interface_class_index = self.class_store.class_idx_from_name(supplied_interface_name).unwrap();
let parsed_expected_descriptor: MethodDescriptor = MethodDescriptor::try_from(supplied_descriptor_string)?;
let (class_index, method_index, method_info) = match ClassMethodIterator::new(target_interface_class_index, &self.class_store)
.filter(|(_cid, _mid, minfo)| minfo.name == *supplied_method_name)
.filter(|(_cid, _mid, minfo)| minfo.descriptor == parsed_expected_descriptor)
.next() {
Some(m) => m,
None => {
// TODO: Throw exception
return Err(Error::RunTimeError(format!("InvokeInterface: Failed to find requested method '{}' with descriptor '{}' in the class '{}'", supplied_method_name, supplied_descriptor_string, supplied_interface_name)));
}
};
let mut arguments = VecDeque::new();
fill_arguments(class, method, &mut arguments, &method_info.descriptor.argument_types, &mut frame.operand_stack)?;
let this_object = wrap_stackframe_error(class, method, frame.operand_stack.pop_reference(0))?;
arguments.push_front(StackValue::Reference(this_object));
let object_class_index = self.heap_area.object_area.get_object_class_index(this_object);
let object_class_file = self.class_store.class_file_from_idx(object_class_index).unwrap();
let object_class_name = object_class_file.get_classname().unwrap();
if object_class_name != supplied_interface_name {
let object_class_description = AbstractTypeDescription::for_class_name(object_class_name);
let supplied_interface_description = AbstractTypeDescription::for_class_name(supplied_interface_name);
if ! self.class_store.are_types_compatible(&object_class_description, &supplied_interface_description) {
return Err(Error::RunTimeError(format!("Tried to invoke interface method : '{supplied_interface_name}.{supplied_method_name}' on object of type '{object_class_name}'")));
}
}
// TODO: I hate this, now I have to find the 'implementation' of a function
let interface_class_file = self.class_store.class_file_from_idx(target_interface_class_index).unwrap();
let interface_frame = StackFrame::new(
interface_class_file,
target_interface_class_index,
method_index as u16,
arguments.make_contiguous()
);
return Ok(JVMCallbackOperation::PushFrame(interface_frame));
}
Instruction::InvokeSpecial(methodref_index) => {
// No instance-based dispatch
let (supplied_class_name, supplied_method_name, supplied_descriptor_string) = class.gather_methodref(methodref_index)?;