Initial implementation of regalloc2.

src/cfg.rs

@@ -38,23 +38,24 @@ pub struct CFGInfo {
 
 impl CFGInfo {
     pub fn new<F: Function>(f: &F) -> Result<CFGInfo, RegAllocError> {
-        let postorder =
-            postorder::calculate(f.blocks(), f.entry_block(), |block| f.block_succs(block));
+        let postorder = postorder::calculate(f.num_blocks(), f.entry_block(), |block| {
+            f.block_succs(block)
+        });
         let domtree = domtree::calculate(
-            f.blocks(),
+            f.num_blocks(),
             |block| f.block_preds(block),
             &postorder[..],
             f.entry_block(),
         );
-        let mut insn_block = vec![Block::invalid(); f.insts()];
+        let mut insn_block = vec![Block::invalid(); f.num_insts()];
         let mut vreg_def_inst = vec![Inst::invalid(); f.num_vregs()];
         let mut vreg_def_blockparam = vec![(Block::invalid(), 0); f.num_vregs()];
-        let mut block_entry = vec![ProgPoint::before(Inst::invalid()); f.blocks()];
-        let mut block_exit = vec![ProgPoint::before(Inst::invalid()); f.blocks()];
-        let mut backedge_in = vec![0; f.blocks()];
-        let mut backedge_out = vec![0; f.blocks()];
+        let mut block_entry = vec![ProgPoint::before(Inst::invalid()); f.num_blocks()];
+        let mut block_exit = vec![ProgPoint::before(Inst::invalid()); f.num_blocks()];
+        let mut backedge_in = vec![0; f.num_blocks()];
+        let mut backedge_out = vec![0; f.num_blocks()];
 
-        for block in 0..f.blocks() {
+        for block in 0..f.num_blocks() {
             let block = Block::new(block);
             for (i, param) in f.block_params(block).iter().enumerate() {
                 vreg_def_blockparam[param.vreg()] = (block, i as u32);
@@ -116,7 +117,7 @@ impl CFGInfo {
         let mut approx_loop_depth = vec![];
         let mut backedge_stack: SmallVec<[usize; 4]> = smallvec![];
         let mut cur_depth = 0;
-        for block in 0..f.blocks() {
+        for block in 0..f.num_blocks() {
             if backedge_in[block] > 0 {
                 cur_depth += 1;
                 backedge_stack.push(backedge_in[block]);

src/checker.rs

@@ -389,17 +389,6 @@ impl CheckerState {
                     self.allocations.remove(&Allocation::reg(*clobber));
                 }
             }
-            &CheckerInst::BlockParams {
-                ref vregs,
-                ref allocs,
-                ..
-            } => {
-                for (vreg, alloc) in vregs.iter().zip(allocs.iter()) {
-                    let reftyped = checker.reftyped_vregs.contains(vreg);
-                    self.allocations
-                        .insert(*alloc, CheckerValue::Reg(*vreg, reftyped));
-                }
-            }
             &CheckerInst::DefAlloc { alloc, vreg } => {
                 let reftyped = checker.reftyped_vregs.contains(&vreg);
                 self.allocations
@@ -478,14 +467,6 @@ pub(crate) enum CheckerInst {
         clobbers: Vec<PReg>,
     },
 
-    /// The top of a block with blockparams. We define the given vregs
-    /// into the given allocations.
-    BlockParams {
-        block: Block,
-        vregs: Vec<VReg>,
-        allocs: Vec<Allocation>,
-    },
-
     /// Define an allocation's contents. Like BlockParams but for one
     /// allocation. Used sometimes when moves are elided but ownership
     /// of a value is logically transferred to a new vreg.
@@ -514,7 +495,7 @@ impl<'a, F: Function> Checker<'a, F> {
         let mut bb_insts = HashMap::new();
         let mut reftyped_vregs = HashSet::new();
 
-        for block in 0..f.blocks() {
+        for block in 0..f.num_blocks() {
             let block = Block::new(block);
             bb_in.insert(block, Default::default());
             bb_insts.insert(block, vec![]);
@@ -548,7 +529,7 @@ impl<'a, F: Function> Checker<'a, F> {
         // For each original instruction, create an `Op`.
         let mut last_inst = None;
         let mut insert_idx = 0;
-        for block in 0..self.f.blocks() {
+        for block in 0..self.f.num_blocks() {
             let block = Block::new(block);
             for inst in self.f.block_insns(block).iter() {
                 assert!(last_inst.is_none() || inst > last_inst.unwrap());
@@ -617,17 +598,6 @@ impl<'a, F: Function> Checker<'a, F> {
                         .unwrap()
                         .push(CheckerInst::DefAlloc { alloc, vreg });
                 }
-                &Edit::BlockParams {
-                    ref vregs,
-                    ref allocs,
-                } => {
-                    let inst = CheckerInst::BlockParams {
-                        block,
-                        vregs: vregs.clone(),
-                        allocs: allocs.clone(),
-                    };
-                    self.bb_insts.get_mut(&block).unwrap().push(inst);
-                }
             }
         }
     }
@@ -636,7 +606,7 @@ impl<'a, F: Function> Checker<'a, F> {
     fn analyze(&mut self) {
         let mut queue = VecDeque::new();
         let mut queue_set = HashSet::new();
-        for block in 0..self.f.blocks() {
+        for block in 0..self.f.num_blocks() {
             let block = Block::new(block);
             queue.push_back(block);
             queue_set.insert(block);
@@ -718,7 +688,7 @@ impl<'a, F: Function> Checker<'a, F> {
         for vreg in self.f.reftype_vregs() {
             log::trace!("  REF: {}", vreg);
         }
-        for bb in 0..self.f.blocks() {
+        for bb in 0..self.f.num_blocks() {
             let bb = Block::new(bb);
             log::trace!("block{}:", bb.index());
             let insts = self.bb_insts.get(&bb).unwrap();
@@ -743,17 +713,6 @@ impl<'a, F: Function> Checker<'a, F> {
                     &CheckerInst::Move { from, into } => {
                         log::trace!("    {} -> {}", from, into);
                     }
-                    &CheckerInst::BlockParams {
-                        ref vregs,
-                        ref allocs,
-                        ..
-                    } => {
-                        let mut args = vec![];
-                        for (vreg, alloc) in vregs.iter().zip(allocs.iter()) {
-                            args.push(format!("{}:{}", vreg, alloc));
-                        }
-                        log::trace!("    blockparams: {}", args.join(", "));
-                    }
                     &CheckerInst::DefAlloc { alloc, vreg } => {
                         log::trace!("    defalloc: {}:{}", vreg, alloc);
                     }

src/fuzzing/func.rs

@@ -75,11 +75,11 @@ pub struct Func {
 }
 
 impl Function for Func {
-    fn insts(&self) -> usize {
+    fn num_insts(&self) -> usize {
         self.insts.len()
     }
 
-    fn blocks(&self) -> usize {
+    fn num_blocks(&self) -> usize {
         self.blocks.len()
     }
 

src/ion/dump.rs

@@ -61,7 +61,7 @@ impl<'a, F: Function> Env<'a, F> {
 
     pub fn dump_results(&self) {
         log::info!("=== REGALLOC RESULTS ===");
-        for block in 0..self.func.blocks() {
+        for block in 0..self.func.num_blocks() {
             let block = Block::new(block);
             log::info!(
                 "block{}: [succs {:?} preds {:?}]",

src/ion/liveranges.rs

@@ -82,7 +82,7 @@ impl<'a, F: Function> Env<'a, F> {
             self.vregs[v.vreg()].is_pinned = true;
         }
         // Create allocations too.
-        for inst in 0..self.func.insts() {
+        for inst in 0..self.func.num_insts() {
             let start = self.allocs.len() as u32;
             self.inst_alloc_offsets.push(start);
             for _ in 0..self.func.inst_operands(Inst::new(inst)).len() {
@@ -247,7 +247,7 @@ impl<'a, F: Function> Env<'a, F> {
 
     pub fn compute_liveness(&mut self) -> Result<(), RegAllocError> {
         // Create initial LiveIn and LiveOut bitsets.
-        for _ in 0..self.func.blocks() {
+        for _ in 0..self.func.num_blocks() {
             self.liveins.push(BitVec::new());
             self.liveouts.push(BitVec::new());
         }
@@ -347,7 +347,7 @@ impl<'a, F: Function> Env<'a, F> {
         let mut vreg_ranges: Vec<LiveRangeIndex> =
             vec![LiveRangeIndex::invalid(); self.func.num_vregs()];
 
-        for i in (0..self.func.blocks()).rev() {
+        for i in (0..self.func.num_blocks()).rev() {
             let block = Block::new(i);
 
             self.stats.livein_blocks += 1;

src/ion/merge.rs

@@ -303,7 +303,7 @@ impl<'a, F: Function> Env<'a, F> {
             self.bundles[bundle.index()].spillset = ssidx;
         }
 
-        for inst in 0..self.func.insts() {
+        for inst in 0..self.func.num_insts() {
             let inst = Inst::new(inst);
 
             // Attempt to merge Reuse-constraint operand outputs with the

src/ion/mod.rs

@@ -44,14 +44,14 @@ impl<'a, F: Function> Env<'a, F> {
         cfginfo: CFGInfo,
         annotations_enabled: bool,
     ) -> Self {
-        let n = func.insts();
+        let n = func.num_insts();
         Self {
             func,
             env,
             cfginfo,
 
-            liveins: Vec::with_capacity(func.blocks()),
-            liveouts: Vec::with_capacity(func.blocks()),
+            liveins: Vec::with_capacity(func.num_blocks()),
+            liveouts: Vec::with_capacity(func.num_blocks()),
             blockparam_outs: vec![],
             blockparam_ins: vec![],
             blockparam_allocs: vec![],

src/ion/moves.rs

@@ -166,8 +166,8 @@ impl<'a, F: Function> Env<'a, F> {
             }
         }
 
-        let mut half_moves: Vec<HalfMove> = Vec::with_capacity(6 * self.func.insts());
-        let mut reuse_input_insts = Vec::with_capacity(self.func.insts() / 2);
+        let mut half_moves: Vec<HalfMove> = Vec::with_capacity(6 * self.func.num_insts());
+        let mut reuse_input_insts = Vec::with_capacity(self.func.num_insts() / 2);
 
         let mut blockparam_in_idx = 0;
         let mut blockparam_out_idx = 0;
@@ -290,7 +290,7 @@ impl<'a, F: Function> Env<'a, F> {
                     // same allocation) and if the vreg is live, add a
                     // Source half-move.
                     let mut block = self.cfginfo.insn_block[range.from.inst().index()];
-                    while block.is_valid() && block.index() < self.func.blocks() {
+                    while block.is_valid() && block.index() < self.func.num_blocks() {
                         if range.to < self.cfginfo.block_exit[block.index()].next() {
                             break;
                         }
@@ -376,7 +376,7 @@ impl<'a, F: Function> Env<'a, F> {
                     if self.cfginfo.block_entry[block.index()] < range.from {
                         block = block.next();
                     }
-                    while block.is_valid() && block.index() < self.func.blocks() {
+                    while block.is_valid() && block.index() < self.func.num_blocks() {
                         if self.cfginfo.block_entry[block.index()] >= range.to {
                             break;
                         }
@@ -1114,11 +1114,13 @@ impl<'a, F: Function> Env<'a, F> {
                 .collect::<Vec<_>>();
             assert_eq!(vregs.len(), self.func.block_params(block).len());
             assert_eq!(allocs.len(), self.func.block_params(block).len());
-            self.add_edit(
-                self.cfginfo.block_entry[block.index()],
-                InsertMovePrio::BlockParam,
-                Edit::BlockParams { vregs, allocs },
-            );
+            for (vreg, alloc) in vregs.into_iter().zip(allocs.into_iter()) {
+                self.add_edit(
+                    self.cfginfo.block_entry[block.index()],
+                    InsertMovePrio::BlockParam,
+                    Edit::DefAlloc { alloc, vreg },
+                );
+            }
         }
 
         // Ensure edits are in sorted ProgPoint order. N.B.: this must
@@ -1139,13 +1141,6 @@ impl<'a, F: Function> Env<'a, F> {
                             format!("move {} -> {} ({:?})", from, to, to_vreg),
                         );
                     }
-                    &Edit::BlockParams {
-                        ref vregs,
-                        ref allocs,
-                    } => {
-                        let s = format!("blockparams vregs:{:?} allocs:{:?}", vregs, allocs);
-                        self.annotate(ProgPoint::from_index(pos), s);
-                    }
                     &Edit::DefAlloc { alloc, vreg } => {
                         let s = format!("defalloc {:?} := {:?}", alloc, vreg);
                         self.annotate(ProgPoint::from_index(pos), s);

src/ion/process.rs

@@ -798,7 +798,7 @@ impl<'a, F: Function> Env<'a, F> {
         loop {
             attempts += 1;
             log::trace!("attempt {}, req {:?}", attempts, req);
-            debug_assert!(attempts < 100 * self.func.insts());
+            debug_assert!(attempts < 100 * self.func.num_insts());
 
             let (class, fixed_preg) = match req {
                 Requirement::Fixed(preg) => (preg.class(), Some(preg)),