Add a register allocation context module.

Collect the data structures that hang around between function
compilations.

Provide a main entry point to the register allocator passes.

lib/cretonne/src/context.rs

@@ -3,10 +3,18 @@
 //! When compiling many small functions, it is important to avoid repeatedly allocating and
 //! deallocating the data structures needed for compilation. The `Context` struct is used to hold
 //! on to memory allocations between function compilations.
+//!
+//! The context does not hold a `TargetIsa` instance which has to be provided as an argument
+//! instead. This is because an ISA instance is immutable and can be used by multiple compilation
+//! contexts concurrently. Typically, you would have one context per compilation thread and only a
+//! single ISA instance.
 
 use cfg::ControlFlowGraph;
 use dominator_tree::DominatorTree;
 use ir::Function;
+use isa::TargetIsa;
+use legalize_function;
+use regalloc;
 
 /// Persistent data structures and compilation pipeline.
 pub struct Context {
@@ -18,6 +26,9 @@ pub struct Context {
 
     /// Dominator tree for `func`.
     pub domtree: DominatorTree,
+
+    /// Register allocation context.
+    pub regalloc: regalloc::Context,
 }
 
 impl Context {
@@ -30,12 +41,23 @@ impl Context {
             func: Function::new(),
             cfg: ControlFlowGraph::new(),
             domtree: DominatorTree::new(),
+            regalloc: regalloc::Context::new(),
         }
     }
 
+    /// Run the legalizer for `isa` on the function.
+    pub fn legalize(&mut self, isa: &TargetIsa) {
+        legalize_function(&mut self.func, isa);
+    }
+
     /// Recompute the control flow graph and dominator tree.
     pub fn flowgraph(&mut self) {
         self.cfg.compute(&self.func);
         self.domtree.compute(&self.func, &self.cfg);
     }
+
+    /// Run the register allocator.
+    pub fn regalloc(&mut self, isa: &TargetIsa) {
+        self.regalloc.run(isa, &mut self.func, &self.cfg, &self.domtree);
+    }
 }