cranelift: bump regalloc.rs to 0.0.24 and adapt to latest API changes;

cranelift/codegen/src/isa/aarch64/inst/mod.rs

@@ -1168,29 +1168,29 @@ fn aarch64_get_regs(inst: &Inst, collector: &mut RegUsageCollector) {
 //=============================================================================
 // Instructions: map_regs
 
-fn aarch64_map_regs(inst: &mut Inst, mapper: &RegUsageMapper) {
-    fn map_use(m: &RegUsageMapper, r: &mut Reg) {
+fn aarch64_map_regs<RUM: RegUsageMapper>(inst: &mut Inst, mapper: &RUM) {
+    fn map_use<RUM: RegUsageMapper>(m: &RUM, r: &mut Reg) {
         if r.is_virtual() {
             let new = m.get_use(r.to_virtual_reg()).unwrap().to_reg();
             *r = new;
         }
     }
 
-    fn map_def(m: &RegUsageMapper, r: &mut Writable<Reg>) {
+    fn map_def<RUM: RegUsageMapper>(m: &RUM, r: &mut Writable<Reg>) {
         if r.to_reg().is_virtual() {
             let new = m.get_def(r.to_reg().to_virtual_reg()).unwrap().to_reg();
             *r = Writable::from_reg(new);
         }
     }
 
-    fn map_mod(m: &RegUsageMapper, r: &mut Writable<Reg>) {
+    fn map_mod<RUM: RegUsageMapper>(m: &RUM, r: &mut Writable<Reg>) {
         if r.to_reg().is_virtual() {
             let new = m.get_mod(r.to_reg().to_virtual_reg()).unwrap().to_reg();
             *r = Writable::from_reg(new);
         }
     }
 
-    fn map_mem(m: &RegUsageMapper, mem: &mut MemArg) {
+    fn map_mem<RUM: RegUsageMapper>(m: &RUM, mem: &mut MemArg) {
         // N.B.: we take only the pre-map here, but this is OK because the
         // only addressing modes that update registers (pre/post-increment on
         // AArch64) both read and write registers, so they are "mods" rather
@@ -1219,7 +1219,7 @@ fn aarch64_map_regs(inst: &mut Inst, mapper: &RegUsageMapper) {
         };
     }
 
-    fn map_pairmem(m: &RegUsageMapper, mem: &mut PairMemArg) {
+    fn map_pairmem<RUM: RegUsageMapper>(m: &RUM, mem: &mut PairMemArg) {
         match mem {
             &mut PairMemArg::SignedOffset(ref mut reg, ..) => map_use(m, reg),
             &mut PairMemArg::PreIndexed(ref mut reg, ..) => map_def(m, reg),
@@ -1227,7 +1227,7 @@ fn aarch64_map_regs(inst: &mut Inst, mapper: &RegUsageMapper) {
         }
     }
 
-    fn map_br(m: &RegUsageMapper, br: &mut CondBrKind) {
+    fn map_br<RUM: RegUsageMapper>(m: &RUM, br: &mut CondBrKind) {
         match br {
             &mut CondBrKind::Zero(ref mut reg) => map_use(m, reg),
             &mut CondBrKind::NotZero(ref mut reg) => map_use(m, reg),
@@ -1738,7 +1738,7 @@ impl MachInst for Inst {
         aarch64_get_regs(self, collector)
     }
 
-    fn map_regs(&mut self, mapper: &RegUsageMapper) {
+    fn map_regs<RUM: RegUsageMapper>(&mut self, mapper: &RUM) {
         aarch64_map_regs(self, mapper);
     }
 

cranelift/codegen/src/isa/x64/inst/mod.rs

@@ -576,21 +576,21 @@ fn x64_get_regs(inst: &Inst, collector: &mut RegUsageCollector) {
 //=============================================================================
 // Instructions and subcomponents: map_regs
 
-fn map_use(m: &RegUsageMapper, r: &mut Reg) {
+fn map_use<RUM: RegUsageMapper>(m: &RUM, r: &mut Reg) {
     if r.is_virtual() {
         let new = m.get_use(r.to_virtual_reg()).unwrap().to_reg();
         *r = new;
     }
 }
 
-fn map_def(m: &RegUsageMapper, r: &mut Writable<Reg>) {
+fn map_def<RUM: RegUsageMapper>(m: &RUM, r: &mut Writable<Reg>) {
     if r.to_reg().is_virtual() {
         let new = m.get_def(r.to_reg().to_virtual_reg()).unwrap().to_reg();
         *r = Writable::from_reg(new);
     }
 }
 
-fn map_mod(m: &RegUsageMapper, r: &mut Writable<Reg>) {
+fn map_mod<RUM: RegUsageMapper>(m: &RUM, r: &mut Writable<Reg>) {
     if r.to_reg().is_virtual() {
         let new = m.get_mod(r.to_reg().to_virtual_reg()).unwrap().to_reg();
         *r = Writable::from_reg(new);
@@ -598,7 +598,7 @@ fn map_mod(m: &RegUsageMapper, r: &mut Writable<Reg>) {
 }
 
 impl Addr {
-    fn map_uses(&mut self, map: &RegUsageMapper) {
+    fn map_uses<RUM: RegUsageMapper>(&mut self, map: &RUM) {
         match self {
             Addr::IR {
                 simm32: _,
@@ -618,7 +618,7 @@ impl Addr {
 }
 
 impl RMI {
-    fn map_uses(&mut self, map: &RegUsageMapper) {
+    fn map_uses<RUM: RegUsageMapper>(&mut self, map: &RUM) {
         match self {
             RMI::R { ref mut reg } => map_use(map, reg),
             RMI::M { ref mut addr } => addr.map_uses(map),
@@ -628,7 +628,7 @@ impl RMI {
 }
 
 impl RM {
-    fn map_uses(&mut self, map: &RegUsageMapper) {
+    fn map_uses<RUM: RegUsageMapper>(&mut self, map: &RUM) {
         match self {
             RM::R { ref mut reg } => map_use(map, reg),
             RM::M { ref mut addr } => addr.map_uses(map),
@@ -636,7 +636,7 @@ impl RM {
     }
 }
 
-fn x64_map_regs(inst: &mut Inst, mapper: &RegUsageMapper) {
+fn x64_map_regs<RUM: RegUsageMapper>(inst: &mut Inst, mapper: &RUM) {
     // Note this must be carefully synchronized with x64_get_regs.
     match inst {
         // ** Nop
@@ -739,7 +739,7 @@ impl MachInst for Inst {
         x64_get_regs(&self, collector)
     }
 
-    fn map_regs(&mut self, mapper: &RegUsageMapper) {
+    fn map_regs<RUM: RegUsageMapper>(&mut self, mapper: &RUM) {
         x64_map_regs(self, mapper);
     }
 

cranelift/codegen/src/machinst/mod.rs

@@ -138,7 +138,7 @@ pub trait MachInst: Clone + Debug {
 
     /// Map virtual registers to physical registers using the given virt->phys
     /// maps corresponding to the program points prior to, and after, this instruction.
-    fn map_regs(&mut self, maps: &RegUsageMapper);
+    fn map_regs<RUM: RegUsageMapper>(&mut self, maps: &RUM);
 
     /// If this is a simple move, return the (source, destination) tuple of registers.
     fn is_move(&self) -> Option<(Writable<Reg>, Reg)>;

cranelift/codegen/src/machinst/vcode.rs

@@ -457,7 +457,7 @@ impl<I: VCodeInst> RegallocFunction for VCode<I> {
         insn.get_regs(collector)
     }
 
-    fn map_regs(insn: &mut I, mapper: &RegUsageMapper) {
+    fn map_regs<RUM: RegUsageMapper>(insn: &mut I, mapper: &RUM) {
         insn.map_regs(mapper);
     }