Update to nightly-2025-07-14.

- `BuilderMethods::dynamic_alloca` was removed.
- `AddressSpace::DATA` was renamed `AddressSpace::ZERO`.
- `GlobalAlloc` has a new variant `TypeId` which must be handled in
  `scalar_to_backend`; I just copied what the llvm backend does.
- `TargetDataLayout::pointer_{size,align}` were changed from fields to
  methods.
- `TargetDataLayout::parse_from_llvm_datalayout_string` gained a second
  argument.

Author: nnethercote

crates/rustc_codegen_nvvm/src/builder.rs

@@ -483,17 +483,6 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
     }
 
-    fn dynamic_alloca(&mut self, size: &'ll Value, align: Align) -> &'ll Value {
-        trace!("Dynamic Alloca `{:?}`", size);
-        unsafe {
-            let alloca =
-                llvm::LLVMBuildArrayAlloca(self.llbuilder, self.cx().type_i8(), size, UNNAMED);
-            llvm::LLVMSetAlignment(alloca, align.bytes() as c_uint);
-            // Cast to default addrspace if necessary
-            llvm::LLVMBuildPointerCast(self.llbuilder, alloca, self.cx().type_ptr(), UNNAMED)
-        }
-    }
-
     fn load(&mut self, ty: &'ll Type, ptr: &'ll Value, align: Align) -> &'ll Value {
         trace!("Load {ty:?} {:?}", ptr);
         let ptr = self.pointercast(ptr, self.cx.type_ptr_to(ty));
@@ -901,7 +890,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
             if kind == llvm::TypeKind::Pointer {
                 let element = self.element_type(ty);
                 let addrspace = llvm::LLVMGetPointerAddressSpace(ty);
-                let new_ty = self.type_ptr_to_ext(element, AddressSpace::DATA);
+                let new_ty = self.type_ptr_to_ext(element, AddressSpace::ZERO);
                 if addrspace != 0 {
                     trace!("injecting addrspace cast for `{:?}` to `{:?}`", ty, new_ty);
                     val = llvm::LLVMBuildAddrSpaceCast(self.llbuilder, val, new_ty, UNNAMED);

crates/rustc_codegen_nvvm/src/const_ty.rs

@@ -87,7 +87,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                 let sc = self.const_bytes(s.as_bytes());
                 let sym = self.generate_local_symbol_name("str");
                 let g = self
-                    .define_global(&sym[..], self.val_ty(sc), AddressSpace::DATA)
+                    .define_global(&sym[..], self.val_ty(sc), AddressSpace::ZERO)
                     .unwrap_or_else(|| {
                         bug!("symbol `{}` is already defined", sym);
                     });
@@ -185,7 +185,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                                     format!("alloc_{hash:032x}").as_bytes(),
                                 );
                             }
-                            (value, AddressSpace::DATA)
+                            (value, AddressSpace::ZERO)
                         }
                     }
                     GlobalAlloc::Function { instance, .. } => (
@@ -204,7 +204,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                             .unwrap_memory();
                         let init = const_alloc_to_llvm(self, alloc, /*static*/ false);
                         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));
@@ -214,6 +214,11 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                             unsafe { llvm::LLVMGetPointerAddressSpace(self.val_ty(val)) };
                         (val, AddressSpace(addrspace))
                     }
+                    GlobalAlloc::TypeId { .. } => {
+                        // Drop the provenance, the offset contains the bytes of the hash
+                        let llval = self.const_usize(offset.bytes());
+                        return unsafe { llvm::LLVMConstIntToPtr(llval, llty) };
+                    }
                 };
                 let llval = unsafe {
                     llvm::LLVMConstInBoundsGEP2(
@@ -228,7 +233,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                 if !matches!(layout.primitive(), Pointer(_)) {
                     unsafe { llvm::LLVMConstPtrToInt(llval, llty) }
                 } else {
-                    if base_addr_space != AddressSpace::DATA {
+                    if base_addr_space != AddressSpace::ZERO {
                         unsafe {
                             let element = llvm::LLVMGetElementType(llty);
                             llty = self.type_ptr_to_ext(element, base_addr_space);

crates/rustc_codegen_nvvm/src/consts.rs

@@ -60,7 +60,7 @@ pub(crate) fn const_alloc_to_llvm<'ll>(
     }
     let mut llvals = Vec::with_capacity(alloc.provenance().ptrs().len() + 1);
     let dl = cx.data_layout();
-    let pointer_size = dl.pointer_size.bytes() as usize;
+    let pointer_size = dl.pointer_size().bytes() as usize;
 
     // Note: this function may call `inspect_with_uninit_and_ptr_outside_interpreter`,
     // so `range` must be within the bounds of `alloc` and not contain or overlap a relocation.
@@ -253,7 +253,7 @@ impl<'ll> CodegenCx<'ll, '_> {
             // TODO(RDambrosio016): replace this with latest rustc's handling when we use llvm 13
             let name = self.generate_local_symbol_name(kind.unwrap_or("private"));
             let gv = self
-                .define_global(&name[..], self.val_ty(cv), AddressSpace::DATA)
+                .define_global(&name[..], self.val_ty(cv), AddressSpace::ZERO)
                 .unwrap_or_else(|| bug!("symbol `{}` is already defined", name));
             llvm::LLVMRustSetLinkage(gv, llvm::Linkage::PrivateLinkage);
             llvm::LLVMSetInitializer(gv, cv);

crates/rustc_codegen_nvvm/src/context.rs

@@ -161,6 +161,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
             local_gen_sym_counter: Cell::new(0),
             nvptx_data_layout: TargetDataLayout::parse_from_llvm_datalayout_string(
                 &target::target().data_layout,
+                AddressSpace::ZERO,
             )
             .unwrap_or_else(|err| tcx.sess.dcx().emit_fatal(err)),
             nvptx_target: target::target(),
@@ -292,7 +293,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
                 }
             }
         } else {
-            AddressSpace::DATA
+            AddressSpace::ZERO
         }
     }
 

crates/rustc_codegen_nvvm/src/debug_info/metadata.rs

@@ -167,7 +167,7 @@ fn build_pointer_or_reference_di_node<'ll, 'tcx>(
         None => {
             // This is a thin pointer. Create a regular pointer type and give it the correct name.
             assert_eq!(
-                (data_layout.pointer_size, data_layout.pointer_align.abi),
+                (data_layout.pointer_size(), data_layout.pointer_align().abi),
                 cx.size_and_align_of(ptr_type),
                 "ptr_type={ptr_type}, pointee_type={pointee_type}",
             );
@@ -176,8 +176,8 @@ fn build_pointer_or_reference_di_node<'ll, 'tcx>(
                 llvm::LLVMRustDIBuilderCreatePointerType(
                     DIB(cx),
                     pointee_type_di_node,
-                    data_layout.pointer_size.bits(),
-                    data_layout.pointer_align.abi.bits() as u32,
+                    data_layout.pointer_size().bits(),
+                    data_layout.pointer_align().abi.bits() as u32,
                     CString::new(ptr_type_debuginfo_name).unwrap().as_ptr(),
                 )
             };
@@ -335,8 +335,8 @@ fn build_subroutine_type_di_node<'ll, 'tcx>(
     let (size, align) = match fn_ty.kind() {
         ty::FnDef(..) => (0, 1),
         ty::FnPtr(..) => (
-            cx.tcx.data_layout.pointer_size.bits(),
-            cx.tcx.data_layout.pointer_align.abi.bits() as u32,
+            cx.tcx.data_layout.pointer_size().bits(),
+            cx.tcx.data_layout.pointer_align().abi.bits() as u32,
         ),
         _ => unreachable!(),
     };
@@ -527,7 +527,7 @@ fn recursion_marker_type_di_node<'ll>(cx: &CodegenCx<'ll, '_>) -> &'ll DIType {
                     DIB(cx),
                     name.as_c_char_ptr(),
                     name.len(),
-                    cx.tcx.data_layout.pointer_size.bits(),
+                    cx.tcx.data_layout.pointer_size().bits(),
                     dwarf_const::DW_ATE_unsigned,
                 )
             }

crates/rustc_codegen_nvvm/src/intrinsic.rs

@@ -528,7 +528,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                         // For rusty ABIs, small aggregates are actually passed
                         // as `RegKind::Integer` (see `FnAbi::adjust_for_abi`),
                         // so we re-use that same threshold here.
-                        layout.size <= self.data_layout().pointer_size * 2
+                        layout.size <= self.data_layout().pointer_size() * 2
                     }
                 };
 

crates/rustc_codegen_nvvm/src/ty.rs

@@ -57,7 +57,7 @@ impl<'ll> CodegenCx<'ll, '_> {
     pub(crate) fn voidp(&self) -> &'ll Type {
         // llvm uses i8* for void ptrs, void* is invalid
         let i8_ty = self.type_i8();
-        self.type_ptr_to_ext(i8_ty, AddressSpace::DATA)
+        self.type_ptr_to_ext(i8_ty, AddressSpace::ZERO)
     }
 
     pub(crate) fn type_named_struct(&self, name: &str) -> &'ll Type {
@@ -93,7 +93,7 @@ impl<'ll> CodegenCx<'ll, '_> {
     }
 
     pub(crate) fn type_i8p(&self) -> &'ll Type {
-        self.type_i8p_ext(AddressSpace::DATA)
+        self.type_i8p_ext(AddressSpace::ZERO)
     }
 
     pub(crate) fn type_i8p_ext(&self, address_space: AddressSpace) -> &'ll Type {
@@ -116,7 +116,7 @@ impl<'ll> CodegenCx<'ll, '_> {
             "don't call ptr_to on function types, use ptr_to_llvm_type on FnAbi instead or explicitly specify an address space if it makes sense"
         );
 
-        unsafe { llvm::LLVMPointerType(ty, AddressSpace::DATA.0) }
+        unsafe { llvm::LLVMPointerType(ty, AddressSpace::ZERO.0) }
     }
 
     pub(crate) fn type_ptr_to_ext(&self, ty: &'ll Type, address_space: AddressSpace) -> &'ll Type {
@@ -211,7 +211,7 @@ impl<'ll, 'tcx> BaseTypeCodegenMethods for CodegenCx<'ll, 'tcx> {
     }
 
     fn type_ptr(&self) -> Self::Type {
-        self.type_ptr_ext(AddressSpace::DATA)
+        self.type_ptr_ext(AddressSpace::ZERO)
     }
 
     fn type_ptr_ext(&self, address_space: AddressSpace) -> Self::Type {
@@ -434,7 +434,7 @@ impl<'tcx> LayoutLlvmExt<'tcx> for TyAndLayout<'tcx> {
                 {
                     (cx.type_pointee_for_align(align), address_space)
                 } else {
-                    (cx.type_i8(), AddressSpace::DATA)
+                    (cx.type_i8(), AddressSpace::ZERO)
                 };
                 cx.type_ptr_to_ext(pointee, address_space)
             }

rust-toolchain.toml

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2025-07-07"
+channel = "nightly-2025-07-14"
 components = ["clippy", "llvm-tools-preview", "rust-src", "rustc-dev", "rustfmt", "rust-analyzer"]