cranelift-assembler-x64: no_std support (#12235)

* cranelift-assembler-x64: no_std support

* cargo fmt

* Update cranelift/assembler-x64/src/xmm.rs

Co-authored-by: bjorn3 <[email protected]>

* Update cranelift/assembler-x64/src/imm.rs

Co-authored-by: bjorn3 <[email protected]>

* Update cranelift/assembler-x64/src/api.rs

Co-authored-by: bjorn3 <[email protected]>

* Reorder import of alloc

* #![no_std]

* revert main.rs

* cargo fmt

* remove core feature

* Fix CI

---------

Co-authored-by: bjorn3 <[email protected]>

Author: the-ssd

.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 --lib &&
             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/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,8 +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 {
@@ -113,7 +115,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

@@ -4,6 +4,10 @@
 //! throughout this crate to avoid depending on the `arbitrary` crate
 //! unconditionally (use the `fuzz` feature instead).
 
+use std::string::{String, ToString};
+use std::vec::Vec;
+use std::{format, println};
+
 use crate::{
     AmodeOffset, AmodeOffsetPlusKnownOffset, AsReg, CodeSink, DeferredTarget, Fixed, Gpr, Inst,
     KnownOffset, NonRspGpr, Registers, TrapCode, Xmm,
@@ -146,7 +150,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 +187,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 +263,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`).
 ///