Add legalization helper instructions.

The isplit_lohi instruction breaks an integer into two halves. This will
typically be used to get the two halves of an `i64` value on 32-bit
CPUs.

The iconcat_lohi is the reverse operation. It reconstructs the `i64`
from the low and high bits.

src/libcretonne/ir/instructions.rs

@@ -120,6 +120,12 @@ pub enum InstructionData {
         opcode: Opcode,
         ty: Type, // TBD: imm: Box<ImmVectorData>
     },
+    UnarySplit {
+        opcode: Opcode,
+        ty: Type,
+        second_result: Value,
+        arg: Value,
+    },
     Binary {
         opcode: Opcode,
         ty: Type,

src/libcretonne/write.rs

@@ -185,6 +185,7 @@ fn write_instruction(w: &mut Write,
         UnaryIeee32 { imm, .. } => writeln!(w, " {}", imm),
         UnaryIeee64 { imm, .. } => writeln!(w, " {}", imm),
         UnaryImmVector { .. } => writeln!(w, " [...]"),
+        UnarySplit { arg, .. } => writeln!(w, " {}", arg),
         Binary { args, .. } => writeln!(w, " {}, {}", args[0], args[1]),
         BinaryImm { arg, imm, .. } => writeln!(w, " {}, {}", arg, imm),
         BinaryImmRev { imm, arg, .. } => writeln!(w, " {}, {}", imm, arg),

src/libreader/parser.rs

@@ -119,6 +119,7 @@ impl Context {
                     InstructionData::UnaryImmVector { .. } => {}
 
                     InstructionData::Unary { ref mut arg, .. } |
+                    InstructionData::UnarySplit { ref mut arg, .. } |
                     InstructionData::BinaryImm { ref mut arg, .. } |
                     InstructionData::BinaryImmRev { ref mut arg, .. } |
                     InstructionData::ExtractLane { ref mut arg, .. } |
@@ -1013,6 +1014,14 @@ impl<'a> Parser<'a> {
             InstructionFormat::UnaryImmVector => {
                 unimplemented!();
             }
+            InstructionFormat::UnarySplit => {
+                InstructionData::UnarySplit {
+                    opcode: opcode,
+                    ty: VOID,
+                    second_result: NO_VALUE,
+                    arg: try!(self.match_value("expected SSA value operand")),
+                }
+            }
             InstructionFormat::Binary => {
                 let lhs = try!(self.match_value("expected SSA value first operand"));
                 try!(self.match_token(Token::Comma, "expected ',' between operands"));