rustup: update to nightly-2025-02-16 (~1.86).

Author: eddyb

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-01-03"
+channel = "nightly-2025-02-16"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = 4363f9b6f6d3656d94adbcabba6348a485ef9a56"#;
+# commit_hash = 9cd60bd2ccc41bc898d2ad86728f14035d2df72d"#;
 
 fn rustc_output(arg: &str) -> Result<String, Box<dyn Error>> {
     let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".into());
@@ -276,6 +276,9 @@ mod maybe_pqp_cg_ssa;
 
     println!("cargo::rustc-check-cfg=cfg(rustc_codegen_spirv_disable_pqp_cg_ssa)");
 
+    // HACK(eddyb) `if cfg!(llvm_enzyme)` added upstream for autodiff support.
+    println!("cargo::rustc-check-cfg=cfg(llvm_enzyme)");
+
     Ok(())
 }
 

crates/rustc_codegen_spirv/src/abi.rs

@@ -6,6 +6,11 @@ use crate::codegen_cx::CodegenCx;
 use crate::spirv_type::SpirvType;
 use itertools::Itertools;
 use rspirv::spirv::{Dim, ImageFormat, StorageClass, Word};
+use rustc_abi::ExternAbi as Abi;
+use rustc_abi::{
+    Align, BackendRepr, FieldsShape, LayoutData, Primitive, ReprFlags, ReprOptions, Scalar, Size,
+    TagEncoding, VariantIdx, Variants,
+};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::ErrorGuaranteed;
 use rustc_index::Idx;
@@ -20,12 +25,7 @@ use rustc_middle::{bug, span_bug};
 use rustc_span::DUMMY_SP;
 use rustc_span::def_id::DefId;
 use rustc_span::{Span, Symbol};
-use rustc_target::abi::call::{ArgAbi, ArgAttributes, FnAbi, PassMode};
-use rustc_target::abi::{
-    Align, BackendRepr, FieldsShape, LayoutData, Primitive, ReprFlags, ReprOptions, Scalar, Size,
-    TagEncoding, VariantIdx, Variants,
-};
-use rustc_target::spec::abi::Abi;
+use rustc_target::callconv::{ArgAbi, ArgAttributes, FnAbi, PassMode};
 use std::cell::RefCell;
 use std::collections::hash_map::Entry;
 use std::fmt;
@@ -110,6 +110,7 @@ pub(crate) fn provide(providers: &mut Providers) {
             size,
             max_repr_align,
             unadjusted_abi_align,
+            randomization_seed,
         } = *layout;
         LayoutData {
             fields: match *fields {
@@ -156,6 +157,7 @@ pub(crate) fn provide(providers: &mut Providers) {
             size,
             max_repr_align,
             unadjusted_abi_align,
+            randomization_seed,
         }
     }
 
@@ -986,9 +988,10 @@ fn trans_intrinsic_type<'tcx>(
                 cx: &CodegenCx<'tcx>,
                 const_: Const<'tcx>,
             ) -> Result<P, ErrorGuaranteed> {
-                let (const_val, const_ty) = const_
-                    .try_to_valtree()
-                    .expect("expected monomorphic const in codegen");
+                let ty::Value {
+                    ty: const_ty,
+                    valtree: const_val,
+                } = const_.to_value();
                 assert!(const_ty.is_integral());
                 const_val
                     .try_to_scalar_int()

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -10,6 +10,7 @@ use crate::spirv_type::SpirvType;
 use itertools::Itertools;
 use rspirv::dr::{InsertPoint, Instruction, Operand};
 use rspirv::spirv::{Capability, MemoryModel, MemorySemantics, Op, Scope, StorageClass, Word};
+use rustc_abi::{Align, BackendRepr, Scalar, Size, WrappingRange};
 use rustc_apfloat::{Float, Round, Status, ieee};
 use rustc_codegen_ssa::MemFlags;
 use rustc_codegen_ssa::common::{
@@ -27,8 +28,7 @@ use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::Span;
-use rustc_target::abi::call::FnAbi;
-use rustc_target::abi::{Align, BackendRepr, Scalar, Size, WrappingRange};
+use rustc_target::callconv::FnAbi;
 use smallvec::SmallVec;
 use std::borrow::Cow;
 use std::cell::Cell;
@@ -1915,6 +1915,11 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         }
     }
 
+    // FIXME(eddyb) `assume` is not implemented atm, so all of its forms should
+    // avoid computing its (potentially illegal) bool input in the first place.
+    fn assume_integer_range(&mut self, _imm: Self::Value, _ty: Self::Type, _range: WrappingRange) {}
+    fn assume_nonnull(&mut self, _val: Self::Value) {}
+
     fn range_metadata(&mut self, _load: Self::Value, _range: WrappingRange) {
         // ignore
     }
@@ -2420,9 +2425,19 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         }
     }
 
-    fn icmp(&mut self, op: IntPredicate, lhs: Self::Value, rhs: Self::Value) -> Self::Value {
+    fn icmp(&mut self, op: IntPredicate, lhs: Self::Value, mut rhs: Self::Value) -> Self::Value {
         // Note: the signedness of the opcode doesn't have to match the signedness of the operands.
         use IntPredicate::*;
+
+        if lhs.ty != rhs.ty
+            && [lhs, rhs].map(|v| matches!(self.lookup_type(v.ty), SpirvType::Pointer { .. }))
+                == [true, true]
+        {
+            // HACK(eddyb) temporary workaround for untyped pointers upstream.
+            // FIXME(eddyb) replace with untyped memory SPIR-V + `qptr` or similar.
+            rhs = self.pointercast(rhs, lhs.ty);
+        }
+
         assert_ty_eq!(self, lhs.ty, rhs.ty);
         let b = SpirvType::Bool.def(self.span(), self);
         match self.lookup_type(lhs.ty) {
@@ -3635,9 +3650,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                                 .map(|s| Cow::Owned(s.replace('%', "%%")))
                                 .interleave(ref_arg_ids_with_ty_and_spec.iter().map(
                                     |&(ref_id, ty, spec)| {
-                                        use rustc_target::abi::{
-                                            Float::*, Integer::*, Primitive::*,
-                                        };
+                                        use rustc_abi::{Float::*, Integer::*, Primitive::*};
 
                                         let layout = self.layout_of(ty);
 

crates/rustc_codegen_spirv/src/builder/byte_addressable_buffer.rs

@@ -5,12 +5,12 @@ use super::Builder;
 use crate::builder_spirv::{SpirvValue, SpirvValueExt, SpirvValueKind};
 use crate::spirv_type::SpirvType;
 use rspirv::spirv::{Decoration, Word};
+use rustc_abi::{Align, Size};
 use rustc_codegen_spirv_types::Capability;
 use rustc_codegen_ssa::traits::BuilderMethods;
 use rustc_errors::ErrorGuaranteed;
 use rustc_span::DUMMY_SP;
-use rustc_target::abi::call::PassMode;
-use rustc_target::abi::{Align, Size};
+use rustc_target::callconv::PassMode;
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     fn load_err(&mut self, original_type: Word, invalid_type: Word) -> SpirvValue {

crates/rustc_codegen_spirv/src/builder/intrinsics.rs

@@ -17,7 +17,7 @@ use rustc_middle::ty::{FnDef, Instance, Ty, TyKind, TypingEnv};
 use rustc_middle::{bug, ty};
 use rustc_span::Span;
 use rustc_span::sym;
-use rustc_target::abi::call::{FnAbi, PassMode};
+use rustc_target::callconv::{FnAbi, PassMode};
 use std::assert_matches::assert_matches;
 
 fn int_type_width_signed(ty: Ty<'_>, cx: &CodegenCx<'_>) -> Option<(u64, bool)> {
@@ -336,9 +336,9 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
         self.abort_with_kind_and_message_debug_printf("abort", "intrinsics::abort() called", []);
     }
 
-    fn assume(&mut self, _val: Self::Value) {
-        // TODO: llvm.assume
-    }
+    // FIXME(eddyb) `assume` is not implemented atm, so all of its forms should
+    // avoid computing its (potentially illegal) bool input in the first place.
+    fn assume(&mut self, _val: Self::Value) {}
 
     fn expect(&mut self, cond: Self::Value, _expected: bool) -> Self::Value {
         // TODO: llvm.expect

crates/rustc_codegen_spirv/src/builder/mod.rs

@@ -17,6 +17,7 @@ use crate::builder_spirv::{BuilderCursor, SpirvValue, SpirvValueExt};
 use crate::codegen_cx::CodegenCx;
 use crate::spirv_type::SpirvType;
 use rspirv::spirv::Word;
+use rustc_abi::{HasDataLayout, Size, TargetDataLayout};
 use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::{
@@ -34,8 +35,7 @@ use rustc_middle::ty::layout::{
 use rustc_middle::ty::{Instance, Ty, TyCtxt, TypingEnv};
 use rustc_span::Span;
 use rustc_span::def_id::DefId;
-use rustc_target::abi::call::{ArgAbi, FnAbi, PassMode};
-use rustc_target::abi::{HasDataLayout, Size, TargetDataLayout};
+use rustc_target::callconv::{ArgAbi, FnAbi, PassMode};
 use rustc_target::spec::{HasTargetSpec, Target};
 use std::ops::{Deref, Range};
 

crates/rustc_codegen_spirv/src/builder_spirv.rs

@@ -12,23 +12,23 @@ use rspirv::spirv::{
     AddressingModel, Capability, MemoryModel, Op, SourceLanguage, StorageClass, Word,
 };
 use rspirv::{binary::Assemble, binary::Disassemble};
+use rustc_abi::Size;
 use rustc_arena::DroplessArena;
 use rustc_codegen_ssa::traits::ConstCodegenMethods as _;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_data_structures::sync::Lrc;
 use rustc_middle::bug;
 use rustc_middle::mir::interpret::ConstAllocation;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::Symbol;
 use rustc_span::{DUMMY_SP, FileName, FileNameDisplayPreference, SourceFile, Span};
-use rustc_target::abi::Size;
 use std::assert_matches::assert_matches;
 use std::cell::{RefCell, RefMut};
 use std::hash::{Hash, Hasher};
 use std::iter;
 use std::ops::Range;
 use std::str;
+use std::sync::Arc;
 use std::{fs::File, io::Write, path::Path};
 
 #[derive(Copy, Clone, Debug, Ord, PartialOrd, Eq, PartialEq, Hash)]
@@ -346,16 +346,16 @@ struct WithConstLegality<V> {
 /// equivalent to a whole `rustc` `SourceFile`, but has O(1) `Eq` and `Hash`
 /// implementations (i.e. not involving the path or the contents of the file).
 ///
-/// This is possible because we can compare `Lrc<SourceFile>`s by equality, as
+/// This is possible because we can compare `Arc<SourceFile>`s by equality, as
 /// `rustc`'s `SourceMap` already ensures that only one `SourceFile` will be
 /// allocated for some given file. For hashing, we could hash the address, or
 ///
-struct DebugFileKey(Lrc<SourceFile>);
+struct DebugFileKey(Arc<SourceFile>);
 
 impl PartialEq for DebugFileKey {
     fn eq(&self, other: &Self) -> bool {
         let (Self(self_sf), Self(other_sf)) = (self, other);
-        Lrc::ptr_eq(self_sf, other_sf)
+        Arc::ptr_eq(self_sf, other_sf)
     }
 }
 impl Eq for DebugFileKey {}
@@ -829,7 +829,7 @@ impl<'tcx> BuilderSpirv<'tcx> {
         (self.def_debug_file(lo_loc.file), lo_line_col..hi_line_col)
     }
 
-    fn def_debug_file(&self, sf: Lrc<SourceFile>) -> DebugFileSpirv<'tcx> {
+    fn def_debug_file(&self, sf: Arc<SourceFile>) -> DebugFileSpirv<'tcx> {
         *self
             .debug_file_cache
             .borrow_mut()
@@ -839,7 +839,7 @@ impl<'tcx> BuilderSpirv<'tcx> {
 
                 // FIXME(eddyb) it would be nicer if we could just rely on
                 // `RealFileName::to_string_lossy` returning `Cow<'_, str>`,
-                // but sadly that `'_` is the lifetime of the temporary `Lrc`,
+                // but sadly that `'_` is the lifetime of the temporary `Arc`,
                 // not `'tcx`, so we have to arena-allocate to get `&'tcx str`.
                 let file_name = match &sf.name {
                     FileName::Real(name) => {

crates/rustc_codegen_spirv/src/codegen_cx/constant.rs

@@ -6,12 +6,12 @@ use crate::abi::ConvSpirvType;
 use crate::builder_spirv::{SpirvConst, SpirvValue, SpirvValueExt, SpirvValueKind};
 use crate::spirv_type::SpirvType;
 use rspirv::spirv::Word;
+use rustc_abi::{self as abi, AddressSpace, Float, HasDataLayout, Integer, Primitive, Size};
 use rustc_codegen_ssa::traits::{ConstCodegenMethods, MiscCodegenMethods, StaticCodegenMethods};
 use rustc_middle::bug;
 use rustc_middle::mir::interpret::{ConstAllocation, GlobalAlloc, Scalar, alloc_range};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_span::{DUMMY_SP, Span};
-use rustc_target::abi::{self, AddressSpace, Float, HasDataLayout, Integer, Primitive, Size};
 
 impl<'tcx> CodegenCx<'tcx> {
     pub fn def_constant(&self, ty: Word, val: SpirvConst<'_, 'tcx>) -> SpirvValue {
@@ -116,6 +116,9 @@ impl<'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'tcx> {
     fn const_undef(&self, ty: Self::Type) -> Self::Value {
         self.undef(ty)
     }
+    fn is_undef(&self, v: Self::Value) -> bool {
+        matches!(self.builder.lookup_const(v), Some(SpirvConst::Undef))
+    }
     fn const_poison(&self, ty: Self::Type) -> Self::Value {
         // No distinction between undef and poison.
         self.const_undef(ty)
@@ -266,7 +269,12 @@ impl<'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'tcx> {
                     GlobalAlloc::VTable(vty, dyn_ty) => {
                         let alloc = self
                             .tcx
-                            .global_alloc(self.tcx.vtable_allocation((vty, dyn_ty.principal())))
+                            .global_alloc(self.tcx.vtable_allocation((
+                                vty,
+                                dyn_ty.principal().map(|principal| {
+                                    self.tcx.instantiate_bound_regions_with_erased(principal)
+                                }),
+                            )))
                             .unwrap_memory();
                         let pointee = match self.lookup_type(ty) {
                             SpirvType::Pointer { pointee } => pointee,

crates/rustc_codegen_spirv/src/codegen_cx/declare.rs

@@ -9,6 +9,7 @@ use crate::custom_decorations::{CustomDecoration, SrcLocDecoration};
 use crate::spirv_type::SpirvType;
 use itertools::Itertools;
 use rspirv::spirv::{FunctionControl, LinkageType, StorageClass, Word};
+use rustc_abi::Align;
 use rustc_attr_parsing::InlineAttr;
 use rustc_codegen_ssa::traits::{PreDefineCodegenMethods, StaticCodegenMethods};
 use rustc_hir::def::DefKind;
@@ -19,13 +20,14 @@ use rustc_middle::ty::layout::{FnAbiOf, LayoutOf};
 use rustc_middle::ty::{self, Instance, TypeVisitableExt, TypingEnv};
 use rustc_span::Span;
 use rustc_span::def_id::DefId;
-use rustc_target::abi::Align;
 
 fn attrs_to_spirv(attrs: &CodegenFnAttrs) -> FunctionControl {
     let mut control = FunctionControl::NONE;
     match attrs.inline {
         InlineAttr::None => (),
-        InlineAttr::Hint | InlineAttr::Always => control.insert(FunctionControl::INLINE),
+        InlineAttr::Hint | InlineAttr::Always | InlineAttr::Force { .. } => {
+            control.insert(FunctionControl::INLINE)
+        }
         InlineAttr::Never => control.insert(FunctionControl::DONT_INLINE),
     }
     if attrs.flags.contains(CodegenFnAttrFlags::FFI_PURE) {

crates/rustc_codegen_spirv/src/codegen_cx/entry.rs

@@ -19,7 +19,7 @@ use rustc_middle::span_bug;
 use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
 use rustc_middle::ty::{self, Instance, Ty};
 use rustc_span::Span;
-use rustc_target::abi::call::{ArgAbi, FnAbi, PassMode};
+use rustc_target::callconv::{ArgAbi, FnAbi, PassMode};
 use std::assert_matches::assert_matches;
 
 /// Various information about an entry-point parameter, which can only be deduced