Handle tied operands that are not killed by their use.

Any tied register uses are interesting enough to be added to the reguses
list if their value is not killed.

A copy needs to be inserted in that case.

lib/cretonne/src/regalloc/spilling.rs

@@ -26,6 +26,7 @@ use regalloc::live_value_tracker::{LiveValue, LiveValueTracker};
 use regalloc::liveness::Liveness;
 use regalloc::pressure::Pressure;
 use regalloc::virtregs::VirtRegs;
+use std::fmt;
 use topo_order::TopoOrder;
 
 /// Persistent data structures for the spilling pass.
@@ -338,7 +339,8 @@ impl<'a> Context<'a> {
             }
 
             // Only collect the interesting register uses.
-            if reguse.fixed || reguse.spilled {
+            if reguse.fixed || reguse.tied || reguse.spilled {
+                dbg!("  reguse: {}", reguse);
                 self.reg_uses.push(reguse);
             }
         }
@@ -578,3 +580,19 @@ impl RegUse {
         }
     }
 }
+
+impl fmt::Display for RegUse {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}@op{}", self.value, self.opidx)?;
+        if self.fixed {
+            write!(f, "/fixed")?;
+        }
+        if self.spilled {
+            write!(f, "/spilled")?;
+        }
+        if self.tied {
+            write!(f, "/tied")?;
+        }
+        Ok(())
+    }
+}