cranelift-codegen: rename most uses of std to core and alloc (#12237)

* rename most std uses to core and alloc

* cargo fmt

Author: the-ssd

cranelift/codegen/meta/src/gen_inst.rs

@@ -312,7 +312,7 @@ fn gen_instruction_data_impl(formats: &[Rc<InstructionFormat>], fmt: &mut Format
                         (Some("args.as_slice(pool)"), "args.len(pool)")
                     } else if format.num_value_operands == 1 {
                         members.push("ref arg");
-                        (Some("std::slice::from_ref(arg)"), "1")
+                        (Some("core::slice::from_ref(arg)"), "1")
                     } else if format.num_value_operands > 0 {
                         members.push("ref args");
                         (Some("args"), "args.len()")
@@ -324,7 +324,7 @@ fn gen_instruction_data_impl(formats: &[Rc<InstructionFormat>], fmt: &mut Format
                         0 => None,
                         1 => {
                             members.push("ref destination");
-                            Some(("std::slice::from_ref(destination)", "1"))
+                            Some(("core::slice::from_ref(destination)", "1"))
                         }
                         _ => {
                             members.push("ref blocks");

cranelift/codegen/shared/src/lib.rs

@@ -2,9 +2,10 @@
 //! `cranelift-codegen-meta` libraries.
 
 #![deny(missing_docs)]
+#![no_std]
 
 pub mod constant_hash;
 pub mod constants;
 
 /// Version number of this crate.
-pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+pub const VERSION: &str = core::env!("CARGO_PKG_VERSION");

cranelift/codegen/src/ctxhash.rs

@@ -4,8 +4,8 @@
 //! node-internal data references some other storage (e.g., offsets into
 //! an array or pool of shared data).
 
+use core::hash::{Hash, Hasher};
 use hashbrown::hash_table::HashTable;
-use std::hash::{Hash, Hasher};
 
 /// Trait that allows for equality comparison given some external
 /// context.
@@ -92,7 +92,7 @@ impl<K, V> CtxHashMap<K, V> {
         match self.raw.find_mut(hash as u64, |bucket| {
             hash == bucket.hash && ctx.ctx_eq(&bucket.k, &k)
         }) {
-            Some(bucket) => Some(std::mem::replace(&mut bucket.v, v)),
+            Some(bucket) => Some(core::mem::replace(&mut bucket.v, v)),
             None => {
                 let data = BucketData { hash, k, v };
                 self.raw

cranelift/codegen/src/data_value.rs

@@ -247,13 +247,13 @@ impl DataValue {
     /// Write a [DataValue] to a memory location in native-endian byte order.
     pub unsafe fn write_value_to(&self, p: *mut u128) {
         let size = self.ty().bytes() as usize;
-        self.write_to_slice_ne(unsafe { std::slice::from_raw_parts_mut(p as *mut u8, size) });
+        self.write_to_slice_ne(unsafe { core::slice::from_raw_parts_mut(p as *mut u8, size) });
     }
 
     /// Read a [DataValue] from a memory location using a given [Type] in native-endian byte order.
     pub unsafe fn read_value_from(p: *const u128, ty: Type) -> Self {
         DataValue::read_from_slice_ne(
-            unsafe { std::slice::from_raw_parts(p as *const u8, ty.bytes() as usize) },
+            unsafe { core::slice::from_raw_parts(p as *const u8, ty.bytes() as usize) },
             ty,
         )
     }
@@ -290,7 +290,7 @@ pub enum DataValueCastFailure {
 
 // This is manually implementing Error and Display instead of using thiserror to reduce the amount
 // of dependencies used by Cranelift.
-impl std::error::Error for DataValueCastFailure {}
+impl core::error::Error for DataValueCastFailure {}
 
 impl Display for DataValueCastFailure {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {

cranelift/codegen/src/dominator_tree.rs

@@ -94,15 +94,15 @@ impl SpanningTree {
     }
 }
 
-impl std::ops::Index<u32> for SpanningTree {
+impl core::ops::Index<u32> for SpanningTree {
     type Output = SpanningTreeNode;
 
     fn index(&self, idx: u32) -> &Self::Output {
         &self.nodes[idx as usize]
     }
 }
 
-impl std::ops::IndexMut<u32> for SpanningTree {
+impl core::ops::IndexMut<u32> for SpanningTree {
     fn index_mut(&mut self, idx: u32) -> &mut Self::Output {
         &mut self.nodes[idx as usize]
     }
@@ -439,7 +439,7 @@ impl DominatorTree {
                 }
 
                 let semi_candidate = self.eval(self.nodes[pred].pre_number, last_linked);
-                semi = std::cmp::min(semi, semi_candidate);
+                semi = core::cmp::min(semi, semi_candidate);
             }
 
             let w_node = &mut self.stree[w];

cranelift/codegen/src/egraph.rs

@@ -660,7 +660,7 @@ where
 
                 let old_vals = ctx.func.dfg.inst_results(inst);
                 let new_vals = if let Some(val) = new_val.as_ref() {
-                    std::slice::from_ref(val)
+                    core::slice::from_ref(val)
                 } else {
                     ctx.func.dfg.inst_results(new_inst)
                 };
@@ -1075,7 +1075,7 @@ impl<'a> CtxEq<(Type, InstructionData), (Type, InstructionData)> for GVNContext<
 
 impl<'a> CtxHash<(Type, InstructionData)> for GVNContext<'a> {
     fn ctx_hash<H: Hasher>(&self, state: &mut H, (ty, inst): &(Type, InstructionData)) {
-        std::hash::Hash::hash(&ty, state);
+        core::hash::Hash::hash(&ty, state);
         inst.hash(state, self.value_lists);
     }
 }

cranelift/codegen/src/egraph/cost.rs

@@ -48,7 +48,7 @@ impl core::fmt::Debug for Cost {
 
 impl Ord for Cost {
     #[inline]
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
         // We make sure that the high bits are the op cost and the low bits are
         // the depth. This means that we can use normal integer comparison to
         // order by op cost and then depth.
@@ -65,7 +65,7 @@ impl Ord for Cost {
 
 impl PartialOrd for Cost {
     #[inline]
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
         Some(self.cmp(other))
     }
 }
@@ -172,24 +172,24 @@ impl Cost {
     }
 }
 
-impl std::iter::Sum<Cost> for Cost {
+impl core::iter::Sum<Cost> for Cost {
     fn sum<I: Iterator<Item = Cost>>(iter: I) -> Self {
         iter.fold(Self::zero(), |a, b| a + b)
     }
 }
 
-impl std::default::Default for Cost {
+impl core::default::Default for Cost {
     fn default() -> Cost {
         Cost::zero()
     }
 }
 
-impl std::ops::Add<Cost> for Cost {
+impl core::ops::Add<Cost> for Cost {
     type Output = Cost;
 
     fn add(self, other: Cost) -> Cost {
         let op_cost = self.op_cost().saturating_add(other.op_cost());
-        let depth = std::cmp::max(self.depth(), other.depth());
+        let depth = core::cmp::max(self.depth(), other.depth());
         Cost::new(op_cost, depth)
     }
 }

cranelift/codegen/src/egraph/elaborate.rs

@@ -82,7 +82,7 @@ impl PartialOrd for BestEntry {
 
 impl Ord for BestEntry {
     #[inline]
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
         self.0.cmp(&other.0).then_with(|| {
             // Note that this comparison is reversed. When costs are equal,
             // prefer the value with the bigger index. This is a heuristic that
@@ -321,9 +321,9 @@ impl<'a> Elaborator<'a> {
                     debug_assert!(!best[x].1.is_reserved_value());
                     debug_assert!(!best[y].1.is_reserved_value());
                     best[value] = if use_worst {
-                        std::cmp::max(best[x], best[y])
+                        core::cmp::max(best[x], best[y])
                     } else {
-                        std::cmp::min(best[x], best[y])
+                        core::cmp::min(best[x], best[y])
                     };
                     trace!(
                         " -> best of union({:?}, {:?}) = {:?}",

cranelift/codegen/src/incremental_cache.rs

@@ -111,7 +111,7 @@ pub trait CacheKvStore {
 #[derive(Clone, Hash, PartialEq, Eq)]
 pub struct CacheKeyHash([u8; 32]);
 
-impl std::fmt::Display for CacheKeyHash {
+impl core::fmt::Display for CacheKeyHash {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "CacheKeyHash:{:?}", self.0)
     }

cranelift/codegen/src/ir/condcodes.rs

@@ -344,7 +344,7 @@ impl FromStr for FloatCC {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::string::ToString;
+    use alloc::string::ToString;
 
     #[test]
     fn int_complement() {