rustup: update to nightly-2025-06-23 (~1.89).

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-05-09"
+channel = "nightly-2025-06-23"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = 50aa04180709189a03dde5fd1c05751b2625ed37"#;
+# commit_hash = be19eda0dc4c22c5cf5f1b48fd163acf9bd4b0a6"#;
 
 fn rustc_output(arg: &str) -> Result<String, Box<dyn Error>> {
     let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".into());
@@ -209,6 +209,13 @@ pub(crate) fn create_object_file(_: &Session) -> Option<write::Object<'static>>
 #[cfg(any())]
 pub(crate) fn create_object_file(sess: &Session) -> Option<write::Object<'static>> {",
                 );
+                src = src.replace(
+                    "
+pub(super) fn elf_e_flags(architecture: Architecture, sess: &Session) -> u32 {",
+                    "
+#[cfg(any())]
+pub(super) fn elf_e_flags(architecture: Architecture, sess: &Session) -> u32 {",
+                );
             }
 
             // HACK(eddyb) "typed alloca" patches.
@@ -320,9 +327,6 @@ mod maybe_pqp_cg_ssa;
     // HACK(eddyb) `if cfg!(llvm_enzyme)` added upstream for autodiff support.
     println!("cargo::rustc-check-cfg=cfg(llvm_enzyme)");
 
-    // HACK(eddyb) `cfg_attr(bootstrap, ...` used upstream temporarily.
-    println!("cargo::rustc-check-cfg=cfg(bootstrap)");
-
     Ok(())
 }
 

crates/rustc_codegen_spirv/src/abi.rs

@@ -290,7 +290,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:
                             &[]
@@ -309,6 +309,7 @@ pub(crate) fn provide(providers: &mut Providers) {
                         where_clause_span: _,
                         span: _,
                     },
+                    _,
                 ) => Some(tcx.adt_def(def_id)),
                 _ => None,
             },
@@ -792,10 +793,11 @@ fn dig_scalar_pointee<'tcx>(
 // the type is really more "Layout with Ty" (`.ty` field + `Deref`s to `Layout`).
 fn trans_aggregate<'tcx>(cx: &CodegenCx<'tcx>, span: Span, ty: TyAndLayout<'tcx>) -> Word {
     fn create_zst<'tcx>(cx: &CodegenCx<'tcx>, span: Span, ty: TyAndLayout<'tcx>) -> Word {
+        assert_eq!(ty.size, Size::ZERO);
         SpirvType::Adt {
             def_id: def_id_for_spirv_type_adt(ty),
             size: Some(Size::ZERO),
-            align: Align::from_bytes(0).unwrap(),
+            align: ty.align.abi,
             field_types: &[],
             field_offsets: &[],
             field_names: None,
@@ -817,14 +819,18 @@ fn trans_aggregate<'tcx>(cx: &CodegenCx<'tcx>, span: Span, ty: TyAndLayout<'tcx>
             // NOTE(eddyb) even if long-term this may become a byte array, that
             // only works for "data types" and not "opaque handles" (images etc.).
             let largest_case = (0..ty.fields.count())
-                .map(|i| ty.field(cx, i))
-                .max_by_key(|case| case.size);
+                .map(|i| (FieldIdx::from_usize(i), ty.field(cx, i)))
+                .max_by_key(|(_, case)| case.size);
 
-            if let Some(case) = largest_case {
-                assert_eq!(ty.size, case.size);
-                case.spirv_type(span, cx)
+            if let Some((case_idx, case)) = largest_case {
+                if ty.align != case.align {
+                    // HACK(eddyb) mismatched alignment requires a wrapper `struct`.
+                    trans_struct_or_union(cx, span, ty, Some(case_idx))
+                } else {
+                    assert_eq!(ty.size, case.size);
+                    case.spirv_type(span, cx)
+                }
             } else {
-                assert_eq!(ty.size, Size::ZERO);
                 create_zst(cx, span, ty)
             }
         }
@@ -859,10 +865,19 @@ fn trans_aggregate<'tcx>(cx: &CodegenCx<'tcx>, span: Span, ty: TyAndLayout<'tcx>
         FieldsShape::Arbitrary {
             offsets: _,
             memory_index: _,
-        } => trans_struct(cx, span, ty),
+        } => trans_struct_or_union(cx, span, ty, None),
     }
 }
 
+#[cfg_attr(
+    not(rustc_codegen_spirv_disable_pqp_cg_ssa),
+    expect(
+        unused,
+        reason = "actually used from \
+            `<rustc_codegen_ssa::traits::ConstCodegenMethods for CodegenCx<'_>>::const_struct`, \
+            but `rustc_codegen_ssa` being `pqp_cg_ssa` makes that trait unexported"
+    )
+)]
 // returns (field_offsets, size, align)
 pub fn auto_struct_layout(
     cx: &CodegenCx<'_>,
@@ -890,14 +905,25 @@ pub fn auto_struct_layout(
 }
 
 // see struct_llfields in librustc_codegen_llvm for implementation hints
-fn trans_struct<'tcx>(cx: &CodegenCx<'tcx>, span: Span, ty: TyAndLayout<'tcx>) -> Word {
+fn trans_struct_or_union<'tcx>(
+    cx: &CodegenCx<'tcx>,
+    span: Span,
+    ty: TyAndLayout<'tcx>,
+    union_case: Option<FieldIdx>,
+) -> Word {
     let size = if ty.is_unsized() { None } else { Some(ty.size) };
     let align = ty.align.abi;
     // FIXME(eddyb) use `AccumulateVec`s just like `rustc` itself does.
     let mut field_types = Vec::new();
     let mut field_offsets = Vec::new();
     let mut field_names = Vec::new();
     for i in ty.fields.index_by_increasing_offset() {
+        if let Some(expected_field_idx) = union_case {
+            if i != expected_field_idx.as_usize() {
+                continue;
+            }
+        }
+
         let field_ty = ty.field(cx, i);
         field_types.push(field_ty.spirv_type(span, cx));
         let offset = ty.fields.offset(i);

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -14,7 +14,7 @@ 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::{
-    AtomicOrdering, AtomicRmwBinOp, IntPredicate, RealPredicate, SynchronizationScope, TypeKind,
+    AtomicRmwBinOp, IntPredicate, RealPredicate, SynchronizationScope, TypeKind,
 };
 use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
 use rustc_codegen_ssa::mir::place::PlaceRef;
@@ -26,7 +26,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_middle::bug;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
 use rustc_middle::ty::layout::LayoutOf;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, AtomicOrdering, Ty};
 use rustc_span::Span;
 use rustc_target::callconv::FnAbi;
 use smallvec::SmallVec;
@@ -157,17 +157,15 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     fn ordering_to_semantics_def(&self, ordering: AtomicOrdering) -> SpirvValue {
         let mut invalid_seq_cst = false;
         let semantics = match ordering {
-            AtomicOrdering::Unordered | AtomicOrdering::Relaxed => MemorySemantics::NONE,
-            // Note: rustc currently has AtomicOrdering::Consume commented out, if it ever becomes
-            // uncommented, it should be MakeVisible | Acquire.
+            AtomicOrdering::Relaxed => MemorySemantics::NONE,
             AtomicOrdering::Acquire => MemorySemantics::MAKE_VISIBLE | MemorySemantics::ACQUIRE,
             AtomicOrdering::Release => MemorySemantics::MAKE_AVAILABLE | MemorySemantics::RELEASE,
-            AtomicOrdering::AcquireRelease => {
+            AtomicOrdering::AcqRel => {
                 MemorySemantics::MAKE_AVAILABLE
                     | MemorySemantics::MAKE_VISIBLE
                     | MemorySemantics::ACQUIRE_RELEASE
             }
-            AtomicOrdering::SequentiallyConsistent => {
+            AtomicOrdering::SeqCst => {
                 let emit = self.emit();
                 let memory_model = emit.module_ref().memory_model.as_ref().unwrap();
                 if memory_model.operands[1].unwrap_memory_model() == MemoryModel::Vulkan {
@@ -182,8 +180,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         if invalid_seq_cst {
             self.zombie(
                 semantics.def(self),
-                "cannot use AtomicOrdering=SequentiallyConsistent on Vulkan memory model \
-                 (check if AcquireRelease fits your needs)",
+                "cannot use `AtomicOrdering::SeqCst` on Vulkan memory model \
+                 (check if `AcqRel` fits your needs)",
             );
         }
         semantics
@@ -3127,6 +3125,14 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                     String::from_utf8(piece_str_bytes).ok()
                 };
 
+                // HACK(eddyb) `panic_explicit` doesn't take any regular arguments,
+                // only an (implicit) `&'static panic::Location<'static>`.
+                if args.len() == 1 {
+                    decoded_format_args.const_pieces =
+                        Some(["explicit panic".into()].into_iter().collect());
+                    return Ok(decoded_format_args);
+                }
+
                 // HACK(eddyb) some entry-points only take a `&str`, not `fmt::Arguments`.
                 if let [
                     SpirvValue {
@@ -3359,17 +3365,14 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                                         }
                                     };
 
-                                    let prepare_args_insts = try_rev_take(3).ok_or_else(|| {
+                                    let prepare_args_insts = try_rev_take(2).ok_or_else(|| {
                                         FormatArgsNotRecognized(
                                             "fmt::Arguments::new_v1_formatted call: ran out of instructions".into(),
                                         )
                                     })?;
                                     let (rt_args_slice_ptr_id, _fmt_placeholders_slice_ptr_id) =
                                         match prepare_args_insts[..] {
                                             [
-                                                // HACK(eddyb) `rt::UnsafeArg::new()` call
-                                                // (`unsafe` ZST "constructor").
-                                                Inst::Call(_, _, ref rt_unsafe_arg_call_args),
                                                 Inst::Bitcast(
                                                     rt_args_cast_out_id,
                                                     rt_args_cast_in_id,
@@ -3378,8 +3381,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                                                     placeholders_cast_out_id,
                                                     placeholders_cast_in_id,
                                                 ),
-                                            ] if rt_unsafe_arg_call_args.is_empty()
-                                                && rt_args_cast_out_id == rt_args_slice_ptr_id
+                                            ] if rt_args_cast_out_id == rt_args_slice_ptr_id
                                                 && placeholders_cast_out_id
                                                     == fmt_placeholders_slice_ptr_id =>
                                             {

crates/rustc_codegen_spirv/src/builder/intrinsics.rs

@@ -17,8 +17,6 @@ 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::callconv::{FnAbi, PassMode};
-use std::assert_matches::assert_matches;
 
 fn int_type_width_signed(ty: Ty<'_>, cx: &CodegenCx<'_>) -> Option<(u64, bool)> {
     match ty.kind() {
@@ -64,9 +62,8 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
     fn codegen_intrinsic_call(
         &mut self,
         instance: Instance<'tcx>,
-        fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
         args: &[OperandRef<'tcx, Self::Value>],
-        llresult: Self::Value,
+        result: PlaceRef<'tcx, Self::Value>,
         _span: Span,
     ) -> Result<(), ty::Instance<'tcx>> {
         let callee_ty = instance.ty(self.tcx, TypingEnv::fully_monomorphized());
@@ -84,7 +81,6 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
         let name = self.tcx.item_name(def_id);
 
         let ret_ty = self.layout_of(sig.output()).spirv_type(self.span(), self);
-        let result = PlaceRef::new_sized(llresult, fn_abi.ret.layout);
 
         let value = match name {
             sym::likely | sym::unlikely => {
@@ -94,7 +90,7 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
 
             sym::breakpoint => {
                 self.abort();
-                assert!(fn_abi.ret.is_ignore());
+                assert!(result.layout.ty.is_unit());
                 return Ok(());
             }
 
@@ -113,7 +109,7 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
             | sym::prefetch_read_instruction
             | sym::prefetch_write_instruction => {
                 // ignore
-                assert!(fn_abi.ret.is_ignore());
+                assert!(result.layout.ty.is_unit());
                 return Ok(());
             }
 
@@ -338,8 +334,14 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
             }
         };
 
-        if !fn_abi.ret.is_ignore() {
-            assert_matches!(fn_abi.ret.mode, PassMode::Direct(_) | PassMode::Pair(..));
+        if result.layout.ty.is_bool() {
+            let val = self.from_immediate(value);
+            self.store_to_place(val, result.val);
+        } else if !result.layout.ty.is_unit() {
+            // FIXME(eddyb) upstream uses `self.store_to_place(value, result.val);`,
+            // which AFAICT does not handle packed pairs explicitly, meaning it
+            // can/will store e.g. LLVM `{A, B}` values, which is legal (in LLVM),
+            // but seems suboptimal (or even risky with e.g. layout randomization).
             OperandRef::from_immediate_or_packed_pair(self, value, result.layout)
                 .val
                 .store(self, result);
@@ -360,10 +362,6 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
         cond
     }
 
-    fn type_test(&mut self, _pointer: Self::Value, _typeid: Self::Metadata) -> Self::Value {
-        todo!()
-    }
-
     fn type_checked_load(
         &mut self,
         _llvtable: Self::Value,

crates/rustc_codegen_spirv/src/builder/mod.rs

@@ -12,7 +12,6 @@ pub use spirv_asm::InstructionTable;
 // HACK(eddyb) avoids rewriting all of the imports (see `lib.rs` and `build.rs`).
 use crate::maybe_pqp_cg_ssa as rustc_codegen_ssa;
 
-use crate::abi::ConvSpirvType;
 use crate::builder_spirv::{BuilderCursor, SpirvValue, SpirvValueExt};
 use crate::codegen_cx::CodegenCx;
 use crate::spirv_type::SpirvType;
@@ -193,10 +192,6 @@ impl<'a, 'tcx> DebugInfoBuilderMethods for Builder<'a, 'tcx> {
         todo!()
     }
 
-    fn get_dbg_loc(&self) -> Option<Self::DILocation> {
-        None
-    }
-
     fn insert_reference_to_gdb_debug_scripts_section_global(&mut self) {
         todo!()
     }
@@ -254,10 +249,6 @@ impl<'a, 'tcx> ArgAbiBuilderMethods<'tcx> for Builder<'a, 'tcx> {
             ),
         }
     }
-
-    fn arg_memory_ty(&self, arg_abi: &ArgAbi<'tcx, Ty<'tcx>>) -> Self::Type {
-        arg_abi.layout.spirv_type(self.span(), self)
-    }
 }
 
 impl AbiBuilderMethods for Builder<'_, '_> {