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

Author: eddyb

Cargo.lock

@@ -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-02-01"
+channel = "nightly-2024-03-01"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = 11f32b73e0dc9287e305b5b9980d24aecdc8c17f"#;
+# commit_hash = 878c8a2a62d49ca5c454547ad67290a1df746cb5"#;
 
 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/build.rs

@@ -317,7 +317,7 @@ impl CheckSpirvAttrVisitor<'_> {
                 | SpirvAttribute::InputAttachmentIndex(_)
                 | SpirvAttribute::SpecConstant(_) => match target {
                     Target::Param => {
-                        let parent_hir_id = self.tcx.hir().parent_id(hir_id);
+                        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())

crates/rustc_codegen_spirv/src/attr.rs

@@ -28,7 +28,6 @@ use rustc_target::abi::{Abi, Align, Scalar, Size, WrappingRange};
 use smallvec::SmallVec;
 use std::borrow::Cow;
 use std::cell::Cell;
-use std::convert::TryInto;
 use std::iter::{self, empty};
 use std::ops::RangeInclusive;
 
@@ -1193,11 +1192,14 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
             int(a, b) => a.wrapping_add(b)
         }
     }
+    // FIXME(eddyb) try to annotate the SPIR-V for `fast` and `algebraic`.
     simple_op! {fadd, f_add}
     simple_op! {fadd_fast, f_add} // fast=normal
+    simple_op! {fadd_algebraic, f_add} // algebraic=normal
     simple_op! {sub, i_sub}
     simple_op! {fsub, f_sub}
     simple_op! {fsub_fast, f_sub} // fast=normal
+    simple_op! {fsub_algebraic, f_sub} // algebraic=normal
     simple_op! {
         mul, i_mul,
         // HACK(eddyb) `rustc_codegen_ssa` relies on `Builder` methods doing
@@ -1208,6 +1210,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
     }
     simple_op! {fmul, f_mul}
     simple_op! {fmul_fast, f_mul} // fast=normal
+    simple_op! {fmul_algebraic, f_mul} // algebraic=normal
     simple_op! {udiv, u_div}
     // Note: exactudiv is UB when there's a remainder, so it's valid to implement as a normal div.
     // TODO: Can we take advantage of the UB and emit something else?
@@ -1217,10 +1220,12 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
     simple_op! {exactsdiv, s_div}
     simple_op! {fdiv, f_div}
     simple_op! {fdiv_fast, f_div} // fast=normal
+    simple_op! {fdiv_algebraic, f_div} // algebraic=normal
     simple_op! {urem, u_mod}
     simple_op! {srem, s_rem}
     simple_op! {frem, f_rem}
     simple_op! {frem_fast, f_rem} // fast=normal
+    simple_op! {frem_algebraic, f_rem} // algebraic=normal
     simple_op_unchecked_type! {shl, shift_left_logical}
     simple_op_unchecked_type! {lshr, shift_right_logical}
     simple_op_unchecked_type! {ashr, shift_right_arithmetic}

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -9,9 +9,9 @@ use rspirv::spirv::GLOp;
 use rustc_codegen_ssa::mir::operand::OperandRef;
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::{BuilderMethods, IntrinsicCallMethods};
-use rustc_middle::bug;
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{FnDef, Instance, ParamEnv, Ty, TyKind};
+use rustc_middle::{bug, ty};
 use rustc_span::sym;
 use rustc_span::Span;
 use rustc_target::abi::call::{FnAbi, PassMode};
@@ -71,7 +71,7 @@ impl<'a, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'tcx> {
         args: &[OperandRef<'tcx, Self::Value>],
         llresult: Self::Value,
         _span: Span,
-    ) {
+    ) -> Result<(), ty::Instance<'tcx>> {
         let callee_ty = instance.ty(self.tcx, ParamEnv::reveal_all());
 
         let (def_id, fn_args) = match *callee_ty.kind() {
@@ -98,7 +98,7 @@ impl<'a, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'tcx> {
             sym::breakpoint => {
                 self.abort();
                 assert!(fn_abi.ret.is_ignore());
-                return;
+                return Ok(());
             }
 
             sym::volatile_load | sym::unaligned_volatile_load => {
@@ -108,7 +108,7 @@ impl<'a, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'tcx> {
                 if !result.layout.is_zst() {
                     self.store(load, result.llval, result.align);
                 }
-                return;
+                return Ok(());
             }
 
             sym::prefetch_read_data
@@ -117,7 +117,7 @@ impl<'a, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'tcx> {
             | sym::prefetch_write_instruction => {
                 // ignore
                 assert!(fn_abi.ret.is_ignore());
-                return;
+                return Ok(());
             }
 
             sym::saturating_add => {
@@ -336,7 +336,10 @@ impl<'a, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'tcx> {
                 undef
             }
 
-            _ => self.fatal(format!("TODO: Unknown intrinsic '{name}'")),
+            _ => {
+                // Call the fallback body instead of generating the intrinsic code
+                return Err(ty::Instance::new(instance.def_id(), instance.args));
+            }
         };
 
         if !fn_abi.ret.is_ignore() {
@@ -345,6 +348,7 @@ impl<'a, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'tcx> {
                 .val
                 .store(self, result);
         }
+        Ok(())
     }
 
     fn abort(&mut self) {

crates/rustc_codegen_spirv/src/builder/intrinsics.rs

@@ -20,7 +20,7 @@ use rustc_codegen_ssa::traits::{
     AbiBuilderMethods, ArgAbiMethods, BackendTypes, BuilderMethods, CoverageInfoBuilderMethods,
     DebugInfoBuilderMethods, HasCodegen, StaticBuilderMethods, TypeMembershipMethods,
 };
-use rustc_errors::{DiagnosticBuilder, DiagnosticMessage};
+use rustc_errors::{Diag, DiagnosticMessage};
 use rustc_middle::mir::Coverage;
 use rustc_middle::span_bug;
 use rustc_middle::ty::layout::{
@@ -69,7 +69,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     }
 
     #[track_caller]
-    pub fn struct_err(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_> {
+    pub fn struct_err(&self, msg: impl Into<DiagnosticMessage>) -> Diag<'_> {
         if let Some(current_span) = self.current_span {
             self.tcx.dcx().struct_span_err(current_span, msg)
         } else {

crates/rustc_codegen_spirv/src/builder/mod.rs

@@ -15,7 +15,6 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_middle::{bug, ty::Instance};
 use rustc_span::{Span, DUMMY_SP};
 use rustc_target::asm::{InlineAsmRegClass, InlineAsmRegOrRegClass, SpirVInlineAsmRegClass};
-use std::convert::TryFrom;
 
 pub struct InstructionTable {
     table: FxHashMap<&'static str, &'static rspirv::grammar::Instruction<'static>>,

crates/rustc_codegen_spirv/src/builder/spirv_asm.rs

@@ -37,7 +37,7 @@ pub enum SpirvValueKind {
 
     /// This can only happen in one specific case - which is as a result of
     /// `codegen_buffer_store_intrinsic`, that function is supposed to return
-    /// OpTypeVoid, however because it gets inline by the compiler it can't.
+    /// `OpTypeVoid`, however because it gets inline by the compiler it can't.
     /// Instead we return this, and trigger an error if we ever end up using the
     /// result of this function call (which we can't).
     IllegalTypeUsed(Word),

crates/rustc_codegen_spirv/src/builder_spirv.rs

@@ -70,9 +70,9 @@ pub struct CodegenCx<'tcx> {
     /// "specifier" as a `char` (' ' for `Display`, `x` for `LowerHex`, etc.)
     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>.
+    /// 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>>,
-    /// Intrinsic for storing a <T> into a &[u32]. The PassMode is the mode of the <T>.
+    /// 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>>,
 
     /// Some runtimes (e.g. intel-compute-runtime) disallow atomics on i8 and i16, even though it's allowed by the spec.

crates/rustc_codegen_spirv/src/codegen_cx/mod.rs

@@ -252,15 +252,11 @@ impl CodegenBackend for SpirvCodegenBackend {
         ongoing_codegen: Box<dyn Any>,
         sess: &Session,
         _outputs: &OutputFilenames,
-    ) -> Result<(CodegenResults, FxIndexMap<WorkProductId, WorkProduct>), ErrorGuaranteed> {
-        let (codegen_results, work_products) = ongoing_codegen
+    ) -> (CodegenResults, FxIndexMap<WorkProductId, WorkProduct>) {
+        ongoing_codegen
             .downcast::<OngoingCodegen<Self>>()
             .expect("Expected OngoingCodegen, found Box<Any>")
-            .join(sess);
-
-        sess.compile_status()?;
-
-        Ok((codegen_results, work_products))
+            .join(sess)
     }
 
     fn link(
@@ -278,8 +274,7 @@ impl CodegenBackend for SpirvCodegenBackend {
         );
         drop(timer);
 
-        sess.compile_status()?;
-        Ok(())
+        sess.dcx().has_errors().map_or(Ok(()), Err)
     }
 }