Do a little function surgery

split `Function` into `FunctionParameters` and `FunctionStencil`, so the
stencil can be compiled and cached, and compilation parameters can be
applied onto the result of compiling a FunctionStencil
(CompiledCodeBase<Stencil>) later on to become a consumable
CompiledCode.

cranelift/codegen/src/cfg_printer.rs

@@ -33,7 +33,11 @@ impl<'a> CFGPrinter<'a> {
     }
 
     fn header(&self, w: &mut dyn Write) -> Result {
-        writeln!(w, "digraph \"{}\" {{", self.func.name)?;
+        writeln!(
+            w,
+            "digraph \"{}\" {{",
+            self.func.params.name().display(Some(&self.func.params))
+        )?;
         if let Some(entry) = self.func.layout.entry_block() {
             writeln!(w, "    {{rank=min; {}}}", entry)?;
         }

cranelift/codegen/src/context.rs

@@ -18,7 +18,7 @@ use crate::isa::TargetIsa;
 use crate::legalizer::simple_legalize;
 use crate::licm::do_licm;
 use crate::loop_analysis::LoopAnalysis;
-use crate::machinst::CompiledCode;
+use crate::machinst::{CompiledCode, CompiledCodeBase, Stencil};
 use crate::nan_canonicalization::do_nan_canonicalization;
 use crate::remove_constant_phis::do_remove_constant_phis;
 use crate::result::{CodegenResult, CompileResult};
@@ -126,7 +126,15 @@ impl Context {
         Ok(compiled_code)
     }
 
-    pub(crate) fn compile_inner(&mut self, isa: &dyn TargetIsa) -> CodegenResult<()> {
+    /// Internally compiles the function into a stencil.
+    ///
+    /// Public only for testing and fuzzing purposes.
+    pub fn compile_stencil(
+        &mut self,
+        isa: &dyn TargetIsa,
+    ) -> CodegenResult<CompiledCodeBase<Stencil>> {
+        let _tt = timing::compile();
+
         self.verify_if(isa)?;
 
         let opt_level = isa.flags().opt_level();
@@ -165,9 +173,7 @@ impl Context {
             self.simple_gvn(isa)?;
         }
 
-        let result = isa.compile_function(&self.func, self.want_disasm)?;
-        self.compiled_code = Some(result);
-        Ok(())
+        isa.compile_function(&self.func, self.want_disasm)
     }
 
     /// Compile the function.
@@ -179,12 +185,13 @@ impl Context {
     /// Returns information about the function's code and read-only data.
     pub fn compile(&mut self, isa: &dyn TargetIsa) -> CompileResult<&CompiledCode> {
         let _tt = timing::compile();
-        self.compile_inner(isa)
-            .map(|_| self.compiled_code.as_ref().unwrap())
-            .map_err(|error| CompileError {
-                inner: error,
-                func: &self.func,
-            })
+        let stencil = self.compile_stencil(isa).map_err(|error| CompileError {
+            inner: error,
+            func: &self.func,
+        })?;
+        Ok(self
+            .compiled_code
+            .insert(stencil.apply_params(&self.func.params)))
     }
 
     /// If available, return information about the code layout in the

cranelift/codegen/src/cursor.rs

@@ -589,7 +589,7 @@ impl<'f> FuncCursor<'f> {
 
     /// Use the source location of `inst` for future instructions.
     pub fn use_srcloc(&mut self, inst: ir::Inst) {
-        self.srcloc = self.func.srclocs[inst];
+        self.srcloc = self.func.srcloc(inst);
     }
 
     /// Create an instruction builder that inserts an instruction at the current position.
@@ -612,6 +612,7 @@ impl<'f> Cursor for FuncCursor<'f> {
     }
 
     fn set_srcloc(&mut self, srcloc: ir::SourceLoc) {
+        self.func.params.ensure_base_srcloc(srcloc);
         self.srcloc = srcloc;
     }
 
@@ -658,7 +659,7 @@ impl<'c, 'f> ir::InstInserterBase<'c> for &'c mut FuncCursor<'f> {
         }
         self.insert_inst(inst);
         if !self.srcloc.is_default() {
-            self.func.srclocs[inst] = self.srcloc;
+            self.func.set_srcloc(inst, self.srcloc);
         }
         &mut self.func.dfg
     }