Add a coalescing pass to the register allocator.

Coalescing means creating virtual registers and transforming the code
into conventional SSA form. This means that every value used as a branch
argument will belong to the same virtual register as the corresponding
EBB argument value.

Conventional SSA form makes it easy to avoid memory-memory copies when
spilling values, and the virtual registers can be used as hints when
picking registers too. This reduces the number of register moves needed
for EBB arguments.

lib/cretonne/src/dbg.rs

@@ -13,6 +13,7 @@ use std::ascii::AsciiExt;
 use std::cell::RefCell;
 use std::env;
 use std::ffi::OsStr;
+use std::fmt;
 use std::fs::File;
 use std::io::{Write, BufWriter};
 use std::sync::atomic;
@@ -98,3 +99,23 @@ macro_rules! dbg {
         }
     }
 }
+
+/// Helper for printing lists.
+pub struct DisplayList<'a, T>(pub &'a [T]) where T: 'a + fmt::Display;
+
+impl<'a, T> fmt::Display for DisplayList<'a, T>
+    where T: 'a + fmt::Display
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.0.split_first() {
+            None => write!(f, "[]"),
+            Some((first, rest)) => {
+                write!(f, "[{}", first)?;
+                for x in rest {
+                    write!(f, ", {}", x)?;
+                }
+                write!(f, "]")
+            }
+        }
+    }
+}