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

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-01"
+channel = "nightly-2024-03-11"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = 878c8a2a62d49ca5c454547ad67290a1df746cb5"#;
+# commit_hash = 3b1717c052de4a2dbdd3badb0e7a885f40a8ad9e"#;
 
 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

@@ -505,8 +505,10 @@ fn trans_scalar<'tcx>(
         Primitive::Int(width, signedness) => {
             SpirvType::Integer(width.size().bits() as u32, signedness).def(span, cx)
         }
+        Primitive::F16 => SpirvType::Float(16).def(span, cx),
         Primitive::F32 => SpirvType::Float(32).def(span, cx),
         Primitive::F64 => SpirvType::Float(64).def(span, cx),
+        Primitive::F128 => SpirvType::Float(128).def(span, cx),
         Primitive::Pointer(_) => {
             let pointee_ty = dig_scalar_pointee(cx, ty, offset);
             // Pointers can be recursive. So, record what we're currently translating, and if we're already translating

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -1465,9 +1465,12 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                 .size(self)
                 .align_to(b.primitive().align(self).abi);
 
-            let pair_ty = place.layout.spirv_type(self.span(), self);
             let mut load = |i, scalar: Scalar, align| {
-                let llptr = self.struct_gep(pair_ty, place.llval, i as u64);
+                let llptr = if i == 0 {
+                    place.llval
+                } else {
+                    self.inbounds_ptradd(place.llval, self.const_usize(b_offset.bytes()))
+                };
                 let load = self.load(
                     self.scalar_pair_element_backend_type(place.layout, i, false),
                     llptr,
@@ -1581,79 +1584,6 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         self.maybe_inbounds_gep(ty, ptr, indices, true)
     }
 
-    fn struct_gep(&mut self, ty: Self::Type, ptr: Self::Value, idx: u64) -> Self::Value {
-        let (offset, result_pointee_type) = match self.lookup_type(ty) {
-            SpirvType::Adt {
-                field_offsets,
-                field_types,
-                ..
-            } => (field_offsets[idx as usize], field_types[idx as usize]),
-            SpirvType::Array { element, .. }
-            | SpirvType::RuntimeArray { element, .. }
-            | SpirvType::Vector { element, .. }
-            | SpirvType::Matrix { element, .. } => (
-                self.lookup_type(element).sizeof(self).unwrap() * idx,
-                element,
-            ),
-            SpirvType::InterfaceBlock { inner_type } => {
-                assert_eq!(idx, 0);
-                (Size::ZERO, inner_type)
-            }
-            other => self.fatal(format!(
-                "struct_gep not on struct, array, or vector type: {other:?}, index {idx}"
-            )),
-        };
-        let result_pointee_size = self.lookup_type(result_pointee_type).sizeof(self);
-        let result_type = self.type_ptr_to(result_pointee_type);
-
-        // Special-case field accesses through a `pointercast`, to accesss the
-        // right field in the original type, for the `Logical` addressing model.
-        let ptr = ptr.strip_ptrcasts();
-        let original_pointee_ty = match self.lookup_type(ptr.ty) {
-            SpirvType::Pointer { pointee } => pointee,
-            other => self.fatal(format!("struct_gep called on non-pointer type: {other:?}")),
-        };
-        if let Some((indices, _)) = self.recover_access_chain_from_offset(
-            original_pointee_ty,
-            offset,
-            result_pointee_size..=result_pointee_size,
-            Some(result_pointee_type),
-        ) {
-            let original_ptr = ptr.def(self);
-            let indices = indices
-                .into_iter()
-                .map(|idx| self.constant_u32(self.span(), idx).def(self))
-                .collect::<Vec<_>>();
-            return self
-                .emit()
-                .in_bounds_access_chain(result_type, None, original_ptr, indices)
-                .unwrap()
-                .with_type(result_type);
-        }
-
-        // FIXME(eddyb) can we even get to this point, with valid SPIR-V?
-
-        // HACK(eddyb) temporary workaround for untyped pointers upstream.
-        // FIXME(eddyb) replace with untyped memory SPIR-V + `qptr` or similar.
-        let ptr = self.pointercast(ptr, self.type_ptr_to(ty));
-
-        // Important! LLVM, and therefore intel-compute-runtime, require the `getelementptr` instruction (and therefore
-        // OpAccessChain) on structs to be a constant i32. Not i64! i32.
-        if idx > u32::MAX as u64 {
-            self.fatal("struct_gep bigger than u32::MAX");
-        }
-        let index_const = self.constant_u32(self.span(), idx as u32).def(self);
-        self.emit()
-            .in_bounds_access_chain(
-                result_type,
-                None,
-                ptr.def(self),
-                [index_const].iter().cloned(),
-            )
-            .unwrap()
-            .with_type(result_type)
-    }
-
     // intcast has the logic for dealing with bools, so use that
     fn trunc(&mut self, val: Self::Value, dest_ty: Self::Type) -> Self::Value {
         self.intcast(val, dest_ty, false)

crates/rustc_codegen_spirv/src/builder/mod.rs

@@ -20,7 +20,7 @@ use rustc_codegen_ssa::traits::{
     AbiBuilderMethods, ArgAbiMethods, BackendTypes, BuilderMethods, CoverageInfoBuilderMethods,
     DebugInfoBuilderMethods, HasCodegen, StaticBuilderMethods, TypeMembershipMethods,
 };
-use rustc_errors::{Diag, DiagnosticMessage};
+use rustc_errors::{Diag, DiagMessage};
 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>) -> Diag<'_> {
+    pub fn struct_err(&self, msg: impl Into<DiagMessage>) -> Diag<'_> {
         if let Some(current_span) = self.current_span {
             self.tcx.dcx().struct_span_err(current_span, msg)
         } else {
@@ -78,7 +78,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     }
 
     #[track_caller]
-    pub fn err(&self, msg: impl Into<DiagnosticMessage>) {
+    pub fn err(&self, msg: impl Into<DiagMessage>) {
         if let Some(current_span) = self.current_span {
             self.tcx.dcx().span_err(current_span, msg);
         } else {
@@ -87,7 +87,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     }
 
     #[track_caller]
-    pub fn fatal(&self, msg: impl Into<DiagnosticMessage>) -> ! {
+    pub fn fatal(&self, msg: impl Into<DiagMessage>) -> ! {
         if let Some(current_span) = self.current_span {
             self.tcx.dcx().span_fatal(current_span, msg)
         } else {

crates/rustc_codegen_spirv/src/builder/spirv_asm.rs

@@ -58,7 +58,8 @@ impl<'a, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'tcx> {
         options: InlineAsmOptions,
         _line_spans: &[Span],
         _instance: Instance<'_>,
-        _dest_catch_funclet: Option<(Self::BasicBlock, Self::BasicBlock, Option<&Self::Funclet>)>,
+        _dest: Option<Self::BasicBlock>,
+        _catch_funclet: Option<(Self::BasicBlock, Option<&Self::Funclet>)>,
     ) {
         const SUPPORTED_OPTIONS: InlineAsmOptions = InlineAsmOptions::NORETURN;
         let unsupported_options = options & !SUPPORTED_OPTIONS;
@@ -889,6 +890,12 @@ impl<'cx, 'tcx> Builder<'cx, 'tcx> {
                         .span_err(span, "cannot write to static variable asm argument");
                     None
                 }
+                InlineAsmOperandRef::Label { label: _ } => {
+                    self.tcx
+                        .dcx()
+                        .span_err(span, "cannot write to label asm argument");
+                    None
+                }
             },
         }
     }
@@ -988,6 +995,12 @@ impl<'cx, 'tcx> Builder<'cx, 'tcx> {
                     );
                     None
                 }
+                InlineAsmOperandRef::Label { label: _ } => {
+                    self.tcx
+                        .dcx()
+                        .span_err(span, "cannot take the type of a label asm argument");
+                    None
+                }
             },
             Token::Placeholder(hole, span) => match hole {
                 InlineAsmOperandRef::In { reg, value } => {
@@ -1032,6 +1045,12 @@ impl<'cx, 'tcx> Builder<'cx, 'tcx> {
                         .span_err(span, "static variable asm argument not supported yet");
                     None
                 }
+                InlineAsmOperandRef::Label { label: _ } => {
+                    self.tcx
+                        .dcx()
+                        .span_err(span, "label asm argument not supported yet");
+                    None
+                }
             },
         }
     }

crates/rustc_codegen_spirv/src/codegen_cx/constant.rs

@@ -265,6 +265,10 @@ impl<'tcx> ConstMethods<'tcx> for CodegenCx<'tcx> {
                             other.debug(ty, self)
                         )),
                     },
+                    Primitive::F16 => self
+                        .tcx
+                        .dcx()
+                        .fatal("scalar_to_backend Primitive::F16 not supported"),
                     Primitive::F32 => {
                         let res = self.constant_f32(DUMMY_SP, f32::from_bits(data as u32));
                         assert_eq!(res.ty, ty);
@@ -275,6 +279,10 @@ impl<'tcx> ConstMethods<'tcx> for CodegenCx<'tcx> {
                         assert_eq!(res.ty, ty);
                         res
                     }
+                    Primitive::F128 => self
+                        .tcx
+                        .dcx()
+                        .fatal("scalar_to_backend Primitive::F128 not supported"),
                     Primitive::Pointer(_) => {
                         if data == 0 {
                             self.constant_null(ty)

crates/rustc_codegen_spirv/src/codegen_cx/entry.rs

@@ -505,11 +505,18 @@ impl<'tcx> CodegenCx<'tcx> {
                 .def(hir_param.span, self);
                 var_ptr_spirv_type = self.type_ptr_to(var_spirv_type);
 
-                let value_ptr = bx.struct_gep(
-                    var_spirv_type,
-                    var_id.unwrap().with_type(var_ptr_spirv_type),
-                    0,
-                );
+                let zero_u32 = self.constant_u32(hir_param.span, 0).def_cx(self);
+                let value_ptr_spirv_type = self.type_ptr_to(value_spirv_type);
+                let value_ptr = bx
+                    .emit()
+                    .in_bounds_access_chain(
+                        value_ptr_spirv_type,
+                        None,
+                        var_id.unwrap(),
+                        [zero_u32].iter().cloned(),
+                    )
+                    .unwrap()
+                    .with_type(value_ptr_spirv_type);
 
                 let value_len = if is_unsized_with_len {
                     match self.lookup_type(value_spirv_type) {

crates/rustc_codegen_spirv/src/codegen_cx/type_.rs

@@ -12,7 +12,7 @@ use rustc_middle::{bug, span_bug};
 use rustc_span::source_map::Spanned;
 use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::call::{CastTarget, FnAbi, Reg};
-use rustc_target::abi::{Abi, AddressSpace, FieldsShape};
+use rustc_target::abi::{Abi, AddressSpace};
 
 impl<'tcx> LayoutOfHelpers<'tcx> for CodegenCx<'tcx> {
     type LayoutOfResult = TyAndLayout<'tcx>;
@@ -107,23 +107,6 @@ impl<'tcx> LayoutTypeMethods<'tcx> for CodegenCx<'tcx> {
         }
     }
 
-    fn backend_field_index(&self, layout: TyAndLayout<'tcx>, index: usize) -> u64 {
-        match layout.abi {
-            Abi::Scalar(_) | Abi::ScalarPair(..) => {
-                bug!("backend_field_index({:?}): not applicable", layout);
-            }
-            _ => {}
-        }
-        match layout.fields {
-            FieldsShape::Primitive | FieldsShape::Union(_) => {
-                bug!("backend_field_index({:?}): not applicable", layout)
-            }
-            FieldsShape::Array { .. } => index as u64,
-            // note: codegen_llvm implements this as 1+index*2 due to padding fields
-            FieldsShape::Arbitrary { .. } => layout.fields.memory_index(index) as u64,
-        }
-    }
-
     fn scalar_pair_element_backend_type(
         &self,
         layout: TyAndLayout<'tcx>,
@@ -165,12 +148,18 @@ impl<'tcx> BaseTypeMethods<'tcx> for CodegenCx<'tcx> {
         SpirvType::Integer(ptr_size, false).def(DUMMY_SP, self)
     }
 
+    fn type_f16(&self) -> Self::Type {
+        SpirvType::Float(16).def(DUMMY_SP, self)
+    }
     fn type_f32(&self) -> Self::Type {
         SpirvType::Float(32).def(DUMMY_SP, self)
     }
     fn type_f64(&self) -> Self::Type {
         SpirvType::Float(64).def(DUMMY_SP, self)
     }
+    fn type_f128(&self) -> Self::Type {
+        SpirvType::Float(128).def(DUMMY_SP, self)
+    }
 
     fn type_array(&self, ty: Self::Type, len: u64) -> Self::Type {
         SpirvType::Array {
@@ -209,6 +198,7 @@ impl<'tcx> BaseTypeMethods<'tcx> for CodegenCx<'tcx> {
                 16 => TypeKind::Half,
                 32 => TypeKind::Float,
                 64 => TypeKind::Double,
+                128 => TypeKind::FP128,
                 other => self
                     .tcx
                     .dcx()

crates/rustc_codegen_spirv/src/linker/mod.rs

@@ -647,6 +647,9 @@ pub fn link(
                         entry.insert((entry_name, module));
                         break;
                     }
+                    // FIXME(eddyb) false positive: `file_stem` was moved out of,
+                    // so assigning it is necessary, but clippy doesn't know that.
+                    #[allow(clippy::assigning_clones)]
                     Entry::Occupied(entry) => {
                         // FIXME(eddyb) there's no way to access the owned key
                         // passed to `BTreeMap::entry` from `OccupiedEntry`.

crates/rustc_codegen_spirv/src/linker/test.rs

@@ -122,20 +122,17 @@ fn link_with_linker_opts(
     // is really a silent unwinding device, that should be treated the same as
     // `Err(ErrorGuaranteed)` returns from `link`).
     rustc_driver::catch_fatal_errors(|| {
-        let mut early_error_handler =
+        let mut early_dcx =
             rustc_session::EarlyDiagCtxt::new(rustc_session::config::ErrorOutputType::default());
-        early_error_handler.initialize_checked_jobserver();
-        let matches = rustc_driver::handle_options(
-            &early_error_handler,
-            &["".to_string(), "x.rs".to_string()],
-        )
-        .unwrap();
-        let sopts =
-            rustc_session::config::build_session_options(&mut early_error_handler, &matches);
+        early_dcx.initialize_checked_jobserver();
+        let matches =
+            rustc_driver::handle_options(&early_dcx, &["".to_string(), "x.rs".to_string()])
+                .unwrap();
+        let sopts = rustc_session::config::build_session_options(&mut early_dcx, &matches);
 
         rustc_span::create_session_globals_then(sopts.edition, || {
             let mut sess = rustc_session::build_session(
-                early_error_handler,
+                early_dcx,
                 sopts,
                 CompilerIO {
                     input: Input::Str {
@@ -160,7 +157,7 @@ fn link_with_linker_opts(
 
             // HACK(eddyb) inject `write_diags` into `sess`, to work around
             // the removals in https://github.com/rust-lang/rust/pull/102992.
-            sess.parse_sess.dcx = {
+            sess.psess.dcx = {
                 let fallback_bundle = {
                     extern crate rustc_error_messages;
                     rustc_error_messages::fallback_fluent_bundle(
@@ -170,7 +167,7 @@ fn link_with_linker_opts(
                 };
                 let emitter =
                     rustc_errors::emitter::HumanEmitter::new(Box::new(buf), fallback_bundle)
-                        .sm(Some(sess.parse_sess.clone_source_map()));
+                        .sm(Some(sess.psess.clone_source_map()));
 
                 rustc_errors::DiagCtxt::new(Box::new(emitter))
                     .with_flags(sess.opts.unstable_opts.dcx_flags(true))