update rspirv 0.11 to 0.12, bulk adjustments

Author: Firestar99

Cargo.lock

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

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_codegen_spirv-types.workspace = true
 rustc-demangle = "0.1.21"
 sanitize-filename = "0.4"

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;
@@ -653,7 +653,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)
@@ -862,13 +862,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());
             }
@@ -431,7 +431,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()
                 .in_bounds_access_chain(leaf_ptr_ty, None, ptr.def(self), indices)
@@ -614,7 +614,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     };
                     let indices = base_indices
                         .into_iter()
-                        .map(|idx| self.constant_u32(self.span(), idx).def(self))
+                        .map(|idx| self.constant_bit32(self.span(), idx).def(self))
                         .chain(indices)
                         .collect();
                     return self.emit_access_chain(
@@ -1106,9 +1106,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 {
@@ -1117,9 +1117,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 {
@@ -1128,7 +1128,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 {
@@ -1137,7 +1137,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
@@ -1478,7 +1478,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()
@@ -1611,7 +1611,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()
@@ -1944,7 +1944,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()
                 .in_bounds_access_chain(dest_ty, None, ptr.def(self), indices)
@@ -2495,7 +2495,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
@@ -2535,7 +2535,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::*;
@@ -2631,7 +2631,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();
@@ -2915,7 +2915,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];

crates/rustc_codegen_spirv/src/builder/byte_addressable_buffer.rs

@@ -45,12 +45,12 @@ impl Builder<'_, '_> {
         let int_ty = SpirvType::Integer(width, false).def(self.span(), self);
         let (mask_sign, mask_value) = match width {
             32 => (
-                self.constant_u32(self.span(), 1 << 31),
-                self.constant_u32(self.span(), u32::MAX >> 1),
+                self.constant_bit32(self.span(), 1 << 31),
+                self.constant_bit32(self.span(), u32::MAX >> 1),
             ),
             64 => (
-                self.constant_u64(self.span(), 1 << 63),
-                self.constant_u64(self.span(), u64::MAX >> 1),
+                self.constant_bit64(self.span(), 1 << 63),
+                self.constant_bit64(self.span(), u64::MAX >> 1),
             ),
             _ => bug!("copysign must have width 32 or 64, not {}", width),
         };
@@ -272,10 +272,10 @@ impl<'a, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'tcx> {
                         self.or(tmp1, tmp2)
                     }
                     32 => {
-                        let offset8 = self.constant_u32(self.span(), 8);
-                        let offset24 = self.constant_u32(self.span(), 24);
-                        let mask16 = self.constant_u32(self.span(), 0xFF00);
-                        let mask24 = self.constant_u32(self.span(), 0xFF0000);
+                        let offset8 = self.constant_bit32(self.span(), 8);
+                        let offset24 = self.constant_bit32(self.span(), 24);
+                        let mask16 = self.constant_bit32(self.span(), 0xFF00);
+                        let mask24 = self.constant_bit32(self.span(), 0xFF0000);
                         let tmp4 = self.shl(arg, offset24);
                         let tmp3 = self.shl(arg, offset8);
                         let tmp2 = self.lshr(arg, offset8);
@@ -287,16 +287,16 @@ impl<'a, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'tcx> {
                         self.or(res1, res2)
                     }
                     64 => {
-                        let offset8 = self.constant_u64(self.span(), 8);
-                        let offset24 = self.constant_u64(self.span(), 24);
-                        let offset40 = self.constant_u64(self.span(), 40);
-                        let offset56 = self.constant_u64(self.span(), 56);
-                        let mask16 = self.constant_u64(self.span(), 0xff00);
-                        let mask24 = self.constant_u64(self.span(), 0xff0000);
-                        let mask32 = self.constant_u64(self.span(), 0xff000000);
-                        let mask40 = self.constant_u64(self.span(), 0xff00000000);
-                        let mask48 = self.constant_u64(self.span(), 0xff0000000000);
-                        let mask56 = self.constant_u64(self.span(), 0xff000000000000);
+                        let offset8 = self.constant_bit64(self.span(), 8);
+                        let offset24 = self.constant_bit64(self.span(), 24);
+                        let offset40 = self.constant_bit64(self.span(), 40);
+                        let offset56 = self.constant_bit64(self.span(), 56);
+                        let mask16 = self.constant_bit64(self.span(), 0xff00);
+                        let mask24 = self.constant_bit64(self.span(), 0xff0000);
+                        let mask32 = self.constant_bit64(self.span(), 0xff000000);
+                        let mask40 = self.constant_bit64(self.span(), 0xff00000000);
+                        let mask48 = self.constant_bit64(self.span(), 0xff0000000000);
+                        let mask56 = self.constant_bit64(self.span(), 0xff000000000000);
                         let tmp8 = self.shl(arg, offset56);
                         let tmp7 = self.shl(arg, offset40);
                         let tmp6 = self.shl(arg, offset24);