Update to nightly-2025-07-14.

- `BuilderMethods::dynamic_alloca` was removed.
- `TargetDataLayout::pointer_{size,align}` were changed from fields to
  methods.
- `AddressSpace::DATA` was renamed `AddressSpace::ZERO`.

Author: nnethercote

crates/rustc_codegen_spirv/build.rs

@@ -18,9 +18,9 @@ use std::{env, fs, mem};
 /// `cargo publish`. We need to figure out a way to do this properly, but let's hardcode it for now :/
 //const REQUIRED_RUST_TOOLCHAIN: &str = include_str!("../../rust-toolchain.toml");
 const REQUIRED_RUST_TOOLCHAIN: &str = r#"[toolchain]
-channel = "nightly-2025-07-07"
+channel = "nightly-2025-07-14"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = a84ab0ce6c4557a2f01a3a6c3fdb0f92098db78d"#;
+# commit_hash = e9182f195b8505c87c4bd055b9f6e114ccda0981"#;
 
 fn rustc_output(arg: &str) -> Result<String, Box<dyn Error>> {
     let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".into());

crates/rustc_codegen_spirv/src/abi.rs

@@ -791,7 +791,7 @@ fn trans_intrinsic_type<'tcx>(
             let sampled_type = match args.type_at(0).kind() {
                 TyKind::Int(int) => match int {
                     IntTy::Isize => {
-                        SpirvType::Integer(cx.tcx.data_layout.pointer_size.bits() as u32, true)
+                        SpirvType::Integer(cx.tcx.data_layout.pointer_size().bits() as u32, true)
                             .def(span, cx)
                     }
                     IntTy::I8 => SpirvType::Integer(8, true).def(span, cx),
@@ -802,7 +802,7 @@ fn trans_intrinsic_type<'tcx>(
                 },
                 TyKind::Uint(uint) => match uint {
                     UintTy::Usize => {
-                        SpirvType::Integer(cx.tcx.data_layout.pointer_size.bits() as u32, false)
+                        SpirvType::Integer(cx.tcx.data_layout.pointer_size().bits() as u32, false)
                             .def(span, cx)
                     }
                     UintTy::U8 => SpirvType::Integer(8, false).def(span, cx),

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -1828,10 +1828,6 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         self.declare_func_local_var(self.type_array(self.type_i8(), size.bytes()), align)
     }
 
-    fn dynamic_alloca(&mut self, _len: Self::Value, _align: Align) -> Self::Value {
-        self.fatal("dynamic alloca not supported yet")
-    }
-
     fn load(&mut self, ty: Self::Type, ptr: Self::Value, _align: Align) -> Self::Value {
         let (ptr, access_ty) = self.adjust_pointer_for_typed_access(ptr, ty);
         let loaded_val = ptr.const_fold_load(self).unwrap_or_else(|| {

crates/rustc_codegen_spirv/src/codegen_cx/constant.rs

@@ -152,7 +152,7 @@ impl ConstCodegenMethods for CodegenCx<'_> {
         self.const_uint_big(ty, i)
     }
     fn const_usize(&self, i: u64) -> Self::Value {
-        let ptr_size = self.tcx.data_layout.pointer_size.bits() as u32;
+        let ptr_size = self.tcx.data_layout.pointer_size().bits() as u32;
         let t = SpirvType::Integer(ptr_size, false).def(DUMMY_SP, self);
         self.constant_int(t, i.into())
     }
@@ -263,7 +263,7 @@ impl ConstCodegenMethods for CodegenCx<'_> {
                             .try_read_from_const_alloc(alloc, pointee)
                             .unwrap_or_else(|| self.const_data_from_alloc(alloc));
                         let value = self.static_addr_of(init, alloc.inner().align, None);
-                        (value, AddressSpace::DATA)
+                        (value, AddressSpace::ZERO)
                     }
                     GlobalAlloc::Function { instance } => (
                         self.get_fn_addr(instance),
@@ -292,13 +292,41 @@ impl ConstCodegenMethods for CodegenCx<'_> {
                             .try_read_from_const_alloc(alloc, pointee)
                             .unwrap_or_else(|| self.const_data_from_alloc(alloc));
                         let value = self.static_addr_of(init, alloc.inner().align, None);
-                        (value, AddressSpace::DATA)
+                        (value, AddressSpace::ZERO)
                     }
                     GlobalAlloc::Static(def_id) => {
                         assert!(self.tcx.is_static(def_id));
                         assert!(!self.tcx.is_thread_local_static(def_id));
-                        (self.get_static(def_id), AddressSpace::DATA)
+                        (self.get_static(def_id), AddressSpace::ZERO)
                     }
+                    GlobalAlloc::TypeId { .. } => {
+                        return if offset.bytes() == 0 {
+                            self.constant_null(ty)
+                        } else {
+                            let result = self.undef(ty);
+                            self.zombie_no_span(
+                                result.def_cx(self),
+                                "pointer has non-null integer address",
+                            );
+                            result
+                        };
+                    }
+// -----------------------------------------------------------------------------
+// // gcc
+// +                    GlobalAlloc::TypeId { .. } => {
+// +                        let val = self.const_usize(offset.bytes());
+// +                        // This is still a variable of pointer type, even though we only use the provenance
+// +                        // of that pointer in CTFE and Miri. But to make LLVM's type system happy,
+// +                        // we need an int-to-ptr cast here (it doesn't matter at all which provenance that picks).
+// +                        return self.context.new_cast(None, val, ty);
+// +                    }
+// -----------------------------------------------------------------------------
+// // llvm
+// +                        // Drop the provenance, the offset contains the bytes of the hash
+// +                        let llval = self.const_usize(offset.bytes());
+// +                        return unsafe { llvm::LLVMConstIntToPtr(llval, llty) };
+
+// -----------------------------------------------------------------------------
                 };
                 self.const_bitcast(self.const_ptr_byte_offset(base_addr, offset), ty)
             }
@@ -430,7 +458,7 @@ impl<'tcx> CodegenCx<'tcx> {
                                 .fatal(format!("invalid size for float: {other}"));
                         }
                     }),
-                    SpirvType::Pointer { .. } => Primitive::Pointer(AddressSpace::DATA),
+                    SpirvType::Pointer { .. } => Primitive::Pointer(AddressSpace::ZERO),
                     _ => unreachable!(),
                 };
 

crates/rustc_codegen_spirv/src/codegen_cx/type_.rs

@@ -124,7 +124,7 @@ impl<'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'tcx> {
 
 impl<'tcx> CodegenCx<'tcx> {
     pub fn type_usize(&self) -> Word {
-        let ptr_size = self.tcx.data_layout.pointer_size.bits() as u32;
+        let ptr_size = self.tcx.data_layout.pointer_size().bits() as u32;
         SpirvType::Integer(ptr_size, false).def(DUMMY_SP, self)
     }
 }
@@ -146,7 +146,7 @@ impl BaseTypeCodegenMethods for CodegenCx<'_> {
         SpirvType::Integer(128, false).def(DUMMY_SP, self)
     }
     fn type_isize(&self) -> Self::Type {
-        let ptr_size = self.tcx.data_layout.pointer_size.bits() as u32;
+        let ptr_size = self.tcx.data_layout.pointer_size().bits() as u32;
         SpirvType::Integer(ptr_size, false).def(DUMMY_SP, self)
     }
 

crates/rustc_codegen_spirv/src/spirv_type.rs

@@ -294,7 +294,7 @@ impl SpirvType<'_> {
                         .try_into()
                         .unwrap()
             }
-            Self::Pointer { .. } => cx.tcx.data_layout.pointer_size,
+            Self::Pointer { .. } => cx.tcx.data_layout.pointer_size(),
             Self::Image { .. }
             | Self::AccelerationStructureKhr
             | Self::RayQueryKhr
@@ -316,7 +316,7 @@ impl SpirvType<'_> {
             Self::Array { element, .. }
             | Self::RuntimeArray { element }
             | Self::Matrix { element, .. } => cx.lookup_type(element).alignof(cx),
-            Self::Pointer { .. } => cx.tcx.data_layout.pointer_align.abi,
+            Self::Pointer { .. } => cx.tcx.data_layout.pointer_align().abi,
             Self::Image { .. }
             | Self::AccelerationStructureKhr
             | Self::RayQueryKhr

rust-toolchain.toml

@@ -1,7 +1,7 @@
 [toolchain]
-channel = "nightly-2025-07-07"
+channel = "nightly-2025-07-14"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = a84ab0ce6c4557a2f01a3a6c3fdb0f92098db78d
+# commit_hash = e9182f195b8505c87c4bd055b9f6e114ccda0981
 
 # Whenever changing the nightly channel, update the commit hash above, and
 # change `REQUIRED_RUST_TOOLCHAIN` in `crates/rustc_codegen_spirv/build.rs` too.