Upgrade vm module to new models

Brian Pfretzschner · Brian Pfretzschner · commit f8604e8e7ea3 · 2024-05-30T21:02:52.000+02:00
diff --git a/cli/Cargo.toml b/cli/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2021"
 model = { path = "../model" }
 parser = { path = "../parser" }
 loader = { path = "../loader" }
-# vm = { path = "../vm" }
+vm = { path = "../vm" }
 rt = { path = "../rt" }
 
 clap = { version = "3.1.2", features = ["derive"] }
diff --git a/cli/src/execute.rs b/cli/src/execute.rs
@@ -1,22 +1,25 @@
 use std::path::PathBuf;
 
+use loader::CompositeLoader;
+use vm::Vm;
+
 const MAIN_METHOD_NAME: &str = "main";
 const MAIN_METHOD_SIGNATURE: &str = "([Ljava/lang/String;)V";
 
 pub fn run(main_class: String, class_paths: Vec<PathBuf>) {
-    unimplemented!()
-    // let parser = parser::ClassfileParser {};
+    let parser = parser::ClassfileParser {};
 
-    // let classloader = loader::classloader_for_paths(class_paths, &parser).unwrap();
-    // let runtime_classloader = rt::make_classloader();
+    let classloader = loader::classloader_for_paths(class_paths, &parser).unwrap();
+    let runtime_classloader = rt::make_classloader(&parser);
 
-    // let classloader = CompositeLoader::open(vec![Box::new(runtime_classloader), Box::new(classloader)]);
+    let classloader =
+        CompositeLoader::open(vec![Box::new(runtime_classloader), Box::new(classloader)]);
 
-    // let vm = Vm::new(classloader);
-    // vm.spawn_thread("Thread-0".to_string()).invoke_method(
-    //     &main_class,
-    //     &MAIN_METHOD_NAME.to_string(),
-    //     &MAIN_METHOD_SIGNATURE.to_string(),
-    //     false,
-    // );
+    let vm = Vm::new(classloader);
+    vm.spawn_thread("Thread-0".to_string()).invoke_method(
+        &main_class,
+        &MAIN_METHOD_NAME.to_string(),
+        &MAIN_METHOD_SIGNATURE.to_string(),
+        false,
+    );
 }
diff --git a/cli/src/runtime_options.rs b/cli/src/runtime_options.rs
@@ -0,0 +1,17 @@
+use std::str::FromStr;
+
+pub enum RuntimeOptions {
+    Native,
+    Java,
+}
+impl FromStr for RuntimeOptions {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "native" => Ok(RuntimeOptions::Native),
+            "java" => Ok(RuntimeOptions::Java),
+            _ => Err(format!("{} is not a valid runtime", s)),
+        }
+    }
+}
diff --git a/parser/src/lib.rs b/parser/src/lib.rs
@@ -2,8 +2,8 @@ use anyhow::{bail, Result};
 use model::class::{ClassVersion, JvmClass};
 use std::io::Read;
 
-mod method_signature;
-mod type_signature;
+pub mod method_signature;
+pub mod type_signature;
 
 mod attributes;
 mod class_info;
diff --git a/rt/src/lib.rs b/rt/src/lib.rs
@@ -4,8 +4,7 @@ use model::api::{Classloader, Parser};
 pub fn make_classloader(parser: &impl Parser) -> impl Classloader {
     let rt_path = std::env::current_dir()
         .unwrap()
-        .join("..")
-        .join("rt/jmods/java.base/classes");
-    println!("### {:?}", rt_path);
+        .join("jmods/java.base/classes");
+
     ClassfileLoader::open(rt_path, parser).unwrap()
 }
diff --git a/vm/src/class_hierarchy.rs b/vm/src/class_hierarchy.rs
@@ -1,7 +1,7 @@
 use std::iter::Iterator;
 
 use crate::VmThread;
-use model::class::{ClassConstant, JvmClass};
+use model::class::JvmClass;
 
 pub type HierarchyClassInfo = (JvmClass, String, Vec<String>);
 
@@ -47,25 +47,12 @@ impl<'a, 'b> Iterator for HierarchyIterator<'a, 'b> {
 
 fn make_hierarchy_class_info(class: &JvmClass) -> Option<HierarchyClassInfo> {
     // Find super class
-    let super_class_path = match class.class_info.super_class {
+    let super_class_path = match class.super_class {
         Some(ref path) => path.clone(),
         None => return None,
     };
 
-    // Also get all interfaces
-    let interface_paths = class
-        .class_info
-        .interfaces
-        .iter()
-        .map(
-            |interface_index| match class.constants.get(*interface_index as usize).unwrap() {
-                &ClassConstant::Class(ref path) => path.clone(),
-                it => panic!("Unexpected constant value: {:?}", it),
-            },
-        )
-        .collect();
-
-    Some((class.clone(), super_class_path, interface_paths))
+    Some((class.clone(), super_class_path, class.interfaces.clone()))
 }
 
 // #[derive(Debug)]
diff --git a/vm/src/eval/getstatic.rs b/vm/src/eval/getstatic.rs
@@ -9,7 +9,7 @@ pub fn eval(
     pc: u16,
 ) -> Option<u16> {
     let index = utils::read_u16_code(code, pc);
-    match jvm_class.constants.get(index as usize).unwrap() {
+    match jvm_class.constants.0.get(index as usize).unwrap() {
         &ClassConstant::Fieldref(ref class_path, ref field_name, ref type_name) => {
             let value = find_static_value(vm_thread, class_path, field_name);
             trace!(
@@ -36,7 +36,7 @@ fn find_static_value(
     let class_paths: Vec<String> = {
         let hierarchy_iter = HierarchyIterator::hierarchy_iter(vm_thread, root_class_path);
         hierarchy_iter
-            .map(|(jvm_class, _, _)| jvm_class.class_info.this_class)
+            .map(|(jvm_class, _, _)| jvm_class.this_class)
             .collect()
     };
 
diff --git a/vm/src/eval/invokevirtual.rs b/vm/src/eval/invokevirtual.rs
@@ -11,7 +11,7 @@ pub fn eval(
 
     // First, find Methodref and extract values
     let (class_path, method_name, method_signature) =
-        match jvm_class.constants.get(index as usize).unwrap() {
+        match jvm_class.constants.0.get(index as usize).unwrap() {
             &ClassConstant::Methodref(ref class_path, ref method_name, ref method_signature) => (
                 class_path.clone(),
                 method_name.clone(),
diff --git a/vm/src/eval/ldc2_w.rs b/vm/src/eval/ldc2_w.rs
@@ -10,7 +10,7 @@ pub fn eval(
     let frame = vm_thread.frame_stack.last_mut().unwrap();
 
     let index = utils::read_u16_code(code, pc);
-    match jvm_class.constants.get(index as usize).unwrap() {
+    match jvm_class.constants.0.get(index as usize).unwrap() {
         &ClassConstant::Long(ref value) => {
             trace!("ldc2_w: Pushing Long {} to stack", value);
             frame.stack_push(Primitive::Long(value.clone()));
diff --git a/vm/src/eval/ldc_x.rs b/vm/src/eval/ldc_x.rs
@@ -16,7 +16,7 @@ pub fn eval(
         i => panic!("Unexpected invocation of this instruction, found: {}", i),
     };
 
-    match jvm_class.constants.get(index as usize).unwrap() {
+    match jvm_class.constants.0.get(index as usize).unwrap() {
         &ClassConstant::String(ref value) => {
             trace!("{}: Pushing String \"{}\" to stack", instr_name, value);
 
diff --git a/vm/src/eval/putfield.rs b/vm/src/eval/putfield.rs
@@ -8,7 +8,7 @@ pub fn eval(
     pc: u16,
 ) -> Option<u16> {
     let index = utils::read_u16_code(code, pc);
-    match jvm_class.constants.get(index as usize).unwrap() {
+    match jvm_class.constants.0.get(index as usize).unwrap() {
         &ClassConstant::Fieldref(ref class_path, ref field_name, _) => {
             // Pop value and Objectref from stack
             let frame = vm_thread.frame_stack.last_mut().unwrap();
diff --git a/vm/src/eval/putstatic.rs b/vm/src/eval/putstatic.rs
@@ -8,7 +8,7 @@ pub fn eval(
     pc: u16,
 ) -> Option<u16> {
     let index = utils::read_u16_code(code, pc);
-    match jvm_class.constants.get(index as usize).unwrap() {
+    match jvm_class.constants.0.get(index as usize).unwrap() {
         &ClassConstant::Fieldref(ref class_path, ref field_name, _) => {
             // Initialize class
             vm_thread.load_and_clinit_class(class_path);
diff --git a/vm/src/instance.rs b/vm/src/instance.rs
@@ -12,7 +12,7 @@ pub struct Instance {
 
 impl Instance {
     pub fn new(vm_thread: &mut VmThread, jvm_class: &JvmClass) -> Instance {
-        let class_path = jvm_class.class_info.this_class.clone();
+        let class_path = jvm_class.this_class.clone();
 
         let mut fields = HashMap::new();
         initialize_instance_fields(&jvm_class, &mut fields);
diff --git a/vm/src/utils.rs b/vm/src/utils.rs
@@ -1,8 +1,6 @@
-use crate::array::Array;
 use crate::class_hierarchy::HierarchyIterator;
-use crate::instance::Instance;
-use crate::{Primitive, VmThread};
-use model::class::{ClassAttribute, ClassMethod, CodeAttribute, JvmClass};
+use crate::VmThread;
+use model::class::{ClassAttribute, ClassMethod, CodeAttribute, JvmClass, MethodAccessFlag};
 
 pub fn find_method(
     vm_thread: &mut VmThread,
@@ -39,7 +37,7 @@ pub fn find_method_in_classfile(
             }
 
             // Make sure, method is not abstract
-            method.access_flags & JvmClass::ACC_ABSTRACT == 0
+            !method.access_flags.contains(MethodAccessFlag::Abstract)
         })
         .map(|m| m.clone())
 }
@@ -68,43 +66,43 @@ pub fn read_i16_code(code: &Vec<u8>, pc: u16) -> i16 {
     (indexbyte1 | indexbyte2) as i16
 }
 
-pub fn read_i32_code(code: &Vec<u8>, pc: u16, offset: u16) -> i32 {
-    let byte1 = *code.get((pc + offset) as usize).unwrap() as u32;
-    let byte2 = *code.get((pc + offset + 1) as usize).unwrap() as u32;
-    let byte3 = *code.get((pc + offset + 2) as usize).unwrap() as u32;
-    let byte4 = *code.get((pc + offset + 3) as usize).unwrap() as u32;
-
-    ((byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4) as i32
-}
-
-pub fn get_java_byte_array_string_value(value_array: &Array) -> String {
-    let element_values: Vec<u16> = value_array
-        .elements
-        .iter()
-        .map(|p| match p {
-            &Primitive::Char(ref code) => *code,
-            p => panic!("Unexpected primitive: {:?}", p),
-        })
-        .collect();
-
-    String::from_utf16_lossy(element_values.as_slice())
-}
-
-pub fn get_java_string_value(string_instance: &Instance) -> String {
-    match string_instance.fields.get("value").unwrap() {
-        &Primitive::Arrayref(ref rc_value_array) => {
-            get_java_byte_array_string_value(&*rc_value_array.borrow())
-        }
-        p => panic!("Unexpected primitive: {:?}", p),
-    }
-}
-
-pub fn get_instance_field_string_value(class_instance: &Instance, field_name: &str) -> String {
-    let rc_string = class_instance.fields.get(field_name).unwrap();
-    match rc_string {
-        &Primitive::Objectref(ref rc_string_instance) => {
-            get_java_string_value(&*rc_string_instance.borrow())
-        }
-        _ => panic!("Expected to find Instance but found {:?}", rc_string),
-    }
-}
+// pub fn read_i32_code(code: &Vec<u8>, pc: u16, offset: u16) -> i32 {
+//     let byte1 = *code.get((pc + offset) as usize).unwrap() as u32;
+//     let byte2 = *code.get((pc + offset + 1) as usize).unwrap() as u32;
+//     let byte3 = *code.get((pc + offset + 2) as usize).unwrap() as u32;
+//     let byte4 = *code.get((pc + offset + 3) as usize).unwrap() as u32;
+
+//     ((byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4) as i32
+// }
+
+// pub fn get_java_byte_array_string_value(value_array: &Array) -> String {
+//     let element_values: Vec<u16> = value_array
+//         .elements
+//         .iter()
+//         .map(|p| match p {
+//             &Primitive::Char(ref code) => *code,
+//             p => panic!("Unexpected primitive: {:?}", p),
+//         })
+//         .collect();
+
+//     String::from_utf16_lossy(element_values.as_slice())
+// }
+
+// pub fn get_java_string_value(string_instance: &Instance) -> String {
+//     match string_instance.fields.get("value").unwrap() {
+//         &Primitive::Arrayref(ref rc_value_array) => {
+//             get_java_byte_array_string_value(&*rc_value_array.borrow())
+//         }
+//         p => panic!("Unexpected primitive: {:?}", p),
+//     }
+// }
+
+// pub fn get_instance_field_string_value(class_instance: &Instance, field_name: &str) -> String {
+//     let rc_string = class_instance.fields.get(field_name).unwrap();
+//     match rc_string {
+//         &Primitive::Objectref(ref rc_string_instance) => {
+//             get_java_string_value(&*rc_string_instance.borrow())
+//         }
+//         _ => panic!("Expected to find Instance but found {:?}", rc_string),
+//     }
+// }
diff --git a/vm/src/vm_thread.rs b/vm/src/vm_thread.rs
@@ -7,8 +7,10 @@ use crate::utils;
 use crate::Vm;
 use lazy_static::lazy_static;
 use log::{debug, trace};
+use model::class::FieldAccessFlag;
+use model::class::MethodAccessFlag;
 use model::class::{ClassAttribute, CodeAttribute, JvmClass};
-use parser::parse_method_signature;
+use parser::method_signature::parse_method_signature;
 use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Mutex;
@@ -54,15 +56,15 @@ impl<'a> VmThread<'a> {
     ) {
         let (class, method) = utils::find_method(self, class_path, method_name, method_signature);
 
-        if method.access_flags & JvmClass::ACC_NATIVE > 0 {
+        if method.access_flags.contains(MethodAccessFlag::Native) {
             let native_method = self
                 .vm
                 .classloader
                 .get_native_method(&class, &method)
                 .expect(
                     format!(
                         "No native method implementation found for {}.{}{}",
-                        class.class_info.this_class, method.name, method.descriptor
+                        class.this_class, method.name, method.descriptor
                     )
                     .as_str(),
                 );
@@ -149,10 +151,10 @@ impl<'a> VmThread<'a> {
     fn clinit_class(&mut self, jvm_class: &JvmClass) {
         // Search for static fields with a ConstantValue attribute and initialize accordingly
         for field in jvm_class.fields.iter() {
-            if field.access_flags & JvmClass::ACC_STATIC > 0 {
+            if field.access_flags.contains(FieldAccessFlag::Static) {
                 // Static field found -> Set the types default value
                 self.vm.mem.static_pool.set_class_field(
-                    &jvm_class.class_info.this_class,
+                    &jvm_class.this_class,
                     field.name.clone(),
                     Primitive::get_default_value(&field.descriptor),
                 );
@@ -162,12 +164,12 @@ impl<'a> VmThread<'a> {
                     if let &ClassAttribute::ConstantValue(ref index) = attr {
                         let value = Primitive::from_constant(
                             self.vm,
-                            jvm_class.constants.get(*index as usize).unwrap(),
+                            jvm_class.constants.0.get(*index as usize).unwrap(),
                         );
 
                         // Set value
                         self.vm.mem.static_pool.set_class_field(
-                            &jvm_class.class_info.this_class,
+                            &jvm_class.this_class,
                             field.name.clone(),
                             value,
                         );
@@ -180,17 +182,17 @@ impl<'a> VmThread<'a> {
         if let Some(_) = utils::find_method_in_classfile(&jvm_class, "<clinit>", "()V") {
             debug!(
                 "Class {} not initialized and contains <clinit> -> executing now",
-                jvm_class.class_info.this_class
+                jvm_class.this_class
             );
 
             self.invoke_method(
-                &jvm_class.class_info.this_class,
+                &jvm_class.this_class,
                 &"<clinit>".to_string(),
                 &"()V".to_string(),
                 false,
             );
 
-            debug!("{}.<clinit> done", jvm_class.class_info.this_class);
+            debug!("{}.<clinit> done", jvm_class.this_class);
         }
     }
 
@@ -213,7 +215,7 @@ impl<'a> VmThread<'a> {
         {
             let parent_frame = self.frame_stack.last_mut().unwrap();
 
-            let sig = parse_method_signature(method_signature);
+            let sig = parse_method_signature(method_signature).unwrap();
             let number_of_locals = sig.parameters.len() + if is_instance { 1 } else { 0 };
             for i in (0..number_of_locals).rev() {
                 let arg = parent_frame.stack_pop();
