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))