Add an icmp_imm instruction.

Compare a scalar integer to an immediate constant. Both Intel and RISC-V
ISAs have this operation.

This requires the addition of a new IntCompareImm instruction format.

lib/cretonne/src/ir/instructions.rs

@@ -175,6 +175,13 @@ pub enum InstructionData {
         cond: IntCC,
         args: [Value; 2],
     },
+    IntCompareImm {
+        opcode: Opcode,
+        ty: Type,
+        cond: IntCC,
+        arg: Value,
+        imm: Imm64,
+    },
     FloatCompare {
         opcode: Opcode,
         ty: Type,

lib/cretonne/src/verifier.rs

@@ -251,6 +251,7 @@ impl<'a> Verifier<'a> {
             &InsertLane { .. } |
             &ExtractLane { .. } |
             &IntCompare { .. } |
+            &IntCompareImm { .. } |
             &FloatCompare { .. } => {}
         }
 
@@ -682,4 +683,4 @@ mod tests {
         let verifier = Verifier::new(&func);
         assert_err_with_msg!(verifier.run(), "instruction format");
     }
-}
+}

lib/cretonne/src/write.rs

@@ -260,6 +260,7 @@ pub fn write_operands(w: &mut Write, dfg: &DataFlowGraph, inst: Inst) -> Result
         InsertLane { lane, args, .. } => write!(w, " {}, {}, {}", args[0], lane, args[1]),
         ExtractLane { lane, arg, .. } => write!(w, " {}, {}", arg, lane),
         IntCompare { cond, args, .. } => write!(w, " {}, {}, {}", cond, args[0], args[1]),
+        IntCompareImm { cond, arg, imm, .. } => write!(w, " {}, {}, {}", cond, arg, imm),
         FloatCompare { cond, args, .. } => write!(w, " {}, {}, {}", cond, args[0], args[1]),
         Jump { destination, ref args, .. } => {
             if args.is_empty() {