asm: add implicit operands

Implicit operands are used by an instruction but not present in its
disassembled output. Instructions like `mul`, e.g., will write to the
`%rax` and `%rdx` registers, but this is all invisible in disassembly.
Implicit operands are always fixed (i.e., the register is known), but
not all fixed operands are implicit (i.e., some fixed registers _are_
disassembled).

Author: abrown

cranelift/assembler-x64/meta/src/dsl.rs

@@ -13,7 +13,7 @@ pub use encoding::{
     Encoding, Group1Prefix, Group2Prefix, Group3Prefix, Group4Prefix, Opcodes, Prefixes, Rex,
 };
 pub use features::{Feature, Features, ALL_FEATURES};
-pub use format::{align, fmt, r, rw, sxl, sxq, sxw, w};
+pub use format::{align, fmt, implicit, r, rw, sxl, sxq, sxw, w};
 pub use format::{Extension, Format, Location, Mutability, Operand, OperandKind};
 
 /// Abbreviated constructor for an x64 instruction.

cranelift/assembler-x64/meta/src/dsl/format.rs

@@ -70,6 +70,16 @@ pub fn align(location: Location) -> Operand {
     }
 }
 
+/// An abbreviated constructor for an operand that is used by the instruction
+/// but not visible in its disassembly.
+pub fn implicit(location: Location) -> Operand {
+    assert!(matches!(location.kind(), OperandKind::FixedReg(_)));
+    Operand {
+        implicit: true,
+        ..Operand::from(location)
+    }
+}
+
 /// An abbreviated constructor for a "read" operand that is sign-extended to 64
 /// bits (quadword).
 ///
@@ -194,6 +204,9 @@ pub struct Operand {
     /// address used in the operand must align to the size of the operand (e.g.,
     /// `m128` must be 16-byte aligned).
     pub align: bool,
+    /// Some register operands are implicit: that is, they do not appear in the
+    /// disassembled output even though they are used in the instruction.
+    pub implicit: bool,
 }
 
 impl core::fmt::Display for Operand {
@@ -203,6 +216,7 @@ impl core::fmt::Display for Operand {
             mutability,
             extension,
             align,
+            implicit,
         } = self;
         write!(f, "{location}")?;
         let mut flags = vec![];
@@ -215,6 +229,9 @@ impl core::fmt::Display for Operand {
         if *align != false {
             flags.push("align".to_owned());
         }
+        if *implicit {
+            flags.push("implicit".to_owned());
+        }
         if !flags.is_empty() {
             write!(f, "[{}]", flags.join(","))?;
         }
@@ -227,11 +244,13 @@ impl From<Location> for Operand {
         let mutability = Mutability::default();
         let extension = Extension::default();
         let align = false;
+        let implicit = false;
         Self {
             location,
             mutability,
             extension,
             align,
+            implicit,
         }
     }
 }

cranelift/assembler-x64/meta/src/generate/format.rs

@@ -18,6 +18,7 @@ impl dsl::Format {
         let ordered_ops: Vec<_> = self
             .operands
             .iter()
+            .filter(|o| !o.implicit)
             .rev()
             .map(|o| format!("{{{}}}", o.location))
             .collect();

cranelift/assembler-x64/meta/src/generate/inst.rs

@@ -194,7 +194,7 @@ impl dsl::Inst {
                 f.add_block(
                     "fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result",
                     |f| {
-                        for op in &self.format.operands {
+                        for op in self.format.operands.iter().filter(|o| !o.implicit) {
                             let location = op.location;
                             let to_string = location.generate_to_string(op.extension);
                             fmtln!(f, "let {location} = {to_string};");