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

Author: eddyb

Cargo.lock

@@ -48,7 +48,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;
+            }
         }
     }
 

crates/rustc_codegen_spirv/src/codegen_cx/entry.rs

@@ -4,7 +4,6 @@
 use crate::builder_spirv::BuilderSpirv;
 use crate::custom_insts::{self, CustomInst};
 use either::Either;
-use itertools::Itertools;
 use rspirv::dr::{Instruction, Module, Operand};
 use rspirv::spirv::{Decoration, Op, Word};
 use rustc_data_structures::fx::FxIndexMap;
@@ -14,7 +13,6 @@ use rustc_span::{FileName, SourceFile};
 use smallvec::SmallVec;
 use std::borrow::Cow;
 use std::marker::PhantomData;
-use std::ops::Range;
 use std::path::PathBuf;
 use std::{fmt, iter, slice, str};
 
@@ -495,61 +493,18 @@ impl<'a> SpanRegenerator<'a> {
         // called with `line`/`col` values that are near eachother - thankfully,
         // this code should only be hit on the error reporting path anyway.
         let line_col_to_bpos = |line: u32, col: u32| {
-            let line_bpos_range = file.line_bounds(line.checked_sub(1)? as usize);
-
-            // Find the special cases (`MultiByteChar`s/`NonNarrowChar`s) in the line.
-            let multibyte_chars = {
-                let find = |bpos| {
-                    file.multibyte_chars
-                        .binary_search_by_key(&file.relative_position(bpos), |mbc| mbc.pos)
-                        .unwrap_or_else(|x| x)
-                };
-                let Range { start, end } = line_bpos_range;
-                file.multibyte_chars[find(start)..find(end)].iter()
-            };
-            let non_narrow_chars = {
-                let find = |bpos| {
-                    file.non_narrow_chars
-                        .binary_search_by_key(&file.relative_position(bpos), |nnc| nnc.pos())
-                        .unwrap_or_else(|x| x)
-                };
-                let Range { start, end } = line_bpos_range;
-                file.non_narrow_chars[find(start)..find(end)].iter()
-            };
-            let mut special_chars = multibyte_chars
-                .merge_join_by(non_narrow_chars, |mbc, nnc| mbc.pos.cmp(&nnc.pos()))
-                .peekable();
-
-            // Increment the `BytePos` until we reach the right `col_display`, using
-            // `MultiByteChar`s/`NonNarrowChar`s to track non-trivial contributions
-            // (this may look inefficient, but lines tend to be short, and `rustc`
-            // itself is even worse than this, when it comes to `BytePos` lookups).
+            let line_idx_in_file = line.checked_sub(1)? as usize;
+            let line_bpos_range = file.line_bounds(line_idx_in_file);
+            let line_contents = file.get_line(line_idx_in_file)?;
+
+            // Increment the `BytePos` until we reach the right `col_display`.
             let (mut cur_bpos, mut cur_col_display) = (line_bpos_range.start, 0);
+            let mut line_chars = line_contents.chars();
             while cur_bpos < line_bpos_range.end && cur_col_display < col {
-                let next_special_bpos = special_chars
-                    .peek()
-                    .map(|special| {
-                        special
-                            .as_ref()
-                            .map_any(|mbc| mbc.pos, |nnc| nnc.pos())
-                            .reduce(|x, _| x)
-                    })
-                    .map(|rel_bpos| file.absolute_position(rel_bpos));
-
-                // Batch trivial chars (i.e. chars 1:1 wrt `BytePos` vs `col_display`).
-                let following_trivial_chars =
-                    next_special_bpos.unwrap_or(line_bpos_range.end).0 - cur_bpos.0;
-                if following_trivial_chars > 0 {
-                    let wanted_trivial_chars = following_trivial_chars.min(col - cur_col_display);
-                    cur_bpos.0 += wanted_trivial_chars;
-                    cur_col_display += wanted_trivial_chars;
-                    continue;
-                }
-
-                // Add a special char's `BytePos` and `col_display` contributions.
-                let mbc_nnc = special_chars.next().unwrap();
-                cur_bpos.0 += mbc_nnc.as_ref().left().map_or(1, |mbc| mbc.bytes as u32);
-                cur_col_display += mbc_nnc.as_ref().right().map_or(1, |nnc| nnc.width() as u32);
+                // Add each char's `BytePos` and `col_display` contributions.
+                let ch = line_chars.next()?;
+                cur_bpos.0 += ch.len_utf8() as u32;
+                cur_col_display += rustc_span::char_width(ch) as u32;
             }
             Some(cur_bpos)
         };

crates/rustc_codegen_spirv/src/custom_decorations.rs

@@ -2,6 +2,7 @@
 #![allow(internal_features)]
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::untranslatable_diagnostic)]
+#![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(if_let_guard)]
 #![feature(let_chains)]
@@ -29,7 +30,6 @@
 //! [`spirv-tools`]: https://rust-gpu.github.io/rust-gpu/api/spirv_tools
 //! [`spirv-tools-sys`]: https://rust-gpu.github.io/rust-gpu/api/spirv_tools_sys
 #![feature(rustc_private)]
-#![feature(assert_matches)]
 #![feature(result_flattening)]
 // crate-specific exceptions:
 #![allow(

crates/rustc_codegen_spirv/src/lib.rs

@@ -604,12 +604,11 @@ fn do_link(
         disambiguated_crate_name_for_dumps,
     );
 
-    match link_result {
-        Ok(v) => v,
-        Err(rustc_errors::ErrorGuaranteed { .. }) => {
-            sess.dcx().abort_if_errors();
-            bug!("Linker errored, but no error reported");
-        }
+    if let Ok(v) = link_result {
+        v
+    } else {
+        sess.dcx().abort_if_errors();
+        bug!("Linker errored, but no error reported");
     }
 }
 

crates/rustc_codegen_spirv/src/link.rs

@@ -2,13 +2,7 @@
 #![cfg_attr(
     target_arch = "spirv",
     allow(internal_features),
-    feature(
-        asm_const,
-        asm_experimental_arch,
-        core_intrinsics,
-        lang_items,
-        repr_simd,
-    )
+    feature(asm_experimental_arch, core_intrinsics, lang_items, repr_simd)
 )]
 // FIXME(eddyb) update/review these lints.
 //