Refactored IR to use arenas

Author: IsaacShelton

Cargo.lock

@@ -5,6 +5,7 @@ edition = "2024"
 
 [dependencies]
 append-only-vec.workspace = true
+arena = { version = "0.1.0", path = "../../support/arena" }
 asg = { version = "0.1.0", path = "../../representations/asg" }
 attributes = { version = "0.1.0", path = "../../representations/attributes" }
 compiler = { version = "0.1.0", path = "../../support/compiler" }

src/components/build_ir/Cargo.toml

@@ -1,26 +1,25 @@
 use crate::error::{LowerError, LowerErrorKind};
 use append_only_vec::AppendOnlyVec;
+use arena::{Arena, LockFreeArena};
 use asg::PolyRecipe;
 use attributes::Tag;
 use std::{borrow::Borrow, cell::OnceCell, collections::HashMap, sync::RwLock};
 
 #[derive(Default)]
 pub struct Funcs {
-    funcs: AppendOnlyVec<ir::Func>,
+    funcs: LockFreeArena<ir::FuncId, ir::Func>,
     monomorphized: RwLock<HashMap<(asg::FuncRef, PolyRecipe), ir::FuncRef>>,
     jobs: AppendOnlyVec<(asg::FuncRef, PolyRecipe, ir::FuncRef)>,
     interpreter_entry_point: OnceCell<ir::FuncRef>,
 }
 
 impl Funcs {
-    pub fn build(self) -> ir::Funcs {
-        ir::Funcs::new(self.funcs.into_iter().collect())
+    pub fn build(self) -> Arena<ir::FuncId, ir::Func> {
+        self.funcs.into_arena()
     }
 
     pub fn insert(&self, func_ref: asg::FuncRef, function: ir::Func) -> ir::FuncRef {
-        let index = self.funcs.len();
-        self.funcs.push(function);
-        let ir_func_ref = ir::FuncRef::new(index);
+        let ir_func_ref = self.funcs.alloc(function);
         self.monomorphized
             .write()
             .unwrap()
@@ -62,7 +61,7 @@ impl Funcs {
     }
 
     pub fn get_mut(&mut self, key: ir::FuncRef) -> &mut ir::Func {
-        &mut self.funcs[key.get()]
+        &mut self.funcs[key]
     }
 
     pub fn monomorphized<'a>(

src/components/build_ir/src/funcs.rs

@@ -1,15 +1,15 @@
-use append_only_vec::AppendOnlyVec;
+use arena::{Arena, LockFreeArena};
 use std::{collections::HashMap, sync::RwLock};
 
 #[derive(Debug, Default)]
 pub struct Globals {
-    globals: AppendOnlyVec<ir::Global>,
+    globals: LockFreeArena<ir::GlobalId, ir::Global>,
     lowered: RwLock<HashMap<asg::GlobalRef, ir::GlobalRef>>,
 }
 
 impl Globals {
-    pub fn build(self) -> ir::Globals {
-        ir::Globals::new(self.globals.into_iter().collect())
+    pub fn build(self) -> Arena<ir::GlobalId, ir::Global> {
+        self.globals.into_arena()
     }
 
     pub fn translate(&self, key: asg::GlobalRef) -> ir::GlobalRef {
@@ -22,7 +22,7 @@ impl Globals {
     }
 
     pub fn insert(&self, asg_global_ref: asg::GlobalRef, global: ir::Global) -> ir::GlobalRef {
-        let ir_global_ref = ir::GlobalRef::new(self.globals.push(global));
+        let ir_global_ref = self.globals.alloc(global);
 
         self.lowered
             .write()

src/components/build_ir/src/globals.rs

@@ -1,16 +1,16 @@
-use append_only_vec::AppendOnlyVec;
+use arena::{Arena, LockFreeArena};
 use asg::PolyRecipe;
 use std::{collections::HashMap, sync::RwLock};
 
 #[derive(Debug, Default)]
 pub struct Structs {
-    structs: AppendOnlyVec<ir::Struct>,
+    structs: LockFreeArena<ir::StructId, ir::Struct>,
     monomorphized: RwLock<HashMap<(asg::StructRef, PolyRecipe), ir::StructRef>>,
 }
 
 impl Structs {
-    pub fn build(self) -> ir::Structs {
-        ir::Structs::new(self.structs.into_iter().collect())
+    pub fn build(self) -> Arena<ir::StructId, ir::Struct> {
+        self.structs.into_arena()
     }
 
     pub fn insert(
@@ -19,7 +19,7 @@ impl Structs {
         structure: ir::Struct,
         poly_recipe: PolyRecipe,
     ) -> ir::StructRef {
-        let ir_struct_ref = ir::StructRef::new(self.structs.push(structure));
+        let ir_struct_ref = self.structs.alloc(structure);
 
         let key = (asg_struct_ref, poly_recipe);
         self.monomorphized

src/components/build_ir/src/structs.rs

@@ -39,7 +39,7 @@ pub fn is_homo_aggregate<'a>(
             })
         }
         ir::Type::Struct(struct_ref) => {
-            let structure = ir_module.structs.get(*struct_ref);
+            let structure = &ir_module.structs[*struct_ref];
 
             is_homo_aggregate_record(
                 decider,

src/components/build_llvm_ir/src/abi/homo_aggregate.rs

@@ -773,7 +773,7 @@ unsafe fn emit_call(
     fn_ctx: &FnCtx,
     value_catalog: &mut ValueCatalog,
 ) -> Result<LLVMValueRef, BackendError> {
-    let ir_function = ctx.ir_module.funcs.get(call.func);
+    let ir_function = &ctx.ir_module.funcs[call.func];
 
     let skeleton = ctx
         .func_skeletons

src/components/build_llvm_ir/src/functions/block.rs

@@ -30,7 +30,7 @@ pub struct FnCtx {
 
 pub unsafe fn create_function_bodies(ctx: &mut BackendCtx) -> Result<(), BackendError> {
     for (ir_func_ref, skeleton) in ctx.func_skeletons.iter() {
-        let ir_function = ctx.ir_module.funcs.get(*ir_func_ref);
+        let ir_function = &ctx.ir_module.funcs[*ir_func_ref];
 
         let mut builder = Builder::new();
         let mut value_catalog = ValueCatalog::new(ir_function.basicblocks.len());

src/components/build_llvm_ir/src/functions/body.rs

@@ -54,7 +54,7 @@ pub fn emit_epilogue(
         });
     };
 
-    let ir_function = ctx.ir_module.funcs.get(skeleton.ir_func_ref);
+    let ir_function = &ctx.ir_module.funcs[skeleton.ir_func_ref];
 
     let ir_return_type = &ir_function.return_type;
     let abi_return_info = &abi_function.return_type;

src/components/build_llvm_ir/src/functions/epilogue/mod.rs

@@ -34,7 +34,7 @@ pub fn emit_prologue(
     alloca_point: LLVMValueRef,
     entry_basicblock: LLVMBasicBlockRef,
 ) -> Result<PrologueInfo, BackendError> {
-    let ir_function = ctx.ir_module.funcs.get(skeleton.ir_func_ref);
+    let ir_function = &ctx.ir_module.funcs[skeleton.ir_func_ref];
     let abi_return_info = &abi_function.return_type;
     let returns_ir_void = ir_function.return_type.is_void();
 
@@ -105,7 +105,7 @@ pub fn emit_prologue(
     }
 
     let mut param_values = ParamValues::new();
-    let ir_function = ctx.ir_module.funcs.get(skeleton.ir_func_ref);
+    let ir_function = &ctx.ir_module.funcs[skeleton.ir_func_ref];
 
     assert_eq!(abi_function.parameter_types.len(), ir_function.params.len());
 

src/components/build_llvm_ir/src/functions/prologue/mod.rs

@@ -69,7 +69,7 @@ impl ReturnLocation {
         inalloca: &InAlloca,
         inalloca_subtypes: &[LLVMTypeRef],
     ) -> Result<Self, BackendError> {
-        let ir_function = ctx.ir_module.funcs.get(skeleton.ir_func_ref);
+        let ir_function = &ctx.ir_module.funcs[skeleton.ir_func_ref];
         let last_argument = unsafe { LLVMGetLastParam(skeleton.function) };
 
         let inalloca_combined_struct = skeleton

src/components/build_llvm_ir/src/functions/return_location.rs

@@ -16,7 +16,7 @@ pub unsafe fn to_backend_struct_type(
 
     // Get cached type or insert computed type
     ctx.struct_cache.cache.try_insert_cloned(struct_ref, |_| {
-        let ir_structure = ctx.ir_module.structs.get(struct_ref);
+        let ir_structure = &ctx.ir_module.structs[struct_ref];
 
         ctx.visited.borrow_mut().insert(struct_ref);
         let mut subtypes =

src/components/build_llvm_ir/src/structure.rs

@@ -60,7 +60,7 @@ impl<'a, S: SyscallHandler> Interpreter<'a, S> {
         func_ref: ir::FuncRef,
         args: Vec<Value<'a>>,
     ) -> Result<Value<'a>, InterpreterError> {
-        let function = self.ir_module.funcs.get(func_ref);
+        let function = &self.ir_module.funcs[func_ref];
 
         if function.is_cstyle_variadic {
             todo!(

src/components/interpret/src/lib.rs

@@ -17,7 +17,7 @@ pub fn size_of(ir_type: &ir::Type, ir_module: &ir::Module) -> u64 {
         ir::Type::Void => 0,
         ir::Type::Union(_) => todo!("interpreter write union"),
         ir::Type::Struct(struct_ref) => {
-            let structure = ir_module.structs.get(*struct_ref);
+            let structure = &ir_module.structs[*struct_ref];
 
             // NOTE: We don't do alignment in the interpreter
             structure

src/components/interpret/src/size_of.rs

@@ -1,2 +1,3 @@
-use arena::{Arena, ArenaMap, Id, new_id_with_niche};
-use std::{collections::VecDeque, num::NonZero};
+
+
+

src/components/job/src/lib.rs

@@ -5,6 +5,7 @@ edition = "2024"
 
 [dependencies]
 append-only-vec.workspace = true
+arena = { version = "0.1.0", path = "../../support/arena" }
 attributes = { version = "0.1.0", path = "../attributes" }
 data_units = { version = "0.1.0", path = "../../support/data_units" }
 derivative.workspace = true

src/representations/ir/Cargo.toml

@@ -1,4 +1,4 @@
-use crate::{Type, funcs::FuncRef, global::GlobalRef, value::Value};
+use crate::{FuncRef, GlobalRef, Type, value::Value};
 use primitives::{FloatOrInteger, FloatOrSign, IntegerBits, IntegerSign};
 
 #[derive(Clone, Debug)]