cranelift-assembler-x64: no_std support

.github/workflows/main.yml

@@ -550,6 +550,7 @@ jobs:
             cargo check -p wasmtime --no-default-features --features runtime,component-model &&
             cargo check -p wasmtime --no-default-features --features runtime,gc,component-model,async,debug-builtins &&
             cargo check -p cranelift-control --no-default-features &&
+            cargo check -p cranelift-assembler-x64 --no-default-features -F core &&
             cargo check -p pulley-interpreter --features encode,decode,disas,interp &&
             cargo check -p wasmtime-wasi-io --no-default-features
         # Use `cross` for illumos to have a C compiler/linker available.

cranelift/assembler-x64/Cargo.toml

@@ -23,3 +23,4 @@ workspace = true
 
 [features]
 fuzz = ['dep:arbitrary', 'dep:capstone']
+core = []

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

@@ -535,7 +535,7 @@ impl Default for Mutability {
 }
 
 impl core::fmt::Display for Mutability {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Self::Read => write!(f, "r"),
             Self::ReadWrite => write!(f, "rw"),
@@ -576,7 +576,7 @@ impl Default for Extension {
 }
 
 impl core::fmt::Display for Extension {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Extension::None => write!(f, ""),
             Extension::SignExtendQuad => write!(f, "sxq"),
@@ -627,7 +627,7 @@ impl Default for Eflags {
 }
 
 impl core::fmt::Display for Eflags {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Self::None => write!(f, ""),
             Self::R => write!(f, "r"),

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

@@ -53,11 +53,11 @@ fn match_variants(f: &mut Formatter, insts: &[dsl::Inst], invoke: &str) {
     });
 }
 
-/// `impl std::fmt::Display for Inst { ... }`
+/// `impl core::fmt::Display for Inst { ... }`
 fn generate_inst_display_impl(f: &mut Formatter, insts: &[dsl::Inst]) {
-    f.add_block("impl<R: Registers> std::fmt::Display for Inst<R>", |f| {
+    f.add_block("impl<R: Registers> core::fmt::Display for Inst<R>", |f| {
         f.add_block(
-            "fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result",
+            "fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result",
             |f| {
                 match_variants(f, insts, "fmt(f)");
             },

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

@@ -107,12 +107,12 @@ impl dsl::Inst {
         fmtln!(f, "#[must_use]");
         fmtln!(f, "#[inline]");
         f.add_block(
-            &format!("pub fn mnemonic(&self) -> std::borrow::Cow<'static, str>"),
+            &format!("pub fn mnemonic(&self) -> alloc::borrow::Cow<'static, str>"),
             |f| {
                 if self.custom.contains(Mnemonic) {
                     fmtln!(f, "crate::custom::mnemonic::{}(self)", self.name());
                 } else {
-                    fmtln!(f, "std::borrow::Cow::Borrowed(\"{}\")", self.mnemonic);
+                    fmtln!(f, "alloc::borrow::Cow::Borrowed(\"{}\")", self.mnemonic);
                 }
             },
         );
@@ -265,10 +265,10 @@ impl dsl::Inst {
         let impl_block = self.generate_impl_block_start();
         let struct_name = self.struct_name_with_generic();
         f.add_block(
-            &format!("{impl_block} std::fmt::Display for {struct_name}"),
+            &format!("{impl_block} core::fmt::Display for {struct_name}"),
             |f| {
                 f.add_block(
-                    "fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result",
+                    "fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result",
                     |f| {
                         if self.custom.contains(Display) {
                             fmtln!(f, "crate::custom::display::{}(f, self)", self.name());

cranelift/assembler-x64/src/api.rs

@@ -3,9 +3,10 @@
 use crate::gpr;
 use crate::xmm;
 use crate::{Amode, DeferredTarget, GprMem, XmmMem};
-use std::fmt;
-use std::{num::NonZeroU8, vec::Vec};
-
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::fmt;
+use core::num::NonZeroU8;
 /// Describe how an instruction is emitted into a code buffer.
 pub trait CodeSink {
     /// Add 1 byte to the code section.
@@ -113,7 +114,7 @@ pub trait Registers {
 }
 
 /// Describe how to interact with an external register type.
-pub trait AsReg: Copy + Clone + std::fmt::Debug + PartialEq {
+pub trait AsReg: Copy + Clone + core::fmt::Debug + PartialEq {
     /// Create a register from its hardware encoding.
     ///
     /// This is primarily useful for fuzzing, though it is also useful for

cranelift/assembler-x64/src/custom.rs

@@ -75,7 +75,7 @@ pub mod encode {
 pub mod mnemonic {
     use crate::inst;
     use crate::{Registers, XmmMem};
-    use std::borrow::Cow;
+    use alloc::borrow::Cow;
 
     macro_rules! lock {
         ($name:tt => $mnemonic:expr) => {
@@ -191,7 +191,8 @@ pub mod mnemonic {
 pub mod display {
     use crate::inst;
     use crate::{Amode, Gpr, GprMem, Registers, Size};
-    use std::fmt;
+    use alloc::string::ToString;
+    use core::fmt;
 
     pub fn callq_d(f: &mut fmt::Formatter, inst: &inst::callq_d) -> fmt::Result {
         let inst::callq_d { imm32 } = inst;

cranelift/assembler-x64/src/features.rs

@@ -32,7 +32,7 @@
 //! [`Inst::features`]: crate::inst::Inst::features
 
 use crate::inst::for_each_feature;
-use std::fmt;
+use core::fmt;
 
 // Helpfully generate `enum Feature`.
 macro_rules! create_feature_enum {

cranelift/assembler-x64/src/fixed.rs

@@ -1,6 +1,7 @@
 //! Operands with fixed register encodings.
 
 use crate::{AsReg, Size};
+use alloc::string::String;
 
 /// A _fixed_ register.
 ///

cranelift/assembler-x64/src/fuzz.rs

@@ -146,7 +146,7 @@ fn disassemble(assembled: &[u8], original: &Inst<FuzzRegs>) -> String {
 }
 
 fn pretty_print_hexadecimal(hex: &[u8]) -> String {
-    use std::fmt::Write;
+    use core::fmt::Write;
     let mut s = String::with_capacity(hex.len() * 2);
     for b in hex {
         write!(&mut s, "{b:02X}").unwrap();
@@ -183,7 +183,7 @@ macro_rules! hex_print_signed_imm {
 /// - print negative values as `-0x...` (signed hex) instead of `0xff...`
 ///   (normal hex)
 /// - print `mov` immediates as base-10 instead of base-16 (?!).
-fn replace_signed_immediates(dis: &str) -> std::borrow::Cow<'_, str> {
+fn replace_signed_immediates(dis: &str) -> alloc::borrow::Cow<'_, str> {
     match dis.find('$') {
         None => dis.into(),
         Some(idx) => {
@@ -259,7 +259,7 @@ fn remove_after_parenthesis_test() {
 }
 
 /// Run some post-processing on the disassembly to make it match Capstone.
-fn fix_up(dis: &str) -> std::borrow::Cow<'_, str> {
+fn fix_up(dis: &str) -> alloc::borrow::Cow<'_, str> {
     let dis = remove_after_semicolon(dis);
     replace_signed_immediates(&dis)
 }

cranelift/assembler-x64/src/gpr.rs

@@ -1,6 +1,7 @@
 //! Pure register operands; see [`Gpr`].
 
 use crate::AsReg;
+use alloc::string::String;
 
 /// A general purpose x64 register (e.g., `%rax`).
 ///

cranelift/assembler-x64/src/imm.rs

@@ -1,7 +1,9 @@
 //! Immediate operands to instructions.
 
 use crate::api::CodeSink;
-use std::fmt;
+use core::fmt;
+
+use alloc::{format, string::String};
 
 /// This helper function prints the unsigned hexadecimal representation of the
 /// immediate value: e.g., this prints `$0xfe` to represent both the signed `-2`
@@ -49,7 +51,7 @@ impl From<u8> for Imm8 {
 }
 
 impl TryFrom<i32> for Imm8 {
-    type Error = std::num::TryFromIntError;
+    type Error = core::num::TryFromIntError;
     fn try_from(simm32: i32) -> Result<Self, Self::Error> {
         Ok(Self(u8::try_from(simm32)?))
     }
@@ -100,7 +102,7 @@ impl From<i8> for Simm8 {
 }
 
 impl TryFrom<i32> for Simm8 {
-    type Error = std::num::TryFromIntError;
+    type Error = core::num::TryFromIntError;
     fn try_from(simm32: i32) -> Result<Self, Self::Error> {
         Ok(Self(i8::try_from(simm32)?))
     }
@@ -134,7 +136,7 @@ impl From<u16> for Imm16 {
 }
 
 impl TryFrom<i32> for Imm16 {
-    type Error = std::num::TryFromIntError;
+    type Error = core::num::TryFromIntError;
     fn try_from(simm32: i32) -> Result<Self, Self::Error> {
         Ok(Self(u16::try_from(simm32)?))
     }
@@ -185,7 +187,7 @@ impl From<i16> for Simm16 {
 }
 
 impl TryFrom<i32> for Simm16 {
-    type Error = std::num::TryFromIntError;
+    type Error = core::num::TryFromIntError;
     fn try_from(simm32: i32) -> Result<Self, Self::Error> {
         Ok(Self(i16::try_from(simm32)?))
     }

cranelift/assembler-x64/src/inst.rs

@@ -14,6 +14,8 @@ use crate::rex::RexPrefix;
 use crate::vex::VexPrefix;
 use crate::xmm::{self, Xmm};
 
+use alloc::string::ToString;
+
 // Include code generated by the `meta` crate.
 include!(concat!(env!("OUT_DIR"), "/assembler.rs"));
 

cranelift/assembler-x64/src/lib.rs

@@ -41,6 +41,8 @@
     non_camel_case_types,
     reason = "all of the generated struct names use snake case"
 )]
+#![cfg_attr(feature = "core", no_std)]
+extern crate alloc;
 
 mod api;
 mod custom;

cranelift/assembler-x64/src/main.rs

@@ -1,8 +1,19 @@
 //! Print the path to the generated code.
+#![cfg_attr(feature = "core", no_std)]
 
+#[cfg(not(feature = "core"))]
 fn main() {
     let paths: Vec<std::path::PathBuf> = include!(concat!(env!("OUT_DIR"), "/generated-files.rs"));
     for path in paths {
         println!("{}", path.display());
     }
 }
+
+#[cfg(feature = "core")]
+fn main() {}
+
+#[cfg(feature = "core")]
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    loop {}
+}

cranelift/assembler-x64/src/mem.rs

@@ -4,6 +4,8 @@ use crate::api::{AsReg, CodeSink, Constant, KnownOffset, Label, TrapCode};
 use crate::gpr::{self, NonRspGpr, Size};
 use crate::rex::{Disp, RexPrefix, encode_modrm, encode_sib};
 
+use alloc::string::{String, ToString};
+
 /// x64 memory addressing modes.
 #[derive(Copy, Clone, Debug, PartialEq)]
 #[cfg_attr(any(test, feature = "fuzz"), derive(arbitrary::Arbitrary))]
@@ -99,8 +101,8 @@ impl From<i32> for AmodeOffset {
     }
 }
 
-impl std::fmt::LowerHex for AmodeOffset {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::LowerHex for AmodeOffset {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         // This rather complex implementation is necessary to match how
         // `capstone` pretty-prints memory immediates.
         if self.0 == 0 {
@@ -116,7 +118,7 @@ impl std::fmt::LowerHex for AmodeOffset {
             Some(i) => i,
             None => -2_147_483_648,
         };
-        std::fmt::LowerHex::fmt(&abs, f)
+        core::fmt::LowerHex::fmt(&abs, f)
     }
 }
 
@@ -154,12 +156,12 @@ impl AmodeOffsetPlusKnownOffset {
     }
 }
 
-impl std::fmt::LowerHex for AmodeOffsetPlusKnownOffset {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::LowerHex for AmodeOffsetPlusKnownOffset {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(offset) = self.offset {
             write!(f, "<offset:{offset}>+")?;
         }
-        std::fmt::LowerHex::fmt(&self.simm32, f)
+        core::fmt::LowerHex::fmt(&self.simm32, f)
     }
 }
 
@@ -172,8 +174,8 @@ pub enum DeferredTarget {
     None,
 }
 
-impl<R: AsReg> std::fmt::Display for Amode<R> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl<R: AsReg> core::fmt::Display for Amode<R> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let pointer_width = Size::Quadword;
         match self {
             Amode::ImmReg { simm32, base, .. } => {

cranelift/assembler-x64/src/xmm.rs

@@ -2,6 +2,9 @@
 
 use crate::{AsReg, CodeSink, rex::encode_modrm};
 
+use alloc::string::String;
+//use core::convert::{AsMut, AsRef, From};
+
 /// An x64 SSE register (e.g., `%xmm0`).
 #[derive(Clone, Copy, Debug)]
 pub struct Xmm<R: AsReg = u8>(pub(crate) R);