feat: SSA globals in monomorphization and SSA gen

compiler/noirc_evaluator/src/acir/mod.rs

@@ -1892,6 +1892,9 @@ impl<'a> Context<'a> {
             Value::Instruction { .. } | Value::Param { .. } => {
                 unreachable!("ICE: Should have been in cache {value_id} {value:?}")
             }
+            Value::Global(_) => {
+                unreachable!("ICE: All globals should have been inlined");
+            }
         };
         self.ssa_values.insert(value_id, acir_value.clone());
         acir_value

compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs

@@ -646,7 +646,10 @@ impl<'block> BrilligBlock<'block> {
                         }
                     }
                 }
-                Value::Instruction { .. } | Value::Param { .. } | Value::NumericConstant { .. } => {
+                Value::Instruction { .. }
+                | Value::Param { .. }
+                | Value::NumericConstant { .. }
+                | Value::Global(_) => {
                     unreachable!("unsupported function call type {:?}", dfg[*func])
                 }
             },
@@ -1557,6 +1560,9 @@ impl<'block> BrilligBlock<'block> {
         let value = &dfg[value_id];
 
         match value {
+            Value::Global(_) => {
+                unreachable!("ICE: All globals should have been inlined");
+            }
             Value::Param { .. } | Value::Instruction { .. } => {
                 // All block parameters and instruction results should have already been
                 // converted to registers so we fetch from the cache.

compiler/noirc_evaluator/src/brillig/brillig_gen/variable_liveness.rs

@@ -53,9 +53,10 @@ pub(crate) fn collect_variables_of_value(
     let value = &dfg[value_id];
 
     match value {
-        Value::Instruction { .. } | Value::Param { .. } | Value::NumericConstant { .. } => {
-            Some(value_id)
-        }
+        Value::Instruction { .. }
+        | Value::Param { .. }
+        | Value::NumericConstant { .. }
+        | Value::Global(_) => Some(value_id),
         // Functions are not variables in a defunctionalized SSA. Only constant function values should appear.
         Value::ForeignFunction(_) | Value::Function(_) | Value::Intrinsic(..) => None,
     }

compiler/noirc_evaluator/src/ssa.rs

@@ -453,7 +453,7 @@ impl SsaBuilder {
             let ssa_path = emit_ssa.with_extension("ssa.json");
             write_to_file(&serde_json::to_vec(&ssa).unwrap(), &ssa_path);
         }
-        Ok(SsaBuilder { ssa_logging, print_codegen_timings, ssa }.print("Initial SSA:"))
+        Ok(SsaBuilder { ssa_logging, print_codegen_timings, ssa }.print("Initial SSA"))
     }
 
     fn finish(self) -> Ssa {

compiler/noirc_evaluator/src/ssa/checks/check_for_underconstrained_values.rs

@@ -332,7 +332,8 @@ impl DependencyContext {
                         }
                         Value::Instruction { .. }
                         | Value::NumericConstant { .. }
-                        | Value::Param { .. } => {
+                        | Value::Param { .. }
+                        | Value::Global(_) => {
                             panic!(
                                 "calling non-function value with ID {func_id} in function {}",
                                 function.name()
@@ -618,7 +619,8 @@ impl Context {
                         }
                         Value::Instruction { .. }
                         | Value::NumericConstant { .. }
-                        | Value::Param { .. } => {
+                        | Value::Param { .. }
+                        | Value::Global(_) => {
                             panic!("At the point we are running disconnect there shouldn't be any other values as arguments")
                         }
                     }

compiler/noirc_evaluator/src/ssa/ir/dfg.rs

@@ -325,6 +325,10 @@ impl DataFlowGraph {
         id
     }
 
+    pub(crate) fn make_global(&mut self, typ: Type) -> ValueId {
+        self.values.insert(Value::Global(typ))
+    }
+
     /// Gets or creates a ValueId for the given FunctionId.
     pub(crate) fn import_function(&mut self, function: FunctionId) -> ValueId {
         if let Some(existing) = self.functions.get(&function) {
@@ -589,6 +593,9 @@ impl DataFlowGraph {
                 }
                 _ => false,
             },
+            // TODO: Make this true and handle instruction simplifications with globals.
+            // Currently all globals are inlined as a temporary measure so this is fine to have as false.
+            Value::Global(_) => false,
             _ => true,
         }
     }

compiler/noirc_evaluator/src/ssa/ir/printer.rs

@@ -35,7 +35,7 @@ pub(crate) fn display_block(
     writeln!(f, "  {}({}):", block_id, value_list_with_types(dfg, block.parameters()))?;
 
     for instruction in block.instructions() {
-        display_instruction(dfg, *instruction, f)?;
+        display_instruction(dfg, *instruction, true, f)?;
     }
 
     display_terminator(dfg, block.terminator(), f)
@@ -53,6 +53,9 @@ fn value(dfg: &DataFlowGraph, id: ValueId) -> String {
         Value::Intrinsic(intrinsic) => intrinsic.to_string(),
         Value::ForeignFunction(function) => function.clone(),
         Value::Param { .. } | Value::Instruction { .. } => id.to_string(),
+        Value::Global(_) => {
+            format!("@{id}")
+        }
     }
 }
 
@@ -110,10 +113,13 @@ pub(crate) fn display_terminator(
 pub(crate) fn display_instruction(
     dfg: &DataFlowGraph,
     instruction: InstructionId,
+    indent: bool,
     f: &mut Formatter,
 ) -> Result {
-    // instructions are always indented within a function
-    write!(f, "    ")?;
+    if indent {
+        // instructions are always indented within a function
+        write!(f, "    ")?;
+    }
 
     let results = dfg.instruction_results(instruction);
     if !results.is_empty() {

compiler/noirc_evaluator/src/ssa/ir/value.rs

@@ -27,16 +27,27 @@ pub(crate) enum Value {
     /// Example, if you add two numbers together, then the resulting
     /// value would have position `0`, the typ would be the type
     /// of the operands, and the instruction would map to an add instruction.
-    Instruction { instruction: InstructionId, position: usize, typ: Type },
+    Instruction {
+        instruction: InstructionId,
+        position: usize,
+        typ: Type,
+    },
 
     /// This Value originates from a block parameter. Since function parameters
     /// are also represented as block parameters, this includes function parameters as well.
     ///
     /// position -- the index of this Value in the block parameters list
-    Param { block: BasicBlockId, position: usize, typ: Type },
+    Param {
+        block: BasicBlockId,
+        position: usize,
+        typ: Type,
+    },
 
     /// This Value originates from a numeric constant
-    NumericConstant { constant: FieldElement, typ: NumericType },
+    NumericConstant {
+        constant: FieldElement,
+        typ: NumericType,
+    },
 
     /// This Value refers to a function in the IR.
     /// Functions always have the type Type::Function.
@@ -53,6 +64,8 @@ pub(crate) enum Value {
     /// ForeignFunction's always have the type Type::Function and have similar semantics to Function,
     /// other than generating different backend operations and being only accessible through Brillig.
     ForeignFunction(String),
+
+    Global(Type),
 }
 
 impl Value {
@@ -64,6 +77,7 @@ impl Value {
             Value::Function { .. } | Value::Intrinsic { .. } | Value::ForeignFunction { .. } => {
                 Cow::Owned(Type::Function)
             }
+            Value::Global(typ) => Cow::Borrowed(typ),
         }
     }
 }

compiler/noirc_evaluator/src/ssa/opt/inlining.rs

@@ -17,7 +17,7 @@ use crate::ssa::{
         instruction::{Instruction, InstructionId, TerminatorInstruction},
         value::{Value, ValueId},
     },
-    ssa_gen::Ssa,
+    ssa_gen::{context::GlobalsContext, Ssa},
 };
 use fxhash::FxHashMap as HashMap;
 
@@ -80,7 +80,7 @@ impl Ssa {
 /// This works using an internal FunctionBuilder to build a new main function from scratch.
 /// Doing it this way properly handles importing instructions between functions and lets us
 /// reuse the existing API at the cost of essentially cloning each of main's instructions.
-struct InlineContext {
+struct InlineContext<'global> {
     recursion_level: u32,
     builder: FunctionBuilder,
 
@@ -98,20 +98,22 @@ struct InlineContext {
 
     // These are the functions of the program that we shouldn't inline.
     functions_not_to_inline: BTreeSet<FunctionId>,
+
+    globals: &'global GlobalsContext,
 }
 
 /// The per-function inlining context contains information that is only valid for one function.
 /// For example, each function has its own DataFlowGraph, and thus each function needs a translation
 /// layer to translate between BlockId to BlockId for the current function and the function to
 /// inline into. The same goes for ValueIds, InstructionIds, and for storing other data like
 /// parameter to argument mappings.
-struct PerFunctionContext<'function> {
+struct PerFunctionContext<'function, 'global> {
     /// The source function is the function we're currently inlining into the function being built.
     source_function: &'function Function,
 
     /// The shared inlining context for all functions. This notably contains the FunctionBuilder used
     /// to build the function we're inlining into.
-    context: &'function mut InlineContext,
+    context: &'function mut InlineContext<'global>,
 
     /// Maps ValueIds in the function being inlined to the new ValueIds to use in the function
     /// being inlined into. This mapping also contains the mapping from parameter values to
@@ -347,18 +349,18 @@ fn compute_function_interface_cost(func: &Function) -> usize {
     func.parameters().len() + func.returns().len()
 }
 
-impl InlineContext {
+impl<'global> InlineContext<'global> {
     /// Create a new context object for the function inlining pass.
     /// This starts off with an empty mapping of instructions for main's parameters.
     /// The function being inlined into will always be the main function, although it is
     /// actually a copy that is created in case the original main is still needed from a function
     /// that could not be inlined calling it.
     fn new(
-        ssa: &Ssa,
+        ssa: &'global Ssa,
         entry_point: FunctionId,
         inline_no_predicates_functions: bool,
         functions_not_to_inline: BTreeSet<FunctionId>,
-    ) -> InlineContext {
+    ) -> Self {
         let source = &ssa.functions[&entry_point];
         let mut builder = FunctionBuilder::new(source.name().to_owned(), entry_point);
         builder.set_runtime(source.runtime());
@@ -369,6 +371,7 @@ impl InlineContext {
             call_stack: CallStackId::root(),
             inline_no_predicates_functions,
             functions_not_to_inline,
+            globals: &ssa.globals,
         }
     }
 
@@ -379,6 +382,10 @@ impl InlineContext {
         let mut context = PerFunctionContext::new(&mut self, entry_point);
         context.inlining_entry = true;
 
+        for (_, value) in ssa.globals.dfg.values_iter() {
+            context.context.builder.current_function.dfg.make_global(value.get_type().into_owned());
+        }
+
         // The entry block is already inserted so we have to add it to context.blocks and add
         // its parameters here. Failing to do so would cause context.translate_block() to add
         // a fresh block for the entry block rather than use the existing one.
@@ -437,12 +444,15 @@ impl InlineContext {
     }
 }
 
-impl<'function> PerFunctionContext<'function> {
+impl<'function, 'global> PerFunctionContext<'function, 'global> {
     /// Create a new PerFunctionContext from the source function.
     /// The value and block mappings for this context are initially empty except
     /// for containing the mapping between parameters in the source_function and
     /// the arguments of the destination function.
-    fn new(context: &'function mut InlineContext, source_function: &'function Function) -> Self {
+    fn new(
+        context: &'function mut InlineContext<'global>,
+        source_function: &'function Function,
+    ) -> Self {
         Self {
             context,
             source_function,
@@ -478,6 +488,28 @@ impl<'function> PerFunctionContext<'function> {
             Value::ForeignFunction(function) => {
                 self.context.builder.import_foreign_function(function)
             }
+            Value::Global(_) => {
+                // TODO: Inlining the global into the function is only a temporary measure
+                // until Brillig gen with globals is working end to end
+                match &self.context.globals.dfg[id] {
+                    Value::Instruction { instruction, .. } => {
+                        let Instruction::MakeArray { elements, typ } =
+                            &self.context.globals.dfg[*instruction]
+                        else {
+                            panic!("Only expect Instruction::MakeArray for a global");
+                        };
+                        let elements = elements
+                            .iter()
+                            .map(|element| self.translate_value(*element))
+                            .collect::<im::Vector<_>>();
+                        self.context.builder.insert_make_array(elements, typ.clone())
+                    }
+                    Value::NumericConstant { constant, typ } => {
+                        self.context.builder.numeric_constant(*constant, *typ)
+                    }
+                    _ => panic!("Expected only an instruction or a numeric constant"),
+                }
+            }
         };
 
         self.values.insert(id, new_value);

compiler/noirc_evaluator/src/ssa/opt/normalize_value_ids.rs

@@ -8,7 +8,7 @@ use crate::ssa::{
         post_order::PostOrder,
         value::{Value, ValueId},
     },
-    ssa_gen::Ssa,
+    ssa_gen::{context::GlobalsContext, Ssa},
 };
 use fxhash::FxHashMap as HashMap;
 use iter_extended::vecmap;
@@ -25,7 +25,7 @@ impl Ssa {
         let mut context = Context::default();
         context.populate_functions(&self.functions);
         for function in self.functions.values_mut() {
-            context.normalize_ids(function);
+            context.normalize_ids(function, &self.globals);
         }
         self.functions = context.functions.into_btree();
     }
@@ -65,13 +65,17 @@ impl Context {
         }
     }
 
-    fn normalize_ids(&mut self, old_function: &mut Function) {
+    fn normalize_ids(&mut self, old_function: &mut Function, globals: &GlobalsContext) {
         self.new_ids.blocks.clear();
         self.new_ids.values.clear();
 
         let new_function_id = self.new_ids.function_ids[&old_function.id()];
         let new_function = &mut self.functions[new_function_id];
 
+        for (_, value) in globals.dfg.values_iter() {
+            new_function.dfg.make_global(value.get_type().into_owned());
+        }
+
         let mut reachable_blocks = PostOrder::with_function(old_function).into_vec();
         reachable_blocks.reverse();
 
@@ -192,6 +196,11 @@ impl IdMaps {
             }
             Value::Intrinsic(intrinsic) => new_function.dfg.import_intrinsic(*intrinsic),
             Value::ForeignFunction(name) => new_function.dfg.import_foreign_function(name),
+            Value::Global(_) => {
+                // Globals are computed at compile-time and thus are expected to be remain normalized
+                // between SSA passes
+                old_value
+            },
         }
     }
 }