Generate instruction unwrapping code for binemit recipes.

Generate code to:

- Unwrap the instruction and generate an error if the instruction format
  doesn't match the recipe.
- Look up the value locations of register and stack arguments.

The recipe_* functions in the ISA binemit modules now take these
unwrapped items as arguments.

Also add an optional `emit` argument to the EncRecipe constructor which
makes it possible to provide inline Rust code snippets for code
emission. This requires a lot less boilerplate than recipe_* functions.

lib/cretonne/meta/cdsl/isa.py

@@ -202,6 +202,7 @@ class EncRecipe(object):
     :param: branch_range `(origin, bits)` range for branches.
     :param: instp Instruction predicate.
     :param: isap ISA predicate.
+    :param: emit Rust code for binary emission.
     """
 
     def __init__(
@@ -213,7 +214,8 @@ class EncRecipe(object):
             outs,               # type: ConstraintSeq
             branch_range=None,  # type: BranchRange
             instp=None,         # type: PredNode
-            isap=None           # type: PredNode
+            isap=None,          # type: PredNode
+            emit=None           # type: str
             ):
         # type: (...) -> None
         self.name = name
@@ -223,6 +225,7 @@ class EncRecipe(object):
         self.branch_range = branch_range
         self.instp = instp
         self.isap = isap
+        self.emit = emit
         if instp:
             assert instp.predicate_context() == format
         self.number = None  # type: int

lib/cretonne/meta/gen_binemit.py

@@ -3,15 +3,108 @@ Generate binary emission code for each ISA.
 """
 
 from __future__ import absolute_import
+from cdsl.registers import RegClass, Stack
 import srcgen
 
 try:
     from typing import Sequence, List  # noqa
-    from cdsl.isa import TargetISA  # noqa
+    from cdsl.isa import TargetISA, EncRecipe  # noqa
 except ImportError:
     pass
 
 
+def gen_recipe(recipe, fmt):
+    # type: (EncRecipe, srcgen.Formatter) -> None
+    """
+    Generate code to handle a single recipe.
+
+    - Unpack the instruction data, knowing the format.
+    - Determine register locations for operands with register constraints.
+    - Determine stack slot locations for operands with stack constraints.
+    - Call hand-written code for the actual emission.
+    """
+    iform = recipe.format
+    nvops = iform.num_value_operands
+    want_args = any(isinstance(i, RegClass) or isinstance(i, Stack)
+                    for i in recipe.ins)
+    assert not want_args or nvops > 0
+    want_outs = any(isinstance(o, RegClass) or isinstance(o, Stack)
+                    for o in recipe.outs)
+
+    # First unpack the instruction.
+    with fmt.indented(
+            'if let InstructionData::{} {{'.format(iform.name),
+            '}'):
+        for f in iform.imm_fields:
+            fmt.line('{},'.format(f.member))
+        if want_args:
+            if iform.has_value_list or nvops > 1:
+                fmt.line('ref args,')
+            else:
+                fmt.line('arg,')
+        fmt.line('..')
+        fmt.outdented_line('} = func.dfg[inst] {')
+
+        # Normalize to an `args` array.
+        if want_args:
+            if iform.has_value_list:
+                fmt.line('let args = args.as_slice(&func.dfg.value_lists);')
+            elif nvops == 1:
+                fmt.line('let args = [arg];')
+
+        # Unwrap interesting input arguments.
+        # Don't bother with fixed registers.
+        args = ''
+        for i, arg in enumerate(recipe.ins):
+            if isinstance(arg, RegClass):
+                v = 'in_reg{}'.format(i)
+                args += ', ' + v
+                fmt.line(
+                    'let {} = func.locations[args[{}]].unwrap_reg();'
+                    .format(v, i))
+            elif isinstance(arg, Stack):
+                v = 'in_ss{}'.format(i)
+                args += ', ' + v
+                fmt.line(
+                    'let {} = func.locations[args[{}]].unwrap_stack();'
+                    .format(v, i))
+
+        # Pass arguments in this order: inputs, imm_fields, outputs.
+        for f in iform.imm_fields:
+            args += ', ' + f.member
+
+        # Unwrap interesting output arguments.
+        if want_outs:
+            if len(recipe.outs) == 1:
+                fmt.line('let results = [func.dfg.first_result(inst)];')
+            else:
+                fmt.line('let results = func.dfg.inst_results(inst);')
+            for i, res in enumerate(recipe.outs):
+                if isinstance(res, RegClass):
+                    v = 'out_reg{}'.format(i)
+                    args += ', ' + v
+                    fmt.line(
+                        'let {} = func.locations[results[{}]].unwrap_reg();'
+                        .format(v, i))
+                elif isinstance(res, Stack):
+                    v = 'out_ss{}'.format(i)
+                    args += ', ' + v
+                    fmt.line(
+                        'let {} = func.locations[results[{}]].unwrap_stack();'
+                        .format(v, i))
+
+        # Call hand-written code. If the recipe contains a code snippet, use
+        # that. Otherwise cal a recipe function in the target ISA's binemit
+        # module.
+        if recipe.emit is None:
+            fmt.format(
+                    'return recipe_{}(func, inst, sink, bits{});',
+                    recipe.name.lower(), args)
+        else:
+            fmt.multi_line(recipe.emit)
+            fmt.line('return;')
+
+
 def gen_isa(isa, fmt):
     # type: (TargetISA, srcgen.Formatter) -> None
     """
@@ -28,14 +121,18 @@ def gen_isa(isa, fmt):
                 '(func: &Function, inst: Inst, _sink: &mut CS) {', '}'):
             fmt.line('bad_encoding(func, inst)')
     else:
+        fmt.line('#[allow(unused_variables, unreachable_code)]')
         with fmt.indented(
                 'pub fn emit_inst<CS: CodeSink + ?Sized>'
                 '(func: &Function, inst: Inst, sink: &mut CS) {', '}'):
+            fmt.line('let bits = func.encodings[inst].bits();')
             with fmt.indented('match func.encodings[inst].recipe() {', '}'):
                 for i, recipe in enumerate(isa.all_recipes):
-                    fmt.line('{} => recipe_{}(func, inst, sink),'.format(
+                    fmt.comment(recipe.name)
-                        i, recipe.name.lower()))
+                    with fmt.indented('{} => {{'.format(i), '}'):
-                fmt.line('_ => bad_encoding(func, inst),')
+                        gen_recipe(recipe, fmt)
+                fmt.line('_ => {}')
+            fmt.line('bad_encoding(func, inst);')
 
 
 def generate(isas, out_dir):

lib/cretonne/meta/isa/riscv/recipes.py

@@ -92,68 +92,123 @@ def LUI():
 
 # R-type 32-bit instructions: These are mostly binary arithmetic instructions.
 # The encbits are `opcode[6:2] | (funct3 << 5) | (funct7 << 8)
-R = EncRecipe('R', Binary, size=4, ins=(GPR, GPR), outs=GPR)
+R = EncRecipe(
+        'R', Binary, size=4, ins=(GPR, GPR), outs=GPR,
+        emit='put_r(bits, in_reg0, in_reg1, out_reg0, sink);')
 
 # R-type with an immediate shift amount instead of rs2.
-Rshamt = EncRecipe('Rshamt', BinaryImm, size=4, ins=GPR, outs=GPR)
+Rshamt = EncRecipe(
+        'Rshamt', BinaryImm, size=4, ins=GPR, outs=GPR,
+        emit='put_rshamt(bits, in_reg0, imm.into(), out_reg0, sink);')
 
 # R-type encoding of an integer comparison.
-Ricmp = EncRecipe('Ricmp', IntCompare, size=4, ins=(GPR, GPR), outs=GPR)
+Ricmp = EncRecipe(
+        'Ricmp', IntCompare, size=4, ins=(GPR, GPR), outs=GPR,
+        emit='put_r(bits, in_reg0, in_reg1, out_reg0, sink);')
 
 I = EncRecipe(
         'I', BinaryImm, size=4, ins=GPR, outs=GPR,
-        instp=IsSignedInt(BinaryImm.imm, 12))
+        instp=IsSignedInt(BinaryImm.imm, 12),
+        emit='put_i(bits, in_reg0, imm.into(), out_reg0, sink);')
 
 # I-type instruction with a hardcoded %x0 rs1.
 Iz = EncRecipe(
         'Iz', UnaryImm, size=4, ins=(), outs=GPR,
-        instp=IsSignedInt(UnaryImm.imm, 12))
+        instp=IsSignedInt(UnaryImm.imm, 12),
+        emit='put_i(bits, 0, imm.into(), out_reg0, sink);')
 
 # I-type encoding of an integer comparison.
 Iicmp = EncRecipe(
         'Iicmp', IntCompareImm, size=4, ins=GPR, outs=GPR,
-        instp=IsSignedInt(IntCompareImm.imm, 12))
+        instp=IsSignedInt(IntCompareImm.imm, 12),
+        emit='put_i(bits, in_reg0, imm.into(), out_reg0, sink);')
 
 # I-type encoding for `jalr` as a return instruction. We won't use the
 # immediate offset.
 # The variable return values are not encoded.
-Iret = EncRecipe('Iret', MultiAry, size=4, ins=(), outs=())
+Iret = EncRecipe(
+        'Iret', MultiAry, size=4, ins=(), outs=(),
+        emit='''
+        // Return instructions are always a jalr to %x1.
+        // The return address is provided as a special-purpose link argument.
+        put_i(bits,
+              1, // rs1 = %x1
+              0, // no offset.
+              0, // rd = %x0: no address written.
+              sink);
+        ''')
 
 # I-type encoding for `jalr` as an indirect call.
-Icall = EncRecipe('Icall', IndirectCall, size=4, ins=GPR, outs=())
+Icall = EncRecipe(
+        'Icall', IndirectCall, size=4, ins=GPR, outs=(),
+        emit='''
+        // Indirect instructions are jalr with rd=%x1.
+        put_i(bits,
+              in_reg0,
+              0, // no offset.
+              1, // rd = %x1: link register.
+              sink);
+        ''')
+
 
 # Copy of a GPR is implemented as addi x, 0.
-Icopy = EncRecipe('Icopy', Unary, size=4, ins=GPR, outs=GPR)
+Icopy = EncRecipe(
+        'Icopy', Unary, size=4, ins=GPR, outs=GPR,
+        emit='put_i(bits, in_reg0, 0, out_reg0, sink);')
 
 # U-type instructions have a 20-bit immediate that targets bits 12-31.
 U = EncRecipe(
         'U', UnaryImm, size=4, ins=(), outs=GPR,
-        instp=IsSignedInt(UnaryImm.imm, 32, 12))
+        instp=IsSignedInt(UnaryImm.imm, 32, 12),
+        emit='put_u(bits, imm.into(), out_reg0, sink);')
 
 # UJ-type unconditional branch instructions.
-UJ = EncRecipe('UJ', Jump, size=4, ins=(), outs=(), branch_range=(0, 21))
+UJ = EncRecipe(
-UJcall = EncRecipe('UJcall', Call, size=4, ins=(), outs=())
+        'UJ', Jump, size=4, ins=(), outs=(), branch_range=(0, 21),
+        emit='''
+        let dest = func.offsets[destination] as i64;
+        let disp = dest - sink.offset() as i64;
+        put_uj(bits, disp, 0, sink);
+        ''')
+
+UJcall = EncRecipe(
+        'UJcall', Call, size=4, ins=(), outs=(),
+        emit='''
+        sink.reloc_func(RelocKind::Call.into(), func_ref);
+        // rd=%x1 is the standard link register.
+        put_uj(bits, 0, 1, sink);
+        ''')
 
 # SB-type branch instructions.
-# TODO: These instructions have a +/- 4 KB branch range. How to encode that
-# constraint?
 SB = EncRecipe(
         'SB', BranchIcmp, size=4,
         ins=(GPR, GPR), outs=(),
-        branch_range=(0, 13))
+        branch_range=(0, 13),
+        emit='''
+        let dest = func.offsets[destination] as i64;
+        let disp = dest - sink.offset() as i64;
+        put_sb(bits, disp, in_reg0, in_reg1, sink);
+        ''')
 
 # SB-type branch instruction with rs2 fixed to zero.
 SBzero = EncRecipe(
         'SBzero', Branch, size=4,
         ins=(GPR), outs=(),
-        branch_range=(0, 13))
+        branch_range=(0, 13),
+        emit='''
+        let dest = func.offsets[destination] as i64;
+        let disp = dest - sink.offset() as i64;
+        put_sb(bits, disp, in_reg0, 0, sink);
+        ''')
 
 # Spill of a GPR.
 GPsp = EncRecipe(
         'GPsp', Unary, size=4,
-        ins=GPR, outs=Stack(GPR))
+        ins=GPR, outs=Stack(GPR),
+        emit='unimplemented!();')
 
 # Fill of a GPR.
 GPfi = EncRecipe(
         'GPfi', Unary, size=4,
-        ins=Stack(GPR), outs=GPR)
+        ins=Stack(GPR), outs=GPR,
+        emit='unimplemented!();')

lib/cretonne/src/ir/valueloc.rs

@@ -33,6 +33,14 @@ impl ValueLoc {
         }
     }
 
+    /// Get the stack slot of this location, or panic.
+    pub fn unwrap_stack(self) -> StackSlot {
+        match self {
+            ValueLoc::Stack(ss) => ss,
+            _ => panic!("Expected stack slot: {:?}", self),
+        }
+    }
+
     /// Return an object that can display this value location, using the register info from the
     /// target ISA.
     pub fn display<'a, R: Into<Option<&'a RegInfo>>>(self, regs: R) -> DisplayValueLoc<'a> {

lib/cretonne/src/isa/intel/binemit.rs

@@ -1,7 +1,8 @@
 //! Emitting binary Intel machine code.
 
 use binemit::{CodeSink, Reloc, bad_encoding};
-use ir::{Function, Inst, InstructionData};
+use ir::{self, Function, Inst, InstructionData, MemFlags};
+use ir::immediates::{Imm64, Offset32};
 use isa::RegUnit;
 
 include!(concat!(env!("OUT_DIR"), "/binemit-intel.rs"));
@@ -100,257 +101,289 @@ fn modrm_disp32<CS: CodeSink + ?Sized>(rm: RegUnit, reg: RegUnit, sink: &mut CS)
     sink.put1(b);
 }
 
-fn recipe_op1rr<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1rr<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Binary { args, .. } = func.dfg[inst] {
+                                       _inst: Inst,
-        put_op1(func.encodings[inst].bits(), sink);
+                                       sink: &mut CS,
-        modrm_rr(func.locations[args[0]].unwrap_reg(),
+                                       bits: u16,
-                 func.locations[args[1]].unwrap_reg(),
+                                       in_reg0: RegUnit,
-                 sink);
+                                       in_reg1: RegUnit) {
-    } else {
-        panic!("Expected Binary format: {:?}", func.dfg[inst]);
-    }
-}
-
-fn recipe_op1ur<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::Unary { arg, .. } = func.dfg[inst] {
-        put_op1(func.encodings[inst].bits(), sink);
-        let res = func.locations[func.dfg.first_result(inst)].unwrap_reg();
-        modrm_rr(res, func.locations[arg].unwrap_reg(), sink);
-    } else {
-        panic!("Expected Unary format: {:?}", func.dfg[inst]);
-    }
-}
-
-fn recipe_op1rc<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::Binary { args, .. } = func.dfg[inst] {
-        let bits = func.encodings[inst].bits();
     put_op1(bits, sink);
-        modrm_r_bits(func.locations[args[0]].unwrap_reg(), bits, sink);
+    modrm_rr(in_reg0, in_reg1, sink);
-    } else {
-        panic!("Expected Binary format: {:?}", func.dfg[inst]);
-    }
 }
 
-fn recipe_op1rib<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1ur<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::BinaryImm { arg, imm, .. } = func.dfg[inst] {
+                                       _inst: Inst,
-        let bits = func.encodings[inst].bits();
+                                       sink: &mut CS,
+                                       bits: u16,
+                                       in_reg0: RegUnit,
+                                       out_reg0: RegUnit) {
     put_op1(bits, sink);
-        modrm_r_bits(func.locations[arg].unwrap_reg(), bits, sink);
+    modrm_rr(out_reg0, in_reg0, sink);
+}
+
+fn recipe_op1rc<CS: CodeSink + ?Sized>(_func: &Function,
+                                       _inst: Inst,
+                                       sink: &mut CS,
+                                       bits: u16,
+                                       in_reg0: RegUnit) {
+    put_op1(bits, sink);
+    modrm_r_bits(in_reg0, bits, sink);
+}
+
+fn recipe_op1rib<CS: CodeSink + ?Sized>(_func: &Function,
+                                        _inst: Inst,
+                                        sink: &mut CS,
+                                        bits: u16,
+                                        in_reg0: RegUnit,
+                                        imm: Imm64) {
+    put_op1(bits, sink);
+    modrm_r_bits(in_reg0, bits, sink);
     let imm: i64 = imm.into();
     sink.put1(imm as u8);
-    } else {
-        panic!("Expected BinaryImm format: {:?}", func.dfg[inst]);
-    }
 }
 
-fn recipe_op1rid<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1rid<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::BinaryImm { arg, imm, .. } = func.dfg[inst] {
+                                        _inst: Inst,
-        let bits = func.encodings[inst].bits();
+                                        sink: &mut CS,
+                                        bits: u16,
+                                        in_reg0: RegUnit,
+                                        imm: Imm64) {
     put_op1(bits, sink);
-        modrm_r_bits(func.locations[arg].unwrap_reg(), bits, sink);
+    modrm_r_bits(in_reg0, bits, sink);
     let imm: i64 = imm.into();
     sink.put4(imm as u32);
-    } else {
-        panic!("Expected BinaryImm format: {:?}", func.dfg[inst]);
-    }
 }
 
-fn recipe_op1uid<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1uid<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::UnaryImm { imm, .. } = func.dfg[inst] {
+                                        _inst: Inst,
-        let bits = func.encodings[inst].bits();
+                                        sink: &mut CS,
-        let reg = func.locations[func.dfg.first_result(inst)].unwrap_reg();
+                                        bits: u16,
+                                        imm: Imm64,
+                                        out_reg0: RegUnit) {
     // The destination register is encoded in the low bits of the opcode. No ModR/M
-        put_op1(bits | (reg & 7), sink);
+    put_op1(bits | (out_reg0 & 7), sink);
     let imm: i64 = imm.into();
     sink.put4(imm as u32);
-    } else {
-        panic!("Expected UnaryImm format: {:?}", func.dfg[inst]);
-    }
 }
 
 // Store recipes.
 
-fn recipe_op1st<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1st<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Store { args, .. } = func.dfg[inst] {
+                                       _inst: Inst,
-        put_op1(func.encodings[inst].bits(), sink);
+                                       sink: &mut CS,
-        modrm_rm(func.locations[args[1]].unwrap_reg(),
+                                       bits: u16,
-                 func.locations[args[0]].unwrap_reg(),
+                                       in_reg0: RegUnit,
-                 sink);
+                                       in_reg1: RegUnit,
-    } else {
+                                       _flags: MemFlags,
-        panic!("Expected Store format: {:?}", func.dfg[inst]);
+                                       _offset: Offset32) {
-    }
+    put_op1(bits, sink);
+    modrm_rm(in_reg1, in_reg0, sink);
 }
 
 // This is just a tighter register class constraint.
-fn recipe_op1st_abcd<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1st_abcd<CS: CodeSink + ?Sized>(func: &Function,
-    recipe_op1st(func, inst, sink)
+                                            inst: Inst,
+                                            sink: &mut CS,
+                                            bits: u16,
+                                            in_reg0: RegUnit,
+                                            in_reg1: RegUnit,
+                                            flags: MemFlags,
+                                            offset: Offset32) {
+    recipe_op1st(func, inst, sink, bits, in_reg0, in_reg1, flags, offset)
 }
 
-fn recipe_mp1st<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_mp1st<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Store { args, .. } = func.dfg[inst] {
+                                       _inst: Inst,
-        put_mp1(func.encodings[inst].bits(), sink);
+                                       sink: &mut CS,
-        modrm_rm(func.locations[args[1]].unwrap_reg(),
+                                       bits: u16,
-                 func.locations[args[0]].unwrap_reg(),
+                                       in_reg0: RegUnit,
-                 sink);
+                                       in_reg1: RegUnit,
-    } else {
+                                       _flags: MemFlags,
-        panic!("Expected Store format: {:?}", func.dfg[inst]);
+                                       _offset: Offset32) {
-    }
+    put_mp1(bits, sink);
+    modrm_rm(in_reg1, in_reg0, sink);
 }
 
-fn recipe_op1stdisp8<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1stdisp8<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Store { args, offset, .. } = func.dfg[inst] {
+                                            _inst: Inst,
-        put_op1(func.encodings[inst].bits(), sink);
+                                            sink: &mut CS,
-        modrm_disp8(func.locations[args[1]].unwrap_reg(),
+                                            bits: u16,
-                    func.locations[args[0]].unwrap_reg(),
+                                            in_reg0: RegUnit,
-                    sink);
+                                            in_reg1: RegUnit,
+                                            _flags: MemFlags,
+                                            offset: Offset32) {
+    put_op1(bits, sink);
+    modrm_disp8(in_reg1, in_reg0, sink);
     let offset: i32 = offset.into();
     sink.put1(offset as u8);
-    } else {
-        panic!("Expected Store format: {:?}", func.dfg[inst]);
-    }
 }
 
-fn recipe_op1stdisp8_abcd<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1stdisp8_abcd<CS: CodeSink + ?Sized>(func: &Function,
-    recipe_op1stdisp8(func, inst, sink)
+                                                 inst: Inst,
+                                                 sink: &mut CS,
+                                                 bits: u16,
+                                                 in_reg0: RegUnit,
+                                                 in_reg1: RegUnit,
+                                                 flags: MemFlags,
+                                                 offset: Offset32) {
+    recipe_op1stdisp8(func, inst, sink, bits, in_reg0, in_reg1, flags, offset)
 }
 
-fn recipe_mp1stdisp8<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_mp1stdisp8<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Store { args, offset, .. } = func.dfg[inst] {
+                                            _inst: Inst,
-        put_mp1(func.encodings[inst].bits(), sink);
+                                            sink: &mut CS,
-        modrm_disp8(func.locations[args[1]].unwrap_reg(),
+                                            bits: u16,
-                    func.locations[args[0]].unwrap_reg(),
+                                            in_reg0: RegUnit,
-                    sink);
+                                            in_reg1: RegUnit,
+                                            _flags: MemFlags,
+                                            offset: Offset32) {
+    put_mp1(bits, sink);
+    modrm_disp8(in_reg1, in_reg0, sink);
     let offset: i32 = offset.into();
     sink.put1(offset as u8);
-    } else {
-        panic!("Expected Store format: {:?}", func.dfg[inst]);
-    }
 }
 
-fn recipe_op1stdisp32<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1stdisp32<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Store { args, offset, .. } = func.dfg[inst] {
+                                             _inst: Inst,
-        put_op1(func.encodings[inst].bits(), sink);
+                                             sink: &mut CS,
-        modrm_disp32(func.locations[args[1]].unwrap_reg(),
+                                             bits: u16,
-                     func.locations[args[0]].unwrap_reg(),
+                                             in_reg0: RegUnit,
-                     sink);
+                                             in_reg1: RegUnit,
+                                             _flags: MemFlags,
+                                             offset: Offset32) {
+    put_op1(bits, sink);
+    modrm_disp32(in_reg1, in_reg0, sink);
     let offset: i32 = offset.into();
     sink.put4(offset as u32);
-    } else {
-        panic!("Expected Store format: {:?}", func.dfg[inst]);
-    }
 }
 
-fn recipe_op1stdisp32_abcd<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1stdisp32_abcd<CS: CodeSink + ?Sized>(func: &Function,
-    recipe_op1stdisp32(func, inst, sink)
+                                                  inst: Inst,
+                                                  sink: &mut CS,
+                                                  bits: u16,
+                                                  in_reg0: RegUnit,
+                                                  in_reg1: RegUnit,
+                                                  flags: MemFlags,
+                                                  offset: Offset32) {
+    recipe_op1stdisp32(func, inst, sink, bits, in_reg0, in_reg1, flags, offset)
 }
 
-fn recipe_mp1stdisp32<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_mp1stdisp32<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Store { args, offset, .. } = func.dfg[inst] {
+                                             _inst: Inst,
-        put_mp1(func.encodings[inst].bits(), sink);
+                                             sink: &mut CS,
-        modrm_disp32(func.locations[args[1]].unwrap_reg(),
+                                             bits: u16,
-                     func.locations[args[0]].unwrap_reg(),
+                                             in_reg0: RegUnit,
-                     sink);
+                                             in_reg1: RegUnit,
+                                             _flags: MemFlags,
+                                             offset: Offset32) {
+    put_mp1(bits, sink);
+    modrm_disp32(in_reg1, in_reg0, sink);
     let offset: i32 = offset.into();
     sink.put4(offset as u32);
-    } else {
-        panic!("Expected Store format: {:?}", func.dfg[inst]);
-    }
 }
 
 // Load recipes
 
-fn recipe_op1ld<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1ld<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Load { arg, .. } = func.dfg[inst] {
+                                       _inst: Inst,
-        put_op1(func.encodings[inst].bits(), sink);
+                                       sink: &mut CS,
-        modrm_rm(func.locations[arg].unwrap_reg(),
+                                       bits: u16,
-                 func.locations[func.dfg.first_result(inst)].unwrap_reg(),
+                                       in_reg0: RegUnit,
-                 sink);
+                                       _flags: MemFlags,
-    } else {
+                                       _offset: Offset32,
-        panic!("Expected Load format: {:?}", func.dfg[inst]);
+                                       out_reg0: RegUnit) {
-    }
+    put_op1(bits, sink);
+    modrm_rm(in_reg0, out_reg0, sink);
 }
 
-fn recipe_op1lddisp8<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1lddisp8<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Load { arg, offset, .. } = func.dfg[inst] {
+                                            _inst: Inst,
-        put_op1(func.encodings[inst].bits(), sink);
+                                            sink: &mut CS,
-        modrm_disp8(func.locations[arg].unwrap_reg(),
+                                            bits: u16,
-                    func.locations[func.dfg.first_result(inst)].unwrap_reg(),
+                                            in_reg0: RegUnit,
-                    sink);
+                                            _flags: MemFlags,
+                                            offset: Offset32,
+                                            out_reg0: RegUnit) {
+    put_op1(bits, sink);
+    modrm_disp8(in_reg0, out_reg0, sink);
     let offset: i32 = offset.into();
     sink.put1(offset as u8);
-    } else {
-        panic!("Expected Load format: {:?}", func.dfg[inst]);
-    }
 }
 
-fn recipe_op1lddisp32<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1lddisp32<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Load { arg, offset, .. } = func.dfg[inst] {
+                                             _inst: Inst,
-        put_op1(func.encodings[inst].bits(), sink);
+                                             sink: &mut CS,
-        modrm_disp32(func.locations[arg].unwrap_reg(),
+                                             bits: u16,
-                     func.locations[func.dfg.first_result(inst)].unwrap_reg(),
+                                             in_reg0: RegUnit,
-                     sink);
+                                             _flags: MemFlags,
+                                             offset: Offset32,
+                                             out_reg0: RegUnit) {
+    put_op1(bits, sink);
+    modrm_disp32(in_reg0, out_reg0, sink);
     let offset: i32 = offset.into();
     sink.put4(offset as u32);
-    } else {
-        panic!("Expected Load format: {:?}", func.dfg[inst]);
-    }
 }
 
-fn recipe_op2ld<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op2ld<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Load { arg, .. } = func.dfg[inst] {
+                                       _inst: Inst,
-        put_op2(func.encodings[inst].bits(), sink);
+                                       sink: &mut CS,
-        modrm_rm(func.locations[arg].unwrap_reg(),
+                                       bits: u16,
-                 func.locations[func.dfg.first_result(inst)].unwrap_reg(),
+                                       in_reg0: RegUnit,
-                 sink);
+                                       _flags: MemFlags,
-    } else {
+                                       _offset: Offset32,
-        panic!("Expected Load format: {:?}", func.dfg[inst]);
+                                       out_reg0: RegUnit) {
-    }
+    put_op2(bits, sink);
+    modrm_rm(in_reg0, out_reg0, sink);
 }
 
-fn recipe_op2lddisp8<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op2lddisp8<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Load { arg, offset, .. } = func.dfg[inst] {
+                                            _inst: Inst,
-        put_op2(func.encodings[inst].bits(), sink);
+                                            sink: &mut CS,
-        modrm_disp8(func.locations[arg].unwrap_reg(),
+                                            bits: u16,
-                    func.locations[func.dfg.first_result(inst)].unwrap_reg(),
+                                            in_reg0: RegUnit,
-                    sink);
+                                            _flags: MemFlags,
+                                            offset: Offset32,
+                                            out_reg0: RegUnit) {
+    put_op2(bits, sink);
+    modrm_disp8(in_reg0, out_reg0, sink);
     let offset: i32 = offset.into();
     sink.put1(offset as u8);
-    } else {
-        panic!("Expected Load format: {:?}", func.dfg[inst]);
-    }
 }
 
-fn recipe_op2lddisp32<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op2lddisp32<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Load { arg, offset, .. } = func.dfg[inst] {
+                                             _inst: Inst,
-        put_op2(func.encodings[inst].bits(), sink);
+                                             sink: &mut CS,
-        modrm_disp32(func.locations[arg].unwrap_reg(),
+                                             bits: u16,
-                     func.locations[func.dfg.first_result(inst)].unwrap_reg(),
+                                             in_reg0: RegUnit,
-                     sink);
+                                             _flags: MemFlags,
+                                             offset: Offset32,
+                                             out_reg0: RegUnit) {
+    put_op2(bits, sink);
+    modrm_disp32(in_reg0, out_reg0, sink);
     let offset: i32 = offset.into();
     sink.put4(offset as u32);
-    } else {
-        panic!("Expected Load format: {:?}", func.dfg[inst]);
-    }
 }
 
-fn recipe_op1call_id<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1call_id<CS: CodeSink + ?Sized>(_func: &Function,
-    if let InstructionData::Call { func_ref, .. } = func.dfg[inst] {
+                                            _inst: Inst,
-        put_op1(func.encodings[inst].bits(), sink);
+                                            sink: &mut CS,
+                                            bits: u16,
+                                            func_ref: ir::FuncRef) {
+    put_op1(bits, sink);
     sink.reloc_func(RelocKind::PCRel4.into(), func_ref);
     sink.put4(0);
-    } else {
-        panic!("Expected Call format: {:?}", func.dfg[inst]);
-    }
 }
 
-fn recipe_op1call_r<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1call_r<CS: CodeSink + ?Sized>(_func: &Function,
-    let bits = func.encodings[inst].bits();
+                                           _inst: Inst,
+                                           sink: &mut CS,
+                                           bits: u16,
+                                           in_reg0: RegUnit,
+                                           _sig_ref: ir::SigRef) {
     put_op1(bits, sink);
-    modrm_r_bits(func.locations[func.dfg.inst_args(inst)[0]].unwrap_reg(),
+    modrm_r_bits(in_reg0, bits, sink);
-                 bits,
-                 sink);
 }
 
-fn recipe_op1ret<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
+fn recipe_op1ret<CS: CodeSink + ?Sized>(_func: &Function, _inst: Inst, sink: &mut CS, bits: u16) {
-    put_op1(func.encodings[inst].bits(), sink);
+    put_op1(bits, sink);
 }

lib/cretonne/src/isa/riscv/binemit.rs

@@ -87,42 +87,6 @@ fn put_rshamt<CS: CodeSink + ?Sized>(bits: u16,
     sink.put4(i);
 }
 
-fn recipe_r<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::Binary { args, .. } = func.dfg[inst] {
-        put_r(func.encodings[inst].bits(),
-              func.locations[args[0]].unwrap_reg(),
-              func.locations[args[1]].unwrap_reg(),
-              func.locations[func.dfg.first_result(inst)].unwrap_reg(),
-              sink);
-    } else {
-        panic!("Expected Binary format: {:?}", func.dfg[inst]);
-    }
-}
-
-fn recipe_ricmp<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::IntCompare { args, .. } = func.dfg[inst] {
-        put_r(func.encodings[inst].bits(),
-              func.locations[args[0]].unwrap_reg(),
-              func.locations[args[1]].unwrap_reg(),
-              func.locations[func.dfg.first_result(inst)].unwrap_reg(),
-              sink);
-    } else {
-        panic!("Expected IntCompare format: {:?}", func.dfg[inst]);
-    }
-}
-
-fn recipe_rshamt<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::BinaryImm { arg, imm, .. } = func.dfg[inst] {
-        put_rshamt(func.encodings[inst].bits(),
-                   func.locations[arg].unwrap_reg(),
-                   imm.into(),
-                   func.locations[func.dfg.first_result(inst)].unwrap_reg(),
-                   sink);
-    } else {
-        panic!("Expected BinaryImm format: {:?}", func.dfg[inst]);
-    }
-}
-
 /// I-type instructions.
 ///
 ///   31  19  14     11 6
@@ -148,73 +112,6 @@ fn put_i<CS: CodeSink + ?Sized>(bits: u16, rs1: RegUnit, imm: i64, rd: RegUnit,
     sink.put4(i);
 }
 
-fn recipe_i<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::BinaryImm { arg, imm, .. } = func.dfg[inst] {
-        put_i(func.encodings[inst].bits(),
-              func.locations[arg].unwrap_reg(),
-              imm.into(),
-              func.locations[func.dfg.first_result(inst)].unwrap_reg(),
-              sink);
-    } else {
-        panic!("Expected BinaryImm format: {:?}", func.dfg[inst]);
-    }
-}
-
-fn recipe_iz<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::UnaryImm { imm, .. } = func.dfg[inst] {
-        put_i(func.encodings[inst].bits(),
-              0,
-              imm.into(),
-              func.locations[func.dfg.first_result(inst)].unwrap_reg(),
-              sink);
-    } else {
-        panic!("Expected UnaryImm format: {:?}", func.dfg[inst]);
-    }
-}
-
-fn recipe_iicmp<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::IntCompareImm { arg, imm, .. } = func.dfg[inst] {
-        put_i(func.encodings[inst].bits(),
-              func.locations[arg].unwrap_reg(),
-              imm.into(),
-              func.locations[func.dfg.first_result(inst)].unwrap_reg(),
-              sink);
-    } else {
-        panic!("Expected IntCompareImm format: {:?}", func.dfg[inst]);
-    }
-}
-
-fn recipe_iret<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    // Return instructions are always a jalr to %x1.
-    // The return address is provided as a special-purpose link argument.
-    put_i(func.encodings[inst].bits(),
-          1, // rs1 = %x1
-          0, // no offset.
-          0, // rd = %x0: no address written.
-          sink);
-}
-
-fn recipe_icall<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    // Indirect instructions are jalr with rd=%x1.
-    put_i(func.encodings[inst].bits(),
-          func.locations[func.dfg.inst_args(inst)[0]].unwrap_reg(),
-          0, // no offset.
-          1, // rd = %x1: link register.
-          sink);
-}
-
-fn recipe_icopy<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::Unary { arg, .. } = func.dfg[inst] {
-        put_i(func.encodings[inst].bits(),
-              func.locations[arg].unwrap_reg(),
-              0,
-              func.locations[func.dfg.first_result(inst)].unwrap_reg(),
-              sink);
-    } else {
-        panic!("Expected Unary format: {:?}", func.dfg[inst]);
-    }
-}
-
 /// U-type instructions.
 ///
 ///   31  11 6
@@ -236,17 +133,6 @@ fn put_u<CS: CodeSink + ?Sized>(bits: u16, imm: i64, rd: RegUnit, sink: &mut CS)
     sink.put4(i);
 }
 
-fn recipe_u<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::UnaryImm { imm, .. } = func.dfg[inst] {
-        put_u(func.encodings[inst].bits(),
-              imm.into(),
-              func.locations[func.dfg.first_result(inst)].unwrap_reg(),
-              sink);
-    } else {
-        panic!("Expected UnaryImm format: {:?}", func.dfg[inst]);
-    }
-}
-
 /// SB-type branch instructions.
 ///
 ///   31  24  19  14     11  6
@@ -280,44 +166,6 @@ fn put_sb<CS: CodeSink + ?Sized>(bits: u16, imm: i64, rs1: RegUnit, rs2: RegUnit
     sink.put4(i);
 }
 
-fn recipe_sb<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::BranchIcmp {
-               destination,
-               ref args,
-               ..
-           } = func.dfg[inst] {
-        let dest = func.offsets[destination] as i64;
-        let disp = dest - sink.offset() as i64;
-        let args = &args.as_slice(&func.dfg.value_lists)[0..2];
-        put_sb(func.encodings[inst].bits(),
-               disp,
-               func.locations[args[0]].unwrap_reg(),
-               func.locations[args[1]].unwrap_reg(),
-               sink);
-    } else {
-        panic!("Expected BranchIcmp format: {:?}", func.dfg[inst]);
-    }
-}
-
-fn recipe_sbzero<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::Branch {
-               destination,
-               ref args,
-               ..
-           } = func.dfg[inst] {
-        let dest = func.offsets[destination] as i64;
-        let disp = dest - sink.offset() as i64;
-        let args = &args.as_slice(&func.dfg.value_lists)[0..1];
-        put_sb(func.encodings[inst].bits(),
-               disp,
-               func.locations[args[0]].unwrap_reg(),
-               0,
-               sink);
-    } else {
-        panic!("Expected Branch format: {:?}", func.dfg[inst]);
-    }
-}
-
 /// UJ-type jump instructions.
 ///
 ///   31  11 6
@@ -346,31 +194,3 @@ fn put_uj<CS: CodeSink + ?Sized>(bits: u16, imm: i64, rd: RegUnit, sink: &mut CS
 
     sink.put4(i);
 }
-
-fn recipe_uj<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::Jump { destination, .. } = func.dfg[inst] {
-        let dest = func.offsets[destination] as i64;
-        let disp = dest - sink.offset() as i64;
-        put_uj(func.encodings[inst].bits(), disp, 0, sink);
-    } else {
-        panic!("Expected Jump format: {:?}", func.dfg[inst]);
-    }
-}
-
-fn recipe_ujcall<CS: CodeSink + ?Sized>(func: &Function, inst: Inst, sink: &mut CS) {
-    if let InstructionData::Call { func_ref, .. } = func.dfg[inst] {
-        sink.reloc_func(RelocKind::Call.into(), func_ref);
-        // rd=%x1 is the standard link register.
-        put_uj(func.encodings[inst].bits(), 0, 1, sink);
-    } else {
-        panic!("Expected Call format: {:?}", func.dfg[inst]);
-    }
-}
-
-fn recipe_gpsp<CS: CodeSink + ?Sized>(_func: &Function, _inst: Inst, _sink: &mut CS) {
-    unimplemented!();
-}
-
-fn recipe_gpfi<CS: CodeSink + ?Sized>(_func: &Function, _inst: Inst, _sink: &mut CS) {
-    unimplemented!();
-}