rustup: update to nightly-2024-09-01 (~1.82).

Author: eddyb

Cargo.lock

@@ -41,7 +41,7 @@ regex = { version = "1", features = ["perf"] }
 
 # HACK(eddyb) deps of `rustc_codegen_ssa`, for `pqp_cg_ssa` (see `build.rs`),
 # that cannot be handled with just `extern crate` pulling out of the sysroot.
-object = { version = "0.32.1",  default-features = false, features = ["read_core", "elf", "macho", "pe", "xcoff", "unaligned", "archive", "write", "wasm"] }
+object = { version = "0.36.2",  default-features = false, features = ["read_core", "elf", "macho", "pe", "xcoff", "unaligned", "archive", "write", "wasm"] }
 thorin-dwp = "0.7"
 
 # Normal dependencies.

crates/rustc_codegen_spirv/Cargo.toml

@@ -15,9 +15,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-2024-07-20"
+channel = "nightly-2024-09-01"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = 9057c3ffec44926d5e149dc13ff3ce1613b69cce"#;
+# commit_hash = a7399ba69d37b019677a9c47fe89ceb8dd82db2d"#;
 
 fn rustc_output(arg: &str) -> Result<String, Box<dyn Error>> {
     let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".into());
@@ -145,7 +145,7 @@ fn generate_pqp_cg_ssa() -> Result<(), Box<dyn Error>> {
                 for line in mem::take(&mut src).lines() {
                     if line.starts_with("#!") {
                         src += "// ";
-                        if !line.starts_with("#![doc(") {
+                        if !line.starts_with("#![doc(") && line != "#![warn(unreachable_pub)]" {
                             writeln(&mut cg_ssa_lib_rc_attrs, line);
                         }
                     } else if line == "#[macro_use]" || line.starts_with("extern crate ") {

crates/rustc_codegen_spirv/build.rs

@@ -548,7 +548,7 @@ fn dig_scalar_pointee<'tcx>(
             TyKind::Ref(_, pointee_ty, _) | TyKind::RawPtr(pointee_ty, _) => {
                 PointeeTy::Ty(cx.layout_of(pointee_ty))
             }
-            TyKind::FnPtr(sig) => PointeeTy::Fn(sig),
+            TyKind::FnPtr(sig_tys, hdr) => PointeeTy::Fn(sig_tys.with(hdr)),
             _ => bug!("Pointer is not `&T`, `*T` or `fn` pointer: {:#?}", layout),
         };
         return pointee;

crates/rustc_codegen_spirv/src/abi.rs

@@ -182,15 +182,14 @@ impl AggregatedSpirvAttributes {
             span: Span,
             category: &'static str,
         ) -> Result<(), MultipleAttrs> {
-            match slot {
-                Some(prev) => Err(MultipleAttrs {
+            if let Some(prev) = slot {
+                Err(MultipleAttrs {
                     prev_span: prev.span,
                     category,
-                }),
-                None => {
-                    *slot = Some(Spanned { value, span });
-                    Ok(())
-                }
+                })
+            } else {
+                *slot = Some(Spanned { value, span });
+                Ok(())
             }
         }
 

crates/rustc_codegen_spirv/src/attr.rs

@@ -56,7 +56,7 @@ macro_rules! simple_op {
                                     _ => return None,
                                 };
                                 Some(if signed {
-                                    size.sign_extend(x)
+                                    size.sign_extend(x) as u128
                                 } else {
                                     size.truncate(x)
                                 })

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -857,12 +857,11 @@ impl<'cx, 'tcx> Builder<'cx, 'tcx> {
                     place,
                 } => {
                     self.check_reg(span, reg);
-                    match place {
-                        Some(place) => Some(OutRegister::Place(*place)),
-                        None => {
-                            self.tcx.dcx().span_err(span, "missing place for register");
-                            None
-                        }
+                    if let Some(place) = place {
+                        Some(OutRegister::Place(*place))
+                    } else {
+                        self.tcx.dcx().span_err(span, "missing place for register");
+                        None
                     }
                 }
                 InlineAsmOperandRef::InOut {
@@ -872,12 +871,11 @@ impl<'cx, 'tcx> Builder<'cx, 'tcx> {
                     out_place,
                 } => {
                     self.check_reg(span, reg);
-                    match out_place {
-                        Some(out_place) => Some(OutRegister::Place(*out_place)),
-                        None => {
-                            self.tcx.dcx().span_err(span, "missing place for register");
-                            None
-                        }
+                    if let Some(out_place) = out_place {
+                        Some(OutRegister::Place(*out_place))
+                    } else {
+                        self.tcx.dcx().span_err(span, "missing place for register");
+                        None
                     }
                 }
                 InlineAsmOperandRef::Const { string: _ } => {
@@ -953,8 +951,8 @@ impl<'cx, 'tcx> Builder<'cx, 'tcx> {
                     place,
                 } => {
                     self.check_reg(span, reg);
-                    match place {
-                        Some(place) => match self.lookup_type(place.val.llval.ty) {
+                    if let Some(place) = place {
+                        match self.lookup_type(place.val.llval.ty) {
                             SpirvType::Pointer { pointee } => Some(pointee),
                             other => {
                                 self.tcx.dcx().span_err(
@@ -966,13 +964,12 @@ impl<'cx, 'tcx> Builder<'cx, 'tcx> {
                                 );
                                 None
                             }
-                        },
-                        None => {
-                            self.tcx
-                                .dcx()
-                                .span_err(span, "missing place for out register typeof");
-                            None
                         }
+                    } else {
+                        self.tcx
+                            .dcx()
+                            .span_err(span, "missing place for out register typeof");
+                        None
                     }
                 }
                 InlineAsmOperandRef::InOut {

crates/rustc_codegen_spirv/src/builder/spirv_asm.rs

@@ -577,7 +577,7 @@ impl<'tcx> BuilderSpirv<'tcx> {
             (SpirvConst::Scalar(val), Some(SpirvType::Integer(bits, signed))) => {
                 let size = Size::from_bits(bits);
                 SpirvConst::Scalar(if signed {
-                    size.sign_extend(val)
+                    size.sign_extend(val) as u128
                 } else {
                     size.truncate(val)
                 })

crates/rustc_codegen_spirv/src/builder_spirv.rs

@@ -195,6 +195,14 @@ impl<'tcx> ConstMethods<'tcx> for CodegenCx<'tcx> {
         .def(DUMMY_SP, self);
         self.constant_composite(struct_ty, elts.iter().map(|f| f.def_cx(self)))
     }
+    fn const_vector(&self, elts: &[Self::Value]) -> Self::Value {
+        let vector_ty = SpirvType::Vector {
+            element: elts[0].ty,
+            count: elts.len() as u32,
+        }
+        .def(DUMMY_SP, self);
+        self.constant_composite(vector_ty, elts.iter().map(|elt| elt.def_cx(self)))
+    }
 
     fn const_to_opt_uint(&self, v: Self::Value) -> Option<u64> {
         self.builder.lookup_const_scalar(v)?.try_into().ok()
@@ -247,10 +255,7 @@ impl<'tcx> ConstMethods<'tcx> for CodegenCx<'tcx> {
                         let value = self.static_addr_of(init, alloc.inner().align, None);
                         (value, AddressSpace::DATA)
                     }
-                    GlobalAlloc::Function {
-                        instance,
-                        unique: _,
-                    } => (
+                    GlobalAlloc::Function { instance } => (
                         self.get_fn_addr(instance.polymorphize(self.tcx)),
                         self.data_layout().instruction_address_space,
                     ),

crates/rustc_codegen_spirv/src/codegen_cx/constant.rs

@@ -831,8 +831,10 @@ impl<'tcx> CodegenCx<'tcx> {
                     }
                 }
             }
-            // Emitted earlier.
-            Err(SpecConstant { .. }) => {}
+            Err(not_var) => {
+                // Emitted earlier.
+                let SpecConstant { .. } = not_var;
+            }
         }
     }