diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen.rs
index ee61a9d13d3..1183f415f79 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen.rs
@@ -9,7 +9,10 @@ mod variable_liveness;
 use acvm::FieldElement;
 
 use self::{brillig_block::BrilligBlock, brillig_fn::FunctionContext};
-use super::brillig_ir::{artifact::BrilligArtifact, BrilligContext};
+use super::brillig_ir::{
+    artifact::{BrilligArtifact, Label},
+    BrilligContext,
+};
 use crate::ssa::ir::function::Function;
 
 /// Converting an SSA function into Brillig bytecode.
@@ -21,7 +24,7 @@ pub(crate) fn convert_ssa_function(
 
     let mut function_context = FunctionContext::new(func);
 
-    brillig_context.enter_context(FunctionContext::function_id_to_function_label(func.id()));
+    brillig_context.enter_context(Label::function(func.id()));
 
     for block in function_context.blocks.clone() {
         BrilligBlock::compile(&mut function_context, &mut brillig_context, block, &func.dfg);
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index 8e2b2fb7a29..802d442885f 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -6,14 +6,15 @@ use acvm::{
 use crate::brillig::brillig_ir::{
     brillig_variable::{BrilligVariable, BrilligVector, SingleAddrVariable},
     debug_show::DebugToString,
+    registers::RegisterAllocator,
     BrilligContext,
 };
 
 /// Transforms SSA's black box function calls into the corresponding brillig instructions
 /// Extracting arguments and results from the SSA function call
 /// And making any necessary type conversions to adapt noir's blackbox calls to brillig's
-pub(crate) fn convert_black_box_call<F: AcirField + DebugToString>(
-    brillig_context: &mut BrilligContext<F>,
+pub(crate) fn convert_black_box_call<F: AcirField + DebugToString, Registers: RegisterAllocator>(
+    brillig_context: &mut BrilligContext<F, Registers>,
     bb_func: &BlackBoxFunc,
     function_arguments: &[BrilligVariable],
     function_results: &[BrilligVariable],
@@ -397,8 +398,8 @@ pub(crate) fn convert_black_box_call<F: AcirField + DebugToString>(
     }
 }
 
-fn convert_array_or_vector<F: AcirField + DebugToString>(
-    brillig_context: &mut BrilligContext<F>,
+fn convert_array_or_vector<F: AcirField + DebugToString, Registers: RegisterAllocator>(
+    brillig_context: &mut BrilligContext<F, Registers>,
     array_or_vector: &BrilligVariable,
     bb_func: &BlackBoxFunc,
 ) -> BrilligVector {
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 76ab613ed1f..74fdbfcdce6 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -1,8 +1,10 @@
+use crate::brillig::brillig_ir::artifact::Label;
 use crate::brillig::brillig_ir::brillig_variable::{
     type_to_heap_value_type, BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable,
 };
+use crate::brillig::brillig_ir::registers::Stack;
 use crate::brillig::brillig_ir::{
-    BrilligBinaryOp, BrilligContext, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+    BrilligBinaryOp, BrilligContext, ReservedRegisters, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
 };
 use crate::ssa::ir::dfg::CallStack;
 use crate::ssa::ir::instruction::ConstrainError;
@@ -34,7 +36,7 @@ pub(crate) struct BrilligBlock<'block> {
     /// The basic block that is being converted
     pub(crate) block_id: BasicBlockId,
     /// Context for creating brillig opcodes
-    pub(crate) brillig_context: &'block mut BrilligContext<FieldElement>,
+    pub(crate) brillig_context: &'block mut BrilligContext<FieldElement, Stack>,
     /// Tracks the available variable during the codegen of the block
     pub(crate) variables: BlockVariables,
     /// For each instruction, the set of values that are not used anymore after it.
@@ -45,7 +47,7 @@ impl<'block> BrilligBlock<'block> {
     /// Converts an SSA Basic block into a sequence of Brillig opcodes
     pub(crate) fn compile(
         function_context: &'block mut FunctionContext,
-        brillig_context: &'block mut BrilligContext<FieldElement>,
+        brillig_context: &'block mut BrilligContext<FieldElement, Stack>,
         block_id: BasicBlockId,
         dfg: &DataFlowGraph,
     ) {
@@ -93,7 +95,7 @@ impl<'block> BrilligBlock<'block> {
     /// This uses the current functions's function ID and the block ID
     /// Making the assumption that the block ID passed in belongs to this
     /// function.
-    fn create_block_label_for_current_function(&self, block_id: BasicBlockId) -> String {
+    fn create_block_label_for_current_function(&self, block_id: BasicBlockId) -> Label {
         Self::create_block_label(self.function_context.function_id, block_id)
     }
     /// Creates a unique label for a block using the function Id and the block ID.
@@ -102,8 +104,8 @@ impl<'block> BrilligBlock<'block> {
     /// for us to create a unique label across functions and blocks.
     ///
     /// This is so that during linking there are no duplicates or labels being overwritten.
-    fn create_block_label(function_id: FunctionId, block_id: BasicBlockId) -> String {
-        format!("{function_id}-{block_id}")
+    fn create_block_label(function_id: FunctionId, block_id: BasicBlockId) -> Label {
+        Label::block(function_id, block_id)
     }
 
     /// Converts an SSA terminator instruction into the necessary opcodes.
@@ -468,13 +470,21 @@ impl<'block> BrilligBlock<'block> {
                         result_ids[1],
                         dfg,
                     );
-                    let source_size_as_register =
-                        self.convert_ssa_array_set(source_variable, destination_variable, None);
 
-                    // we need to explicitly set the destination_len_variable
                     self.brillig_context
-                        .mov_instruction(destination_len_variable.address, source_size_as_register);
-                    self.brillig_context.deallocate_register(source_size_as_register);
+                        .call_array_copy_procedure(source_variable, destination_variable);
+
+                    let BrilligVariable::BrilligArray(BrilligArray { size: source_size, .. }) =
+                        source_variable
+                    else {
+                        unreachable!("ICE: AsSlice on non-array")
+                    };
+
+                    // we need to explicitly set the destination_len_variable
+                    self.brillig_context.usize_const_instruction(
+                        destination_len_variable.address,
+                        source_size.into(),
+                    );
                 }
                 Value::Intrinsic(
                     Intrinsic::SlicePushBack
@@ -660,12 +670,12 @@ impl<'block> BrilligBlock<'block> {
                     dfg,
                 );
                 self.validate_array_index(source_variable, index_register);
-                let source_size_as_register = self.convert_ssa_array_set(
+                self.convert_ssa_array_set(
                     source_variable,
                     destination_variable,
-                    Some((index_register.address, value_variable)),
+                    index_register,
+                    value_variable,
                 );
-                self.brillig_context.deallocate_register(source_size_as_register);
             }
             Instruction::RangeCheck { value, max_bit_size, assert_message } => {
                 let value = self.convert_ssa_single_addr_value(*value, dfg);
@@ -761,9 +771,6 @@ impl<'block> BrilligBlock<'block> {
             .flat_map(|argument_id| self.convert_ssa_value(*argument_id, dfg).extract_registers())
             .collect();
 
-        // Create label for the function that will be called
-        let label_of_function_to_call = FunctionContext::function_id_to_function_label(func_id);
-
         let variables_to_save = self.variables.get_available_variables(self.function_context);
 
         let saved_registers = self
@@ -774,7 +781,7 @@ impl<'block> BrilligBlock<'block> {
         self.variables.dump_constants();
 
         // Call instruction, which will interpret above registers 0..num args
-        self.brillig_context.add_external_call_instruction(label_of_function_to_call);
+        self.brillig_context.add_external_call_instruction(func_id);
 
         // Important: resolve after pre_call_save_registers_prep_args
         // This ensures we don't save the results to registers unnecessarily.
@@ -870,88 +877,23 @@ impl<'block> BrilligBlock<'block> {
         &mut self,
         source_variable: BrilligVariable,
         destination_variable: BrilligVariable,
-        opt_index_and_value: Option<(MemoryAddress, BrilligVariable)>,
-    ) -> MemoryAddress {
+        index_register: SingleAddrVariable,
+        value_variable: BrilligVariable,
+    ) {
+        assert!(index_register.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
         let destination_pointer = match destination_variable {
             BrilligVariable::BrilligArray(BrilligArray { pointer, .. }) => pointer,
             BrilligVariable::BrilligVector(BrilligVector { pointer, .. }) => pointer,
             _ => unreachable!("ICE: array_set SSA returns non-array"),
         };
 
-        let reference_count = match source_variable {
-            BrilligVariable::BrilligArray(BrilligArray { rc, .. })
-            | BrilligVariable::BrilligVector(BrilligVector { rc, .. }) => rc,
-            _ => unreachable!("ICE: array_set SSA on non-array"),
-        };
-
-        let (source_pointer, source_size_as_register) = match source_variable {
-            BrilligVariable::BrilligArray(BrilligArray { size, pointer, rc: _ }) => {
-                let source_size_register = self.brillig_context.allocate_register();
-                self.brillig_context.usize_const_instruction(source_size_register, size.into());
-                (pointer, source_size_register)
-            }
-            BrilligVariable::BrilligVector(BrilligVector { size, pointer, rc: _ }) => {
-                let source_size_register = self.brillig_context.allocate_register();
-                self.brillig_context.mov_instruction(source_size_register, size);
-                (pointer, source_size_register)
-            }
-            _ => unreachable!("ICE: array_set SSA on non-array"),
-        };
-
-        // Here we want to compare the reference count against 1.
-        let one = self.brillig_context.make_usize_constant_instruction(1_usize.into());
-        let condition = self.brillig_context.allocate_register();
-        self.brillig_context.memory_op_instruction(
-            reference_count,
-            one.address,
-            condition,
-            BrilligBinaryOp::Equals,
+        self.brillig_context.call_array_copy_procedure(source_variable, destination_variable);
+        // Then set the value in the newly created array
+        self.brillig_context.codegen_store_variable_in_array(
+            destination_pointer,
+            index_register,
+            value_variable,
         );
-        self.brillig_context.codegen_branch(condition, |ctx, cond| {
-            if cond {
-                // Reference count is 1, we can mutate the array directly
-                ctx.mov_instruction(destination_pointer, source_pointer);
-            } else {
-                // First issue a array copy to the destination
-                ctx.codegen_allocate_array(destination_pointer, source_size_as_register);
-
-                ctx.codegen_copy_array(
-                    source_pointer,
-                    destination_pointer,
-                    SingleAddrVariable::new(
-                        source_size_as_register,
-                        BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
-                    ),
-                );
-            }
-        });
-
-        match destination_variable {
-            BrilligVariable::BrilligArray(BrilligArray { rc: target_rc, .. }) => {
-                self.brillig_context.usize_const_instruction(target_rc, 1_usize.into());
-            }
-            BrilligVariable::BrilligVector(BrilligVector {
-                size: target_size,
-                rc: target_rc,
-                ..
-            }) => {
-                self.brillig_context.mov_instruction(target_size, source_size_as_register);
-                self.brillig_context.usize_const_instruction(target_rc, 1_usize.into());
-            }
-            _ => unreachable!("ICE: array_set SSA on non-array"),
-        }
-
-        if let Some((index_register, value_variable)) = opt_index_and_value {
-            // Then set the value in the newly created array
-            self.brillig_context.codegen_store_variable_in_array(
-                destination_pointer,
-                SingleAddrVariable::new_usize(index_register),
-                value_variable,
-            );
-        }
-
-        self.brillig_context.deallocate_register(condition);
-        source_size_as_register
     }
 
     /// Convert the SSA slice operations to brillig slice operations
@@ -1733,11 +1675,9 @@ impl<'block> BrilligBlock<'block> {
             let subitem_pointer =
                 SingleAddrVariable::new_usize(self.brillig_context.allocate_register());
 
-            let one = self.brillig_context.make_usize_constant_instruction(1_usize.into());
-
             // Initializes a single subitem
             let initializer_fn =
-                |ctx: &mut BrilligContext<_>, subitem_start_pointer: SingleAddrVariable| {
+                |ctx: &mut BrilligContext<_, _>, subitem_start_pointer: SingleAddrVariable| {
                     ctx.mov_instruction(subitem_pointer.address, subitem_start_pointer.address);
                     for (subitem_index, subitem) in
                         subitem_to_repeat_variables.into_iter().enumerate()
@@ -1746,7 +1686,7 @@ impl<'block> BrilligBlock<'block> {
                         if subitem_index != item_types.len() - 1 {
                             ctx.memory_op_instruction(
                                 subitem_pointer.address,
-                                one.address,
+                                ReservedRegisters::usize_one(),
                                 subitem_pointer.address,
                                 BrilligBinaryOp::Add,
                             );
@@ -1764,13 +1704,13 @@ impl<'block> BrilligBlock<'block> {
 
             self.brillig_context.deallocate_single_addr(step_variable);
             self.brillig_context.deallocate_single_addr(subitem_pointer);
-            self.brillig_context.deallocate_single_addr(one);
         } else {
             let subitem = subitem_to_repeat_variables.into_iter().next().unwrap();
 
-            let initializer_fn = |ctx: &mut BrilligContext<_>, item_pointer: SingleAddrVariable| {
-                ctx.codegen_store_variable_in_pointer(item_pointer.address, subitem);
-            };
+            let initializer_fn =
+                |ctx: &mut BrilligContext<_, _>, item_pointer: SingleAddrVariable| {
+                    ctx.codegen_store_variable_in_pointer(item_pointer.address, subitem);
+                };
 
             // for (let item_pointer = pointer; item_pointer < pointer + data_length; item_pointer += 1) { initializer_fn(iterator) }
             self.brillig_context.codegen_for_loop(
@@ -1791,7 +1731,6 @@ impl<'block> BrilligBlock<'block> {
     ) {
         // Allocate a register for the iterator
         let write_pointer_register = self.brillig_context.allocate_register();
-        let one = self.brillig_context.make_usize_constant_instruction(1_usize.into());
 
         self.brillig_context.mov_instruction(write_pointer_register, pointer);
 
@@ -1804,7 +1743,7 @@ impl<'block> BrilligBlock<'block> {
                 // Increment the write_pointer_register
                 self.brillig_context.memory_op_instruction(
                     write_pointer_register,
-                    one.address,
+                    ReservedRegisters::usize_one(),
                     write_pointer_register,
                     BrilligBinaryOp::Add,
                 );
@@ -1812,7 +1751,6 @@ impl<'block> BrilligBlock<'block> {
         }
 
         self.brillig_context.deallocate_register(write_pointer_register);
-        self.brillig_context.deallocate_single_addr(one);
     }
 
     /// Converts an SSA `ValueId` into a `MemoryAddress`. Initializes if necessary.
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
index ffbca256d28..63b2073c654 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
@@ -7,6 +7,7 @@ use crate::{
             get_bit_size_from_ssa_type, BrilligArray, BrilligVariable, BrilligVector,
             SingleAddrVariable,
         },
+        registers::{RegisterAllocator, Stack},
         BrilligContext,
     },
     ssa::ir::{
@@ -51,7 +52,7 @@ impl BlockVariables {
     pub(crate) fn define_variable(
         &mut self,
         function_context: &mut FunctionContext,
-        brillig_context: &mut BrilligContext<FieldElement>,
+        brillig_context: &mut BrilligContext<FieldElement, Stack>,
         value_id: ValueId,
         dfg: &DataFlowGraph,
     ) -> BrilligVariable {
@@ -71,7 +72,7 @@ impl BlockVariables {
     pub(crate) fn define_single_addr_variable(
         &mut self,
         function_context: &mut FunctionContext,
-        brillig_context: &mut BrilligContext<FieldElement>,
+        brillig_context: &mut BrilligContext<FieldElement, Stack>,
         value: ValueId,
         dfg: &DataFlowGraph,
     ) -> SingleAddrVariable {
@@ -84,7 +85,7 @@ impl BlockVariables {
         &mut self,
         value_id: &ValueId,
         function_context: &mut FunctionContext,
-        brillig_context: &mut BrilligContext<FieldElement>,
+        brillig_context: &mut BrilligContext<FieldElement, Stack>,
     ) {
         assert!(self.available_variables.remove(value_id), "ICE: Variable is not available");
         let variable = function_context
@@ -123,7 +124,7 @@ impl BlockVariables {
     /// We keep constants block-local.
     pub(crate) fn allocate_constant(
         &mut self,
-        brillig_context: &mut BrilligContext<FieldElement>,
+        brillig_context: &mut BrilligContext<FieldElement, Stack>,
         value_id: ValueId,
         dfg: &DataFlowGraph,
     ) -> BrilligVariable {
@@ -155,9 +156,9 @@ pub(crate) fn compute_array_length(item_typ: &CompositeType, elem_count: usize)
 }
 
 /// For a given value_id, allocates the necessary registers to hold it.
-pub(crate) fn allocate_value<F>(
+pub(crate) fn allocate_value<F, Registers: RegisterAllocator>(
     value_id: ValueId,
-    brillig_context: &mut BrilligContext<F>,
+    brillig_context: &mut BrilligContext<F, Registers>,
     dfg: &DataFlowGraph,
 ) -> BrilligVariable {
     let typ = dfg.type_of_value(value_id);
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
index f0752c80c46..c1abad17a8f 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
@@ -2,7 +2,7 @@ use iter_extended::vecmap;
 
 use crate::{
     brillig::brillig_ir::{
-        artifact::{BrilligParameter, Label},
+        artifact::BrilligParameter,
         brillig_variable::{get_bit_size_from_ssa_type, BrilligVariable},
     },
     ssa::ir::{
@@ -44,11 +44,6 @@ impl FunctionContext {
         }
     }
 
-    /// Creates a function label from a given SSA function id.
-    pub(crate) fn function_id_to_function_label(function_id: FunctionId) -> Label {
-        function_id.to_string()
-    }
-
     pub(crate) fn ssa_type_to_parameter(typ: &Type) -> BrilligParameter {
         match typ {
             Type::Numeric(_) | Type::Reference(_) => {
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
index 55679432b1f..9dbf0ee9bb6 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
@@ -24,7 +24,7 @@ impl<'block> BrilligBlock<'block> {
         self.brillig_context.usize_const_instruction(target_vector.rc, 1_usize.into());
 
         // Now we copy the source vector into the target vector
-        self.brillig_context.codegen_copy_array(
+        self.brillig_context.codegen_mem_copy(
             source_vector.pointer,
             target_vector.pointer,
             SingleAddrVariable::new_usize(source_vector.size),
@@ -74,7 +74,7 @@ impl<'block> BrilligBlock<'block> {
         );
 
         // Now we copy the source vector into the target vector starting at index variables_to_insert.len()
-        self.brillig_context.codegen_copy_array(
+        self.brillig_context.codegen_mem_copy(
             source_vector.pointer,
             destination_copy_pointer,
             SingleAddrVariable::new_usize(source_vector.size),
@@ -121,7 +121,7 @@ impl<'block> BrilligBlock<'block> {
         );
 
         // Now we copy the source vector starting at index removed_items.len() into the target vector
-        self.brillig_context.codegen_copy_array(
+        self.brillig_context.codegen_mem_copy(
             source_copy_pointer,
             target_vector.pointer,
             SingleAddrVariable::new_usize(target_vector.size),
@@ -154,7 +154,7 @@ impl<'block> BrilligBlock<'block> {
         self.brillig_context.usize_const_instruction(target_vector.rc, 1_usize.into());
 
         // Now we copy all elements except the last items into the target vector
-        self.brillig_context.codegen_copy_array(
+        self.brillig_context.codegen_mem_copy(
             source_vector.pointer,
             target_vector.pointer,
             SingleAddrVariable::new_usize(target_vector.size),
@@ -192,11 +192,7 @@ impl<'block> BrilligBlock<'block> {
         self.brillig_context.usize_const_instruction(target_vector.rc, 1_usize.into());
 
         // Copy the elements to the left of the index
-        self.brillig_context.codegen_copy_array(
-            source_vector.pointer,
-            target_vector.pointer,
-            index,
-        );
+        self.brillig_context.codegen_mem_copy(source_vector.pointer, target_vector.pointer, index);
 
         // Compute the source pointer just at the index
         let source_pointer_at_index = self.brillig_context.allocate_register();
@@ -231,7 +227,7 @@ impl<'block> BrilligBlock<'block> {
         );
 
         // Copy the elements to the right of the index
-        self.brillig_context.codegen_copy_array(
+        self.brillig_context.codegen_mem_copy(
             source_pointer_at_index,
             target_pointer_after_index,
             SingleAddrVariable::new_usize(item_count),
@@ -279,11 +275,7 @@ impl<'block> BrilligBlock<'block> {
         self.brillig_context.usize_const_instruction(target_vector.rc, 1_usize.into());
 
         // Copy the elements to the left of the index
-        self.brillig_context.codegen_copy_array(
-            source_vector.pointer,
-            target_vector.pointer,
-            index,
-        );
+        self.brillig_context.codegen_mem_copy(source_vector.pointer, target_vector.pointer, index);
 
         // Compute the source pointer after the removed items
         let source_pointer_after_index = self.brillig_context.allocate_register();
@@ -323,7 +315,7 @@ impl<'block> BrilligBlock<'block> {
         );
 
         // Copy the elements to the right of the index
-        self.brillig_context.codegen_copy_array(
+        self.brillig_context.codegen_mem_copy(
             source_pointer_after_index,
             target_pointer_at_index,
             SingleAddrVariable::new_usize(item_count),
@@ -371,10 +363,11 @@ mod tests {
     use crate::brillig::brillig_gen::brillig_block::BrilligBlock;
     use crate::brillig::brillig_gen::brillig_block_variables::BlockVariables;
     use crate::brillig::brillig_gen::brillig_fn::FunctionContext;
-    use crate::brillig::brillig_ir::artifact::BrilligParameter;
+    use crate::brillig::brillig_ir::artifact::{BrilligParameter, Label};
     use crate::brillig::brillig_ir::brillig_variable::{
         BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable,
     };
+    use crate::brillig::brillig_ir::registers::Stack;
     use crate::brillig::brillig_ir::tests::{
         create_and_run_vm, create_context, create_entry_point_bytecode,
     };
@@ -384,12 +377,14 @@ mod tests {
     use crate::ssa::ir::map::Id;
     use crate::ssa::ssa_gen::Ssa;
 
-    fn create_test_environment() -> (Ssa, FunctionContext, BrilligContext<FieldElement>) {
+    fn create_test_environment() -> (Ssa, FunctionContext, BrilligContext<FieldElement, Stack>) {
         let mut builder = FunctionBuilder::new("main".to_string(), Id::test_new(0));
         builder.set_runtime(RuntimeType::Brillig);
 
         let ssa = builder.finish();
-        let brillig_context = create_context();
+        let mut brillig_context = create_context(ssa.main_id);
+        brillig_context.enter_context(Label::block(ssa.main_id, Id::test_new(0)));
+        brillig_context.disable_procedures();
 
         let function_context = FunctionContext::new(ssa.main());
         (ssa, function_context, brillig_context)
@@ -397,7 +392,7 @@ mod tests {
 
     fn create_brillig_block<'a>(
         function_context: &'a mut FunctionContext,
-        brillig_context: &'a mut BrilligContext<FieldElement>,
+        brillig_context: &'a mut BrilligContext<FieldElement, Stack>,
     ) -> BrilligBlock<'a> {
         let variables = BlockVariables::default();
         BrilligBlock {
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index 21f8722c116..05117b96c5d 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -12,6 +12,7 @@
 pub(crate) mod artifact;
 pub(crate) mod brillig_variable;
 pub(crate) mod debug_show;
+pub(crate) mod procedures;
 pub(crate) mod registers;
 
 mod codegen_binary;
@@ -23,11 +24,11 @@ mod codegen_stack;
 mod entry_point;
 mod instructions;
 
+use artifact::Label;
 pub(crate) use instructions::BrilligBinaryOp;
+use registers::{RegisterAllocator, ScratchSpace};
 
-use self::{
-    artifact::BrilligArtifact, debug_show::DebugToString, registers::BrilligRegistersContext,
-};
+use self::{artifact::BrilligArtifact, debug_show::DebugToString, registers::Stack};
 use crate::ssa::ir::dfg::CallStack;
 use acvm::{
     acir::brillig::{MemoryAddress, Opcode as BrilligOpcode},
@@ -46,6 +47,8 @@ pub(crate) enum ReservedRegisters {
     FreeMemoryPointer = 0,
     /// This register stores the previous stack pointer. The registers of the caller are stored here.
     PreviousStackPointer = 1,
+    /// This register stores a 1_usize constant.
+    UsizeOne = 2,
 }
 
 impl ReservedRegisters {
@@ -53,7 +56,7 @@ impl ReservedRegisters {
     ///
     /// This is used to offset the general registers
     /// which should not overwrite the special register
-    const NUM_RESERVED_REGISTERS: usize = 2;
+    const NUM_RESERVED_REGISTERS: usize = 3;
 
     /// Returns the length of the reserved registers
     pub(crate) fn len() -> usize {
@@ -70,42 +73,67 @@ impl ReservedRegisters {
         MemoryAddress::from(ReservedRegisters::PreviousStackPointer as usize)
     }
 
-    /// Returns a user defined (non-reserved) register index.
-    fn user_register_index(index: usize) -> MemoryAddress {
-        MemoryAddress::from(index + ReservedRegisters::len())
+    /// Returns the usize one register. This will be used to perform arithmetic operations.
+    pub(crate) fn usize_one() -> MemoryAddress {
+        MemoryAddress::from(ReservedRegisters::UsizeOne as usize)
     }
 }
 
 /// Brillig context object that is used while constructing the
 /// Brillig bytecode.
-pub(crate) struct BrilligContext<F> {
+pub(crate) struct BrilligContext<F, Registers> {
     obj: BrilligArtifact<F>,
     /// Tracks register allocations
-    registers: BrilligRegistersContext,
+    registers: Registers,
     /// Context label, must be unique with respect to the function
     /// being linked.
-    context_label: String,
+    context_label: Label,
     /// Section label, used to separate sections of code
-    section_label: usize,
+    current_section: usize,
     /// Stores the next available section
     next_section: usize,
     /// IR printer
     debug_show: DebugShow,
+    /// Whether this context can call procedures or not.
+    /// This is used to prevent a procedure from calling another procedure.
+    can_call_procedures: bool,
 }
 
-impl<F: AcirField + DebugToString> BrilligContext<F> {
-    /// Initial context state
-    pub(crate) fn new(enable_debug_trace: bool) -> BrilligContext<F> {
+/// Regular brillig context to codegen user defined functions
+impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
+    pub(crate) fn new(enable_debug_trace: bool) -> BrilligContext<F, Stack> {
         BrilligContext {
             obj: BrilligArtifact::default(),
-            registers: BrilligRegistersContext::new(),
-            context_label: String::default(),
-            section_label: 0,
+            registers: Stack::new(),
+            context_label: Label::entrypoint(),
+            current_section: 0,
             next_section: 1,
             debug_show: DebugShow::new(enable_debug_trace),
+            can_call_procedures: true,
         }
     }
+    /// Allows disabling procedures so tests don't need a linking pass
+    pub(crate) fn disable_procedures(&mut self) {
+        self.can_call_procedures = false;
+    }
+}
+
+/// Special brillig context to codegen compiler intrinsic shared procedures
+impl<F: AcirField + DebugToString> BrilligContext<F, ScratchSpace> {
+    pub(crate) fn new_for_procedure(enable_debug_trace: bool) -> BrilligContext<F, ScratchSpace> {
+        BrilligContext {
+            obj: BrilligArtifact::default(),
+            registers: ScratchSpace::new(),
+            context_label: Label::entrypoint(),
+            current_section: 0,
+            next_section: 1,
+            debug_show: DebugShow::new(enable_debug_trace),
+            can_call_procedures: false,
+        }
+    }
+}
 
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
     /// Adds a brillig instruction to the brillig byte code
     fn push_opcode(&mut self, opcode: BrilligOpcode<F>) {
         self.obj.push_opcode(opcode);
@@ -135,8 +163,10 @@ pub(crate) mod tests {
     use acvm::{BlackBoxFunctionSolver, BlackBoxResolutionError, FieldElement};
 
     use crate::brillig::brillig_ir::{BrilligBinaryOp, BrilligContext};
+    use crate::ssa::ir::function::FunctionId;
 
-    use super::artifact::{BrilligParameter, GeneratedBrillig};
+    use super::artifact::{BrilligParameter, GeneratedBrillig, Label};
+    use super::registers::Stack;
     use super::{BrilligOpcode, ReservedRegisters};
 
     pub(crate) struct DummyBlackBoxSolver;
@@ -195,20 +225,20 @@ pub(crate) mod tests {
         }
     }
 
-    pub(crate) fn create_context() -> BrilligContext<FieldElement> {
+    pub(crate) fn create_context(id: FunctionId) -> BrilligContext<FieldElement, Stack> {
         let mut context = BrilligContext::new(true);
-        context.enter_context("test");
+        context.enter_context(Label::function(id));
         context
     }
 
     pub(crate) fn create_entry_point_bytecode(
-        context: BrilligContext<FieldElement>,
+        context: BrilligContext<FieldElement, Stack>,
         arguments: Vec<BrilligParameter>,
         returns: Vec<BrilligParameter>,
     ) -> GeneratedBrillig<FieldElement> {
         let artifact = context.artifact();
         let mut entry_point_artifact =
-            BrilligContext::new_entry_point_artifact(arguments, returns, "test".to_string());
+            BrilligContext::new_entry_point_artifact(arguments, returns, FunctionId::test_new(0));
         entry_point_artifact.link_with(&artifact);
         entry_point_artifact.finish()
     }
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
index 2d0bdb5955c..ca37ea225a4 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
@@ -1,7 +1,8 @@
 use acvm::acir::brillig::Opcode as BrilligOpcode;
 use std::collections::{BTreeMap, HashMap};
 
-use crate::ssa::ir::dfg::CallStack;
+use crate::brillig::brillig_ir::procedures::ProcedureId;
+use crate::ssa::ir::{basic_block::BasicBlockId, dfg::CallStack, function::FunctionId};
 
 /// Represents a parameter or a return value of an entry point function.
 #[derive(Debug, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
@@ -44,7 +45,7 @@ pub(crate) struct BrilligArtifact<F> {
     /// which are defined in other bytecode, that this bytecode has called.
     /// TODO: perhaps we should combine this with the `unresolved_jumps` field
     /// TODO: and have an enum which indicates whether the jump is internal or external
-    unresolved_external_call_labels: Vec<(JumpInstructionPosition, UnresolvedJumpLocation)>,
+    unresolved_external_call_labels: Vec<(JumpInstructionPosition, Label)>,
     /// Maps the opcodes that are associated with a callstack to it.
     locations: BTreeMap<OpcodeLocation, CallStack>,
     /// The current call stack. All opcodes that are pushed will be associated with this call stack.
@@ -53,11 +54,74 @@ pub(crate) struct BrilligArtifact<F> {
 
 /// A pointer to a location in the opcode.
 pub(crate) type OpcodeLocation = usize;
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+pub(crate) enum LabelType {
+    /// Labels for the entry point bytecode
+    Entrypoint,
+    /// Labels for user defined functions
+    Function(FunctionId, Option<BasicBlockId>),
+    /// Labels for intrinsic procedures
+    Procedure(ProcedureId),
+}
+
+impl std::fmt::Display for LabelType {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            LabelType::Function(function_id, block_id) => {
+                if let Some(block_id) = block_id {
+                    write!(f, "Function({:?}, {:?})", function_id, block_id)
+                } else {
+                    write!(f, "Function({:?})", function_id)
+                }
+            }
+            LabelType::Entrypoint => write!(f, "Entrypoint"),
+            LabelType::Procedure(procedure_id) => write!(f, "Procedure({:?})", procedure_id),
+        }
+    }
+}
+
 /// An identifier for a location in the code.
 ///
 /// It is assumed that an entity will keep a map
 /// of labels to Opcode locations.
-pub(crate) type Label = String;
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+pub(crate) struct Label {
+    pub(crate) label_type: LabelType,
+    pub(crate) section: Option<usize>,
+}
+
+impl Label {
+    pub(crate) fn add_section(&self, section: usize) -> Self {
+        Label { label_type: self.label_type, section: Some(section) }
+    }
+
+    pub(crate) fn function(func_id: FunctionId) -> Self {
+        Label { label_type: LabelType::Function(func_id, None), section: None }
+    }
+
+    pub(crate) fn block(func_id: FunctionId, block_id: BasicBlockId) -> Self {
+        Label { label_type: LabelType::Function(func_id, Some(block_id)), section: None }
+    }
+
+    pub(crate) fn entrypoint() -> Self {
+        Label { label_type: LabelType::Entrypoint, section: None }
+    }
+
+    pub(crate) fn procedure(procedure_id: ProcedureId) -> Self {
+        Label { label_type: LabelType::Procedure(procedure_id), section: None }
+    }
+}
+
+impl std::fmt::Display for Label {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        if let Some(section) = self.section {
+            write!(f, "{:?} - {}", self.label_type, section)
+        } else {
+            write!(f, "{:?}", self.label_type)
+        }
+    }
+}
 /// Pointer to a unresolved Jump instruction in
 /// the bytecode.
 pub(crate) type JumpInstructionPosition = OpcodeLocation;
@@ -86,7 +150,7 @@ impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
 
     /// Gets the first unresolved function call of this artifact.
     pub(crate) fn first_unresolved_function_call(&self) -> Option<Label> {
-        self.unresolved_external_call_labels.first().map(|(_, label)| label.clone())
+        self.unresolved_external_call_labels.first().map(|(_, label)| *label)
     }
 
     /// Link with an external brillig artifact called from this artifact.
@@ -131,17 +195,16 @@ impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
     fn add_unresolved_jumps_and_calls(&mut self, obj: &BrilligArtifact<F>) {
         let offset = self.index_of_next_opcode();
         for (jump_label, jump_location) in &obj.unresolved_jumps {
-            self.unresolved_jumps.push((jump_label + offset, jump_location.clone()));
+            self.unresolved_jumps.push((jump_label + offset, *jump_location));
         }
 
         for (label_id, position_in_bytecode) in &obj.labels {
-            let old_value = self.labels.insert(label_id.clone(), position_in_bytecode + offset);
+            let old_value = self.labels.insert(*label_id, position_in_bytecode + offset);
             assert!(old_value.is_none(), "overwriting label {label_id} {old_value:?}");
         }
 
         for (position_in_bytecode, label_id) in &obj.unresolved_external_call_labels {
-            self.unresolved_external_call_labels
-                .push((position_in_bytecode + offset, label_id.clone()));
+            self.unresolved_external_call_labels.push((position_in_bytecode + offset, *label_id));
         }
 
         for (position_in_bytecode, message) in &obj.assert_messages {
@@ -199,8 +262,8 @@ impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
 
     /// Adds a label in the bytecode to specify where this block's
     /// opcodes will start.
-    pub(crate) fn add_label_at_position(&mut self, label: String, position: OpcodeLocation) {
-        let old_value = self.labels.insert(label.clone(), position);
+    pub(crate) fn add_label_at_position(&mut self, label: Label, position: OpcodeLocation) {
+        let old_value = self.labels.insert(label, position);
         assert!(
             old_value.is_none(),
             "overwriting label {label}. old_value = {old_value:?}, new_value = {position}"
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs
index a9c4f238491..9f573543e2a 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs
@@ -1,8 +1,11 @@
 use acvm::{acir::brillig::MemoryAddress, AcirField};
 
-use super::{debug_show::DebugToString, instructions::BrilligBinaryOp, BrilligContext};
+use super::{
+    debug_show::DebugToString, instructions::BrilligBinaryOp, registers::RegisterAllocator,
+    BrilligContext, ReservedRegisters,
+};
 
-impl<F: AcirField + DebugToString> BrilligContext<F> {
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
     /// Utility method to perform a binary instruction with a constant value in place
     pub(crate) fn codegen_usize_op_in_place(
         &mut self,
@@ -21,9 +24,13 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
         op: BrilligBinaryOp,
         constant: usize,
     ) {
-        let const_register = self.make_usize_constant_instruction(F::from(constant));
-        self.memory_op_instruction(operand, const_register.address, destination, op);
-        // Mark as no longer used for this purpose, frees for reuse
-        self.deallocate_single_addr(const_register);
+        if constant == 1 {
+            self.memory_op_instruction(operand, ReservedRegisters::usize_one(), destination, op);
+        } else {
+            let const_register = self.make_usize_constant_instruction(F::from(constant));
+            self.memory_op_instruction(operand, const_register.address, destination, op);
+            // Mark as no longer used for this purpose, frees for reuse
+            self.deallocate_single_addr(const_register);
+        }
     }
 }
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs
index 2d93cf70181..e65e2766257 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs
@@ -1,11 +1,11 @@
 use acvm::{acir::brillig::MemoryAddress, AcirField};
 
 use super::{
-    brillig_variable::BrilligVariable, debug_show::DebugToString, BrilligBinaryOp, BrilligContext,
-    ReservedRegisters,
+    brillig_variable::BrilligVariable, debug_show::DebugToString, registers::RegisterAllocator,
+    BrilligBinaryOp, BrilligContext, ReservedRegisters,
 };
 
-impl<F: AcirField + DebugToString> BrilligContext<F> {
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
     /// Saves all of the registers that have been used up until this point.
     fn codegen_save_registers_of_vars(&mut self, vars: &[BrilligVariable]) -> Vec<MemoryAddress> {
         // Save all of the used registers at this point in memory
@@ -66,8 +66,11 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
         //
         // This means that the arguments will be in the first `n` registers after
         // the number of reserved registers.
-        let (sources, destinations): (Vec<_>, Vec<_>) =
-            arguments.iter().enumerate().map(|(i, argument)| (*argument, self.register(i))).unzip();
+        let (sources, destinations): (Vec<_>, Vec<_>) = arguments
+            .iter()
+            .enumerate()
+            .map(|(i, argument)| (*argument, self.stack_register(i)))
+            .unzip();
         destinations
             .iter()
             .for_each(|destination| self.registers.ensure_register_is_allocated(*destination));
@@ -88,7 +91,7 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
         let (sources, destinations): (Vec<_>, Vec<_>) = result_registers
             .iter()
             .enumerate()
-            .map(|(i, result_register)| (self.register(i), *result_register))
+            .map(|(i, result_register)| (self.stack_register(i), *result_register))
             .unzip();
         sources.iter().for_each(|source| self.registers.ensure_register_is_allocated(*source));
         self.codegen_mov_registers_to_registers(sources, destinations);
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
index 8e52cf072b4..649f6940da4 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
@@ -5,39 +5,13 @@ use acvm::{
 
 use super::{
     artifact::BrilligParameter,
-    brillig_variable::{BrilligVariable, SingleAddrVariable},
+    brillig_variable::{BrilligArray, BrilligVariable, SingleAddrVariable},
     debug_show::DebugToString,
+    registers::{RegisterAllocator, Stack},
     BrilligBinaryOp, BrilligContext, ReservedRegisters,
 };
 
-impl<F: AcirField + DebugToString> BrilligContext<F> {
-    /// Codegens a return from the current function.
-    ///
-    /// For Brillig, the return is implicit, since there is no explicit return instruction.
-    /// The caller will take `N` values from the Register starting at register index 0.
-    /// `N` indicates the number of return values expected.
-    ///
-    /// Brillig does not have an explicit return instruction, so this
-    /// method will move all register values to the first `N` values in
-    /// the VM.
-    pub(crate) fn codegen_return(&mut self, return_registers: &[MemoryAddress]) {
-        let mut sources = Vec::with_capacity(return_registers.len());
-        let mut destinations = Vec::with_capacity(return_registers.len());
-
-        for (destination_index, return_register) in return_registers.iter().enumerate() {
-            // In case we have fewer return registers than indices to write to, ensure we've allocated this register
-            let destination_register = ReservedRegisters::user_register_index(destination_index);
-            self.registers.ensure_register_is_allocated(destination_register);
-            sources.push(*return_register);
-            destinations.push(destination_register);
-        }
-        destinations
-            .iter()
-            .for_each(|destination| self.registers.ensure_register_is_allocated(*destination));
-        self.codegen_mov_registers_to_registers(sources, destinations);
-        self.stop_instruction();
-    }
-
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
     /// This codegen will issue a loop for (let iterator_register = loop_start; i < loop_bound; i += step)
     /// The body of the loop should be issued by the caller in the on_iteration closure.
     pub(crate) fn codegen_for_loop(
@@ -45,7 +19,7 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
         loop_start: Option<MemoryAddress>, // Defaults to zero
         loop_bound: MemoryAddress,
         step: Option<MemoryAddress>, // Defaults to 1
-        on_iteration: impl FnOnce(&mut BrilligContext<F>, SingleAddrVariable),
+        on_iteration: impl FnOnce(&mut BrilligContext<F, Registers>, SingleAddrVariable),
     ) {
         let iterator_register = if let Some(loop_start) = loop_start {
             let iterator_register = SingleAddrVariable::new_usize(self.allocate_register());
@@ -55,11 +29,7 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
             self.make_usize_constant_instruction(0_usize.into())
         };
 
-        let step_register = if let Some(step) = step {
-            step
-        } else {
-            self.make_usize_constant_instruction(1_usize.into()).address
-        };
+        let step_register = step.unwrap_or(ReservedRegisters::usize_one());
 
         let (loop_section, loop_label) = self.reserve_next_section_label();
         self.enter_section(loop_section);
@@ -102,10 +72,6 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
         // Deallocate our temporary registers
         self.deallocate_single_addr(iterator_less_than_iterations);
         self.deallocate_single_addr(iterator_register);
-        // Only deallocate step if we allocated it
-        if step.is_none() {
-            self.deallocate_register(step_register);
-        }
     }
 
     /// This codegen will issue a loop that will iterate from 0 to iteration_count
@@ -113,7 +79,7 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
     pub(crate) fn codegen_loop(
         &mut self,
         iteration_count: MemoryAddress,
-        on_iteration: impl FnOnce(&mut BrilligContext<F>, SingleAddrVariable),
+        on_iteration: impl FnOnce(&mut BrilligContext<F, Registers>, SingleAddrVariable),
     ) {
         self.codegen_for_loop(None, iteration_count, None, on_iteration);
     }
@@ -125,23 +91,23 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
     pub(crate) fn codegen_branch(
         &mut self,
         condition: MemoryAddress,
-        mut f: impl FnMut(&mut BrilligContext<F>, bool),
+        mut f: impl FnMut(&mut BrilligContext<F, Registers>, bool),
     ) {
         // Reserve 3 sections
         let (then_section, then_label) = self.reserve_next_section_label();
         let (otherwise_section, otherwise_label) = self.reserve_next_section_label();
         let (end_section, end_label) = self.reserve_next_section_label();
 
-        self.jump_if_instruction(condition, then_label.clone());
-        self.jump_instruction(otherwise_label.clone());
+        self.jump_if_instruction(condition, then_label);
+        self.jump_instruction(otherwise_label);
 
         self.enter_section(then_section);
         f(self, true);
-        self.jump_instruction(end_label.clone());
+        self.jump_instruction(end_label);
 
         self.enter_section(otherwise_section);
         f(self, false);
-        self.jump_instruction(end_label.clone());
+        self.jump_instruction(end_label);
 
         self.enter_section(end_section);
     }
@@ -150,13 +116,13 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
     pub(crate) fn codegen_if(
         &mut self,
         condition: MemoryAddress,
-        f: impl FnOnce(&mut BrilligContext<F>),
+        f: impl FnOnce(&mut BrilligContext<F, Registers>),
     ) {
         let (end_section, end_label) = self.reserve_next_section_label();
         let (then_section, then_label) = self.reserve_next_section_label();
 
-        self.jump_if_instruction(condition, then_label.clone());
-        self.jump_instruction(end_label.clone());
+        self.jump_if_instruction(condition, then_label);
+        self.jump_instruction(end_label);
 
         self.enter_section(then_section);
         f(self);
@@ -168,11 +134,11 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
     pub(crate) fn codegen_if_not(
         &mut self,
         condition: MemoryAddress,
-        f: impl FnOnce(&mut BrilligContext<F>),
+        f: impl FnOnce(&mut BrilligContext<F, Registers>),
     ) {
         let (end_section, end_label) = self.reserve_next_section_label();
 
-        self.jump_if_instruction(condition, end_label.clone());
+        self.jump_if_instruction(condition, end_label);
 
         f(self);
 
@@ -258,4 +224,167 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
             }
         });
     }
+
+    /// Computes the size of a parameter if it was flattened
+    pub(super) fn flattened_size(param: &BrilligParameter) -> usize {
+        match param {
+            BrilligParameter::SingleAddr(_) => 1,
+            BrilligParameter::Array(item_types, item_count)
+            | BrilligParameter::Slice(item_types, item_count) => {
+                let item_size: usize = item_types.iter().map(Self::flattened_size).sum();
+                item_count * item_size
+            }
+        }
+    }
+
+    /// Computes the size of a parameter if it was flattened
+    pub(super) fn flattened_tuple_size(tuple: &[BrilligParameter]) -> usize {
+        tuple.iter().map(Self::flattened_size).sum()
+    }
+
+    /// Computes the size of a parameter if it was flattened
+    pub(crate) fn has_nested_arrays(tuple: &[BrilligParameter]) -> bool {
+        tuple.iter().any(|param| !matches!(param, BrilligParameter::SingleAddr(_)))
+    }
+
+    // Flattens an array by recursively copying nested arrays and regular items.
+    pub(super) fn flatten_array(
+        &mut self,
+        item_type: &[BrilligParameter],
+        item_count: usize,
+        flattened_array_pointer: MemoryAddress,
+        deflattened_array_pointer: MemoryAddress,
+    ) {
+        if Self::has_nested_arrays(item_type) {
+            let movement_register = self.allocate_register();
+
+            let source_item_size = item_type.len();
+            let target_item_size: usize = item_type.iter().map(Self::flattened_size).sum();
+
+            for item_index in 0..item_count {
+                let source_item_base_index = item_index * source_item_size;
+                let target_item_base_index = item_index * target_item_size;
+
+                let mut target_offset = 0;
+
+                for (subitem_index, subitem) in item_type.iter().enumerate() {
+                    let source_index = self.make_usize_constant_instruction(
+                        (source_item_base_index + subitem_index).into(),
+                    );
+                    let target_index = self.make_usize_constant_instruction(
+                        (target_item_base_index + target_offset).into(),
+                    );
+
+                    match subitem {
+                        BrilligParameter::SingleAddr(_) => {
+                            self.codegen_array_get(
+                                deflattened_array_pointer,
+                                source_index,
+                                movement_register,
+                            );
+                            self.codegen_array_set(
+                                flattened_array_pointer,
+                                target_index,
+                                movement_register,
+                            );
+                            target_offset += 1;
+                        }
+                        BrilligParameter::Array(
+                            nested_array_item_type,
+                            nested_array_item_count,
+                        ) => {
+                            let nested_array_reference = self.allocate_register();
+                            self.codegen_array_get(
+                                deflattened_array_pointer,
+                                source_index,
+                                nested_array_reference,
+                            );
+
+                            let nested_array_variable =
+                                BrilligVariable::BrilligArray(BrilligArray {
+                                    pointer: self.allocate_register(),
+                                    size: nested_array_item_type.len() * nested_array_item_count,
+                                    rc: self.allocate_register(),
+                                });
+
+                            self.codegen_load_variable(
+                                nested_array_variable,
+                                nested_array_reference,
+                            );
+
+                            let flattened_nested_array_pointer = self.allocate_register();
+
+                            self.mov_instruction(
+                                flattened_nested_array_pointer,
+                                flattened_array_pointer,
+                            );
+
+                            self.memory_op_instruction(
+                                flattened_nested_array_pointer,
+                                target_index.address,
+                                flattened_nested_array_pointer,
+                                BrilligBinaryOp::Add,
+                            );
+
+                            self.flatten_array(
+                                nested_array_item_type,
+                                *nested_array_item_count,
+                                flattened_nested_array_pointer,
+                                nested_array_variable.extract_array().pointer,
+                            );
+
+                            self.deallocate_register(nested_array_reference);
+                            self.deallocate_register(flattened_nested_array_pointer);
+                            nested_array_variable
+                                .extract_registers()
+                                .into_iter()
+                                .for_each(|register| self.deallocate_register(register));
+
+                            target_offset += Self::flattened_size(subitem);
+                        }
+                        BrilligParameter::Slice(..) => unreachable!("ICE: Cannot flatten slices"),
+                    }
+
+                    self.deallocate_single_addr(source_index);
+                    self.deallocate_single_addr(target_index);
+                }
+            }
+
+            self.deallocate_register(movement_register);
+        } else {
+            let item_count =
+                self.make_usize_constant_instruction((item_count * item_type.len()).into());
+            self.codegen_mem_copy(deflattened_array_pointer, flattened_array_pointer, item_count);
+            self.deallocate_single_addr(item_count);
+        }
+    }
+}
+
+impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
+    /// Codegens a return from the current function.
+    ///
+    /// For Brillig, the return is implicit, since there is no explicit return instruction.
+    /// The caller will take `N` values from the Register starting at register index 0.
+    /// `N` indicates the number of return values expected.
+    ///
+    /// Brillig does not have an explicit return instruction, so this
+    /// method will move all register values to the first `N` values in
+    /// the VM.
+    pub(crate) fn codegen_return(&mut self, return_registers: &[MemoryAddress]) {
+        let mut sources = Vec::with_capacity(return_registers.len());
+        let mut destinations = Vec::with_capacity(return_registers.len());
+
+        for (destination_index, return_register) in return_registers.iter().enumerate() {
+            // In case we have fewer return registers than indices to write to, ensure we've allocated this register
+            let destination_register = MemoryAddress(Stack::start() + destination_index);
+            self.registers.ensure_register_is_allocated(destination_register);
+            sources.push(*return_register);
+            destinations.push(destination_register);
+        }
+        destinations
+            .iter()
+            .for_each(|destination| self.registers.ensure_register_is_allocated(*destination));
+        self.codegen_mov_registers_to_registers(sources, destinations);
+        self.stop_instruction();
+    }
 }
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
index d07b411f5a1..66cbcad7bef 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
@@ -8,10 +8,11 @@ use crate::brillig::brillig_ir::BrilligBinaryOp;
 use super::{
     brillig_variable::{BrilligVector, SingleAddrVariable},
     debug_show::DebugToString,
+    registers::RegisterAllocator,
     BrilligContext,
 };
 
-impl<F: AcirField + DebugToString> BrilligContext<F> {
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
     /// Codegens a truncation of a value to the given bit size
     pub(crate) fn codegen_truncate(
         &mut self,
@@ -107,7 +108,7 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
         self.deallocate_single_addr(limb_casted);
 
         if big_endian {
-            self.codegen_reverse_vector_in_place(target_vector);
+            self.codegen_array_reverse(target_vector.pointer, target_vector.size);
         }
     }
 }
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs
index d20f736ee6d..88f7e35865e 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs
@@ -5,10 +5,11 @@ use crate::brillig::brillig_ir::BrilligBinaryOp;
 use super::{
     brillig_variable::{BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable},
     debug_show::DebugToString,
+    registers::RegisterAllocator,
     BrilligContext, ReservedRegisters, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
 };
 
-impl<F: AcirField + DebugToString> BrilligContext<F> {
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
     /// Allocates an array of size `size` and stores the pointer to the array
     /// in `pointer_register`
     pub(crate) fn codegen_allocate_fixed_length_array(
@@ -156,9 +157,9 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
         }
     }
 
-    /// Copies the values of an array pointed by source with length stored in `num_elements_register`
-    /// Into the array pointed by destination
-    pub(crate) fn codegen_copy_array(
+    /// Copies the values of memory pointed by source with length stored in `num_elements_register`
+    /// After the address pointed by destination
+    pub(crate) fn codegen_mem_copy(
         &mut self,
         source_pointer: MemoryAddress,
         destination_pointer: MemoryAddress,
@@ -166,14 +167,22 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
     ) {
         assert!(num_elements_variable.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
 
-        let value_register = self.allocate_register();
+        if self.can_call_procedures {
+            self.call_mem_copy_procedure(
+                source_pointer,
+                destination_pointer,
+                num_elements_variable.address,
+            );
+        } else {
+            let value_register = self.allocate_register();
 
-        self.codegen_loop(num_elements_variable.address, |ctx, iterator| {
-            ctx.codegen_array_get(source_pointer, iterator, value_register);
-            ctx.codegen_array_set(destination_pointer, iterator, value_register);
-        });
+            self.codegen_loop(num_elements_variable.address, |ctx, iterator| {
+                ctx.codegen_array_get(source_pointer, iterator, value_register);
+                ctx.codegen_array_set(destination_pointer, iterator, value_register);
+            });
 
-        self.deallocate_register(value_register);
+            self.deallocate_register(value_register);
+        }
     }
 
     /// Loads a variable stored previously
@@ -254,10 +263,14 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
         }
     }
 
-    /// This instruction will reverse the order of the elements in a vector.
-    pub(crate) fn codegen_reverse_vector_in_place(&mut self, vector: BrilligVector) {
+    /// This instruction will reverse the order of the `size` elements pointed by `pointer`.
+    pub(crate) fn codegen_array_reverse(&mut self, pointer: MemoryAddress, size: MemoryAddress) {
+        if self.can_call_procedures {
+            self.call_array_reverse_procedure(pointer, size);
+            return;
+        }
         let iteration_count = self.allocate_register();
-        self.codegen_usize_op(vector.size, iteration_count, BrilligBinaryOp::UnsignedDiv, 2);
+        self.codegen_usize_op(size, iteration_count, BrilligBinaryOp::UnsignedDiv, 2);
 
         let start_value_register = self.allocate_register();
         let index_at_end_of_array = self.allocate_register();
@@ -265,10 +278,10 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
 
         self.codegen_loop(iteration_count, |ctx, iterator_register| {
             // Load both values
-            ctx.codegen_array_get(vector.pointer, iterator_register, start_value_register);
+            ctx.codegen_array_get(pointer, iterator_register, start_value_register);
 
             // The index at the end of array is size - 1 - iterator
-            ctx.mov_instruction(index_at_end_of_array, vector.size);
+            ctx.mov_instruction(index_at_end_of_array, size);
             ctx.codegen_usize_op_in_place(index_at_end_of_array, BrilligBinaryOp::Sub, 1);
             ctx.memory_op_instruction(
                 index_at_end_of_array,
@@ -278,15 +291,15 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
             );
 
             ctx.codegen_array_get(
-                vector.pointer,
+                pointer,
                 SingleAddrVariable::new_usize(index_at_end_of_array),
                 end_value_register,
             );
 
             // Write both values
-            ctx.codegen_array_set(vector.pointer, iterator_register, end_value_register);
+            ctx.codegen_array_set(pointer, iterator_register, end_value_register);
             ctx.codegen_array_set(
-                vector.pointer,
+                pointer,
                 SingleAddrVariable::new_usize(index_at_end_of_array),
                 start_value_register,
             );
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs
index 943b0b9d7a3..945b768efcf 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs
@@ -1,8 +1,8 @@
 use acvm::{acir::brillig::MemoryAddress, AcirField};
 
-use super::{debug_show::DebugToString, BrilligContext};
+use super::{debug_show::DebugToString, registers::RegisterAllocator, BrilligContext};
 
-impl<F: AcirField + DebugToString> BrilligContext<F> {
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
     /// This function moves values from a set of registers to another set of registers.
     /// It first moves all sources to new allocated registers to avoid overwriting.
     pub(crate) fn codegen_mov_registers_to_registers(
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
index d10e31533dc..5ee00cf6c29 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
@@ -1,29 +1,26 @@
+use crate::ssa::ir::function::FunctionId;
+
 use super::{
     artifact::{BrilligArtifact, BrilligParameter},
     brillig_variable::{BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable},
-    debug_show::{DebugShow, DebugToString},
-    registers::BrilligRegistersContext,
+    debug_show::DebugToString,
+    registers::Stack,
     BrilligBinaryOp, BrilligContext, ReservedRegisters,
 };
 use acvm::{acir::brillig::MemoryAddress, acir::AcirField};
 
 pub(crate) const MAX_STACK_SIZE: usize = 2048;
+pub(crate) const MAX_SCRATCH_SPACE: usize = 64;
 
-impl<F: AcirField + DebugToString> BrilligContext<F> {
+impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
     /// Creates an entry point artifact that will jump to the function label provided.
-    pub(crate) fn new_entry_point_artifact<T: ToString>(
+    pub(crate) fn new_entry_point_artifact(
         arguments: Vec<BrilligParameter>,
         return_parameters: Vec<BrilligParameter>,
-        target_function: T,
+        target_function: FunctionId,
     ) -> BrilligArtifact<F> {
-        let mut context = BrilligContext {
-            obj: BrilligArtifact::default(),
-            registers: BrilligRegistersContext::new(),
-            context_label: String::default(),
-            section_label: 0,
-            next_section: 1,
-            debug_show: DebugShow::new(false),
-        };
+        let mut context = BrilligContext::new(false);
+        context.disable_procedures();
 
         context.codegen_entry_point(&arguments, &return_parameters);
 
@@ -33,6 +30,14 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
         context.artifact()
     }
 
+    fn calldata_start_offset() -> usize {
+        ReservedRegisters::len() + MAX_STACK_SIZE + MAX_SCRATCH_SPACE
+    }
+
+    fn return_data_start_offset(calldata_size: usize) -> usize {
+        Self::calldata_start_offset() + calldata_size
+    }
+
     /// Adds the instructions needed to handle entry point parameters
     /// The runtime will leave the parameters in calldata.
     /// Arrays will be passed flattened.
@@ -44,17 +49,23 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
         let calldata_size = Self::flattened_tuple_size(arguments);
         let return_data_size = Self::flattened_tuple_size(return_parameters);
 
-        // Set initial value of stack pointer: MAX_STACK_SIZE + calldata_size + return_data_size
+        // Set reserved registers constants
+        self.const_instruction(
+            SingleAddrVariable::new_usize(ReservedRegisters::usize_one()),
+            1_usize.into(),
+        );
+
+        // Set initial value of stack pointer: calldata_start_offset + calldata_size + return_data_size
         self.const_instruction(
             SingleAddrVariable::new_usize(ReservedRegisters::free_memory_pointer()),
-            (MAX_STACK_SIZE + calldata_size + return_data_size).into(),
+            (Self::calldata_start_offset() + calldata_size + return_data_size).into(),
         );
 
         // Copy calldata
         self.copy_and_cast_calldata(arguments);
 
         // Allocate the variables for every argument:
-        let mut current_calldata_pointer = MAX_STACK_SIZE;
+        let mut current_calldata_pointer = Self::calldata_start_offset();
 
         let mut argument_variables: Vec<_> = arguments
             .iter()
@@ -139,7 +150,11 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
 
     fn copy_and_cast_calldata(&mut self, arguments: &[BrilligParameter]) {
         let calldata_size = Self::flattened_tuple_size(arguments);
-        self.calldata_copy_instruction(MemoryAddress(MAX_STACK_SIZE), calldata_size, 0);
+        self.calldata_copy_instruction(
+            MemoryAddress(Self::calldata_start_offset()),
+            calldata_size,
+            0,
+        );
 
         fn flat_bit_sizes(param: &BrilligParameter) -> Box<dyn Iterator<Item = u32> + '_> {
             match param {
@@ -155,35 +170,16 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
             // Calldatacopy tags everything with field type, so when downcast when necessary
             if bit_size < F::max_num_bits() {
                 self.cast_instruction(
-                    SingleAddrVariable::new(MemoryAddress(MAX_STACK_SIZE + i), bit_size),
-                    SingleAddrVariable::new_field(MemoryAddress(MAX_STACK_SIZE + i)),
+                    SingleAddrVariable::new(
+                        MemoryAddress(Self::calldata_start_offset() + i),
+                        bit_size,
+                    ),
+                    SingleAddrVariable::new_field(MemoryAddress(Self::calldata_start_offset() + i)),
                 );
             }
         }
     }
 
-    /// Computes the size of a parameter if it was flattened
-    pub(super) fn flattened_size(param: &BrilligParameter) -> usize {
-        match param {
-            BrilligParameter::SingleAddr(_) => 1,
-            BrilligParameter::Array(item_types, item_count)
-            | BrilligParameter::Slice(item_types, item_count) => {
-                let item_size: usize = item_types.iter().map(Self::flattened_size).sum();
-                item_count * item_size
-            }
-        }
-    }
-
-    /// Computes the size of a parameter if it was flattened
-    pub(super) fn flattened_tuple_size(tuple: &[BrilligParameter]) -> usize {
-        tuple.iter().map(Self::flattened_size).sum()
-    }
-
-    /// Computes the size of a parameter if it was flattened
-    fn has_nested_arrays(tuple: &[BrilligParameter]) -> bool {
-        tuple.iter().any(|param| !matches!(param, BrilligParameter::SingleAddr(_)))
-    }
-
     /// Deflatten an array by recursively allocating nested arrays and copying the plain values.
     /// Returns the pointer to the deflattened items.
     fn deflatten_array(
@@ -331,7 +327,7 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
         let return_data_size = Self::flattened_tuple_size(return_parameters);
 
         // Return data has a reserved space after calldata
-        let return_data_offset = MAX_STACK_SIZE + calldata_size;
+        let return_data_offset = Self::return_data_start_offset(calldata_size);
         let mut return_data_index = return_data_offset;
 
         for (return_param, returned_variable) in return_parameters.iter().zip(&returned_variables) {
@@ -366,118 +362,6 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
 
         self.external_stop_instruction(return_data_offset, return_data_size);
     }
-
-    // Flattens an array by recursively copying nested arrays and regular items.
-    pub(super) fn flatten_array(
-        &mut self,
-        item_type: &[BrilligParameter],
-        item_count: usize,
-        flattened_array_pointer: MemoryAddress,
-        deflattened_array_pointer: MemoryAddress,
-    ) {
-        if Self::has_nested_arrays(item_type) {
-            let movement_register = self.allocate_register();
-
-            let source_item_size = item_type.len();
-            let target_item_size: usize = item_type.iter().map(Self::flattened_size).sum();
-
-            for item_index in 0..item_count {
-                let source_item_base_index = item_index * source_item_size;
-                let target_item_base_index = item_index * target_item_size;
-
-                let mut target_offset = 0;
-
-                for (subitem_index, subitem) in item_type.iter().enumerate() {
-                    let source_index = self.make_usize_constant_instruction(
-                        (source_item_base_index + subitem_index).into(),
-                    );
-                    let target_index = self.make_usize_constant_instruction(
-                        (target_item_base_index + target_offset).into(),
-                    );
-
-                    match subitem {
-                        BrilligParameter::SingleAddr(_) => {
-                            self.codegen_array_get(
-                                deflattened_array_pointer,
-                                source_index,
-                                movement_register,
-                            );
-                            self.codegen_array_set(
-                                flattened_array_pointer,
-                                target_index,
-                                movement_register,
-                            );
-                            target_offset += 1;
-                        }
-                        BrilligParameter::Array(
-                            nested_array_item_type,
-                            nested_array_item_count,
-                        ) => {
-                            let nested_array_reference = self.allocate_register();
-                            self.codegen_array_get(
-                                deflattened_array_pointer,
-                                source_index,
-                                nested_array_reference,
-                            );
-
-                            let nested_array_variable =
-                                BrilligVariable::BrilligArray(BrilligArray {
-                                    pointer: self.allocate_register(),
-                                    size: nested_array_item_type.len() * nested_array_item_count,
-                                    rc: self.allocate_register(),
-                                });
-
-                            self.codegen_load_variable(
-                                nested_array_variable,
-                                nested_array_reference,
-                            );
-
-                            let flattened_nested_array_pointer = self.allocate_register();
-
-                            self.mov_instruction(
-                                flattened_nested_array_pointer,
-                                flattened_array_pointer,
-                            );
-
-                            self.memory_op_instruction(
-                                flattened_nested_array_pointer,
-                                target_index.address,
-                                flattened_nested_array_pointer,
-                                BrilligBinaryOp::Add,
-                            );
-
-                            self.flatten_array(
-                                nested_array_item_type,
-                                *nested_array_item_count,
-                                flattened_nested_array_pointer,
-                                nested_array_variable.extract_array().pointer,
-                            );
-
-                            self.deallocate_register(nested_array_reference);
-                            self.deallocate_register(flattened_nested_array_pointer);
-                            nested_array_variable
-                                .extract_registers()
-                                .into_iter()
-                                .for_each(|register| self.deallocate_register(register));
-
-                            target_offset += Self::flattened_size(subitem);
-                        }
-                        BrilligParameter::Slice(..) => unreachable!("ICE: Cannot flatten slices"),
-                    }
-
-                    self.deallocate_single_addr(source_index);
-                    self.deallocate_single_addr(target_index);
-                }
-            }
-
-            self.deallocate_register(movement_register);
-        } else {
-            let item_count =
-                self.make_usize_constant_instruction((item_count * item_type.len()).into());
-            self.codegen_copy_array(deflattened_array_pointer, flattened_array_pointer, item_count);
-            self.deallocate_single_addr(item_count);
-        }
-    }
 }
 
 #[cfg(test)]
@@ -485,10 +369,13 @@ mod tests {
 
     use acvm::FieldElement;
 
-    use crate::brillig::brillig_ir::{
-        brillig_variable::BrilligArray,
-        entry_point::BrilligParameter,
-        tests::{create_and_run_vm, create_context, create_entry_point_bytecode},
+    use crate::{
+        brillig::brillig_ir::{
+            brillig_variable::BrilligArray,
+            entry_point::BrilligParameter,
+            tests::{create_and_run_vm, create_context, create_entry_point_bytecode},
+        },
+        ssa::ir::function::FunctionId,
     };
 
     #[test]
@@ -510,7 +397,7 @@ mod tests {
         )];
         let returns = vec![BrilligParameter::SingleAddr(8)];
 
-        let mut context = create_context();
+        let mut context = create_context(FunctionId::test_new(0));
 
         // Allocate the parameter
         let array_pointer = context.allocate_register();
@@ -549,7 +436,7 @@ mod tests {
         let arguments = vec![array_param.clone()];
         let returns = vec![array_param];
 
-        let mut context = create_context();
+        let mut context = create_context(FunctionId::test_new(0));
 
         // Allocate the parameter
         let brillig_array = BrilligArray {
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
index 69a6b12c9b0..3cd487b0c4a 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
@@ -9,16 +9,20 @@ use acvm::{
     FieldElement,
 };
 
+use crate::ssa::ir::function::FunctionId;
+
 use super::{
-    artifact::UnresolvedJumpLocation,
+    artifact::{Label, UnresolvedJumpLocation},
     brillig_variable::{BrilligArray, BrilligVector, SingleAddrVariable},
     debug_show::DebugToString,
+    procedures::ProcedureId,
+    registers::RegisterAllocator,
     BrilligContext, ReservedRegisters, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
 };
 
 /// Low level instructions of the brillig IR, used by the brillig ir codegens and brillig_gen
 /// Printed using debug_slow
-impl<F: AcirField + DebugToString> BrilligContext<F> {
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
     /// Processes a binary instruction according `operation`.
     ///
     /// This method will compute lhs <operation> rhs
@@ -184,31 +188,28 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
 
     /// Adds a unresolved external `Call` instruction to the bytecode.
     /// This calls into another function compiled into this brillig artifact.
-    pub(crate) fn add_external_call_instruction<T: ToString>(&mut self, func_label: T) {
+    pub(crate) fn add_external_call_instruction(&mut self, func_id: FunctionId) {
+        let func_label = Label::function(func_id);
         self.debug_show.add_external_call_instruction(func_label.to_string());
-        self.obj.add_unresolved_external_call(
-            BrilligOpcode::Call { location: 0 },
-            func_label.to_string(),
-        );
+        self.obj.add_unresolved_external_call(BrilligOpcode::Call { location: 0 }, func_label);
+    }
+
+    pub(super) fn add_procedure_call_instruction(&mut self, procedure_id: ProcedureId) {
+        let proc_label = Label::procedure(procedure_id);
+        self.debug_show.add_external_call_instruction(proc_label.to_string());
+        self.obj.add_unresolved_external_call(BrilligOpcode::Call { location: 0 }, proc_label);
     }
 
     /// Adds a unresolved `Jump` instruction to the bytecode.
-    pub(crate) fn jump_instruction<T: ToString>(&mut self, target_label: T) {
+    pub(crate) fn jump_instruction(&mut self, target_label: Label) {
         self.debug_show.jump_instruction(target_label.to_string());
-        self.add_unresolved_jump(BrilligOpcode::Jump { location: 0 }, target_label.to_string());
+        self.add_unresolved_jump(BrilligOpcode::Jump { location: 0 }, target_label);
     }
 
     /// Adds a unresolved `JumpIf` instruction to the bytecode.
-    pub(crate) fn jump_if_instruction<T: ToString>(
-        &mut self,
-        condition: MemoryAddress,
-        target_label: T,
-    ) {
+    pub(crate) fn jump_if_instruction(&mut self, condition: MemoryAddress, target_label: Label) {
         self.debug_show.jump_if_instruction(condition, target_label.to_string());
-        self.add_unresolved_jump(
-            BrilligOpcode::JumpIf { condition, location: 0 },
-            target_label.to_string(),
-        );
+        self.add_unresolved_jump(BrilligOpcode::JumpIf { condition, location: 0 }, target_label);
     }
 
     /// Adds a unresolved `Jump` to the bytecode.
@@ -221,39 +222,39 @@ impl<F: AcirField + DebugToString> BrilligContext<F> {
     }
 
     /// Adds a label to the next opcode
-    pub(crate) fn enter_context<T: ToString>(&mut self, label: T) {
+    pub(crate) fn enter_context(&mut self, label: Label) {
         self.debug_show.enter_context(label.to_string());
-        self.context_label = label.to_string();
-        self.section_label = 0;
+        self.context_label = label;
+        self.current_section = 0;
         // Add a context label to the next opcode
-        self.obj.add_label_at_position(label.to_string(), self.obj.index_of_next_opcode());
+        self.obj.add_label_at_position(label, self.obj.index_of_next_opcode());
         // Add a section label to the next opcode
         self.obj
             .add_label_at_position(self.current_section_label(), self.obj.index_of_next_opcode());
     }
 
-    /// Enter the given section
+    /// Enter the given section within a basic block
     pub(super) fn enter_section(&mut self, section: usize) {
-        self.section_label = section;
+        self.current_section = section;
         self.obj
             .add_label_at_position(self.current_section_label(), self.obj.index_of_next_opcode());
     }
 
     /// Create, reserve, and return a new section label.
-    pub(super) fn reserve_next_section_label(&mut self) -> (usize, String) {
+    pub(super) fn reserve_next_section_label(&mut self) -> (usize, Label) {
         let section = self.next_section;
         self.next_section += 1;
         (section, self.compute_section_label(section))
     }
 
     /// Internal function used to compute the section labels
-    fn compute_section_label(&self, section: usize) -> String {
-        format!("{}-{}", self.context_label, section)
+    fn compute_section_label(&self, section: usize) -> Label {
+        self.context_label.add_section(section)
     }
 
     /// Returns the current section label
-    fn current_section_label(&self) -> String {
-        self.compute_section_label(self.section_label)
+    fn current_section_label(&self) -> Label {
+        self.compute_section_label(self.current_section)
     }
 
     /// Emits a stop instruction
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_copy.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_copy.rs
new file mode 100644
index 00000000000..0ea51603991
--- /dev/null
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_copy.rs
@@ -0,0 +1,98 @@
+use std::vec;
+
+use acvm::{acir::brillig::MemoryAddress, AcirField};
+
+use super::ProcedureId;
+use crate::brillig::brillig_ir::{
+    brillig_variable::{BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable},
+    debug_show::DebugToString,
+    registers::{RegisterAllocator, ScratchSpace},
+    BrilligBinaryOp, BrilligContext,
+};
+
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
+    /// Conditionally copies a source array/vector to a destination array/vector.
+    /// If the reference count of the source array/vector is 1, then we can directly copy the pointer of the source array/vector to the destination array/vector.
+    pub(crate) fn call_array_copy_procedure(
+        &mut self,
+        source_variable: BrilligVariable,
+        destination_variable: BrilligVariable,
+    ) {
+        // Args
+        let source_pointer = MemoryAddress::from(ScratchSpace::start());
+        let size_register = MemoryAddress::from(ScratchSpace::start() + 1);
+        let is_rc_one_register = MemoryAddress::from(ScratchSpace::start() + 2);
+
+        // Returns
+        let destination_pointer = MemoryAddress::from(ScratchSpace::start() + 3);
+
+        match source_variable {
+            BrilligVariable::BrilligArray(BrilligArray { pointer, rc, .. })
+            | BrilligVariable::BrilligVector(BrilligVector { pointer, rc, .. }) => {
+                self.mov_instruction(source_pointer, pointer);
+                self.codegen_usize_op(rc, is_rc_one_register, BrilligBinaryOp::Equals, 1_usize);
+            }
+            _ => unreachable!("ICE: array_copy on non-array"),
+        }
+
+        match source_variable {
+            BrilligVariable::BrilligArray(BrilligArray { size, .. }) => {
+                self.usize_const_instruction(size_register, size.into());
+            }
+            BrilligVariable::BrilligVector(BrilligVector { size, .. }) => {
+                self.mov_instruction(size_register, size);
+            }
+            _ => unreachable!("ICE: array_copy on non-array"),
+        }
+
+        self.add_procedure_call_instruction(ProcedureId::ArrayCopy);
+
+        match destination_variable {
+            BrilligVariable::BrilligArray(BrilligArray { pointer, rc, .. })
+            | BrilligVariable::BrilligVector(BrilligVector { pointer, rc, .. }) => {
+                self.mov_instruction(pointer, destination_pointer);
+                self.usize_const_instruction(rc, 1_usize.into());
+            }
+            _ => unreachable!("ICE: array_copy on non-array"),
+        }
+
+        if let BrilligVariable::BrilligVector(BrilligVector { size, .. }) = destination_variable {
+            self.mov_instruction(size, size_register);
+        }
+    }
+}
+
+pub(super) fn compile_array_copy_procedure<F: AcirField + DebugToString>(
+    brillig_context: &mut BrilligContext<F, ScratchSpace>,
+) {
+    // Args
+    let source_pointer = MemoryAddress::from(ScratchSpace::start());
+    let size_register = MemoryAddress::from(ScratchSpace::start() + 1);
+    let is_rc_one_register = MemoryAddress::from(ScratchSpace::start() + 2);
+
+    // Returns
+    let destination_pointer = MemoryAddress::from(ScratchSpace::start() + 3);
+
+    brillig_context.set_allocated_registers(vec![
+        source_pointer,
+        destination_pointer,
+        size_register,
+        is_rc_one_register,
+    ]);
+
+    brillig_context.codegen_branch(is_rc_one_register, |ctx, cond| {
+        if cond {
+            // Reference count is 1, we can mutate the array directly
+            ctx.mov_instruction(destination_pointer, source_pointer);
+        } else {
+            // First issue a array copy to the destination
+            ctx.codegen_allocate_array(destination_pointer, size_register);
+
+            ctx.codegen_mem_copy(
+                source_pointer,
+                destination_pointer,
+                SingleAddrVariable::new_usize(size_register),
+            );
+        }
+    });
+}
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_reverse.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_reverse.rs
new file mode 100644
index 00000000000..0d98599bf96
--- /dev/null
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_reverse.rs
@@ -0,0 +1,37 @@
+use std::vec;
+
+use acvm::{acir::brillig::MemoryAddress, AcirField};
+
+use super::ProcedureId;
+use crate::brillig::brillig_ir::{
+    debug_show::DebugToString,
+    registers::{RegisterAllocator, ScratchSpace},
+    BrilligContext,
+};
+
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
+    pub(crate) fn call_array_reverse_procedure(
+        &mut self,
+        pointer: MemoryAddress,
+        size: MemoryAddress,
+    ) {
+        let source_pointer = MemoryAddress::from(ScratchSpace::start());
+        let size_register = MemoryAddress::from(ScratchSpace::start() + 1);
+
+        self.mov_instruction(source_pointer, pointer);
+        self.mov_instruction(size_register, size);
+
+        self.add_procedure_call_instruction(ProcedureId::ArrayReverse);
+    }
+}
+
+pub(super) fn compile_array_reverse_procedure<F: AcirField + DebugToString>(
+    brillig_context: &mut BrilligContext<F, ScratchSpace>,
+) {
+    let source_pointer = MemoryAddress::from(ScratchSpace::start());
+    let size_register = MemoryAddress::from(ScratchSpace::start() + 1);
+
+    brillig_context.set_allocated_registers(vec![source_pointer, size_register]);
+
+    brillig_context.codegen_array_reverse(source_pointer, size_register);
+}
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mem_copy.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mem_copy.rs
new file mode 100644
index 00000000000..b4e1d37af38
--- /dev/null
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mem_copy.rs
@@ -0,0 +1,45 @@
+use std::vec;
+
+use acvm::{acir::brillig::MemoryAddress, AcirField};
+
+use super::ProcedureId;
+use crate::brillig::brillig_ir::{
+    brillig_variable::SingleAddrVariable,
+    debug_show::DebugToString,
+    registers::{RegisterAllocator, ScratchSpace},
+    BrilligContext,
+};
+
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
+    pub(crate) fn call_mem_copy_procedure(
+        &mut self,
+        source_pointer: MemoryAddress,
+        destination_pointer: MemoryAddress,
+        num_elements_variable: MemoryAddress,
+    ) {
+        self.mov_instruction(MemoryAddress::from(ScratchSpace::start()), source_pointer);
+        self.mov_instruction(MemoryAddress::from(ScratchSpace::start() + 1), destination_pointer);
+        self.mov_instruction(MemoryAddress::from(ScratchSpace::start() + 2), num_elements_variable);
+        self.add_procedure_call_instruction(ProcedureId::MemCopy);
+    }
+}
+
+pub(super) fn compile_mem_copy_procedure<F: AcirField + DebugToString>(
+    brillig_context: &mut BrilligContext<F, ScratchSpace>,
+) {
+    let source_pointer = MemoryAddress::from(ScratchSpace::start());
+    let destination_pointer = MemoryAddress::from(ScratchSpace::start() + 1);
+    let num_elements_variable = MemoryAddress::from(ScratchSpace::start() + 2);
+
+    brillig_context.set_allocated_registers(vec![
+        source_pointer,
+        destination_pointer,
+        num_elements_variable,
+    ]);
+
+    brillig_context.codegen_mem_copy(
+        source_pointer,
+        destination_pointer,
+        SingleAddrVariable::new_usize(num_elements_variable),
+    );
+}
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mod.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mod.rs
new file mode 100644
index 00000000000..92857823945
--- /dev/null
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mod.rs
@@ -0,0 +1,42 @@
+mod array_copy;
+mod array_reverse;
+mod mem_copy;
+
+use array_copy::compile_array_copy_procedure;
+use array_reverse::compile_array_reverse_procedure;
+use mem_copy::compile_mem_copy_procedure;
+
+use crate::brillig::brillig_ir::AcirField;
+
+use super::{
+    artifact::{BrilligArtifact, Label},
+    debug_show::DebugToString,
+    BrilligContext,
+};
+
+/// Procedures are a set of complex operations that are common in the noir language.
+/// Extracting them to reusable procedures allows us to reduce the size of the generated Brillig.
+/// Procedures receive their arguments on scratch space to avoid stack dumping&restoring.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+pub(crate) enum ProcedureId {
+    ArrayCopy,
+    ArrayReverse,
+    MemCopy,
+}
+
+pub(crate) fn compile_procedure<F: AcirField + DebugToString>(
+    procedure_id: ProcedureId,
+) -> BrilligArtifact<F> {
+    let mut brillig_context = BrilligContext::new_for_procedure(false);
+    brillig_context.enter_context(Label::procedure(procedure_id));
+
+    match procedure_id {
+        ProcedureId::MemCopy => compile_mem_copy_procedure(&mut brillig_context),
+        ProcedureId::ArrayCopy => compile_array_copy_procedure(&mut brillig_context),
+        ProcedureId::ArrayReverse => compile_array_reverse_procedure(&mut brillig_context),
+    };
+
+    brillig_context.stop_instruction();
+
+    brillig_context.artifact()
+}
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs
index ae506462b25..43f85c159d1 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs
@@ -2,52 +2,150 @@ use acvm::acir::brillig::MemoryAddress;
 
 use crate::brillig::brillig_ir::entry_point::MAX_STACK_SIZE;
 
-use super::{brillig_variable::SingleAddrVariable, BrilligContext, ReservedRegisters};
+use super::{
+    brillig_variable::SingleAddrVariable, entry_point::MAX_SCRATCH_SPACE, BrilligContext,
+    ReservedRegisters,
+};
+
+pub(crate) trait RegisterAllocator {
+    /// First valid memory address
+    fn start() -> usize;
+    /// Last valid memory address
+    fn end() -> usize;
+    /// Allocates a new register.
+    fn allocate_register(&mut self) -> MemoryAddress;
+    /// Push a register to the deallocation list, ready for reuse.
+    fn deallocate_register(&mut self, register_index: MemoryAddress);
+    /// Ensures a register is allocated, allocating it if necessary
+    fn ensure_register_is_allocated(&mut self, register: MemoryAddress);
+    /// Creates a new register context from a set of registers allocated previously.
+    fn from_preallocated_registers(preallocated_registers: Vec<MemoryAddress>) -> Self;
+}
 
 /// Every brillig stack frame/call context has its own view of register space.
 /// This is maintained by copying these registers to the stack during calls and reading them back.
-///
-/// Each has a stack base pointer from which all stack allocations can be offset.
-pub(crate) struct BrilligRegistersContext {
-    /// A free-list of registers that have been deallocated and can be used again.
-    deallocated_registers: Vec<MemoryAddress>,
-    /// A usize indicating the next un-used register.
-    next_free_register_index: usize,
+pub(crate) struct Stack {
+    storage: DeallocationListAllocator,
 }
 
-impl BrilligRegistersContext {
-    /// Initial register allocation
+impl Stack {
     pub(crate) fn new() -> Self {
+        Self { storage: DeallocationListAllocator::new(Self::start()) }
+    }
+
+    fn is_within_bounds(register: MemoryAddress) -> bool {
+        let index = register.to_usize();
+        index >= Self::start() && index < Self::end()
+    }
+}
+
+impl RegisterAllocator for Stack {
+    fn start() -> usize {
+        ReservedRegisters::len()
+    }
+
+    fn end() -> usize {
+        ReservedRegisters::len() + MAX_STACK_SIZE
+    }
+
+    fn ensure_register_is_allocated(&mut self, register: MemoryAddress) {
+        assert!(Self::is_within_bounds(register), "Register out of stack bounds");
+        self.storage.ensure_register_is_allocated(register);
+    }
+
+    fn allocate_register(&mut self) -> MemoryAddress {
+        let allocated = self.storage.allocate_register();
+        assert!(Self::is_within_bounds(allocated), "Stack too deep");
+        allocated
+    }
+
+    fn deallocate_register(&mut self, register_index: MemoryAddress) {
+        self.storage.deallocate_register(register_index);
+    }
+
+    fn from_preallocated_registers(preallocated_registers: Vec<MemoryAddress>) -> Self {
+        for register in &preallocated_registers {
+            assert!(Self::is_within_bounds(*register), "Register out of stack bounds");
+        }
+
         Self {
-            deallocated_registers: Vec::new(),
-            next_free_register_index: ReservedRegisters::len(),
+            storage: DeallocationListAllocator::from_preallocated_registers(
+                Self::start(),
+                preallocated_registers,
+            ),
         }
     }
+}
 
-    /// Creates a new register context from a set of registers allocated previously.
-    pub(crate) fn from_preallocated_registers(preallocated_registers: Vec<MemoryAddress>) -> Self {
-        let next_free_register_index = preallocated_registers.iter().fold(
-            ReservedRegisters::len(),
-            |free_register_index, preallocated_register| {
-                if preallocated_register.to_usize() < free_register_index {
-                    free_register_index
-                } else {
-                    preallocated_register.to_usize() + 1
-                }
-            },
-        );
-        let mut deallocated_registers = Vec::new();
-        for i in ReservedRegisters::len()..next_free_register_index {
-            if !preallocated_registers.contains(&MemoryAddress::from(i)) {
-                deallocated_registers.push(MemoryAddress::from(i));
-            }
+/// Procedure arguments and returns are passed through scratch space.
+/// This avoids having to dump and restore the stack to call procedures.
+/// The scratch space is a much smaller set of memory cells.
+pub(crate) struct ScratchSpace {
+    storage: DeallocationListAllocator,
+}
+
+impl ScratchSpace {
+    pub(crate) fn new() -> Self {
+        Self { storage: DeallocationListAllocator::new(Self::start()) }
+    }
+
+    fn is_within_bounds(register: MemoryAddress) -> bool {
+        let index = register.to_usize();
+        index >= Self::start() && index < Self::end()
+    }
+}
+
+impl RegisterAllocator for ScratchSpace {
+    fn start() -> usize {
+        ReservedRegisters::len() + MAX_STACK_SIZE
+    }
+
+    fn end() -> usize {
+        ReservedRegisters::len() + MAX_STACK_SIZE + MAX_SCRATCH_SPACE
+    }
+
+    fn ensure_register_is_allocated(&mut self, register: MemoryAddress) {
+        assert!(Self::is_within_bounds(register), "Register out of scratch space bounds");
+        self.storage.ensure_register_is_allocated(register);
+    }
+
+    fn allocate_register(&mut self) -> MemoryAddress {
+        let allocated = self.storage.allocate_register();
+        assert!(Self::is_within_bounds(allocated), "Scratch space too deep");
+        allocated
+    }
+
+    fn deallocate_register(&mut self, register_index: MemoryAddress) {
+        self.storage.deallocate_register(register_index);
+    }
+
+    fn from_preallocated_registers(preallocated_registers: Vec<MemoryAddress>) -> Self {
+        for register in &preallocated_registers {
+            assert!(Self::is_within_bounds(*register), "Register out of scratch space bounds");
         }
 
-        Self { deallocated_registers, next_free_register_index }
+        Self {
+            storage: DeallocationListAllocator::from_preallocated_registers(
+                Self::start(),
+                preallocated_registers,
+            ),
+        }
+    }
+}
+
+struct DeallocationListAllocator {
+    /// A free-list of registers that have been deallocated and can be used again.
+    deallocated_registers: Vec<MemoryAddress>,
+    /// A usize indicating the next un-used register.
+    next_free_register_index: usize,
+}
+
+impl DeallocationListAllocator {
+    fn new(start: usize) -> Self {
+        Self { deallocated_registers: Vec::new(), next_free_register_index: start }
     }
 
-    /// Ensures a register is allocated.
-    pub(crate) fn ensure_register_is_allocated(&mut self, register: MemoryAddress) {
+    fn ensure_register_is_allocated(&mut self, register: MemoryAddress) {
         let index = register.to_usize();
         if index < self.next_free_register_index {
             // If it could be allocated, check if it's in the deallocated list and remove it from there
@@ -55,12 +153,10 @@ impl BrilligRegistersContext {
         } else {
             // If it couldn't yet be, expand the register space.
             self.next_free_register_index = index + 1;
-            assert!(self.next_free_register_index < MAX_STACK_SIZE, "Stack too deep");
         }
     }
 
-    /// Creates a new register.
-    pub(crate) fn allocate_register(&mut self) -> MemoryAddress {
+    fn allocate_register(&mut self) -> MemoryAddress {
         // If we have a register in our free list of deallocated registers,
         // consume it first. This prioritizes reuse.
         if let Some(register) = self.deallocated_registers.pop() {
@@ -69,22 +165,42 @@ impl BrilligRegistersContext {
         // Otherwise, move to our latest register.
         let register = MemoryAddress::from(self.next_free_register_index);
         self.next_free_register_index += 1;
-        assert!(self.next_free_register_index < MAX_STACK_SIZE, "Stack too deep");
         register
     }
 
-    /// Push a register to the deallocation list, ready for reuse.
-    /// TODO(AD): currently, register deallocation is only done with immediate values.
-    /// TODO(AD): See https://github.com/noir-lang/noir/issues/1720
-    pub(crate) fn deallocate_register(&mut self, register_index: MemoryAddress) {
+    fn deallocate_register(&mut self, register_index: MemoryAddress) {
         assert!(!self.deallocated_registers.contains(&register_index));
         self.deallocated_registers.push(register_index);
     }
+
+    fn from_preallocated_registers(
+        start: usize,
+        preallocated_registers: Vec<MemoryAddress>,
+    ) -> Self {
+        let next_free_register_index = preallocated_registers.iter().fold(
+            start,
+            |free_register_index, preallocated_register| {
+                if preallocated_register.to_usize() < free_register_index {
+                    free_register_index
+                } else {
+                    preallocated_register.to_usize() + 1
+                }
+            },
+        );
+        let mut deallocated_registers = Vec::new();
+        for i in start..next_free_register_index {
+            if !preallocated_registers.contains(&MemoryAddress::from(i)) {
+                deallocated_registers.push(MemoryAddress::from(i));
+            }
+        }
+
+        Self { deallocated_registers, next_free_register_index }
+    }
 }
 
-impl<F> BrilligContext<F> {
+impl<F, Registers: RegisterAllocator> BrilligContext<F, Registers> {
     /// Returns the i'th register after the reserved ones
-    pub(crate) fn register(&self, i: usize) -> MemoryAddress {
+    pub(crate) fn stack_register(&self, i: usize) -> MemoryAddress {
         MemoryAddress::from(ReservedRegisters::NUM_RESERVED_REGISTERS + i)
     }
 
@@ -94,7 +210,7 @@ impl<F> BrilligContext<F> {
     }
 
     pub(crate) fn set_allocated_registers(&mut self, allocated_registers: Vec<MemoryAddress>) {
-        self.registers = BrilligRegistersContext::from_preallocated_registers(allocated_registers);
+        self.registers = Registers::from_preallocated_registers(allocated_registers);
     }
 
     /// Push a register to the deallocation list, ready for reuse.
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/mod.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/mod.rs
index 70c0959517b..9a628d601df 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/mod.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/mod.rs
@@ -2,16 +2,21 @@ pub(crate) mod brillig_gen;
 pub(crate) mod brillig_ir;
 
 use acvm::FieldElement;
+use brillig_ir::artifact::LabelType;
 
 use self::{
-    brillig_gen::{brillig_fn::FunctionContext, convert_ssa_function},
-    brillig_ir::artifact::{BrilligArtifact, Label},
+    brillig_gen::convert_ssa_function,
+    brillig_ir::{
+        artifact::{BrilligArtifact, Label},
+        procedures::compile_procedure,
+    },
 };
 use crate::ssa::{
     ir::function::{Function, FunctionId, RuntimeType},
     ssa_gen::Ssa,
 };
-use std::collections::{BTreeSet, HashMap};
+use fxhash::FxHashMap as HashMap;
+use std::{borrow::Cow, collections::BTreeSet};
 
 /// Context structure for the brillig pass.
 /// It stores brillig-related data required for brillig generation.
@@ -28,18 +33,19 @@ impl Brillig {
         self.ssa_function_to_brillig.insert(func.id(), obj);
     }
 
-    /// Finds a brillig function artifact by its function label
-    pub(crate) fn find_by_function_label(
+    /// Finds a brillig artifact by its label
+    pub(crate) fn find_by_label(
         &self,
         function_label: Label,
-    ) -> Option<&BrilligArtifact<FieldElement>> {
-        self.ssa_function_to_brillig.iter().find_map(|(function_id, obj)| {
-            if FunctionContext::function_id_to_function_label(*function_id) == function_label {
-                Some(obj)
-            } else {
-                None
+    ) -> Option<Cow<BrilligArtifact<FieldElement>>> {
+        match function_label.label_type {
+            LabelType::Function(function_id, _) => {
+                self.ssa_function_to_brillig.get(&function_id).map(Cow::Borrowed)
             }
-        })
+            // Procedures are compiled as needed
+            LabelType::Procedure(procedure_id) => Some(Cow::Owned(compile_procedure(procedure_id))),
+            _ => unreachable!("ICE: Expected a function or procedure label"),
+        }
     }
 }
 
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 22b13aeae79..b66d469e33c 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -953,11 +953,11 @@ impl<'a> Context<'a> {
         let mut entry_point = BrilligContext::new_entry_point_artifact(
             arguments,
             BrilligFunctionContext::return_values(func),
-            BrilligFunctionContext::function_id_to_function_label(func.id()),
+            func.id(),
         );
         // Link the entry point with all dependencies
         while let Some(unresolved_fn_label) = entry_point.first_unresolved_function_call() {
-            let artifact = &brillig.find_by_function_label(unresolved_fn_label.clone());
+            let artifact = &brillig.find_by_label(unresolved_fn_label);
             let artifact = match artifact {
                 Some(artifact) => artifact,
                 None => {