compiler: use vector instead of hashmap in rustc_abi's TargetDataLayout

Author: xdoardo

compiler/rustc_abi/src/lib.rs

@@ -47,7 +47,6 @@ use std::ops::{Add, AddAssign, Deref, Mul, RangeInclusive, Sub};
 use std::str::FromStr;
 
 use bitflags::bitflags;
-use rustc_data_structures::fx::FxHashMap;
 #[cfg(feature = "nightly")]
 use rustc_data_structures::stable_hasher::StableOrd;
 use rustc_hashes::Hash64;
@@ -292,14 +291,14 @@ impl Default for TargetDataLayout {
                 (Size::from_bits(128), AbiAlign::new(align(128))),
             ],
             default_address_space: AddressSpace::ZERO,
-            address_space_info: FxHashMap::from_iter([(
+            address_space_info: vec![(
                 AddressSpace::ZERO,
                 AddressSpaceInfo {
                     pointer_size: Size::from_bits(64),
                     pointer_align: AbiAlign::new(align(64)),
                     pointer_index: Size::from_bits(64),
                 },
-            )]),
+            )],
             instruction_address_space: AddressSpace::ZERO,
             c_enum_min_size: Integer::I32,
         }
@@ -396,11 +395,16 @@ impl TargetDataLayout {
                         pointer_size,
                         pointer_align: parse_align(a, p)?,
                     };
-
-                    dl.address_space_info
-                        .entry(addr_space)
-                        .and_modify(|v| *v = info)
-                        .or_insert(info);
+                    match dl.address_space_info.iter_mut().find(|(a, _)| *a == addr_space) {
+                        Some(e) => e.1 = info,
+                        None => {
+                            if addr_space == default_address_space {
+                                dl.address_space_info.insert(0, (addr_space, info));
+                            } else {
+                                dl.address_space_info.push((addr_space, info));
+                            }
+                        }
+                    }
                 }
                 [p, s, _pr, i, a @ ..] if p.starts_with("p") => {
                     // Some targets, such as CHERI, use the 'f' suffix in the p- spec to signal that
@@ -419,10 +423,16 @@ impl TargetDataLayout {
                         pointer_index: parse_size(i, p)?,
                     };
 
-                    dl.address_space_info
-                        .entry(addr_space)
-                        .and_modify(|v| *v = info)
-                        .or_insert(info);
+                    match dl.address_space_info.iter_mut().find(|(a, _)| *a == addr_space) {
+                        Some(e) => e.1 = info,
+                        None => {
+                            if addr_space == default_address_space {
+                                dl.address_space_info.insert(0, (addr_space, info));
+                            } else {
+                                dl.address_space_info.push((addr_space, info));
+                            }
+                        }
+                    }
                 }
 
                 [s, a @ ..] if s.starts_with('i') => {
@@ -460,7 +470,7 @@ impl TargetDataLayout {
             }
         }
 
-        if !dl.address_space_info.contains_key(&default_address_space) {
+        if dl.address_space_info.iter().find(|(a, _)| *a == default_address_space).is_none() {
             return Err(TargetDataLayoutErrors::MissingAddressSpaceInfo {
                 addr_space: default_address_space,
             });
@@ -469,11 +479,17 @@ impl TargetDataLayout {
         // Inherit, if not given, address space informations for specific LLVM elements from the
         // default data address space.
 
-        if !dl.address_space_info.contains_key(&dl.instruction_address_space) {
-            dl.address_space_info.insert(
+        if dl.address_space_info.iter().find(|(a, _)| *a == dl.instruction_address_space).is_none()
+        {
+            dl.address_space_info.push((
                 dl.instruction_address_space,
-                dl.address_space_info.get(&default_address_space).unwrap().clone(),
-            );
+                dl.address_space_info
+                    .iter()
+                    .find(|(a, _)| *a == default_address_space)
+                    .unwrap()
+                    .1
+                    .clone(),
+            ));
         }
 
         Ok(dl)
@@ -491,7 +507,12 @@ impl TargetDataLayout {
     /// so we adopt such a more-constrained size bound due to its technical limitations.
     #[inline]
     pub fn obj_size_bound(&self) -> u64 {
-        self.obj_size_bound_in(self.default_address_space)
+        match self.pointer_size().bits() {
+            16 => 1 << 15,
+            32 => 1 << 31,
+            64 => 1 << 61,
+            bits => panic!("obj_size_bound: unknown pointer bit size {bits}"),
+        }
     }
 
     /// Returns **exclusive** upper bound on object size in bytes.
@@ -515,7 +536,13 @@ impl TargetDataLayout {
 
     #[inline]
     pub fn ptr_sized_integer(&self) -> Integer {
-        self.ptr_sized_integer_in(self.default_address_space)
+        use Integer::*;
+        match self.pointer_index().bits() {
+            16 => I16,
+            32 => I32,
+            64 => I64,
+            bits => panic!("ptr_sized_integer: unknown pointer bit size {bits}"),
+        }
     }
 
     #[inline]
@@ -549,14 +576,14 @@ impl TargetDataLayout {
     /// Get the pointer size in the default data address space.
     #[inline]
     pub fn pointer_size(&self) -> Size {
-        self.pointer_size_in(self.default_address_space)
+        self.address_space_info[0].1.pointer_size
     }
 
     /// Get the pointer size in a specific address space.
     #[inline]
     pub fn pointer_size_in(&self, c: AddressSpace) -> Size {
-        if let Some(c) = self.address_space_info.get(&c) {
-            c.pointer_size
+        if let Some(e) = self.address_space_info.iter().find(|(a, _)| a == &c) {
+            e.1.pointer_size
         } else {
             panic!("Use of unknown address space {c:?}");
         }
@@ -565,14 +592,14 @@ impl TargetDataLayout {
     /// Get the pointer index in the default data address space.
     #[inline]
     pub fn pointer_index(&self) -> Size {
-        self.pointer_index_in(self.default_address_space)
+        self.address_space_info[0].1.pointer_index
     }
 
     /// Get the pointer index in a specific address space.
     #[inline]
     pub fn pointer_index_in(&self, c: AddressSpace) -> Size {
-        if let Some(c) = self.address_space_info.get(&c) {
-            c.pointer_index
+        if let Some(e) = self.address_space_info.iter().find(|(a, _)| a == &c) {
+            e.1.pointer_index
         } else {
             panic!("Use of unknown address space {c:?}");
         }
@@ -581,14 +608,14 @@ impl TargetDataLayout {
     /// Get the pointer alignment in the default data address space.
     #[inline]
     pub fn pointer_align(&self) -> AbiAlign {
-        self.pointer_align_in(self.default_address_space)
+        self.address_space_info[0].1.pointer_align
     }
 
     /// Get the pointer alignment in a specific address space.
     #[inline]
     pub fn pointer_align_in(&self, c: AddressSpace) -> AbiAlign {
-        if let Some(c) = self.address_space_info.get(&c) {
-            c.pointer_align
+        if let Some(e) = self.address_space_info.iter().find(|(a, _)| a == &c) {
+            e.1.pointer_align
         } else {
             panic!("Use of unknown address space {c:?}");
         }