runtime: Make more use of vtable instead of class instance

dora-runtime/src/boots.rs

@@ -17,8 +17,8 @@ use crate::size::InstanceSize;
 use crate::threads::current_thread;
 use crate::vm::compute_vtable_index;
 use crate::vm::{
-    create_class_instance, create_enum_instance, ensure_class_instance_for_enum_variant, get_vm,
-    impls, CodeDescriptor, FctImplementation, VM,
+    create_enum_instance, ensure_class_instance_for_enum_variant, get_vm, impls, CodeDescriptor,
+    FctImplementation, VM,
 };
 
 use self::deserializer::{decode_bytecode_type, decode_bytecode_type_array};
@@ -211,7 +211,7 @@ extern "C" fn get_class_pointer_for_lambda(data: Handle<UInt8Array>) -> Address
 
     let id = crate::vm::ensure_class_instance_for_lambda(vm, fct_id, type_params);
     let cls = vm.class_instances.idx(id);
-    cls.vtblptr()
+    cls.vtable_address()
 }
 
 extern "C" fn get_class_pointer_for_trait_object_raw(data: Handle<UInt8Array>) -> Address {
@@ -234,7 +234,7 @@ extern "C" fn get_class_pointer_for_trait_object_raw(data: Handle<UInt8Array>) -
 
     let id = crate::vm::ensure_class_instance_for_trait_object(vm, trait_ty, actual_object_ty);
     let cls = vm.class_instances.idx(id);
-    cls.vtblptr()
+    cls.vtable_address()
 }
 
 extern "C" fn get_class_size_for_trait_object_raw(data: Handle<UInt8Array>) -> i32 {
@@ -312,13 +312,8 @@ extern "C" fn get_class_size(data: Handle<UInt8Array>) -> u32 {
 }
 
 fn get_class_size_raw(vm: &VM, cls_id: ClassId, type_params: BytecodeTypeArray) -> u32 {
-    let class_instance_id = create_class_instance(vm, cls_id, &type_params);
-    let cls = vm.class_instances.idx(class_instance_id);
-
-    match cls.size {
-        InstanceSize::Fixed(size) => size as u32,
-        _ => unreachable!(),
-    }
+    let vtable = vm.vtable_for_class(cls_id, &type_params);
+    vtable.instance_size() as u32
 }
 
 fn get_element_size_raw(data: Handle<UInt8Array>) -> u32 {
@@ -339,16 +334,8 @@ fn get_element_size_raw(data: Handle<UInt8Array>) -> u32 {
     let type_params = decode_bytecode_type_array(&mut reader);
     assert!(!reader.has_more());
 
-    let class_instance_id = create_class_instance(vm, cls_id, &type_params);
-    let cls = vm.class_instances.idx(class_instance_id);
-
-    match cls.size {
-        InstanceSize::StructArray(element_size) => element_size as u32,
-        InstanceSize::ObjArray => crate::mem::ptr_width() as u32,
-        InstanceSize::PrimitiveArray(element_size) => element_size as u32,
-        InstanceSize::UnitArray => 0,
-        _ => unreachable!(),
-    }
+    let vtable = vm.vtable_for_class(cls_id, &type_params);
+    vtable.element_size() as u32
 }
 
 extern "C" fn get_class_pointer(data: Handle<UInt8Array>) -> Address {
@@ -373,9 +360,7 @@ extern "C" fn get_class_pointer(data: Handle<UInt8Array>) -> Address {
 }
 
 fn get_class_pointer_raw(vm: &VM, cls_id: ClassId, type_params: BytecodeTypeArray) -> Address {
-    let class_instance_id = create_class_instance(vm, cls_id, &type_params);
-    let cls = vm.class_instances.idx(class_instance_id);
-    cls.vtblptr()
+    vm.vtable_for_class(cls_id, &type_params).address()
 }
 
 extern "C" fn get_field_offset(data: Handle<UInt8Array>) -> u32 {
@@ -406,9 +391,8 @@ fn get_field_offset_raw(
     type_params: BytecodeTypeArray,
     field_id: u32,
 ) -> u32 {
-    let class_instance_id = create_class_instance(vm, cls_id, &type_params);
-    let cls = vm.class_instances.idx(class_instance_id);
-    let field = &cls.fields[field_id as usize];
+    let vtable = vm.vtable_for_class(cls_id, &type_params);
+    let field = &vtable.fields[field_id as usize];
     field.offset.try_into().expect("overflow")
 }
 
@@ -545,7 +529,7 @@ extern "C" fn get_class_data_for_enum_variant_raw(data: Handle<UInt8Array>) -> R
     };
 
     let mut buffer = ByteBuffer::new();
-    buffer.emit_address(cls.vtblptr());
+    buffer.emit_address(cls.vtable_address());
     buffer.emit_u32(alloc_size as u32);
     byte_array_from_buffer(vm, buffer.data()).cast()
 }

dora-runtime/src/cannon/asm.rs

@@ -12,12 +12,12 @@ use crate::gc::Address;
 use crate::masm::{CondCode, Label, MacroAssembler, Mem, ScratchReg};
 use crate::mirror::Header;
 use crate::mode::MachineMode;
-use crate::size::InstanceSize;
 use crate::threads::ThreadLocalData;
 use crate::vm::{
-    create_enum_instance, create_struct_instance, get_concrete_tuple_bty_array, ClassInstance,
-    CodeDescriptor, EnumLayout, GcPoint, LazyCompilationSite, Trap, INITIALIZED, VM,
+    create_enum_instance, create_struct_instance, get_concrete_tuple_bty_array, CodeDescriptor,
+    EnumLayout, GcPoint, LazyCompilationSite, Trap, INITIALIZED, VM,
 };
+use crate::VTable;
 use dora_bytecode::{BytecodeType, BytecodeTypeArray, FunctionId, GlobalId, Location, StructId};
 
 pub struct BaselineAssembler<'a> {
@@ -1098,18 +1098,14 @@ impl<'a> BaselineAssembler<'a> {
         ));
     }
 
-    pub fn initialize_object(&mut self, obj: Reg, class_instance: &ClassInstance) {
-        let size = match class_instance.size {
-            InstanceSize::Fixed(size) => size,
-            _ => unreachable!(),
-        };
-
+    pub fn initialize_object(&mut self, obj: Reg, vtable: &VTable) {
+        let size = vtable.instance_size();
         let tmp_reg = self.get_scratch();
 
         // Store classptr/vtable in object.
         let (is_marked, is_remembered) = self.vm.gc.initial_metadata_value(size as usize, false);
         let header_word_value = Header::compute_header_word(
-            class_instance.vtblptr(),
+            vtable.address(),
             self.vm.meta_space_start(),
             is_marked,
             is_remembered,
@@ -1134,20 +1130,16 @@ impl<'a> BaselineAssembler<'a> {
     pub fn initialize_array_header(
         &mut self,
         obj: Reg,
-        class_instance: &ClassInstance,
+        vtable: &VTable,
         length_reg: Reg,
         size_reg: Reg,
     ) {
         let tmp_reg = self.get_scratch();
         assert!(obj != length_reg && length_reg != *tmp_reg && obj != *tmp_reg);
 
         // store classptr in object
-        let header_word_value = Header::compute_header_word(
-            class_instance.vtblptr(),
-            self.vm.meta_space_start(),
-            false,
-            false,
-        );
+        let header_word_value =
+            Header::compute_header_word(vtable.address(), self.vm.meta_space_start(), false, false);
 
         self.masm.load_int_const(
             MachineMode::IntPtr,