rustup: update to nightly-2024-04-01.

Author: eddyb

crates/rustc_codegen_spirv/build.rs

@@ -10,9 +10,9 @@ use std::process::{Command, ExitCode};
 /// `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-03-21"
+channel = "nightly-2024-04-01"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = 1388d7a069d872bcfe5e5dd97ef61fa0a586fac0"#;
+# commit_hash = 805813650248c1a2f6f271460d728d1bb852d2a7"#;
 
 fn get_rustc_commit_hash() -> Result<String, Box<dyn Error>> {
     let rustc = std::env::var("RUSTC").unwrap_or_else(|_| String::from("rustc"));

crates/rustc_codegen_spirv/src/abi.rs

@@ -12,8 +12,7 @@ use rustc_middle::query::Providers;
 use rustc_middle::ty::layout::{FnAbiOf, LayoutOf, TyAndLayout};
 use rustc_middle::ty::GenericArgsRef;
 use rustc_middle::ty::{
-    self, Const, CoroutineArgs, FloatTy, IntTy, ParamEnv, PolyFnSig, Ty, TyCtxt, TyKind,
-    TypeAndMut, UintTy,
+    self, Const, CoroutineArgs, FloatTy, IntTy, ParamEnv, PolyFnSig, Ty, TyCtxt, TyKind, UintTy,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_span::def_id::DefId;
@@ -547,7 +546,7 @@ fn dig_scalar_pointee<'tcx>(
     if let FieldsShape::Primitive = layout.fields {
         assert_eq!(offset, Size::ZERO);
         let pointee = match *layout.ty.kind() {
-            TyKind::Ref(_, pointee_ty, _) | TyKind::RawPtr(TypeAndMut { ty: pointee_ty, .. }) => {
+            TyKind::Ref(_, pointee_ty, _) | TyKind::RawPtr(pointee_ty, _) => {
                 PointeeTy::Ty(cx.layout_of(pointee_ty))
             }
             TyKind::FnPtr(sig) => PointeeTy::Fn(sig),

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -21,7 +21,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::Ty;
+use rustc_middle::ty::{self, Ty};
 use rustc_span::Span;
 use rustc_target::abi::call::FnAbi;
 use rustc_target::abi::{Abi, Align, Scalar, Size, WrappingRange};
@@ -1175,9 +1175,10 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         then: Self::BasicBlock,
         _catch: Self::BasicBlock,
         funclet: Option<&Self::Funclet>,
+        instance: Option<ty::Instance<'tcx>>,
     ) -> Self::Value {
         // Exceptions don't exist, jump directly to then block
-        let result = self.call(llty, fn_attrs, fn_abi, llfn, args, funclet);
+        let result = self.call(llty, fn_attrs, fn_abi, llfn, args, funclet, instance);
         self.emit().branch(then).unwrap();
         result
     }
@@ -2616,6 +2617,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         callee: Self::Value,
         args: &[Self::Value],
         funclet: Option<&Self::Funclet>,
+        instance: Option<ty::Instance<'tcx>>,
     ) -> Self::Value {
         if funclet.is_some() {
             self.fatal("TODO: Funclets are not supported");
@@ -2674,17 +2676,19 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
             .collect();
         let args = &args[..];
 
-        let libm_intrinsic = self.libm_intrinsics.borrow().get(&callee_val).copied();
-        let buffer_load_intrinsic = self
-            .buffer_load_intrinsic_fn_id
-            .borrow()
-            .get(&callee_val)
-            .copied();
-        let buffer_store_intrinsic = self
-            .buffer_store_intrinsic_fn_id
-            .borrow()
-            .get(&callee_val)
-            .copied();
+        // FIXME(eddyb) should the maps exist at all, now that the `DefId` is known
+        // at `call` time, and presumably its high-level details can be looked up?
+        let instance_def_id = instance.map(|instance| instance.def_id());
+
+        let libm_intrinsic =
+            instance_def_id.and_then(|def_id| self.libm_intrinsics.borrow().get(&def_id).copied());
+        let buffer_load_intrinsic = instance_def_id
+            .and_then(|def_id| self.buffer_load_intrinsics.borrow().get(&def_id).copied());
+        let buffer_store_intrinsic = instance_def_id
+            .and_then(|def_id| self.buffer_store_intrinsics.borrow().get(&def_id).copied());
+        let is_panic_entry_point = instance_def_id
+            .is_some_and(|def_id| self.panic_entry_points.borrow().contains(&def_id));
+
         if let Some(libm_intrinsic) = libm_intrinsic {
             let result = self.call_libm_intrinsic(libm_intrinsic, result_type, args);
             if result_type != result.ty {
@@ -2696,7 +2700,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                 );
             }
             result
-        } else if self.panic_entry_point_ids.borrow().contains(&callee_val) {
+        } else if is_panic_entry_point {
             // HACK(eddyb) Rust 2021 `panic!` always uses `format_args!`, even
             // in the simple case that used to pass a `&str` constant, which
             // would not remain reachable in the SPIR-V - but `format_args!` is

crates/rustc_codegen_spirv/src/builder/mod.rs

@@ -21,7 +21,7 @@ use rustc_codegen_ssa::traits::{
     DebugInfoBuilderMethods, HasCodegen, StaticBuilderMethods, TypeMembershipMethods,
 };
 use rustc_errors::{Diag, DiagMessage};
-use rustc_middle::mir::Coverage;
+use rustc_middle::mir::coverage::CoverageKind;
 use rustc_middle::span_bug;
 use rustc_middle::ty::layout::{
     FnAbiError, FnAbiOfHelpers, FnAbiRequest, HasParamEnv, HasTyCtxt, LayoutError, LayoutOfHelpers,
@@ -147,7 +147,7 @@ impl<'a, 'tcx> Deref for Builder<'a, 'tcx> {
 }
 
 impl<'a, 'tcx> CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'tcx> {
-    fn add_coverage(&mut self, _instance: Instance<'tcx>, _coverage: &Coverage) {}
+    fn add_coverage(&mut self, _instance: Instance<'tcx>, _kind: &CoverageKind) {}
 }
 
 impl<'a, 'tcx> DebugInfoBuilderMethods for Builder<'a, 'tcx> {

crates/rustc_codegen_spirv/src/codegen_cx/declare.rs

@@ -59,9 +59,11 @@ impl<'tcx> CodegenCx<'tcx> {
     // MiscMethods::get_fn_addr -> get_fn_ext -> declare_fn_ext
     // PreDefineMethods::predefine_fn -> declare_fn_ext
     fn declare_fn_ext(&self, instance: Instance<'tcx>, linkage: Option<LinkageType>) -> SpirvValue {
-        let control = attrs_to_spirv(self.tcx.codegen_fn_attrs(instance.def_id()));
+        let def_id = instance.def_id();
+
+        let control = attrs_to_spirv(self.tcx.codegen_fn_attrs(def_id));
         let fn_abi = self.fn_abi_of_instance(instance, ty::List::empty());
-        let span = self.tcx.def_span(instance.def_id());
+        let span = self.tcx.def_span(def_id);
         let function_type = fn_abi.spirv_type(span, self);
         let (return_type, argument_types) = match self.lookup_type(function_type) {
             SpirvType::Function {
@@ -99,7 +101,7 @@ impl<'tcx> CodegenCx<'tcx> {
         // which prevents us from attaching `OpLine`s to `OpFunction` definitions,
         // but we can use our custom `SrcLocDecoration` instead.
         let src_loc_inst = SrcLocDecoration::from_rustc_span(
-            self.tcx.def_ident_span(instance.def_id()).unwrap_or(span),
+            self.tcx.def_ident_span(def_id).unwrap_or(span),
             &self.builder,
         )
         .map(|src_loc| src_loc.encode_to_inst(fn_id));
@@ -128,12 +130,12 @@ impl<'tcx> CodegenCx<'tcx> {
 
         let attrs = AggregatedSpirvAttributes::parse(
             self,
-            match self.tcx.def_kind(instance.def_id()) {
+            match self.tcx.def_kind(def_id) {
                 // This was made to ICE cross-crate at some point, but then got
                 // reverted in https://github.com/rust-lang/rust/pull/111381.
                 // FIXME(eddyb) remove this workaround once we rustup past that.
                 DefKind::Closure => &[],
-                _ => self.tcx.get_attrs_unchecked(instance.def_id()),
+                _ => self.tcx.get_attrs_unchecked(def_id),
             },
         );
         if let Some(entry) = attrs.entry.map(|attr| attr.value) {
@@ -143,28 +145,29 @@ impl<'tcx> CodegenCx<'tcx> {
                 .map_or_else(|| instance.to_string(), ToString::to_string);
             self.entry_stub(&instance, fn_abi, declared, entry_name, entry);
         }
+
+        // FIXME(eddyb) should the maps exist at all, now that the `DefId` is known
+        // at `call` time, and presumably its high-level details can be looked up?
         if attrs.buffer_load_intrinsic.is_some() {
             let mode = &fn_abi.ret.mode;
-            self.buffer_load_intrinsic_fn_id
+            self.buffer_load_intrinsics
                 .borrow_mut()
-                .insert(fn_id, mode);
+                .insert(def_id, mode);
         }
         if attrs.buffer_store_intrinsic.is_some() {
             let mode = &fn_abi.args.last().unwrap().mode;
-            self.buffer_store_intrinsic_fn_id
+            self.buffer_store_intrinsics
                 .borrow_mut()
-                .insert(fn_id, mode);
+                .insert(def_id, mode);
         }
 
-        let instance_def_id = instance.def_id();
-
-        if self.tcx.crate_name(instance_def_id.krate) == self.sym.libm {
-            let item_name = self.tcx.item_name(instance_def_id);
+        if self.tcx.crate_name(def_id.krate) == self.sym.libm {
+            let item_name = self.tcx.item_name(def_id);
             let intrinsic = self.sym.libm_intrinsics.get(&item_name);
-            if self.tcx.visibility(instance.def_id()) == ty::Visibility::Public {
+            if self.tcx.visibility(def_id) == ty::Visibility::Public {
                 match intrinsic {
                     Some(&intrinsic) => {
-                        self.libm_intrinsics.borrow_mut().insert(fn_id, intrinsic);
+                        self.libm_intrinsics.borrow_mut().insert(def_id, intrinsic);
                     }
                     None => {
                         self.tcx.dcx().err(format!(
@@ -179,9 +182,9 @@ impl<'tcx> CodegenCx<'tcx> {
             self.tcx.lang_items().panic_fn(),
             self.tcx.lang_items().panic_fmt(),
         ]
-        .contains(&Some(instance_def_id))
+        .contains(&Some(def_id))
         {
-            self.panic_entry_point_ids.borrow_mut().insert(fn_id);
+            self.panic_entry_points.borrow_mut().insert(def_id);
         }
 
         // HACK(eddyb) there is no good way to identify these definitions

crates/rustc_codegen_spirv/src/codegen_cx/entry.rs

@@ -199,6 +199,7 @@ impl<'tcx> CodegenCx<'tcx> {
             entry_func,
             &call_args,
             None,
+            None,
         );
         bx.ret_void();
 

crates/rustc_codegen_spirv/src/codegen_cx/mod.rs

@@ -19,6 +19,7 @@ use rustc_codegen_ssa::traits::{
     AsmMethods, BackendTypes, DebugInfoMethods, GlobalAsmOperandRef, MiscMethods,
 };
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::def_id::DefId;
 use rustc_middle::mir;
 use rustc_middle::mir::mono::CodegenUnit;
 use rustc_middle::ty::layout::{HasParamEnv, HasTyCtxt};
@@ -57,11 +58,14 @@ pub struct CodegenCx<'tcx> {
     /// Cache of all the builtin symbols we need
     pub sym: Rc<Symbols>,
     pub instruction_table: InstructionTable,
-    pub libm_intrinsics: RefCell<FxHashMap<Word, super::builder::libm_intrinsics::LibmIntrinsic>>,
+
+    // FIXME(eddyb) should the maps exist at all, now that the `DefId` is known
+    // at `call` time, and presumably its high-level details can be looked up?
+    pub libm_intrinsics: RefCell<FxHashMap<DefId, super::builder::libm_intrinsics::LibmIntrinsic>>,
 
     /// All `panic!(...)`s and builtin panics (from MIR `Assert`s) call into one
     /// of these lang items, which we always replace with an "abort".
-    pub panic_entry_point_ids: RefCell<FxHashSet<Word>>,
+    pub panic_entry_points: RefCell<FxHashSet<DefId>>,
 
     /// `core::fmt::Arguments::new_{v1,const}` instances (for Rust 2021 panics).
     pub fmt_args_new_fn_ids: RefCell<FxHashSet<Word>>,
@@ -72,18 +76,15 @@ pub struct CodegenCx<'tcx> {
     pub fmt_rt_arg_new_fn_ids_to_ty_and_spec: RefCell<FxHashMap<Word, (Ty<'tcx>, char)>>,
 
     /// Intrinsic for loading a `<T>` from a `&[u32]`. The `PassMode` is the mode of the `<T>`.
-    pub buffer_load_intrinsic_fn_id: RefCell<FxHashMap<Word, &'tcx PassMode>>,
+    pub buffer_load_intrinsics: RefCell<FxHashMap<DefId, &'tcx PassMode>>,
     /// Intrinsic for storing a `<T>` into a `&[u32]`. The `PassMode` is the mode of the `<T>`.
-    pub buffer_store_intrinsic_fn_id: RefCell<FxHashMap<Word, &'tcx PassMode>>,
+    pub buffer_store_intrinsics: RefCell<FxHashMap<DefId, &'tcx PassMode>>,
 
     /// Some runtimes (e.g. intel-compute-runtime) disallow atomics on i8 and i16, even though it's allowed by the spec.
     /// This enables/disables them.
     pub i8_i16_atomics_allowed: bool,
 
     pub codegen_args: CodegenArgs,
-
-    /// Information about the SPIR-V target.
-    pub target: SpirvTarget,
 }
 
 impl<'tcx> CodegenCx<'tcx> {
@@ -190,15 +191,14 @@ impl<'tcx> CodegenCx<'tcx> {
             vtables: Default::default(),
             ext_inst: Default::default(),
             zombie_decorations: Default::default(),
-            target,
             sym,
             instruction_table: InstructionTable::new(),
             libm_intrinsics: Default::default(),
-            panic_entry_point_ids: Default::default(),
+            panic_entry_points: Default::default(),
             fmt_args_new_fn_ids: Default::default(),
             fmt_rt_arg_new_fn_ids_to_ty_and_spec: Default::default(),
-            buffer_load_intrinsic_fn_id: Default::default(),
-            buffer_store_intrinsic_fn_id: Default::default(),
+            buffer_load_intrinsics: Default::default(),
+            buffer_store_intrinsics: Default::default(),
             i8_i16_atomics_allowed: false,
             codegen_args,
         }
@@ -296,7 +296,6 @@ pub enum SpirvMetadata {
 }
 
 pub struct CodegenArgs {
-    pub module_output_type: ModuleOutputType,
     pub disassemble: bool,
     pub disassemble_fn: Option<String>,
     pub disassemble_entry: Option<String>,
@@ -554,8 +553,6 @@ impl CodegenArgs {
             std::process::exit(1);
         }
 
-        let module_output_type =
-            matches.opt_get_default("module-output", ModuleOutputType::Single)?;
         let disassemble = matches.opt_present("disassemble");
         let disassemble_fn = matches.opt_str("disassemble-fn");
         let disassemble_entry = matches.opt_str("disassemble-entry");
@@ -617,9 +614,9 @@ impl CodegenArgs {
                 .collect(),
 
             abort_strategy: matches.opt_str("abort-strategy"),
+            module_output_type: matches.opt_get_default("module-output", Default::default())?,
 
             // FIXME(eddyb) deduplicate between `CodegenArgs` and `linker::Options`.
-            emit_multiple_modules: module_output_type == ModuleOutputType::Multiple,
             spirv_metadata,
             keep_link_exports: false,
 
@@ -639,7 +636,6 @@ impl CodegenArgs {
         };
 
         Ok(Self {
-            module_output_type,
             disassemble,
             disassemble_fn,
             disassemble_entry,
@@ -781,8 +777,9 @@ impl CodegenArgs {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum ModuleOutputType {
+    #[default]
     Single,
     Multiple,
 }

crates/rustc_codegen_spirv/src/linker/mod.rs

@@ -18,7 +18,7 @@ mod zombies;
 
 use std::borrow::Cow;
 
-use crate::codegen_cx::SpirvMetadata;
+use crate::codegen_cx::{ModuleOutputType, SpirvMetadata};
 use crate::custom_decorations::{CustomDecoration, SrcLocDecoration, ZombieDecoration};
 use crate::custom_insts;
 use either::Either;
@@ -45,8 +45,8 @@ pub struct Options {
     pub spirt_passes: Vec<String>,
 
     pub abort_strategy: Option<String>,
+    pub module_output_type: ModuleOutputType,
 
-    pub emit_multiple_modules: bool,
     pub spirv_metadata: SpirvMetadata,
 
     /// Whether to preserve `LinkageAttributes "..." Export` decorations,
@@ -620,7 +620,7 @@ pub fn link(
         simple_passes::sort_globals(&mut output);
     }
 
-    let mut output = if opts.emit_multiple_modules {
+    let mut output = if opts.module_output_type == ModuleOutputType::Multiple {
         let mut file_stem_to_entry_name_and_module = BTreeMap::new();
         for (i, entry) in output.entry_points.iter().enumerate() {
             let mut module = output.clone();
@@ -695,7 +695,7 @@ pub fn link(
             )
             .unwrap();
         }
-        // Run DCE again, even if emit_multiple_modules==false - the first DCE ran before
+        // Run DCE again, even if module_output_type == ModuleOutputType::Multiple - the first DCE ran before
         // structurization and mem2reg (for perf reasons), and mem2reg may remove references to
         // invalid types, so we need to DCE again.
         if opts.dce {

crates/rustc_codegen_spirv/src/spirv_type.rs

@@ -22,7 +22,7 @@ use std::sync::{LazyLock, Mutex};
 /// the `result_id` of the type declaration instruction, merely the contents.
 //
 // FIXME(eddyb) should `SpirvType`s be behind `&'tcx` from `tcx.arena.dropless`?
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum SpirvType<'tcx> {
     Void,
     Bool,

crates/rustc_codegen_spirv/src/symbols.rs

@@ -19,9 +19,7 @@ pub struct Symbols {
     pub discriminant: Symbol,
     pub rust_gpu: Symbol,
     pub spirv: Symbol,
-    pub spirv_std: Symbol,
     pub libm: Symbol,
-    pub num_traits: Symbol,
     pub entry_point_name: Symbol,
     pub spv_intel_shader_integer_functions2: Symbol,
     pub spv_khr_vulkan_memory_model: Symbol,
@@ -383,9 +381,7 @@ impl Symbols {
             discriminant: Symbol::intern("discriminant"),
             rust_gpu: Symbol::intern("rust_gpu"),
             spirv: Symbol::intern("spirv"),
-            spirv_std: Symbol::intern("spirv_std"),
             libm: Symbol::intern("libm"),
-            num_traits: Symbol::intern("num_traits"),
             entry_point_name: Symbol::intern("entry_point_name"),
             spv_intel_shader_integer_functions2: Symbol::intern(
                 "SPV_INTEL_shader_integer_functions2",