wip

Cargo.toml

@@ -11,7 +11,6 @@ members = [
     "jmod",
     "versioning",
     "platform",
-    "symbols",
     "jni",
     "jni/sys",
 ]
@@ -20,15 +19,18 @@ members = [
 classfile = { path = "classfile" }
 common = { path = "common" }
 instructions = { path = "instructions" }
+jimage = { path = "jimage" }
 jni = { path = "jni" }
 jni_sys = { path = "jni/sys" }
-symbols = { path = "symbols" }
+platform = { path = "platform" }
+vm_symbols = { path = "generators/vm_symbols" }
 
 byteorder = "1.5.0"
 byte-slice-cast = "1.2.2"
 cesu8 = "1.1.0"
 cfg-if = "1.0.0"
 const_format = "0.2.33"
+fxhash = "0.2.1"
 libc = "0.2"
 libloading = "0.8.5"
 tracing = "0.1.41"

classfile/src/constant_pool/mod.rs

@@ -1,6 +1,8 @@
 pub mod types;
 
-use crate::constant_pool::types::{CpEntry, LoadableConstantPoolValue};
+use crate::constant_pool::types::{
+	CpEntry, LoadableConstantPoolValue, LoadableConstantPoolValueInner,
+};
 
 use std::fmt::{Debug, Formatter};
 use std::ops::{Deref, Index};
@@ -38,55 +40,60 @@ impl ConstantPool {
 	pub fn get_loadable_entry(&self, index: u2) -> LoadableConstantPoolValue {
 		let constant = &self[index];
 
-		match constant {
+		let value = match constant {
 			ConstantPoolValueInfo::Integer { bytes } => {
-				LoadableConstantPoolValue::Integer(types::raw::Integer::handle(self, *bytes))
+				LoadableConstantPoolValueInner::Integer(types::raw::Integer::handle(self, *bytes))
 			},
 			ConstantPoolValueInfo::Float { bytes } => {
-				LoadableConstantPoolValue::Float(types::raw::Float::handle(self, *bytes))
+				LoadableConstantPoolValueInner::Float(types::raw::Float::handle(self, *bytes))
 			},
 			ConstantPoolValueInfo::Long {
 				high_bytes,
 				low_bytes,
-			} => LoadableConstantPoolValue::Long(types::raw::Long::handle(
+			} => LoadableConstantPoolValueInner::Long(types::raw::Long::handle(
 				self,
 				(*high_bytes, *low_bytes),
 			)),
 			ConstantPoolValueInfo::Double {
 				high_bytes,
 				low_bytes,
-			} => LoadableConstantPoolValue::Double(types::raw::Double::handle(
+			} => LoadableConstantPoolValueInner::Double(types::raw::Double::handle(
 				self,
 				(*high_bytes, *low_bytes),
 			)),
-			ConstantPoolValueInfo::Class { name_index } => LoadableConstantPoolValue::Class(
+			ConstantPoolValueInfo::Class { name_index } => LoadableConstantPoolValueInner::Class(
 				types::raw::RawClassName::handle(self, *name_index),
 			),
-			ConstantPoolValueInfo::String { string_index } => LoadableConstantPoolValue::String(
-				types::raw::RawString::handle(self, *string_index),
-			),
+			ConstantPoolValueInfo::String { string_index } => {
+				LoadableConstantPoolValueInner::String(types::raw::RawString::handle(
+					self,
+					*string_index,
+				))
+			},
 			ConstantPoolValueInfo::MethodHandle {
 				reference_kind,
 				reference_index,
-			} => LoadableConstantPoolValue::MethodHandle(types::raw::RawMethodHandle::handle(
+			} => LoadableConstantPoolValueInner::MethodHandle(types::raw::RawMethodHandle::handle(
 				self,
 				(*reference_kind, *reference_index),
 			)),
 			ConstantPoolValueInfo::MethodType { descriptor_index } => {
-				LoadableConstantPoolValue::MethodType(types::raw::RawMethodType::handle(
+				LoadableConstantPoolValueInner::MethodType(types::raw::RawMethodType::handle(
 					self,
 					*descriptor_index,
 				))
 			},
 			ConstantPoolValueInfo::Dynamic {
 				bootstrap_method_attr_index,
 				name_and_type_index,
-			} => LoadableConstantPoolValue::Dynamic(types::raw::RawDynamic::handle(
+			} => LoadableConstantPoolValueInner::Dynamic(types::raw::RawDynamic::handle(
 				self,
 				(*bootstrap_method_attr_index, *name_and_type_index),
 			)),
 			_ => panic!("Expected a loadable constant pool entry"),
-		}
+		};
+
+		LoadableConstantPoolValue { index, value }
 	}
 }
 

classfile/src/constant_pool/types.rs

@@ -7,7 +7,7 @@ use common::int_types::{s4, s8, u1, u2, u4};
 
 // https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-4.html#jvms-4.4-310
 #[derive(Clone, Debug)]
-pub enum LoadableConstantPoolValue<'a> {
+pub enum LoadableConstantPoolValueInner<'a> {
 	Integer(s4),
 	Float(f32),
 	Long(s8),
@@ -19,28 +19,49 @@ pub enum LoadableConstantPoolValue<'a> {
 	Dynamic(<raw::RawDynamic as CpEntry<'a>>::Entry),
 }
 
-impl<'a> LoadableConstantPoolValue<'a> {
-	pub fn into_owned(self) -> LoadableConstantPoolValue<'static> {
+impl<'a> LoadableConstantPoolValueInner<'a> {
+	pub fn into_owned(self) -> LoadableConstantPoolValueInner<'static> {
 		match self {
-			LoadableConstantPoolValue::Integer(val) => LoadableConstantPoolValue::Integer(val),
-			LoadableConstantPoolValue::Float(val) => LoadableConstantPoolValue::Float(val),
-			LoadableConstantPoolValue::Long(val) => LoadableConstantPoolValue::Long(val),
-			LoadableConstantPoolValue::Double(val) => LoadableConstantPoolValue::Double(val),
-			LoadableConstantPoolValue::Class(val) => {
-				LoadableConstantPoolValue::Class(val.into_owned())
+			LoadableConstantPoolValueInner::Integer(val) => {
+				LoadableConstantPoolValueInner::Integer(val)
+			},
+			LoadableConstantPoolValueInner::Float(val) => {
+				LoadableConstantPoolValueInner::Float(val)
+			},
+			LoadableConstantPoolValueInner::Long(val) => LoadableConstantPoolValueInner::Long(val),
+			LoadableConstantPoolValueInner::Double(val) => {
+				LoadableConstantPoolValueInner::Double(val)
 			},
-			LoadableConstantPoolValue::String(val) => {
-				LoadableConstantPoolValue::String(Cow::Owned(val.into_owned()))
+			LoadableConstantPoolValueInner::Class(val) => {
+				LoadableConstantPoolValueInner::Class(val.into_owned())
 			},
-			LoadableConstantPoolValue::MethodHandle(val) => {
-				LoadableConstantPoolValue::MethodHandle(val.into_owned())
+			LoadableConstantPoolValueInner::String(val) => {
+				LoadableConstantPoolValueInner::String(Cow::Owned(val.into_owned()))
 			},
-			LoadableConstantPoolValue::MethodType(val) => {
-				LoadableConstantPoolValue::MethodType(Cow::Owned(val.into_owned()))
+			LoadableConstantPoolValueInner::MethodHandle(val) => {
+				LoadableConstantPoolValueInner::MethodHandle(val.into_owned())
 			},
-			LoadableConstantPoolValue::Dynamic(val) => {
-				LoadableConstantPoolValue::Dynamic(val.into_owned())
+			LoadableConstantPoolValueInner::MethodType(val) => {
+				LoadableConstantPoolValueInner::MethodType(Cow::Owned(val.into_owned()))
 			},
+			LoadableConstantPoolValueInner::Dynamic(val) => {
+				LoadableConstantPoolValueInner::Dynamic(val.into_owned())
+			},
+		}
+	}
+}
+
+#[derive(Clone, Debug)]
+pub struct LoadableConstantPoolValue<'a> {
+	pub index: u2,
+	pub value: LoadableConstantPoolValueInner<'a>,
+}
+
+impl<'a> LoadableConstantPoolValue<'a> {
+	pub fn into_owned(self) -> LoadableConstantPoolValue<'static> {
+		LoadableConstantPoolValue {
+			index: self.index,
+			value: self.value.into_owned(),
 		}
 	}
 }

classfile/src/fieldinfo.rs

@@ -157,6 +157,25 @@ impl FieldType {
 			Self::Array(component) => format!("[{}", component.as_signature()).into(),
 		}
 	}
+
+	/// Get the [array type code] for this field type
+	///
+	/// This is only applicable for primitive types
+	///
+	/// [array type code]: https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-6.html#jvms-6.5.newarray
+	pub fn as_array_type_code(&self) -> Option<u8> {
+		match self {
+			FieldType::Boolean => Some(4),
+			FieldType::Char => Some(5),
+			FieldType::Float => Some(6),
+			FieldType::Double => Some(7),
+			FieldType::Byte => Some(8),
+			FieldType::Short => Some(9),
+			FieldType::Int => Some(10),
+			FieldType::Long => Some(11),
+			_ => None,
+		}
+	}
 }
 
 impl Display for FieldType {

generators/native_methods/src/intrinsics.rs

@@ -156,15 +156,15 @@ fn create_method_mappings<'a>(
 		r#"
 impl IntrinsicId {
 	/// Attempt to map the method to an `IntrinsicId`
-	pub fn for_method(class: symbols::Symbol, method_name: symbols::Symbol, signature: symbols::Symbol, flags: MethodAccessFlags) -> Self {
-		use symbols::sym;
+	pub fn for_method(class: crate::symbols::Symbol, method_name: crate::symbols::Symbol, signature: crate::symbols::Symbol, flags: MethodAccessFlags) -> Self {
+		use crate::symbols::sym;
 
 		// Creates a unique ID for a method using its class, name, and signature
 		macro_rules! intrinsics_id3 {
 			($class:expr, $method_name:expr, $method_signature:expr) => {
 				(($method_signature.as_u32() as u64) +
-					(($method_name.as_u32()  as u64) <<    symbols::Symbol::PRE_INTERNED_LIMIT_LOG2) +
-					(($class .as_u32()       as u64) << (2*symbols::Symbol::PRE_INTERNED_LIMIT_LOG2)))
+					(($method_name.as_u32()  as u64) <<    crate::symbols::Symbol::PRE_INTERNED_LIMIT_LOG2) +
+					(($class .as_u32()       as u64) << (2*crate::symbols::Symbol::PRE_INTERNED_LIMIT_LOG2)))
 			};
 		}
 

generators/native_methods/src/lib.rs

@@ -23,7 +23,7 @@ use std::path::{Path, PathBuf};
 static CRATE_ROOT: &str = env!("CARGO_MANIFEST_DIR");
 static INIT_FN_FILE_HEADER: &str = r#"#[allow(trivial_casts)]
 fn init_native_method_table() -> HashMap<NativeMethodDef, NativeMethodPtr> {
-	use symbols::sym;
+	use crate::symbols::sym;
 	
 	fn insert(map: &mut HashMap<NativeMethodDef, NativeMethodPtr>, key: NativeMethodDef, value: NativeMethodPtr) {
 		let existing = map.insert(key, value);
@@ -59,16 +59,18 @@ impl SymbolCollector {
 	}
 
 	/// Generates additional symbols, injecting them into the `vm_symbols::define_symbols!` call
-	/// in `runtime/src/symbols.rs`
+	/// in `runtime/src/symbols/mod.rs`
 	fn generate_symbols<'a>(&self, generated_directory: &Path) {
 		// ../../symbols/src/lib.rs
 		let symbols_project_dir = generated_directory
 			.parent()
 			.unwrap()
 			.parent()
 			.unwrap()
+			.join("runtime")
+			.join("src")
 			.join("symbols");
-		let symbols_file_path = symbols_project_dir.join("src").join("lib.rs");
+		let symbols_file_path = symbols_project_dir.join("mod.rs");
 
 		let symbols_file_contents = std::fs::read_to_string(&symbols_file_path).unwrap();
 

generators/native_methods/src/registernatives.rs

@@ -13,7 +13,7 @@ static NATIVES_REGISTERED: std::sync::atomic::AtomicBool = std::sync::atomic::At
 
 #[allow(trivial_casts, unused_imports)]
 pub fn registerNatives(_: ::jni::env::JniEnv, _: &'static crate::objects::class::Class) {{
-	use symbols::sym;
+	use crate::symbols::sym;
 	
 	if NATIVES_REGISTERED.compare_exchange(false, true, std::sync::atomic::Ordering::SeqCst, std::sync::atomic::Ordering::Acquire) != Ok(false) {{
 		return;

generators/vm_symbols/Cargo.toml

@@ -7,6 +7,6 @@ edition = "2021"
 proc-macro = true
 
 [dependencies]
-syn = { workspace = true, features = ["full", "parsing"] }
+syn = { workspace = true, features = ["clone-impls", "parsing", "extra-traits", "printing"] }
 proc-macro2.workspace = true
 quote.workspace = true

runtime/Cargo.toml

@@ -7,21 +7,24 @@ build = "build.rs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-classfile = { path = "../classfile" }
-common = { path = "../common" }
-instructions = { path = "../instructions" }
-jimage = { path = "../jimage" }
-jni = { path = "../jni" }
+classfile.workspace = true
+common.workspace = true
+instructions.workspace = true
+jimage.workspace = true
+jni.workspace = true
+vm_symbols.workspace = true
 
 bytemuck = "1.20.0"
-byte-slice-cast = { workspace = true }
-tracing = { workspace = true }
+byte-slice-cast.workspace = true
+fxhash.workspace = true
+tracing.workspace = true
 libc.workspace = true
 num_cpus = "1.16.0"
 paste = { workspace = true }
-platform = { path = "../platform" }
-symbols = { path = "../symbols" }
-zip = { workspace = true }
+platform.workspace = true
+zip.workspace = true
+indexmap = "2.7.0"
+bumpalo = "3.16.0"
 
 [build-dependencies]
 native_methods = { path = "../generators/native_methods" }

runtime/build.rs

@@ -1,8 +1,8 @@
 fn main() {
 	println!("cargo::rerun-if-changed=../generators/native_methods/");
 	println!("cargo::rerun-if-changed=src/native/mod.rs");
-	println!("cargo::rerun-if-changed=src/native/java/");
-	println!("cargo::rerun-if-changed=src/native/jdk/");
+	println!("cargo::rerun-if-changed=src/native/java");
+	println!("cargo::rerun-if-changed=src/native/jdk");
 
 	if let Err(e) = native_methods::generate() {
 		println!("cargo::error=Failed to generate native methods: {e}");

runtime/src/calls/jcall.rs

@@ -40,7 +40,7 @@ macro_rules! java_call {
 		tracing::debug!(target: "java_call", "Invoking manual Java call for method `{:?}`", $method);
 		let max_locals = $method.code.max_locals;
 		let __thread = $thread;
-		let __ret = __thread.invoke_method_scoped($method, $crate::stack::local_stack::LocalStack::new_with_args(vec![$(Operand::from($arg)),+], max_locals as usize));
+		let __ret = __thread.invoke_method_scoped($method, $crate::stack::local_stack::LocalStack::new_with_args(vec![$(::instructions::Operand::from($arg)),+], max_locals as usize));
 		tracing::debug!(target: "java_call", "Manual Java call finished for method `{:?}`", $method);
 
 		// Exception thrown, nothing left to do

runtime/src/classpath/loader/mod.rs

@@ -6,6 +6,7 @@ use crate::objects::class::Class;
 use crate::objects::instance::Instance;
 use crate::objects::reference::Reference;
 use crate::string_interner::StringInterner;
+use crate::symbols::Symbol;
 use crate::thread::exceptions::{throw, Throws};
 
 use std::cell::SyncUnsafeCell;
@@ -18,7 +19,6 @@ use classfile::constant_pool::types::raw as raw_types;
 use classfile::{ClassFile, FieldType};
 use common::int_types::u1;
 use common::traits::PtrType;
-use symbols::Symbol;
 
 const SUPPORTED_MAJOR_LOWER_BOUND: u1 = 45;
 const SUPPORTED_MAJOR_UPPER_BOUND: u1 = 69;

runtime/src/classpath/mod.rs

@@ -2,6 +2,8 @@ pub mod jar;
 pub mod jimage;
 pub mod loader;
 
+use crate::symbols::Symbol;
+
 use std::fs::File;
 use std::io::Read;
 use std::path::{Path, PathBuf};
@@ -10,8 +12,6 @@ use std::sync::{LazyLock, Mutex, RwLock};
 use common::int_types::u1;
 use zip::ZipArchive;
 
-use symbols::Symbol;
-
 static CLASSPATH: LazyLock<RwLock<ClassPath>> = LazyLock::new(|| RwLock::new(ClassPath::default()));
 
 pub fn add_classpath_entry(entry: ClassPathEntry) {

runtime/src/globals/fields.rs

@@ -6,12 +6,14 @@
 const MAX_FIELD_COUNT: usize = 8;
 
 macro_rules! get_sym {
-	($specified_sym_name:ident $_fallback:ident) => {
-		symbols::sym!($specified_sym_name)
-	};
-	($fallback:ident) => {
-		symbols::sym!($fallback)
-	};
+	($specified_sym_name:ident $_fallback:ident) => {{
+		use crate::symbols::sym;
+		sym!($specified_sym_name)
+	}};
+	($fallback:ident) => {{
+		use crate::symbols::sym;
+		sym!($fallback)
+	}};
 }
 
 macro_rules! instance_field_count {
@@ -442,7 +444,7 @@ pub mod java_lang_StackTraceElement {
 pub mod java_lang_Throwable {
 	use crate::objects::class_instance::ClassInstance;
 	use crate::objects::instance::Instance;
-	use crate::objects::reference::{ClassInstanceRef, Reference};
+	use crate::objects::reference::Reference;
 	use classfile::FieldType;
 	use instructions::Operand;