update rspirv 0.11 to 0.12, bulk adjustments

Author: Firestar99

Cargo.lock

@@ -8,5 +8,5 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-rspirv = "0.11"
+rspirv = "0.12"
 serde = { version = "1.0", features = ["derive"] }

crates/rustc_codegen_spirv-types/Cargo.toml

@@ -50,7 +50,7 @@ regex = { version = "1", features = ["perf"] }
 ar = "0.9.0"
 either = "1.8.0"
 indexmap = "1.6.0"
-rspirv = "0.11"
+rspirv = "0.12"
 rustc-demangle = "0.1.21"
 sanitize-filename = "0.4"
 serde = { version = "1.0", features = ["derive"] }

crates/rustc_codegen_spirv/Cargo.toml

@@ -4,7 +4,7 @@
 use crate::attr::{AggregatedSpirvAttributes, IntrinsicType};
 use crate::codegen_cx::CodegenCx;
 use crate::spirv_type::SpirvType;
-use rspirv::spirv::{StorageClass, Word};
+use rspirv::spirv::{Dim, ImageFormat, StorageClass, Word};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::ErrorGuaranteed;
 use rustc_index::Idx;
@@ -647,7 +647,7 @@ fn trans_aggregate<'tcx>(cx: &CodegenCx<'tcx>, span: Span, ty: TyAndLayout<'tcx>
                 // spir-v doesn't support zero-sized arrays
                 create_zst(cx, span, ty)
             } else {
-                let count_const = cx.constant_u32(span, count as u32);
+                let count_const = cx.constant_bit32(span, count as u32);
                 let element_spv = cx.lookup_type(element_type);
                 let stride_spv = element_spv
                     .sizeof(cx)
@@ -856,13 +856,35 @@ fn trans_intrinsic_type<'tcx>(
             // let image_format: spirv::ImageFormat =
             //     type_from_variant_discriminant(cx, args.const_at(6));
 
-            fn const_int_value<'tcx, P: FromPrimitive>(
+            trait FromU128Const: Sized {
+                fn from_u128_const(n: u128) -> Option<Self>;
+            }
+
+            impl FromU128Const for u32 {
+                fn from_u128_const(n: u128) -> Option<Self> {
+                    u32::from_u128(n)
+                }
+            }
+
+            impl FromU128Const for Dim {
+                fn from_u128_const(n: u128) -> Option<Self> {
+                    Dim::from_u32(u32::from_u128(n)?)
+                }
+            }
+
+            impl FromU128Const for ImageFormat {
+                fn from_u128_const(n: u128) -> Option<Self> {
+                    ImageFormat::from_u32(u32::from_u128(n)?)
+                }
+            }
+
+            fn const_int_value<'tcx, P: FromU128Const>(
                 cx: &CodegenCx<'tcx>,
                 const_: Const<'tcx>,
             ) -> Result<P, ErrorGuaranteed> {
                 assert!(const_.ty().is_integral());
                 let value = const_.eval_bits(cx.tcx, ParamEnv::reveal_all());
-                match P::from_u128(value) {
+                match P::from_u128_const(value) {
                     Some(v) => Ok(v),
                     None => Err(cx
                         .tcx

crates/rustc_codegen_spirv/src/abi.rs

@@ -175,7 +175,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     | MemorySemantics::SEQUENTIALLY_CONSISTENT
             }
         };
-        let semantics = self.constant_u32(self.span(), semantics.bits());
+        let semantics = self.constant_bit32(self.span(), semantics.bits());
         if invalid_seq_cst {
             self.zombie(
                 semantics.def(self),
@@ -196,10 +196,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     .constant_u16(self.span(), memset_fill_u16(fill_byte))
                     .def(self),
                 32 => self
-                    .constant_u32(self.span(), memset_fill_u32(fill_byte))
+                    .constant_bit32(self.span(), memset_fill_u32(fill_byte))
                     .def(self),
                 64 => self
-                    .constant_u64(self.span(), memset_fill_u64(fill_byte))
+                    .constant_bit64(self.span(), memset_fill_u64(fill_byte))
                     .def(self),
                 _ => self.fatal(format!(
                     "memset on integer width {width} not implemented yet"
@@ -314,7 +314,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             self.store(pat, ptr, Align::from_bytes(0).unwrap());
         } else {
             for index in 0..count {
-                let const_index = self.constant_u32(self.span(), index as u32);
+                let const_index = self.constant_bit32(self.span(), index as u32);
                 let gep_ptr = self.gep(pat.ty, ptr, &[const_index]);
                 self.store(pat, gep_ptr, Align::from_bytes(0).unwrap());
             }
@@ -428,7 +428,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         } else {
             let indices = indices
                 .into_iter()
-                .map(|idx| self.constant_u32(self.span(), idx).def(self))
+                .map(|idx| self.constant_bit32(self.span(), idx).def(self))
                 .collect::<Vec<_>>();
             self.emit()
                 .access_chain(leaf_ptr_ty, None, ptr.def(self), indices)
@@ -904,9 +904,9 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                 ))
             } else if signed {
                 // this cast chain can probably be collapsed, but, whatever, be safe
-                Operand::LiteralInt32(v as u8 as i8 as i32 as u32)
+                Operand::LiteralBit32(v as u8 as i8 as i32 as u32)
             } else {
-                Operand::LiteralInt32(v as u8 as u32)
+                Operand::LiteralBit32(v as u8 as u32)
             }
         }
         fn construct_16(self_: &Builder<'_, '_>, signed: bool, v: u128) -> Operand {
@@ -915,9 +915,9 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                     "Switches to values above u16::MAX not supported: {v:?}"
                 ))
             } else if signed {
-                Operand::LiteralInt32(v as u16 as i16 as i32 as u32)
+                Operand::LiteralBit32(v as u16 as i16 as i32 as u32)
             } else {
-                Operand::LiteralInt32(v as u16 as u32)
+                Operand::LiteralBit32(v as u16 as u32)
             }
         }
         fn construct_32(self_: &Builder<'_, '_>, _signed: bool, v: u128) -> Operand {
@@ -926,7 +926,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                     "Switches to values above u32::MAX not supported: {v:?}"
                 ))
             } else {
-                Operand::LiteralInt32(v as u32)
+                Operand::LiteralBit32(v as u32)
             }
         }
         fn construct_64(self_: &Builder<'_, '_>, _signed: bool, v: u128) -> Operand {
@@ -935,7 +935,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                     "Switches to values above u64::MAX not supported: {v:?}"
                 ))
             } else {
-                Operand::LiteralInt64(v as u64)
+                Operand::LiteralBit64(v as u64)
             }
         }
         // pass in signed into the closure to be able to unify closure types
@@ -1217,7 +1217,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         let (ptr, access_ty) = self.adjust_pointer_for_typed_access(ptr, ty);
 
         // TODO: Default to device scope
-        let memory = self.constant_u32(self.span(), Scope::Device as u32);
+        let memory = self.constant_bit32(self.span(), Scope::Device as u32);
         let semantics = self.ordering_to_semantics_def(order);
         let result = self
             .emit()
@@ -1347,7 +1347,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         let val = self.bitcast(val, access_ty);
 
         // TODO: Default to device scope
-        let memory = self.constant_u32(self.span(), Scope::Device as u32);
+        let memory = self.constant_bit32(self.span(), Scope::Device as u32);
         let semantics = self.ordering_to_semantics_def(order);
         self.validate_atomic(val.ty, ptr.def(self));
         self.emit()
@@ -1413,7 +1413,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
             let original_ptr = ptr.def(self);
             let indices = indices
                 .into_iter()
-                .map(|idx| self.constant_u32(self.span(), idx).def(self))
+                .map(|idx| self.constant_bit32(self.span(), idx).def(self))
                 .collect::<Vec<_>>();
             return self
                 .emit()
@@ -1433,7 +1433,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         if idx > u32::MAX as u64 {
             self.fatal("struct_gep bigger than u32::MAX");
         }
-        let index_const = self.constant_u32(self.span(), idx as u32).def(self);
+        let index_const = self.constant_bit32(self.span(), idx as u32).def(self);
         self.emit()
             .access_chain(
                 result_type,
@@ -1741,7 +1741,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         ) {
             let indices = indices
                 .into_iter()
-                .map(|idx| self.constant_u32(self.span(), idx).def(self))
+                .map(|idx| self.constant_bit32(self.span(), idx).def(self))
                 .collect::<Vec<_>>();
             self.emit()
                 .access_chain(dest_ty, None, ptr.def(self), indices)
@@ -2292,7 +2292,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
 
         self.validate_atomic(access_ty, dst.def(self));
         // TODO: Default to device scope
-        let memory = self.constant_u32(self.span(), Scope::Device as u32);
+        let memory = self.constant_bit32(self.span(), Scope::Device as u32);
         let semantics_equal = self.ordering_to_semantics_def(order);
         let semantics_unequal = self.ordering_to_semantics_def(failure_order);
         // Note: OpAtomicCompareExchangeWeak is deprecated, and has the same semantics
@@ -2328,7 +2328,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         self.validate_atomic(access_ty, dst.def(self));
         // TODO: Default to device scope
         let memory = self
-            .constant_u32(self.span(), Scope::Device as u32)
+            .constant_bit32(self.span(), Scope::Device as u32)
             .def(self);
         let semantics = self.ordering_to_semantics_def(order).def(self);
         use AtomicRmwBinOp::*;
@@ -2424,7 +2424,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         // Ignore sync scope (it only has "single thread" and "cross thread")
         // TODO: Default to device scope
         let memory = self
-            .constant_u32(self.span(), Scope::Device as u32)
+            .constant_bit32(self.span(), Scope::Device as u32)
             .def(self);
         let semantics = self.ordering_to_semantics_def(order).def(self);
         self.emit().memory_barrier(memory, semantics).unwrap();
@@ -2697,7 +2697,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
 
                         // HACK(eddyb) avoid the logic below that assumes only ID operands
                         if inst.class.opcode == Op::CompositeExtract {
-                            if let (Some(r), &[Operand::IdRef(x), Operand::LiteralInt32(i)]) =
+                            if let (Some(r), &[Operand::IdRef(x), Operand::LiteralBit32(i)]) =
                                 (inst.result_id, &inst.operands[..])
                             {
                                 return Some(Inst::CompositeExtract(r, x, i));

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -31,7 +31,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         constant_offset: u32,
     ) -> SpirvValue {
         let actual_index = if constant_offset != 0 {
-            let const_offset_val = self.constant_u32(DUMMY_SP, constant_offset);
+            let const_offset_val = self.constant_bit32(DUMMY_SP, constant_offset);
             self.add(dynamic_index, const_offset_val)
         } else {
             dynamic_index
@@ -199,7 +199,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // Note that the &[u32] gets split into two arguments - pointer, length
         let array = args[0];
         let byte_index = args[2];
-        let two = self.constant_u32(DUMMY_SP, 2);
+        let two = self.constant_bit32(DUMMY_SP, 2);
         let word_index = self.lshr(byte_index, two);
         self.recurse_load_type(result_type, result_type, array, word_index, 0)
     }
@@ -223,7 +223,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         value: SpirvValue,
     ) -> Result<(), ErrorGuaranteed> {
         let actual_index = if constant_offset != 0 {
-            let const_offset_val = self.constant_u32(DUMMY_SP, constant_offset);
+            let const_offset_val = self.constant_bit32(DUMMY_SP, constant_offset);
             self.add(dynamic_index, const_offset_val)
         } else {
             dynamic_index
@@ -367,7 +367,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // Note that the &[u32] gets split into two arguments - pointer, length
         let array = args[0];
         let byte_index = args[2];
-        let two = self.constant_u32(DUMMY_SP, 2);
+        let two = self.constant_bit32(DUMMY_SP, 2);
         let word_index = self.lshr(byte_index, two);
         if is_pair {
             let value_one = args[3];