Merge pull request #170 from alexcrichton/merge

Merge with main

Author: alexcrichton

.github/workflows/main.yml

@@ -283,7 +283,7 @@ jobs:
         toolchain: wasmtime-ci-pinned-nightly
 
     # Build C API documentation
-    - run: curl -L https://sourceforge.net/projects/doxygen/files/rel-1.9.3/doxygen-1.9.3.linux.bin.tar.gz/download | tar xzf -
+    - run: curl -L https://github.com/doxygen/doxygen/releases/download/Release_1_9_3/doxygen-1.9.3.linux.bin.tar.gz | tar xzf -
     - run: echo "`pwd`/doxygen-1.9.3/bin" >> $GITHUB_PATH
     - run: cmake -S crates/c-api -B target/c-api
     - run: cmake --build target/c-api --target doc

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

@@ -13,8 +13,8 @@ pub use encoding::{
 };
 pub use encoding::{rex, vex};
 pub use features::{ALL_FEATURES, Feature, Features};
-pub use format::{Extension, Format, Location, Mutability, Operand, OperandKind};
-pub use format::{align, fmt, r, rw, sxl, sxq, sxw, w};
+pub use format::{Extension, Format, Location, Mutability, Operand, OperandKind, RegClass};
+pub use format::{align, fmt, implicit, r, rw, sxl, sxq, sxw, w};
 
 /// Abbreviated constructor for an x64 instruction.
 pub fn inst(

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

@@ -65,6 +65,10 @@ pub enum Feature {
     sse,
     sse2,
     ssse3,
+    sse41,
+    bmi1,
+    lzcnt,
+    popcnt,
 }
 
 /// List all CPU features.
@@ -80,17 +84,15 @@ pub const ALL_FEATURES: &[Feature] = &[
     Feature::sse,
     Feature::sse2,
     Feature::ssse3,
+    Feature::sse41,
+    Feature::bmi1,
+    Feature::lzcnt,
+    Feature::popcnt,
 ];
 
 impl fmt::Display for Feature {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Feature::_64b => write!(f, "_64b"),
-            Feature::compat => write!(f, "compat"),
-            Feature::sse => write!(f, "sse"),
-            Feature::sse2 => write!(f, "sse2"),
-            Feature::ssse3 => write!(f, "ssse3"),
-        }
+        fmt::Debug::fmt(self, f)
     }
 }
 

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

@@ -34,13 +34,12 @@ pub fn fmt(
 /// This function panics if the location is an immediate (i.e., an immediate
 /// cannot be written to).
 #[must_use]
-pub fn rw(location: Location) -> Operand {
-    assert!(!matches!(location.kind(), OperandKind::Imm(_)));
+pub fn rw(op: impl Into<Operand>) -> Operand {
+    let op = op.into();
+    assert!(!matches!(op.location.kind(), OperandKind::Imm(_)));
     Operand {
-        location,
         mutability: Mutability::ReadWrite,
-        extension: Extension::default(),
-        align: false,
+        ..op
     }
 }
 
@@ -54,23 +53,30 @@ pub fn r(op: impl Into<Operand>) -> Operand {
 
 /// An abbreviated constructor for a "write" operand.
 #[must_use]
-pub fn w(location: Location) -> Operand {
+pub fn w(op: impl Into<Operand>) -> Operand {
+    let op = op.into();
     Operand {
-        location,
         mutability: Mutability::Write,
-        extension: Extension::None,
-        align: false,
+        ..op
     }
 }
 
 /// An abbreviated constructor for a memory operand that requires alignment.
 pub fn align(location: Location) -> Operand {
     assert!(location.uses_memory());
     Operand {
-        location,
-        mutability: Mutability::Read,
-        extension: Extension::None,
         align: true,
+        ..Operand::from(location)
+    }
+}
+
+/// 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)
     }
 }
 
@@ -84,10 +90,8 @@ pub fn align(location: Location) -> Operand {
 pub fn sxq(location: Location) -> Operand {
     assert!(location.bits() <= 64);
     Operand {
-        location,
-        mutability: Mutability::Read,
         extension: Extension::SignExtendQuad,
-        align: false,
+        ..Operand::from(location)
     }
 }
 
@@ -101,10 +105,8 @@ pub fn sxq(location: Location) -> Operand {
 pub fn sxl(location: Location) -> Operand {
     assert!(location.bits() <= 32);
     Operand {
-        location,
-        mutability: Mutability::Read,
         extension: Extension::SignExtendLong,
-        align: false,
+        ..Operand::from(location)
     }
 }
 
@@ -118,10 +120,8 @@ pub fn sxl(location: Location) -> Operand {
 pub fn sxw(location: Location) -> Operand {
     assert!(location.bits() <= 16);
     Operand {
-        location,
-        mutability: Mutability::Read,
         extension: Extension::SignExtendWord,
-        align: false,
+        ..Operand::from(location)
     }
 }
 
@@ -204,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 {
@@ -213,6 +216,7 @@ impl core::fmt::Display for Operand {
             mutability,
             extension,
             align,
+            implicit,
         } = self;
         write!(f, "{location}")?;
         let mut flags = vec![];
@@ -225,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(","))?;
         }
@@ -237,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,
         }
     }
 }
@@ -270,6 +279,9 @@ pub enum Location {
     ax,
     eax,
     rax,
+    dx,
+    edx,
+    rdx,
     cl,
 
     // Immediate values.
@@ -307,9 +319,9 @@ impl Location {
         use Location::*;
         match self {
             al | cl | imm8 | r8 | rm8 | m8 => 8,
-            ax | imm16 | r16 | rm16 | m16 => 16,
-            eax | imm32 | r32 | rm32 | m32 | xmm_m32 => 32,
-            rax | r64 | rm64 | m64 | xmm_m64 => 64,
+            ax | dx | imm16 | r16 | rm16 | m16 => 16,
+            eax | edx | imm32 | r32 | rm32 | m32 | xmm_m32 => 32,
+            rax | rdx | r64 | rm64 | m64 | xmm_m64 => 64,
             xmm | xmm_m128 => 128,
         }
     }
@@ -325,7 +337,8 @@ impl Location {
     pub fn uses_memory(&self) -> bool {
         use Location::*;
         match self {
-            al | cl | ax | eax | rax | imm8 | imm16 | imm32 | r8 | r16 | r32 | r64 | xmm => false,
+            al | ax | eax | rax | cl | dx | edx | rdx | imm8 | imm16 | imm32 | r8 | r16 | r32
+            | r64 | xmm => false,
             rm8 | rm16 | rm32 | rm64 | xmm_m32 | xmm_m64 | xmm_m128 | m8 | m16 | m32 | m64 => true,
         }
     }
@@ -337,8 +350,8 @@ impl Location {
         use Location::*;
         match self {
             imm8 | imm16 | imm32 => false,
-            al | ax | eax | rax | cl | r8 | r16 | r32 | r64 | rm8 | rm16 | rm32 | rm64 | xmm
-            | xmm_m32 | xmm_m64 | xmm_m128 | m8 | m16 | m32 | m64 => true,
+            al | ax | eax | rax | cl | dx | edx | rdx | r8 | r16 | r32 | r64 | rm8 | rm16
+            | rm32 | rm64 | xmm | xmm_m32 | xmm_m64 | xmm_m128 | m8 | m16 | m32 | m64 => true,
         }
     }
 
@@ -347,7 +360,7 @@ impl Location {
     pub fn kind(&self) -> OperandKind {
         use Location::*;
         match self {
-            al | ax | eax | rax | cl => OperandKind::FixedReg(*self),
+            al | ax | eax | rax | cl | dx | edx | rdx => OperandKind::FixedReg(*self),
             imm8 | imm16 | imm32 => OperandKind::Imm(*self),
             r8 | r16 | r32 | r64 | xmm => OperandKind::Reg(*self),
             rm8 | rm16 | rm32 | rm64 | xmm_m32 | xmm_m64 | xmm_m128 => OperandKind::RegMem(*self),
@@ -364,9 +377,8 @@ impl Location {
         use Location::*;
         match self {
             imm8 | imm16 | imm32 | m8 | m16 | m32 | m64 => None,
-            al | ax | eax | rax | cl | r8 | r16 | r32 | r64 | rm8 | rm16 | rm32 | rm64 => {
-                Some(RegClass::Gpr)
-            }
+            al | ax | eax | rax | cl | dx | edx | rdx | r8 | r16 | r32 | r64 | rm8 | rm16
+            | rm32 | rm64 => Some(RegClass::Gpr),
             xmm | xmm_m32 | xmm_m64 | xmm_m128 => Some(RegClass::Xmm),
         }
     }
@@ -385,6 +397,9 @@ impl core::fmt::Display for Location {
             eax => write!(f, "eax"),
             rax => write!(f, "rax"),
             cl => write!(f, "cl"),
+            dx => write!(f, "dx"),
+            edx => write!(f, "edx"),
+            rdx => write!(f, "rdx"),
 
             r8 => write!(f, "r8"),
             r16 => write!(f, "r16"),

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

@@ -47,7 +47,7 @@ fn generate_inst_enum(f: &mut Formatter, insts: &[dsl::Inst]) {
 
 /// `#[derive(...)]`
 fn generate_derive(f: &mut Formatter) {
-    fmtln!(f, "#[derive(Clone, Debug)]");
+    fmtln!(f, "#[derive(Copy, Clone, Debug)]");
     fmtln!(
         f,
         "#[cfg_attr(any(test, feature = \"fuzz\"), derive(arbitrary::Arbitrary))]"
@@ -72,7 +72,7 @@ fn generate_inst_display_impl(f: &mut Formatter, insts: &[dsl::Inst]) {
                 f.add_block("match self", |f| {
                     for inst in insts {
                         let variant_name = inst.name();
-                        fmtln!(f, "Self::{variant_name}(i) => write!(f, \"{{i}}\"),");
+                        fmtln!(f, "Self::{variant_name}(i) => i.fmt(f),");
                     }
                 });
             },

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

@@ -11,7 +11,7 @@ impl dsl::Feature {
     pub fn generate_enum(f: &mut Formatter) {
         fmtln!(f, "#[doc(hidden)]");
         generate_derive(f);
-        fmtln!(f, "#[derive(Copy, PartialEq)]"); // Add a couple more helpful derives.
+        fmtln!(f, "#[derive(PartialEq)]"); // Add more helpful derives.
         f.add_block("pub enum Feature", |f| {
             for feature in dsl::ALL_FEATURES {
                 fmtln!(f, "{feature},");