rustup: update to nightly-2025-03-29 (~1.87).

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-02-16"
+channel = "nightly-2025-03-29"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = 9cd60bd2ccc41bc898d2ad86728f14035d2df72d"#;
+# commit_hash = 920d95eaf23d7eb6b415d09868e4f793024fa604"#;
 
 fn rustc_output(arg: &str) -> Result<String, Box<dyn Error>> {
     let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".into());
@@ -159,9 +159,9 @@ fn generate_pqp_cg_ssa() -> Result<(), Box<dyn Error>> {
                 }
             }
 
-            // HACK(eddyb) remove `windows` dependency (from MSVC linker output
-            // parsing, which `rustc_codegen_spirv` will never invoke anyway).
             if relative_path == Path::new("src/back/link.rs") {
+                // HACK(eddyb) remove `windows` dependency (from MSVC linker output
+                // parsing, which `rustc_codegen_spirv` will never invoke anyway).
                 src = src.replace(
                     "#[cfg(not(windows))]
 fn escape_linker_output(",
@@ -179,6 +179,33 @@ mod win {",
                     "#[cfg(any())]
 mod win {",
                 );
+                // HACK(eddyb) remove `object` dependency (for Windows `raw_dylib`
+                // handling, which `rustc_codegen_spirv` will never invoke anyway).
+                src = src.replace("mod raw_dylib;", "// mod raw_dylib;");
+                src = src.replace(
+                    "
+        for output_path in raw_dylib::",
+                    "
+        #[cfg(any())]
+        for output_path in raw_dylib::",
+                );
+                src = src.replace(
+                    "
+        for link_path in raw_dylib::",
+                    "
+        #[cfg(any())]
+        for link_path in raw_dylib::",
+                );
+            }
+            if relative_path == Path::new("src/back/metadata.rs") {
+                // HACK(eddyb) remove `object` dependency.
+                src = src.replace("
+pub(crate) fn create_object_file(sess: &Session) -> Option<write::Object<'static>> {","
+pub(crate) fn create_object_file(_: &Session) -> Option<write::Object<'static>> {
+    None
+}
+#[cfg(any())]
+pub(crate) fn create_object_file(sess: &Session) -> Option<write::Object<'static>> {");
             }
 
             // HACK(eddyb) "typed alloca" patches.
@@ -259,6 +286,9 @@ mod win {",
             println!("cargo::warning={line}");
         }
         println!("cargo::warning=");
+
+        // HACK(eddyb) allow the warning to be cleared after `lib.rs` is fixed.
+        println!("cargo:rerun-if-changed=src/lib.rs");
     }
 
     // HACK(eddyb) write a file that can be `include!`d from `lib.rs`.

crates/rustc_codegen_spirv/src/abi.rs

@@ -8,8 +8,8 @@ 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,
+    Align, BackendRepr, FieldIdx, FieldsShape, LayoutData, Primitive, ReprFlags, ReprOptions,
+    Scalar, Size, TagEncoding, VariantIdx, Variants,
 };
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::ErrorGuaranteed;
@@ -106,6 +106,7 @@ pub(crate) fn provide(providers: &mut Providers) {
             ref variants,
             backend_repr,
             largest_niche,
+            uninhabited,
             align,
             size,
             max_repr_align,
@@ -153,6 +154,7 @@ pub(crate) fn provide(providers: &mut Providers) {
             },
             backend_repr,
             largest_niche,
+            uninhabited,
             align,
             size,
             max_repr_align,
@@ -201,7 +203,7 @@ pub(crate) fn provide(providers: &mut Providers) {
         let trivial_struct = match tcx.hir_node_by_def_id(def_id) {
             rustc_hir::Node::Item(item) => match item.kind {
                 rustc_hir::ItemKind::Struct(
-                    _,
+                    ..,
                     &rustc_hir::Generics {
                         params:
                             &[]
@@ -465,7 +467,7 @@ impl<'tcx> ConvSpirvType<'tcx> for TyAndLayout<'tcx> {
         // `ScalarPair`.
         // There's a few layers that we go through here. First we inspect layout.backend_repr, then if relevant, layout.fields, etc.
         match self.backend_repr {
-            BackendRepr::Uninhabited => SpirvType::Adt {
+            _ if self.uninhabited => SpirvType::Adt {
                 def_id: def_id_for_spirv_type_adt(*self),
                 size: Some(Size::ZERO),
                 align: Align::from_bytes(0).unwrap(),
@@ -526,7 +528,7 @@ impl<'tcx> ConvSpirvType<'tcx> for TyAndLayout<'tcx> {
                 if let TyKind::Adt(adt, _) = self.ty.kind() {
                     if let Variants::Single { index } = self.variants {
                         for i in self.fields.index_by_increasing_offset() {
-                            let field = &adt.variants()[index].fields[i.into()];
+                            let field = &adt.variants()[index].fields[FieldIdx::new(i)];
                             field_names.push(field.name);
                         }
                     }
@@ -545,7 +547,7 @@ impl<'tcx> ConvSpirvType<'tcx> for TyAndLayout<'tcx> {
                 }
                 .def_with_name(cx, span, TyLayoutNameKey::from(*self))
             }
-            BackendRepr::Vector { element, count } => {
+            BackendRepr::SimdVector { element, count } => {
                 let elem_spirv = trans_scalar(cx, span, *self, element, Size::ZERO);
                 SpirvType::Vector {
                     element: elem_spirv,
@@ -815,7 +817,7 @@ fn trans_struct<'tcx>(cx: &CodegenCx<'tcx>, span: Span, ty: TyAndLayout<'tcx>) -
         field_offsets.push(offset);
         if let Variants::Single { index } = ty.variants {
             if let TyKind::Adt(adt, _) = ty.ty.kind() {
-                let field = &adt.variants()[index].fields[i.into()];
+                let field = &adt.variants()[index].fields[FieldIdx::new(i)];
                 field_names.push(field.name);
             } else {
                 // FIXME(eddyb) this looks like something that should exist in rustc.

crates/rustc_codegen_spirv/src/attr.rs

@@ -253,8 +253,8 @@ fn target_from_impl_item(tcx: TyCtxt<'_>, impl_item: &hir::ImplItem<'_>) -> Targ
     match impl_item.kind {
         hir::ImplItemKind::Const(..) => Target::AssocConst,
         hir::ImplItemKind::Fn(..) => {
-            let parent_owner_id = tcx.hir().get_parent_item(impl_item.hir_id());
-            let containing_item = tcx.hir().expect_item(parent_owner_id.def_id);
+            let parent_owner_id = tcx.hir_get_parent_item(impl_item.hir_id());
+            let containing_item = tcx.hir_expect_item(parent_owner_id.def_id);
             let containing_impl_is_for_trait = match &containing_item.kind {
                 hir::ItemKind::Impl(hir::Impl { of_trait, .. }) => of_trait.is_some(),
                 _ => unreachable!("parent of an ImplItem must be an Impl"),
@@ -280,7 +280,7 @@ impl CheckSpirvAttrVisitor<'_> {
 
         let parse_attrs = |attrs| crate::symbols::parse_attrs_for_checking(&self.sym, attrs);
 
-        let attrs = self.tcx.hir().attrs(hir_id);
+        let attrs = self.tcx.hir_attrs(hir_id);
         for parse_attr_result in parse_attrs(attrs) {
             let (span, parsed_attr) = match parse_attr_result {
                 Ok(span_and_parsed_attr) => span_and_parsed_attr,
@@ -326,10 +326,9 @@ impl CheckSpirvAttrVisitor<'_> {
                 | SpirvAttribute::SpecConstant(_) => match target {
                     Target::Param => {
                         let parent_hir_id = self.tcx.parent_hir_id(hir_id);
-                        let parent_is_entry_point =
-                            parse_attrs(self.tcx.hir().attrs(parent_hir_id))
-                                .filter_map(|r| r.ok())
-                                .any(|(_, attr)| matches!(attr, SpirvAttribute::Entry(_)));
+                        let parent_is_entry_point = parse_attrs(self.tcx.hir_attrs(parent_hir_id))
+                            .filter_map(|r| r.ok())
+                            .any(|(_, attr)| matches!(attr, SpirvAttribute::Entry(_)));
                         if !parent_is_entry_point {
                             self.tcx.dcx().span_err(
                                 span,
@@ -417,8 +416,8 @@ impl CheckSpirvAttrVisitor<'_> {
 impl<'tcx> Visitor<'tcx> for CheckSpirvAttrVisitor<'tcx> {
     type NestedFilter = nested_filter::OnlyBodies;
 
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.tcx.hir()
+    fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
+        self.tcx
     }
 
     fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
@@ -497,8 +496,7 @@ fn check_mod_attrs(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {
         tcx,
         sym: Symbols::get(),
     };
-    tcx.hir()
-        .visit_item_likes_in_module(module_def_id, check_spirv_attr_visitor);
+    tcx.hir_visit_item_likes_in_module(module_def_id, check_spirv_attr_visitor);
     if module_def_id.is_top_level_module() {
         check_spirv_attr_visitor.check_spirv_attributes(CRATE_HIR_ID, Target::Mod);
     }

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -1851,7 +1851,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                 place.val.llval,
                 place.val.align,
             );
-            OperandValue::Immediate(self.to_immediate(llval, place.layout))
+            OperandValue::Immediate(llval)
         } else if let BackendRepr::ScalarPair(a, b) = place.layout.backend_repr {
             let b_offset = a
                 .primitive()

crates/rustc_codegen_spirv/src/builder/intrinsics.rs

@@ -46,16 +46,10 @@ 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),
-            ),
-            64 => (
-                self.constant_u64(self.span(), 1 << 63),
-                self.constant_u64(self.span(), u64::MAX >> 1),
-            ),
-            _ => bug!("copysign must have width 32 or 64, not {}", width),
+        let [mask_sign, mask_value] = {
+            let sign_bit = 1u128.checked_shl(width - 1).unwrap();
+            let value_mask = sign_bit - 1;
+            [sign_bit, value_mask].map(|v| self.constant_int(int_ty, v))
         };
         let val_bits = self.bitcast(val, int_ty);
         let sign_bits = self.bitcast(sign, int_ty);
@@ -154,30 +148,44 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
                 result
             }
 
-            sym::sqrtf32 | sym::sqrtf64 => self.gl_op(GLOp::Sqrt, ret_ty, [args[0].immediate()]),
-            sym::powif32 | sym::powif64 => {
+            sym::sqrtf32 | sym::sqrtf64 | sym::sqrtf128 => {
+                self.gl_op(GLOp::Sqrt, ret_ty, [args[0].immediate()])
+            }
+            sym::powif32 | sym::powif64 | sym::powif128 => {
                 let float = self.sitofp(args[1].immediate(), args[0].immediate().ty);
                 self.gl_op(GLOp::Pow, ret_ty, [args[0].immediate(), float])
             }
-            sym::sinf32 | sym::sinf64 => self.gl_op(GLOp::Sin, ret_ty, [args[0].immediate()]),
-            sym::cosf32 | sym::cosf64 => self.gl_op(GLOp::Cos, ret_ty, [args[0].immediate()]),
-            sym::powf32 | sym::powf64 => self.gl_op(
+            sym::sinf32 | sym::sinf64 | sym::sinf128 => {
+                self.gl_op(GLOp::Sin, ret_ty, [args[0].immediate()])
+            }
+            sym::cosf32 | sym::cosf64 | sym::cosf128 => {
+                self.gl_op(GLOp::Cos, ret_ty, [args[0].immediate()])
+            }
+            sym::powf32 | sym::powf64 | sym::powf128 => self.gl_op(
                 GLOp::Pow,
                 ret_ty,
                 [args[0].immediate(), args[1].immediate()],
             ),
-            sym::expf32 | sym::expf64 => self.gl_op(GLOp::Exp, ret_ty, [args[0].immediate()]),
-            sym::exp2f32 | sym::exp2f64 => self.gl_op(GLOp::Exp2, ret_ty, [args[0].immediate()]),
-            sym::logf32 | sym::logf64 => self.gl_op(GLOp::Log, ret_ty, [args[0].immediate()]),
-            sym::log2f32 | sym::log2f64 => self.gl_op(GLOp::Log2, ret_ty, [args[0].immediate()]),
-            sym::log10f32 | sym::log10f64 => {
+            sym::expf32 | sym::expf64 | sym::expf128 => {
+                self.gl_op(GLOp::Exp, ret_ty, [args[0].immediate()])
+            }
+            sym::exp2f32 | sym::exp2f64 | sym::exp2f128 => {
+                self.gl_op(GLOp::Exp2, ret_ty, [args[0].immediate()])
+            }
+            sym::logf32 | sym::logf64 | sym::logf128 => {
+                self.gl_op(GLOp::Log, ret_ty, [args[0].immediate()])
+            }
+            sym::log2f32 | sym::log2f64 | sym::log2f128 => {
+                self.gl_op(GLOp::Log2, ret_ty, [args[0].immediate()])
+            }
+            sym::log10f32 | sym::log10f64 | sym::log10f128 => {
                 // spir-v glsl doesn't have log10, so,
                 // log10(x) == (1 / ln(10)) * ln(x)
                 let mul = self.constant_float(args[0].immediate().ty, 1.0 / 10.0f64.ln());
                 let ln = self.gl_op(GLOp::Log, ret_ty, [args[0].immediate()]);
                 self.fmul(mul, ln)
             }
-            sym::fmaf32 | sym::fmaf64 => self.gl_op(
+            sym::fmaf32 | sym::fmaf64 | sym::fmaf128 => self.gl_op(
                 GLOp::Fma,
                 ret_ty,
                 [
@@ -186,30 +194,37 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
                     args[2].immediate(),
                 ],
             ),
-            sym::fabsf32 | sym::fabsf64 => self.gl_op(GLOp::FAbs, ret_ty, [args[0].immediate()]),
-            sym::minnumf32 | sym::minnumf64 => self.gl_op(
+            sym::fabsf32 | sym::fabsf64 | sym::fabsf128 => {
+                self.gl_op(GLOp::FAbs, ret_ty, [args[0].immediate()])
+            }
+            sym::minnumf32 | sym::minnumf64 | sym::minnumf128 => self.gl_op(
                 GLOp::FMin,
                 ret_ty,
                 [args[0].immediate(), args[1].immediate()],
             ),
-            sym::maxnumf32 | sym::maxnumf64 => self.gl_op(
+            sym::maxnumf32 | sym::maxnumf64 | sym::maxnumf128 => self.gl_op(
                 GLOp::FMax,
                 ret_ty,
                 [args[0].immediate(), args[1].immediate()],
             ),
-            sym::copysignf32 | sym::copysignf64 => {
+            sym::copysignf32 | sym::copysignf64 | sym::copysignf128 => {
                 let val = args[0].immediate();
                 let sign = args[1].immediate();
                 self.copysign(val, sign)
             }
-            sym::floorf32 | sym::floorf64 => self.gl_op(GLOp::Floor, ret_ty, [args[0].immediate()]),
-            sym::ceilf32 | sym::ceilf64 => self.gl_op(GLOp::Ceil, ret_ty, [args[0].immediate()]),
-            sym::truncf32 | sym::truncf64 => self.gl_op(GLOp::Trunc, ret_ty, [args[0].immediate()]),
-            sym::rintf32 | sym::rintf64 => {
+            sym::floorf32 | sym::floorf64 | sym::floorf128 => {
+                self.gl_op(GLOp::Floor, ret_ty, [args[0].immediate()])
+            }
+            sym::ceilf32 | sym::ceilf64 | sym::ceilf128 => {
+                self.gl_op(GLOp::Ceil, ret_ty, [args[0].immediate()])
+            }
+            sym::truncf32 | sym::truncf64 | sym::truncf128 => {
+                self.gl_op(GLOp::Trunc, ret_ty, [args[0].immediate()])
+            }
+            sym::round_ties_even_f32 | sym::round_ties_even_f64 | sym::round_ties_even_f128 => {
                 self.gl_op(GLOp::RoundEven, ret_ty, [args[0].immediate()])
             }
-            // TODO: Correctness of all these rounds
-            sym::nearbyintf32 | sym::nearbyintf64 | sym::roundf32 | sym::roundf64 => {
+            sym::roundf32 | sym::roundf64 | sym::roundf128 => {
                 self.gl_op(GLOp::Round, ret_ty, [args[0].immediate()])
             }
 

crates/rustc_codegen_spirv/src/builder/mod.rs

@@ -260,7 +260,7 @@ impl<'a, 'tcx> ArgAbiBuilderMethods<'tcx> for Builder<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> AbiBuilderMethods<'tcx> for Builder<'a, 'tcx> {
+impl AbiBuilderMethods for Builder<'_, '_> {
     fn get_param(&mut self, index: usize) -> Self::Value {
         self.function_parameter_values.borrow()[&self.current_fn.def(self)][index]
     }

crates/rustc_codegen_spirv/src/codegen_cx/constant.rs

@@ -109,16 +109,13 @@ impl<'tcx> CodegenCx<'tcx> {
     }
 }
 
-impl<'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'tcx> {
+impl ConstCodegenMethods for CodegenCx<'_> {
     fn const_null(&self, t: Self::Type) -> Self::Value {
         self.constant_null(t)
     }
     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)
@@ -319,7 +316,12 @@ impl<'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'tcx> {
     // the actual value generation until after a pointer to this value is cast
     // to its final type (e.g. that will be loaded as).
     // FIXME(eddyb) replace this with `qptr` handling of constant data.
-    fn const_data_from_alloc(&self, alloc: ConstAllocation<'tcx>) -> Self::Value {
+    fn const_data_from_alloc(&self, alloc: ConstAllocation<'_>) -> Self::Value {
+        // HACK(eddyb) the `ConstCodegenMethods` trait no longer guarantees the
+        // lifetime that `alloc` is interned for, but since it *is* interned,
+        // we can cheaply recover it (see also the `ty::Lift` infrastructure).
+        let alloc = self.tcx.lift(alloc).unwrap();
+
         let void_type = SpirvType::Void.def(DUMMY_SP, self);
         self.def_constant(void_type, SpirvConst::ConstDataFromAlloc(alloc))
     }

crates/rustc_codegen_spirv/src/codegen_cx/entry.rs

@@ -82,7 +82,7 @@ impl<'tcx> CodegenCx<'tcx> {
                     .span_err(span, format!("cannot declare {name} as an entry point"));
                 return;
             };
-            self.tcx.hir().body_owned_by(fn_local_def_id).params
+            self.tcx.hir_body_owned_by(fn_local_def_id).params
         };
         for (arg_abi, hir_param) in fn_abi.args.iter().zip(hir_params) {
             match arg_abi.mode {
@@ -429,7 +429,7 @@ impl<'tcx> CodegenCx<'tcx> {
         call_args: &mut Vec<SpirvValue>,
         decoration_locations: &mut FxHashMap<StorageClass, u32>,
     ) {
-        let attrs = AggregatedSpirvAttributes::parse(self, self.tcx.hir().attrs(hir_param.hir_id));
+        let attrs = AggregatedSpirvAttributes::parse(self, self.tcx.hir_attrs(hir_param.hir_id));
 
         let EntryParamDeducedFromRustRefOrValue {
             value_layout,