Simplify the arguments() return type.

Now that variable arguments are always stored in a value list with the
fixed arguments, we no longer need the arcane [&[Value]; 2] return type.

Arguments are always stored contiguously, so just return a &[Value]
slice.

Also remove the each_arg() methods which were just trying to make it
easier to work with the old slice pair.

lib/cretonne/src/ir/instructions.rs

@@ -336,30 +336,6 @@ impl Display for TernaryOverflowData {
 /// Avoid large matches on instruction formats by using the methods defined here to examine
 /// instructions.
 impl InstructionData {
-    /// Execute a closure once for each argument to this instruction.
-    /// See also the `arguments()` method.
-    pub fn each_arg<F>(&self, pool: &ValueListPool, mut func: F)
-        where F: FnMut(Value)
-    {
-        for part in &self.arguments(pool) {
-            for &arg in part.iter() {
-                func(arg);
-            }
-        }
-    }
-
-    /// Execute a closure with a mutable reference to each argument to this instruction.
-    /// See also the `arguments_mut()` method.
-    pub fn each_arg_mut<F>(&mut self, pool: &mut ValueListPool, mut func: F)
-        where F: FnMut(&mut Value)
-    {
-        for part in &mut self.arguments_mut(pool) {
-            for arg in part.iter_mut() {
-                func(arg);
-            }
-        }
-    }
-
     /// Return information about the destination of a branch or jump instruction.
     ///
     /// Any instruction that can transfer control to another EBB reveals its possible destinations

lib/cretonne/src/regalloc/coloring.rs

@@ -299,7 +299,7 @@ impl<'a> Context<'a> {
                         }
                         ConstraintKind::Tied(arg_index) => {
                             // This def must use the same register as a fixed instruction argument.
-                            let arg = dfg[inst].arguments(&dfg.value_lists)[0][arg_index as usize];
+                            let arg = dfg[inst].arguments(&dfg.value_lists)[arg_index as usize];
                             let loc = locations[arg];
                             *locations.ensure(lv.value) = loc;
                             // Mark the reused register. It's not really clear if we support tied

lib/cretonne/src/regalloc/liveness.rs

@@ -318,7 +318,7 @@ impl Liveness {
                 let mut operand_constraints =
                     recipe_constraints.get(recipe).map(|c| c.ins).unwrap_or(&[]).iter();
 
-                func.dfg[inst].each_arg(&func.dfg.value_lists, |arg| {
+                for &arg in func.dfg[inst].arguments(&func.dfg.value_lists) {
                     // Get the live range, create it as a dead range if necessary.
                     let lr = get_or_create(&mut self.ranges, arg, func, recipe_constraints);
 
@@ -333,7 +333,7 @@ impl Liveness {
                     if let Some(constraint) = operand_constraints.next() {
                         lr.affinity.merge(constraint, &reg_info);
                     }
-                });
+                }
             }
         }
     }

lib/cretonne/src/write.rs

@@ -157,7 +157,7 @@ fn type_suffix(func: &Function, inst: Inst) -> Option<Type> {
 
 // Write out any value aliases appearing in `inst`.
 fn write_value_aliases(w: &mut Write, func: &Function, inst: Inst, indent: usize) -> Result {
-    for &arg in func.dfg[inst].arguments(&func.dfg.value_lists).iter().flat_map(|x| x.iter()) {
+    for &arg in func.dfg[inst].arguments(&func.dfg.value_lists) {
         let resolved = func.dfg.resolve_aliases(arg);
         if resolved != arg {
             writeln!(w, "{1:0$}{2} -> {3}", indent, "", arg, resolved)?;