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/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(
-                        i, recipe.name.lower()))
-                fmt.line('_ => bad_encoding(func, inst),')
+                    fmt.comment(recipe.name)
+                    with fmt.indented('{} => {{'.format(i), '}'):
+                        gen_recipe(recipe, fmt)
+                fmt.line('_ => {}')
+            fmt.line('bad_encoding(func, inst);')
 
 
 def generate(isas, out_dir):