Add reference types R32 and R64

-Add resumable_trap, safepoint, isnull, and null instructions
-Add Stackmap struct and StackmapSink trait

Co-authored-by: Mir Ahmed <mirahmed753@gmail.com>
Co-authored-by: Dan Gohman <sunfish@mozilla.com>

cranelift/codegen/src/regalloc/context.rs

@@ -13,6 +13,7 @@ use crate::regalloc::coloring::Coloring;
 use crate::regalloc::live_value_tracker::LiveValueTracker;
 use crate::regalloc::liveness::Liveness;
 use crate::regalloc::reload::Reload;
+use crate::regalloc::safepoint::emit_stackmaps;
 use crate::regalloc::spilling::Spilling;
 use crate::regalloc::virtregs::VirtRegs;
 use crate::result::CodegenResult;
@@ -192,6 +193,20 @@ impl Context {
         self.coloring
             .run(isa, func, domtree, &mut self.liveness, &mut self.tracker);
 
+        // This function runs after register allocation has taken
+        // place, meaning values have locations assigned already.
+        if isa.flags().enable_safepoints() {
+            emit_stackmaps(func, domtree, &self.liveness, &mut self.tracker, isa);
+        } else {
+            // Make sure no references are used.
+            for val in func.dfg.values() {
+                let ty = func.dfg.value_type(val);
+                if ty.lane_type().is_ref() {
+                    panic!("reference types were found but safepoints were not enabled.");
+                }
+            }
+        }
+
         if isa.flags().enable_verifier() {
             let ok = verify_context(func, cfg, domtree, isa, &mut errors).is_ok()
                 && verify_liveness(isa, func, cfg, &self.liveness, &mut errors).is_ok()

cranelift/codegen/src/regalloc/mod.rs

@@ -15,9 +15,11 @@ mod context;
 mod diversion;
 mod pressure;
 mod reload;
+mod safepoint;
 mod solver;
 mod spilling;
 
 pub use self::context::Context;
 pub use self::diversion::RegDiversions;
 pub use self::register_set::RegisterSet;
+pub use self::safepoint::emit_stackmaps;

cranelift/codegen/src/regalloc/safepoint.rs

@@ -0,0 +1,72 @@
+use crate::cursor::{Cursor, FuncCursor};
+use crate::dominator_tree::DominatorTree;
+use crate::ir::{Function, InstBuilder, InstructionData, Opcode, TrapCode};
+use crate::isa::TargetIsa;
+use crate::regalloc::live_value_tracker::LiveValueTracker;
+use crate::regalloc::liveness::Liveness;
+use std::vec::Vec;
+
+fn insert_and_encode_safepoint<'f>(
+    pos: &mut FuncCursor<'f>,
+    tracker: &LiveValueTracker,
+    isa: &dyn TargetIsa,
+) {
+    // Iterate through all live values, collect only the references.
+    let live_ref_values = tracker
+        .live()
+        .iter()
+        .filter(|live_value| pos.func.dfg.value_type(live_value.value).is_ref())
+        .map(|live_val| live_val.value)
+        .collect::<Vec<_>>();
+
+    if !live_ref_values.is_empty() {
+        pos.ins().safepoint(&live_ref_values);
+        // Move cursor to the new safepoint instruction to encode it.
+        if let Some(inst) = pos.prev_inst() {
+            let ok = pos.func.update_encoding(inst, isa).is_ok();
+            debug_assert!(ok);
+        }
+        // Restore cursor position.
+        pos.next_inst();
+    }
+}
+
+// The emit_stackmaps() function analyzes each instruction to retrieve the liveness of
+// the defs and operands by traversing a function's ebbs in layout order.
+pub fn emit_stackmaps(
+    func: &mut Function,
+    domtree: &DominatorTree,
+    liveness: &Liveness,
+    tracker: &mut LiveValueTracker,
+    isa: &dyn TargetIsa,
+) {
+    let mut curr = func.layout.entry_block();
+
+    while let Some(ebb) = curr {
+        tracker.ebb_top(ebb, &func.dfg, liveness, &func.layout, domtree);
+        tracker.drop_dead_params();
+        let mut pos = FuncCursor::new(func);
+
+        // From the top of the ebb, step through the instructions.
+        pos.goto_top(ebb);
+
+        while let Some(inst) = pos.next_inst() {
+            if let InstructionData::Trap {
+                code: TrapCode::Interrupt,
+                ..
+            } = &pos.func.dfg[inst]
+            {
+                insert_and_encode_safepoint(&mut pos, tracker, isa);
+            } else if pos.func.dfg[inst].opcode().is_call() {
+                insert_and_encode_safepoint(&mut pos, tracker, isa);
+            } else if pos.func.dfg[inst].opcode() == Opcode::Safepoint {
+                panic!("safepoint instruction can only be used by the compiler!");
+            }
+
+            // Process the instruction and get rid of dead values.
+            tracker.process_inst(inst, &pos.func.dfg, liveness);
+            tracker.drop_dead(inst);
+        }
+        curr = func.layout.next_ebb(ebb);
+    }
+}