jessebrault/deimos-lang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Properly implement load and store instructions.

Browse Source
This commit is contained in:
Jesse Brault 2024-12-28 15:10:56 -06:00
parent 376ac2fa3a
commit 420db38f70
9 changed files with 176 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
src/bin/dvm/main.rs
View File

@ -2,7 +2,7 @@ use deimos::vm::dm_type::DmType;
use deimos::vm::lib::{DmConstant, DmLib}; use deimos::vm::lib::{DmConstant, DmLib};
use deimos::vm::object_type::{DmField, DmFn, DmImplementation, DmInterface, DmMethod}; use deimos::vm::object_type::{DmField, DmFn, DmImplementation, DmInterface, DmMethod};
use deimos::vm::op_codes::{ use deimos::vm::op_codes::{
add_alloc, add_invoke_fn, add_mov_const, add_mov_register_to, add_platform_call, add_alloc, add_dealloc, add_invoke_fn, add_mov_const, add_platform_call, add_store,
}; };
use deimos::vm::platform::init_platform_functions; use deimos::vm::platform::init_platform_functions;
use deimos::vm::{call_fn, DvmContext, DvmState}; use deimos::vm::{call_fn, DvmContext, DvmState};
@ -28,9 +28,9 @@ fn main() {
Some(array_int_rc.clone()), Some(array_int_rc.clone()),
); );
let array_impl_ptr_address_fld = DmField::new("ptr_address", DmType::USize, 0); let array_impl_ptr_address_fld = DmField::new("ptr_address", DmType::USize);
let array_impl_ptr_size_fld = DmField::new("ptr_size", DmType::USize, 8); let array_impl_ptr_size_fld = DmField::new("ptr_size", DmType::USize);
let array_impl_length_fld = DmField::new("length", DmType::Long, 16); let array_impl_length_fld = DmField::new("length", DmType::Long);
array_impl.fields.push(array_impl_ptr_address_fld); array_impl.fields.push(array_impl_ptr_address_fld);
array_impl.fields.push(array_impl_ptr_size_fld); array_impl.fields.push(array_impl_ptr_size_fld);
@ -44,9 +44,9 @@ fn main() {
// ) // )
let mut array_impl_ctor_0_bytecode: Vec<u8> = Vec::new(); let mut array_impl_ctor_0_bytecode: Vec<u8> = Vec::new();
add_mov_register_to(&mut array_impl_ctor_0_bytecode, 0, 0, 1); add_store(&mut array_impl_ctor_0_bytecode, 0, 0, 1);
add_mov_register_to(&mut array_impl_ctor_0_bytecode, 0, 8, 2); add_store(&mut array_impl_ctor_0_bytecode, 0, 1, 2);
add_mov_register_to(&mut array_impl_ctor_0_bytecode, 0, 16, 3); add_store(&mut array_impl_ctor_0_bytecode, 0, 2, 3);
let array_impl_ctor_0_fn = DmFn::new( let array_impl_ctor_0_fn = DmFn::new(
"std::core::ArrayImpl::_ctor_0", "std::core::ArrayImpl::_ctor_0",
@ -70,7 +70,7 @@ fn main() {
let mut string_impl = DmImplementation::new("std::core::StringImpl", "StringImpl", None); let mut string_impl = DmImplementation::new("std::core::StringImpl", "StringImpl", None);
let bytes_field = DmField::new("bytes", DmType::Object, 0); let bytes_field = DmField::new("bytes", DmType::Object);
string_impl.fields.push(bytes_field); string_impl.fields.push(bytes_field);
// std::core::String::_ctor_0( // std::core::String::_ctor_0(
@ -78,7 +78,7 @@ fn main() {
// r1: Array<Byte> bytes // r1: Array<Byte> bytes
// ) // )
let mut string_ctor_0_bytecode: Vec<u8> = Vec::new(); let mut string_ctor_0_bytecode: Vec<u8> = Vec::new();
add_mov_register_to(&mut string_ctor_0_bytecode, 0, 0, 1); add_store(&mut string_ctor_0_bytecode, 0, 0, 1);
let string_ctor_0_fn = DmFn::new( let string_ctor_0_fn = DmFn::new(
"std::core::StringImpl::_ctor_0", "std::core::StringImpl::_ctor_0",
@ -91,7 +91,6 @@ fn main() {
let string_ctor_0_method = DmMethod::new(string_ctor_0_fn, None); let string_ctor_0_method = DmMethod::new(string_ctor_0_fn, None);
string_impl.methods.push(Rc::new(string_ctor_0_method)); string_impl.methods.push(Rc::new(string_ctor_0_method));
let core_string_impl_size = string_impl.size_in_bytes();
string_lib.interfaces.push(Rc::new(string_int)); string_lib.interfaces.push(Rc::new(string_int));
string_lib.implementations.push(Rc::new(string_impl)); string_lib.implementations.push(Rc::new(string_impl));
@ -110,12 +109,7 @@ fn main() {
add_mov_const(&mut main_byte_code, 0, 1, "greeting", 0); add_mov_const(&mut main_byte_code, 0, 1, "greeting", 0);
// Alloc Array<Byte> greeting bytes // Alloc Array<Byte> greeting bytes
add_alloc( add_alloc(&mut main_byte_code, 2, "std::core::ArrayImpl");
&mut main_byte_code,
2,
array_impl_rc.size_in_bytes() as u32,
"std::core::ArrayImpl",
);
// Call ArrayImpl(ptr_address, ptr_size, length) // Call ArrayImpl(ptr_address, ptr_size, length)
add_invoke_fn( add_invoke_fn(
@ -126,12 +120,7 @@ fn main() {
); );
// Alloc StringImpl greeting // Alloc StringImpl greeting
add_alloc( add_alloc(&mut main_byte_code, 4, "std::core::StringImpl");
&mut main_byte_code,
4,
core_string_impl_size as u32,
"std::core::StringImpl",
);
// Call StringImpl(greeting_bytes) // Call StringImpl(greeting_bytes)
add_invoke_fn( add_invoke_fn(
@ -144,6 +133,12 @@ fn main() {
// Call println(greeting) // Call println(greeting)
add_platform_call(&mut main_byte_code, "std::core::println", 6, &[4]); add_platform_call(&mut main_byte_code, "std::core::println", 6, &[4]);
// Dealloc StringImpl
add_dealloc(&mut main_byte_code, 4);
// Dealloc ArrayImpl
add_dealloc(&mut main_byte_code, 2);
let main_dm_fn = DmFn::new("main", "main", main_byte_code, 7, None); let main_dm_fn = DmFn::new("main", "main", main_byte_code, 7, None);
greeting_lib.functions.push(Rc::new(main_dm_fn)); greeting_lib.functions.push(Rc::new(main_dm_fn));

2
src/vm/dm_type.rs
View File

@ -7,7 +7,6 @@ pub enum DmType {
Boolean, Boolean,
Object, Object,
USize, USize,
Unit,
} }
impl DmType { impl DmType {
@ -20,7 +19,6 @@ impl DmType {
DmType::Boolean => size_of::<bool>(), DmType::Boolean => size_of::<bool>(),
DmType::Object => size_of::<usize>(), DmType::Object => size_of::<usize>(),
DmType::USize => size_of::<usize>(), DmType::USize => size_of::<usize>(),
DmType::Unit => todo!("Need to determine size of Unit... is it dependent on the size of the thing which is Unit?")
} }
} }
} }

7
src/vm/dvm_value.rs
View File

@ -31,6 +31,13 @@ impl DvmValue {
} }
} }
pub fn is_object(&self) -> bool {
match self {
DvmValue::Object(_) => true,
_ => false,
}
}
pub fn expect_usize(&self) -> usize { pub fn expect_usize(&self) -> usize {
if let DvmValue::USize(u) = self { if let DvmValue::USize(u) = self {
*u *u

122
src/vm/mem.rs
View File

@ -1,70 +1,86 @@
use crate::vm::dm_type::DmType; use crate::vm::dm_type::DmType;
use crate::vm::dvm_value::DvmValue; use crate::vm::dvm_value::DvmValue;
use crate::vm::object::DvmObject; use crate::vm::object::DvmObject;
use crate::vm::object_type::DmField;
use std::rc::Rc; use std::rc::Rc;
pub unsafe fn get_field_value(dm_field: &DmField, self_object: &DvmObject) -> DvmValue { unsafe fn read_field(data_pointer: *const u8, dm_type: &DmType) -> DvmValue {
let data_size = dm_field.dm_type().size_in_bytes(); match dm_type {
let mut raw_data: Vec<u8> = Vec::with_capacity(data_size); DmType::Byte => DvmValue::Byte(data_pointer.read()),
for i in dm_field.data_offset()..(dm_field.data_offset() + data_size) { DmType::Int => DvmValue::Int(data_pointer.cast::<i32>().read()),
raw_data.push(self_object.data.offset(i as isize).read()); DmType::Long => DvmValue::Long(data_pointer.cast::<i64>().read()),
} DmType::USize => DvmValue::USize(data_pointer.cast::<usize>().read()),
match dm_field.dm_type() { DmType::Double => DvmValue::Double(data_pointer.cast::<f64>().read()),
DmType::Byte => DvmValue::Byte(raw_data[0]), DmType::Boolean => DvmValue::Boolean(data_pointer.cast::<bool>().read()),
DmType::Int => DvmValue::Int(i32::from_ne_bytes( DmType::Object => DvmValue::Object(data_pointer.cast::<Rc<DvmObject>>().read()),
raw_data[0..data_size].try_into().unwrap(),
)),
DmType::Long => DvmValue::Long(i64::from_ne_bytes(
raw_data[0..data_size].try_into().unwrap(),
)),
DmType::Double => DvmValue::Double(f64::from_ne_bytes(
raw_data[0..data_size].try_into().unwrap(),
)),
DmType::Boolean => DvmValue::Boolean(raw_data[0] != 0),
DmType::Object => {
// read the pointer's (address) value
let address = usize::from_ne_bytes(raw_data[0..data_size].try_into().unwrap());
DvmValue::Object(Rc::from_raw(address as *const DvmObject))
}
DmType::USize => DvmValue::USize(usize::from_ne_bytes(
raw_data[0..data_size].try_into().unwrap(),
)),
DmType::Unit => DvmValue::Uninit,
} }
} }
macro_rules! read_array { pub fn read_field_by_name(field_name: &str, self_object: &DvmObject) -> DvmValue {
( $T: ty, $raw_data: expr, $length: expr ) => {{ let (field_index, field) = self_object
let t_size = size_of::<$T>(); .implementation()
let mut arr: Vec<$T> = Vec::with_capacity($length); .fields
for i in 0..$length { .iter()
arr.push(<$T>::from_ne_bytes( .enumerate()
$raw_data[(i * t_size)..(i * t_size + t_size)] .find(|(_index, field)| field.name() == field_name)
.try_into() .expect(&format!(
.unwrap(), "Cannot find field {} in {}",
)) field_name,
} self_object.implementation().fqn
arr ));
}}; let data_pointer = self_object.data()[field_index];
unsafe { read_field(data_pointer, field.dm_type()) }
} }
fn read_i32_array(raw_data: &Vec<u8>, length: usize) -> Vec<i32> { pub fn read_field_by_index(index: usize, self_object: &DvmObject) -> DvmValue {
read_array!(i32, raw_data, length) let field = &self_object.implementation().fields[index];
let data_pointer = self_object.data()[index];
unsafe { read_field(data_pointer, field.dm_type()) }
} }
fn read_i64_array(raw_data: &Vec<u8>, length: usize) -> Vec<i64> { unsafe fn write_field(data_pointer: *mut u8, value: DvmValue) {
read_array!(i64, raw_data, length) match value {
DvmValue::Byte(b) => {
data_pointer.write(b);
}
DvmValue::Int(i) => {
data_pointer.cast::<i32>().write(i);
}
DvmValue::Long(l) => {
data_pointer.cast::<i64>().write(l);
}
DvmValue::USize(u) => {
data_pointer.cast::<usize>().write(u);
}
DvmValue::Double(d) => {
data_pointer.cast::<f64>().write(d);
}
DvmValue::Boolean(b) => {
data_pointer.cast::<bool>().write(b);
}
DvmValue::Object(o) => {
data_pointer.cast::<Rc<DvmObject>>().write(o);
}
DvmValue::Uninit => panic!("Cannot write DvmValue::Uninit to field."),
DvmValue::Void => panic!("Cannot write DvmValue::Void to field."),
}
} }
fn read_f64_array(raw_data: &Vec<u8>, length: usize) -> Vec<f64> { pub fn write_field_by_name(field_name: &str, self_object: &DvmObject, value: DvmValue) {
read_array!(f64, raw_data, length) let field_index = self_object
.implementation()
.fields
.iter()
.position(|field| field.name() == field_name)
.expect(&format!(
"Cannot find field {} in {}",
field_name,
self_object.implementation().fqn
));
let data_pointer = self_object.data()[field_index];
unsafe { write_field(data_pointer, value) };
} }
fn read_bool_array(raw_data: &Vec<u8>) -> Vec<bool> { pub fn write_field_by_index(index: usize, self_object: &DvmObject, value: DvmValue) {
raw_data.iter().map(|b| *b == 1).collect() let data_pointer = self_object.data()[index];
} unsafe { write_field(data_pointer, value) };
fn read_usize_array(raw_data: &Vec<u8>, length: usize) -> Vec<usize> {
read_array!(usize, raw_data, length)
} }

174
src/vm/mod.rs
View File

@ -11,6 +11,7 @@ pub mod util;
use crate::vm::dvm_value::DvmValue; use crate::vm::dvm_value::DvmValue;
use crate::vm::lib::{DmConstant, DmLib}; use crate::vm::lib::{DmConstant, DmLib};
use crate::vm::mem::{read_field_by_index, write_field_by_index};
use crate::vm::object::DvmObject; use crate::vm::object::DvmObject;
use crate::vm::object_type::DmFn; use crate::vm::object_type::DmFn;
use op_codes::*; use op_codes::*;
@ -294,10 +295,10 @@ pub fn run_byte_code(state: &mut DvmState, context: &DvmContext, byte_code: &[u8
let source_value = state.registers.get(source_register).unwrap(); let source_value = state.registers.get(source_register).unwrap();
state.registers[target_register] = source_value.clone(); state.registers[target_register] = source_value.clone();
} }
LOAD_OBJECT => { LOAD => {
let target_register = next_8!(iter, usize); let target_register = next_8!(iter, usize);
let source_register = next_8!(iter, usize); let source_register = next_8!(iter, usize);
let offset = next_usize_le!(iter); let source_object_field_index = next_usize_le!(iter);
let source_object = state let source_object = state
.registers .registers
@ -305,17 +306,15 @@ pub fn run_byte_code(state: &mut DvmState, context: &DvmContext, byte_code: &[u8
.unwrap() .unwrap()
.expect_object(); .expect_object();
let object = state.registers[target_register] =
unsafe { Rc::from_raw(source_object.data.add(offset).cast::<DvmObject>()) }; read_field_by_index(source_object_field_index, &source_object);
state.registers[target_register] = DvmValue::Object(object);
} }
STORE => { STORE => {
let target_register = next_8!(iter, usize); let target_register = next_8!(iter, usize);
let offset = next_usize_le!(iter); let target_object_field_index = next_usize_le!(iter);
let source_register = next_8!(iter, usize); let source_register = next_8!(iter, usize);
let target_alloc_object = state let target_object = state
.registers .registers
.get(target_register) .get(target_register)
.unwrap() .unwrap()
@ -323,45 +322,10 @@ pub fn run_byte_code(state: &mut DvmState, context: &DvmContext, byte_code: &[u8
let source_value = let source_value =
std::mem::replace(&mut state.registers[source_register], DvmValue::Uninit); std::mem::replace(&mut state.registers[source_register], DvmValue::Uninit);
write_field_by_index(target_object_field_index, &target_object, source_value);
match source_value {
DvmValue::Int(i) => {
write_bytes!(target_alloc_object.data, offset, i.to_ne_bytes());
}
DvmValue::Byte(b) => unsafe {
target_alloc_object.data.add(offset).write(b);
},
DvmValue::Long(l) => {
write_bytes!(target_alloc_object.data, offset, l.to_ne_bytes());
}
DvmValue::Double(d) => {
write_bytes!(target_alloc_object.data, offset, d.to_ne_bytes());
}
DvmValue::Boolean(b) => unsafe {
target_alloc_object.data.add(offset).write(b as u8);
},
DvmValue::Object(source_object) => {
let source_object_ptr = Rc::into_raw(source_object);
write_bytes!(
target_alloc_object.data,
offset,
(source_object_ptr as usize).to_ne_bytes()
);
}
DvmValue::USize(u) => {
write_bytes!(target_alloc_object.data, offset, u.to_ne_bytes());
}
DvmValue::Uninit => {
panic!("Cannot store DvmValue::Uninit to object.")
}
DvmValue::Void => {
panic!("Cannot store DvmValue::Void to object.")
}
}
} }
ALLOC => { ALLOC => {
let target_register = next_8!(iter, usize); let target_register = next_8!(iter, usize);
let alloc_size = next_32_le!(iter, usize);
let impl_name = read_string!(iter); let impl_name = read_string!(iter);
let implementation = context let implementation = context
@ -374,86 +338,19 @@ pub fn run_byte_code(state: &mut DvmState, context: &DvmContext, byte_code: &[u8
}) })
.expect(&format!("Implementation not found: {}", impl_name)); .expect(&format!("Implementation not found: {}", impl_name));
let dm_alloc_object = DvmObject::new(alloc_size, implementation.clone()); let dm_alloc_object = DvmObject::new(implementation.clone());
state.registers[target_register] = DvmValue::Object(Rc::new(dm_alloc_object)); state.registers[target_register] = DvmValue::Object(Rc::new(dm_alloc_object));
} }
DEALLOC => { DEALLOC => {
let target_register = next_8!(iter, usize); let target_register = next_8!(iter, usize);
let dm_alloc_object = state let dvm_object = state
.registers .registers
.get(target_register) .get(target_register)
.unwrap() .unwrap()
.expect_object(); .expect_object();
drop(dm_alloc_object); // explicit drop(dvm_object); // explicit
state.registers[target_register] = DvmValue::Uninit; state.registers[target_register] = DvmValue::Uninit;
} }
MOV_INT_TO => {
let target_register = next_8!(iter, usize);
let offset = next_32_le!(iter, usize);
let operand = next_32_le!(iter, u32) as i32;
let dm_alloc_object = state
.registers
.get(target_register)
.unwrap()
.expect_object();
write_bytes!(dm_alloc_object.data, offset, operand.to_ne_bytes());
}
MOV_LONG_TO => {
todo!()
}
MOV_DOUBLE_TO => {
todo!()
}
MOV_REGISTER_TO => {
// Moves the value from the source register to the object pointed to by the target
// register, at the given offset.
let target_register = next_8!(iter, usize);
let offset = next_32_le!(iter, usize);
let source_register = next_8!(iter, usize);
let target_alloc_object = state
.registers
.get(target_register)
.unwrap()
.expect_object();
let source_value = state.registers.get(source_register).unwrap();
match source_value {
DvmValue::Int(i) => {
write_bytes!(target_alloc_object.data, offset, i.to_ne_bytes());
}
DvmValue::Byte(b) => unsafe {
target_alloc_object.data.add(offset).write(*b);
},
DvmValue::Long(l) => {
write_bytes!(target_alloc_object.data, offset, l.to_ne_bytes());
}
DvmValue::Double(d) => {
write_bytes!(target_alloc_object.data, offset, d.to_ne_bytes());
}
DvmValue::Boolean(b) => unsafe {
target_alloc_object.data.add(offset).write(*b as u8);
},
DvmValue::Object(source_object) => {
let source_object_ptr = Rc::into_raw(source_object.clone());
write_bytes!(
target_alloc_object.data,
offset,
(source_object_ptr as usize).to_ne_bytes()
);
}
DvmValue::USize(us) => {
write_bytes!(target_alloc_object.data, offset, us.to_ne_bytes());
}
DvmValue::Uninit => {
panic!("Cannot move DvmValue::Uninit to object.")
}
DvmValue::Void => {
panic!("Cannot move DvmValue::Void to object.")
}
}
}
MOV_CONST => { MOV_CONST => {
// Decode // Decode
let address_register = next_8!(iter, usize); let address_register = next_8!(iter, usize);
@ -565,7 +462,7 @@ pub fn run_byte_code(state: &mut DvmState, context: &DvmContext, byte_code: &[u8
let self_obj = args.get(0).unwrap().expect_object(); let self_obj = args.get(0).unwrap().expect_object();
let method = self_obj let method = self_obj
.implementation .implementation()
.get_method(&symbol_name, &self_obj) .get_method(&symbol_name, &self_obj)
.expect(&format!("Could not find method: {}", symbol_name)); .expect(&format!("Could not find method: {}", symbol_name));
let dm_fn = method.dm_fn(); let dm_fn = method.dm_fn();
@ -604,13 +501,17 @@ mod run_code_tests {
}; };
} }
fn setup() -> (DvmState, DvmContext) { fn setup(number_of_registers: usize) -> (DvmState, DvmContext) {
(DvmState::new(), DvmContext::new()) let mut state = DvmState::new();
state
.registers
.resize(number_of_registers, DvmValue::Uninit);
(state, DvmContext::new())
} }
fn impl_with_object_field() -> DmImplementation { fn impl_with_object_field() -> DmImplementation {
let mut dm_impl = DmImplementation::new("ImplWithObjectField", "ImplWithObjectField", None); let mut dm_impl = DmImplementation::new("ImplWithObjectField", "ImplWithObjectField", None);
let object_field = DmField::new("object_field", DmType::Object, 0); let object_field = DmField::new("object_field", DmType::Object);
dm_impl.fields.push(object_field); dm_impl.fields.push(object_field);
dm_impl dm_impl
} }
@ -619,7 +520,7 @@ mod run_code_tests {
fn mov_1_as_int() { fn mov_1_as_int() {
let mut code = Vec::new(); let mut code = Vec::new();
add_mov_int(&mut code, 0, 1); add_mov_int(&mut code, 0, 1);
let (mut state, context) = setup(); let (mut state, context) = setup(1);
run_byte_code(&mut state, &context, &code); run_byte_code(&mut state, &context, &code);
assert_register!(DvmValue::Int(1), state, 0); assert_register!(DvmValue::Int(1), state, 0);
} }
@ -628,7 +529,7 @@ mod run_code_tests {
fn move_65535_as_int() { fn move_65535_as_int() {
let mut code = Vec::new(); let mut code = Vec::new();
add_mov_int(&mut code, 0, 0xffff); add_mov_int(&mut code, 0, 0xffff);
let (mut state, context) = setup(); let (mut state, context) = setup(1);
run_byte_code(&mut state, &context, &code); run_byte_code(&mut state, &context, &code);
assert_register!(DvmValue::Int(0xffff), state, 0); assert_register!(DvmValue::Int(0xffff), state, 0);
} }
@ -637,7 +538,7 @@ mod run_code_tests {
fn move_int_max_as_int() { fn move_int_max_as_int() {
let mut code = Vec::new(); let mut code = Vec::new();
add_mov_int(&mut code, 0, 0x0fff_ffff); add_mov_int(&mut code, 0, 0x0fff_ffff);
let (mut state, context) = setup(); let (mut state, context) = setup(1);
run_byte_code(&mut state, &context, &code); run_byte_code(&mut state, &context, &code);
assert_register!(DvmValue::Int(0x0fff_ffff), state, 0); assert_register!(DvmValue::Int(0x0fff_ffff), state, 0);
} }
@ -647,8 +548,7 @@ mod run_code_tests {
let mut code = Vec::new(); let mut code = Vec::new();
add_mov_int(&mut code, 1, 1); add_mov_int(&mut code, 1, 1);
add_mov_register(&mut code, 0, 1); add_mov_register(&mut code, 0, 1);
let (mut state, context) = setup(); let (mut state, context) = setup(2);
state.registers.resize(2, DvmValue::Uninit);
run_byte_code(&mut state, &context, &code); run_byte_code(&mut state, &context, &code);
assert_register!(DvmValue::Int(1), state, 0); assert_register!(DvmValue::Int(1), state, 0);
} }
@ -657,36 +557,20 @@ mod run_code_tests {
fn load_object() { fn load_object() {
let dummy_impl = impl_with_object_field(); let dummy_impl = impl_with_object_field();
let dummy_impl_rc = Rc::new(dummy_impl); let dummy_impl_rc = Rc::new(dummy_impl);
let dummy_impl_object_field = dummy_impl_rc
.fields
.iter()
.find(|field| field.name() == "object_field")
.unwrap();
let mut dummy_lib = DmLib::new("dummy"); let mut dummy_lib = DmLib::new("dummy");
dummy_lib.implementations.push(dummy_impl_rc.clone()); dummy_lib.implementations.push(dummy_impl_rc.clone());
let mut code = Vec::new(); let mut code = Vec::new();
add_alloc( add_alloc(&mut code, 0, &dummy_impl_rc.fqn);
&mut code, add_alloc(&mut code, 1, &dummy_impl_rc.fqn);
0, add_store(&mut code, 0, 0, 1);
dummy_impl_rc.size_in_bytes() as u32, add_load(&mut code, 2, 0, 0);
&dummy_impl_rc.fqn,
);
add_alloc(
&mut code,
1,
dummy_impl_rc.size_in_bytes() as u32,
&dummy_impl_rc.fqn,
);
add_store(&mut code, 0, dummy_impl_object_field.data_offset(), 1);
add_load_object(&mut code, 2, 0, dummy_impl_object_field.data_offset());
let (mut state, mut context) = setup(); let (mut state, mut context) = setup(3);
state.registers.resize(3, DvmValue::Uninit); state.registers.resize(3, DvmValue::Uninit);
context.load_libs(vec![Rc::new(dummy_lib)]); context.load_libs(vec![Rc::new(dummy_lib)]);
run_byte_code(&mut state, &context, &code); run_byte_code(&mut state, &context, &code);
let referenced_object = state.registers.get(1).unwrap().expect_object(); assert!(state.registers[2].is_object())
assert_register!(DvmValue::Object(referenced_object), state, 2);
} }
} }

46
src/vm/object.rs
View File

@ -1,34 +1,52 @@
use crate::vm::dm_type::DmType;
use crate::vm::object_type::DmImplementation; use crate::vm::object_type::DmImplementation;
use std::alloc::{alloc, dealloc, Layout}; use std::alloc::{alloc, dealloc, Layout};
use std::collections::HashSet; use std::ptr;
use std::rc::Rc; use std::rc::Rc;
#[derive(Debug, PartialEq, Eq)] #[derive(Debug, PartialEq, Eq)]
pub struct DvmObject { pub struct DvmObject {
pub data: *mut u8, data: Vec<*mut u8>,
pub units: HashSet<usize>, implementation: Rc<DmImplementation>,
pub size: usize, }
pub layout: Layout,
pub implementation: Rc<DmImplementation>, fn layout_for(dm_type: &DmType) -> Layout {
match dm_type {
DmType::Byte => Layout::new::<u8>(),
DmType::Int => Layout::new::<i32>(),
DmType::Long => Layout::new::<i64>(),
DmType::USize => Layout::new::<usize>(),
DmType::Double => Layout::new::<f64>(),
DmType::Boolean => Layout::new::<bool>(),
DmType::Object => Layout::new::<Rc<DvmObject>>(),
}
} }
impl DvmObject { impl DvmObject {
pub fn new(size: usize, implementation: Rc<DmImplementation>) -> Self { pub fn new(implementation: Rc<DmImplementation>) -> Self {
let layout = Layout::from_size_align(size, 1).unwrap(); let mut data = vec![ptr::null_mut(); implementation.fields.len()];
for (index, field) in implementation.fields.iter().enumerate() {
data[index] = unsafe { alloc(layout_for(field.dm_type())) }
}
DvmObject { DvmObject {
data: unsafe { alloc(layout) }, data,
units: HashSet::new(),
size,
layout,
implementation, implementation,
} }
} }
pub fn data(&self) -> &[*mut u8] {
&self.data
}
pub fn implementation(&self) -> &DmImplementation {
&self.implementation
}
} }
impl Drop for DvmObject { impl Drop for DvmObject {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { for (index, field) in self.implementation.fields.iter().enumerate() {
dealloc(self.data, self.layout); unsafe { dealloc(self.data[index], layout_for(field.dm_type())) }
} }
} }
} }

18
src/vm/object_type.rs
View File

@ -138,7 +138,7 @@ impl DmInterface {
.find(|&dm_fn| dm_fn.fqn == name) .find(|&dm_fn| dm_fn.fqn == name)
.is_some() .is_some()
{ {
return self_object.implementation.get_method(name, self_object); return self_object.implementation().get_method(name, self_object);
} }
None None
} }
@ -216,10 +216,6 @@ impl DmImplementation {
pub fn get_field(&self, name: &str, self_object: &DvmObject) -> Option<&DmField> { pub fn get_field(&self, name: &str, self_object: &DvmObject) -> Option<&DmField> {
self.fields.iter().find(|field| field.name == name) self.fields.iter().find(|field| field.name == name)
} }
pub fn size_in_bytes(&self) -> usize {
self.fields.iter().map(|field| field.size_in_bytes()).sum()
}
} }
#[derive(Debug, Eq)] #[derive(Debug, Eq)]
@ -239,7 +235,6 @@ impl PartialEq for DmProperty {
pub struct DmField { pub struct DmField {
name: String, name: String,
dm_type: DmType, dm_type: DmType,
data_offset: usize,
} }
impl PartialEq for DmField { impl PartialEq for DmField {
@ -249,11 +244,10 @@ impl PartialEq for DmField {
} }
impl DmField { impl DmField {
pub fn new(name: &str, dm_type: DmType, data_offset: usize) -> Self { pub fn new(name: &str, dm_type: DmType) -> Self {
DmField { DmField {
name: name.to_string(), name: name.to_string(),
dm_type, dm_type,
data_offset,
} }
} }
@ -264,12 +258,4 @@ impl DmField {
pub fn dm_type(&self) -> &DmType { pub fn dm_type(&self) -> &DmType {
&self.dm_type &self.dm_type
} }
pub fn data_offset(&self) -> usize {
self.data_offset
}
pub fn size_in_bytes(&self) -> usize {
self.dm_type.size_in_bytes()
}
} }

17
src/vm/op_codes.rs
View File

@ -51,7 +51,7 @@ pub const MOV_SIZE_OF: u8 = 0x30;
pub const MULTIPLY: u8 = 0x40; pub const MULTIPLY: u8 = 0x40;
pub const LOAD_OBJECT: u8 = 0x50; pub const LOAD: u8 = 0x50;
pub const STORE: u8 = 0x60; pub const STORE: u8 = 0x60;
@ -79,10 +79,9 @@ pub fn add_mov_register(code: &mut Vec<u8>, target_register: u8, source_register
code.push(source_register); code.push(source_register);
} }
pub fn add_alloc(code: &mut Vec<u8>, target_register: u8, size: u32, implementation_name: &str) { pub fn add_alloc(code: &mut Vec<u8>, target_register: u8, implementation_name: &str) {
code.push(ALLOC); code.push(ALLOC);
code.push(target_register); code.push(target_register);
push_number!(code, size);
push_number!(code, implementation_name.len() as u32); push_number!(code, implementation_name.len() as u32);
push_string!(code, implementation_name); push_string!(code, implementation_name);
} }
@ -117,27 +116,27 @@ pub fn add_mov_register_to(
code.push(source_register); code.push(source_register);
} }
pub fn add_load_object( pub fn add_load(
code: &mut Vec<u8>, code: &mut Vec<u8>,
target_register: u8, target_register: u8,
source_register: u8, source_register: u8,
offset: usize field_index: usize
) { ) {
code.push(LOAD_OBJECT); code.push(LOAD);
code.push(target_register); code.push(target_register);
code.push(source_register); code.push(source_register);
push_number!(code, offset); push_number!(code, field_index);
} }
pub fn add_store( pub fn add_store(
code: &mut Vec<u8>, code: &mut Vec<u8>,
target_register: u8, target_register: u8,
offset: usize, field_index: usize,
source_register: u8, source_register: u8,
) { ) {
code.push(STORE); code.push(STORE);
code.push(target_register); code.push(target_register);
push_number!(code, offset); push_number!(code, field_index);
code.push(source_register); code.push(source_register);
} }

31
src/vm/platform/std_lib/core.rs
View File

@ -1,5 +1,5 @@
use crate::vm::dvm_value::DvmValue; use crate::vm::dvm_value::DvmValue;
use crate::vm::mem::get_field_value; use crate::vm::mem::read_field_by_name;
use crate::vm::object::DvmObject; use crate::vm::object::DvmObject;
use crate::vm::{DvmContext, DvmState}; use crate::vm::{DvmContext, DvmState};
use std::rc::Rc; use std::rc::Rc;
@ -8,9 +8,7 @@ pub fn dm_print(args: Vec<DvmValue>, _state: &mut DvmState, _context: &DvmContex
if args.len() != 1 { if args.len() != 1 {
return DvmValue::Void; // TODO: make exception return DvmValue::Void; // TODO: make exception
} }
unsafe {
print!("{}", get_string(&args[0])); print!("{}", get_string(&args[0]));
}
DvmValue::Void DvmValue::Void
} }
@ -18,13 +16,11 @@ pub fn dm_println(args: Vec<DvmValue>, _state: &mut DvmState, _context: &DvmCont
if args.len() != 1 { if args.len() != 1 {
return DvmValue::Uninit; return DvmValue::Uninit;
} }
unsafe {
println!("{}", get_string(&args[0])); println!("{}", get_string(&args[0]));
}
DvmValue::Void DvmValue::Void
} }
unsafe fn get_string(dvm_value: &DvmValue) -> String { fn get_string(dvm_value: &DvmValue) -> String {
match dvm_value { match dvm_value {
DvmValue::Byte(b) => b.to_string(), DvmValue::Byte(b) => b.to_string(),
DvmValue::Int(i) => i.to_string(), DvmValue::Int(i) => i.to_string(),
@ -39,7 +35,7 @@ unsafe fn get_string(dvm_value: &DvmValue) -> String {
} }
fn object_to_string(alloc_object_rc: Rc<DvmObject>) -> String { fn object_to_string(alloc_object_rc: Rc<DvmObject>) -> String {
if alloc_object_rc.implementation.fqn == "std::core::StringImpl" { if alloc_object_rc.implementation().fqn == "std::core::StringImpl" {
extract_string_from_string(alloc_object_rc.clone()) extract_string_from_string(alloc_object_rc.clone())
} else { } else {
todo!("what happens if we don't have a String?") todo!("what happens if we don't have a String?")
@ -47,26 +43,13 @@ fn object_to_string(alloc_object_rc: Rc<DvmObject>) -> String {
} }
fn extract_string_from_string(string_object: Rc<DvmObject>) -> String { fn extract_string_from_string(string_object: Rc<DvmObject>) -> String {
let bytes_field = string_object let bytes_object = read_field_by_name("bytes", &string_object).expect_object();
.implementation if bytes_object.implementation().fqn != "std::core::ArrayImpl" {
.get_field("bytes", &string_object)
.expect("Could not get String.bytes field.");
let bytes_object = unsafe { get_field_value(&bytes_field, &string_object) }.expect_object();
if bytes_object.implementation.fqn != "std::core::ArrayImpl" {
panic!("String.bytes field is not a std::core::ArrayImpl"); panic!("String.bytes field is not a std::core::ArrayImpl");
} }
let ptr_address_field = bytes_object let address = read_field_by_name("ptr_address", &bytes_object).expect_usize();
.implementation let size = read_field_by_name("ptr_size", &bytes_object).expect_usize();
.get_field("ptr_address", &bytes_object)
.expect("Could not get ArrayImpl.ptr_address field.");
let address = unsafe { get_field_value(&ptr_address_field, &bytes_object) }.expect_usize();
let ptr_size_field = bytes_object
.implementation
.get_field("ptr_size", &bytes_object)
.expect("Could not get ArrayImpl.ptr_size field.");
let size = unsafe { get_field_value(&ptr_size_field, &bytes_object) }.expect_usize();
let raw_bytes_pointer = address as *mut u8; let raw_bytes_pointer = address as *mut u8;
let mut v: Vec<u8> = Vec::new(); let mut v: Vec<u8> = Vec::new();