aarch64: Migrate uextend/sextend to ISLE

This commit migrates the sign/zero extension instructions from
`lower_inst.rs` to ISLE. There's actually a fair amount going on in this
migration since a few other pieces needed touching up along the way as
well:

* First is the actual migration of `uextend` and `sextend`. These
  instructions are relatively simple but end up having a number of special
  cases. I've attempted to replicate all the cases here but
  double-checks would be good.

* This commit actually fixes a few issues where if the result of a vector
  extraction is sign/zero-extended into i128 that actually results in
  panics in the current backend.

* This commit adds exhaustive testing for
  extension-of-a-vector-extraction is a noop wrt extraction.

* A bugfix around ISLE glue was required to get this commit working,
  notably the case where the `RegMapper` implementation was trying to
  map an input to an output (meaning ISLE was passing through an input
  unmodified to the output) wasn't working. This requires a `mov`
  instruction to be generated and this commit updates the glue to do
  this. At the same time this commit updates the ISLE glue to share more
  infrastructure between x64 and aarch64 so both backends get this fix
  instead of just aarch64.

Overall I think that the translation to ISLE was a net benefit for these
instructions. It's relatively obvious what all the cases are now unlike
before where it took a few reads of the code and some boolean switches
to figure out which path was taken for each flavor of input. I think
there's still possible improvements here where, for example, the
`put_in_reg_{s,z}ext64` helper doesn't use this logic so technically
those helpers could also pattern match the "well atomic loads and vector
extractions automatically do this for us" but that's a possible future
improvement for later (and shouldn't be too too hard with some ISLE
refactoring).

cranelift/codegen/src/isa/x64/lower/isle.rs

@@ -9,7 +9,7 @@ use super::{
 };
 use crate::isa::x64::inst::args::SyntheticAmode;
 use crate::isa::x64::inst::regs;
-use crate::isa::x64::settings as x64_settings;
+use crate::isa::x64::settings::Flags;
 use crate::machinst::isle::*;
 use crate::{
     ir::{immediates::*, types::*, Inst, InstructionData, Opcode, TrapCode, Value, ValueList},
@@ -19,9 +19,8 @@ use crate::{
         },
         x64_map_regs,
     },
-    machinst::{get_output_reg, InsnInput, InsnOutput, LowerCtx, RegRenamer},
+    machinst::{InsnInput, InsnOutput, LowerCtx},
 };
-use smallvec::SmallVec;
 use std::convert::TryFrom;
 
 pub struct SinkableLoad {
@@ -33,78 +32,24 @@ pub struct SinkableLoad {
 /// The main entry point for lowering with ISLE.
 pub(crate) fn lower<C>(
     lower_ctx: &mut C,
-    isa_flags: &x64_settings::Flags,
+    isa_flags: &Flags,
     outputs: &[InsnOutput],
     inst: Inst,
 ) -> Result<(), ()>
 where
     C: LowerCtx<I = MInst>,
 {
-    // TODO: reuse the ISLE context across lowerings so we can reuse its
-    // internal heap allocations.
-    let mut isle_ctx = IsleContext::new(lower_ctx, isa_flags);
-
-    let temp_regs = generated_code::constructor_lower(&mut isle_ctx, inst).ok_or(())?;
-    let mut temp_regs = temp_regs.regs().iter();
-
-    #[cfg(debug_assertions)]
-    {
-        let all_dsts_len = outputs
-            .iter()
-            .map(|out| get_output_reg(isle_ctx.lower_ctx, *out).len())
-            .sum();
-        debug_assert_eq!(
-            temp_regs.len(),
-            all_dsts_len,
-            "the number of temporary registers and destination registers do \
-         not match ({} != {}); ensure the correct registers are being \
-         returned.",
-            temp_regs.len(),
-            all_dsts_len,
-        );
-    }
-
-    // The ISLE generated code emits its own registers to define the
-    // instruction's lowered values in. We rename those registers to the
-    // registers they were assigned when their value was used as an operand in
-    // earlier lowerings.
-    let mut renamer = RegRenamer::default();
-    for output in outputs {
-        let dsts = get_output_reg(isle_ctx.lower_ctx, *output);
-        for (temp, dst) in temp_regs.by_ref().zip(dsts.regs()) {
-            renamer.add_rename(*temp, dst.to_reg());
-        }
-    }
-
-    for mut inst in isle_ctx.into_emitted_insts() {
-        x64_map_regs(&mut inst, &renamer);
-        lower_ctx.emit(inst);
-    }
-
-    Ok(())
+    lower_common(
+        lower_ctx,
+        isa_flags,
+        outputs,
+        inst,
+        |cx, insn| generated_code::constructor_lower(cx, insn),
+        x64_map_regs,
+    )
 }
 
-pub struct IsleContext<'a, C> {
-    lower_ctx: &'a mut C,
-    isa_flags: &'a x64_settings::Flags,
-    emitted_insts: SmallVec<[MInst; 6]>,
-}
-
-impl<'a, C> IsleContext<'a, C> {
-    pub fn new(lower_ctx: &'a mut C, isa_flags: &'a x64_settings::Flags) -> Self {
-        IsleContext {
-            lower_ctx,
-            isa_flags,
-            emitted_insts: SmallVec::new(),
-        }
-    }
-
-    pub fn into_emitted_insts(self) -> SmallVec<[MInst; 6]> {
-        self.emitted_insts
-    }
-}
-
-impl<'a, C> generated_code::Context for IsleContext<'a, C>
+impl<C> generated_code::Context for IsleContext<'_, C, Flags, 6>
 where
     C: LowerCtx<I = MInst>,
 {