rustup: update to nightly-2024-06-08 (~1.80).

Author: eddyb

crates/rustc_codegen_spirv/build.rs

@@ -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-05-01"
+channel = "nightly-2024-06-08"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = f705de59625bb76067a5d102edc1575ff23b8845"#;
+# commit_hash = 804421dff5542c9c7da5c60257b5dbc849719505"#;
 
 fn rustc_output(arg: &str) -> Result<String, Box<dyn Error>> {
     let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".into());
@@ -167,8 +167,8 @@ fn generate_pqp_cg_ssa() -> Result<(), Box<dyn Error>> {
                 );
             } else if relative_path == Path::new("src/mir/place.rs") {
                 src = src.replace(
-                    "alloca(layout.size,",
-                    "typed_alloca(bx.cx().backend_type(layout),",
+                    "PlaceValue::alloca(bx, layout.size, layout.align.abi)",
+                    "PlaceValue::new_sized(bx.typed_alloca(bx.cx().backend_type(layout), layout.align.abi), layout.align.abi)",
                 );
             } else if relative_path == Path::new("src/mir/operand.rs") {
                 src = src.replace("alloca(field.size,", "typed_alloca(llfield_ty,");

crates/rustc_codegen_spirv/src/abi.rs

@@ -8,12 +8,14 @@ use rspirv::spirv::{Dim, ImageFormat, StorageClass, Word};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::ErrorGuaranteed;
 use rustc_index::Idx;
+use rustc_middle::mir::interpret::ErrorHandled;
 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, UintTy,
+    self, Const, CoroutineArgs, CoroutineArgsExt as _, FloatTy, IntTy, ParamEnv, PolyFnSig, Ty,
+    TyCtxt, TyKind, UintTy,
 };
+use rustc_middle::ty::{GenericArgsRef, ScalarInt};
 use rustc_middle::{bug, span_bug};
 use rustc_span::def_id::DefId;
 use rustc_span::DUMMY_SP;
@@ -27,8 +29,6 @@ use std::cell::RefCell;
 use std::collections::hash_map::Entry;
 use std::fmt;
 
-use num_traits::cast::FromPrimitive;
-
 pub(crate) fn provide(providers: &mut Providers) {
     // This is a lil weird: so, we obviously don't support C ABIs at all. However, libcore does declare some extern
     // C functions:
@@ -501,13 +501,12 @@ fn trans_scalar<'tcx>(
     }
 
     match scalar.primitive() {
-        Primitive::Int(width, signedness) => {
-            SpirvType::Integer(width.size().bits() as u32, signedness).def(span, cx)
+        Primitive::Int(int_kind, signedness) => {
+            SpirvType::Integer(int_kind.size().bits() as u32, signedness).def(span, cx)
+        }
+        Primitive::Float(float_kind) => {
+            SpirvType::Float(float_kind.size().bits() as u32).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
@@ -862,41 +861,51 @@ fn trans_intrinsic_type<'tcx>(
             // let image_format: spirv::ImageFormat =
             //     type_from_variant_discriminant(cx, args.const_at(6));
 
-            trait FromU128Const: Sized {
-                fn from_u128_const(n: u128) -> Option<Self>;
+            trait FromScalarInt: Sized {
+                fn from_scalar_int(n: ScalarInt) -> Option<Self>;
             }
 
-            impl FromU128Const for u32 {
-                fn from_u128_const(n: u128) -> Option<Self> {
-                    u32::from_u128(n)
+            impl FromScalarInt for u32 {
+                fn from_scalar_int(n: ScalarInt) -> Option<Self> {
+                    n.try_to_u32().ok()
                 }
             }
 
-            impl FromU128Const for Dim {
-                fn from_u128_const(n: u128) -> Option<Self> {
-                    Dim::from_u32(u32::from_u128(n)?)
+            impl FromScalarInt for Dim {
+                fn from_scalar_int(n: ScalarInt) -> Option<Self> {
+                    Dim::from_u32(u32::from_scalar_int(n)?)
                 }
             }
 
-            impl FromU128Const for ImageFormat {
-                fn from_u128_const(n: u128) -> Option<Self> {
-                    ImageFormat::from_u32(u32::from_u128(n)?)
+            impl FromScalarInt for ImageFormat {
+                fn from_scalar_int(n: ScalarInt) -> Option<Self> {
+                    ImageFormat::from_u32(u32::from_scalar_int(n)?)
                 }
             }
 
-            fn const_int_value<'tcx, P: FromU128Const>(
+            fn const_int_value<'tcx, P: FromScalarInt>(
                 cx: &CodegenCx<'tcx>,
                 const_: Const<'tcx>,
             ) -> Result<P, ErrorGuaranteed> {
-                assert!(const_.ty().is_integral());
-                let value = const_.eval_bits(cx.tcx, ParamEnv::reveal_all());
-                match P::from_u128_const(value) {
-                    Some(v) => Ok(v),
-                    None => Err(cx
-                        .tcx
-                        .dcx()
-                        .err(format!("Invalid value for Image const generic: {value}"))),
-                }
+                const_
+                    .eval(cx.tcx, ParamEnv::reveal_all(), DUMMY_SP)
+                    .map_err(|e| match e {
+                        ErrorHandled::Reported(reported_error_info, _) => {
+                            Some(reported_error_info.into())
+                        }
+                        ErrorHandled::TooGeneric(_) => None,
+                    })
+                    .and_then(|(const_ty, const_val)| {
+                        assert!(const_ty.is_integral());
+                        P::from_scalar_int(const_val.try_to_scalar_int().ok_or(None)?).ok_or(None)
+                    })
+                    .map_err(|already_reported| {
+                        already_reported.unwrap_or_else(|| {
+                            cx.tcx
+                                .dcx()
+                                .err(format!("invalid value for Image const generic: {const_}"))
+                        })
+                    })
             }
 
             let dim = const_int_value(cx, args.const_at(1))?;

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -977,7 +977,6 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
             cx,
             cursor,
             current_fn,
-            basic_block: llbb,
             current_span: Default::default(),
         }
     }
@@ -987,7 +986,8 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
     }
 
     fn llbb(&self) -> Self::BasicBlock {
-        self.basic_block
+        // FIXME(eddyb) `llbb` should be removed from `rustc_codegen_ssa::traits`.
+        unreachable!("dead code within `rustc_codegen_ssa`")
     }
 
     fn set_span(&mut self, span: Span) {
@@ -2797,7 +2797,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                 ///
                 /// E.g. for `format_args!("{a} {b:x}")` they'll be:
                 /// * `&a` with `typeof a` and ' ',
-                ///  *`&b` with `typeof b` and 'x'
+                /// * `&b` with `typeof b` and 'x'
                 ref_arg_ids_with_ty_and_spec: SmallVec<[(Word, Ty<'tcx>, char); 2]>,
             }
             struct FormatArgsNotRecognized(String);
@@ -2810,24 +2810,23 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                     SpirvConst::Scalar(x) => Some(u32::try_from(x).ok()? as usize),
                     _ => None,
                 };
-                let const_slice_as_elem_ids = |slice_ptr_and_len_ids: &[Word]| {
-                    if let [ptr_id, len_id] = slice_ptr_and_len_ids[..] {
-                        if let SpirvConst::PtrTo { pointee } =
-                            self.builder.lookup_const_by_id(ptr_id)?
+                let const_slice_as_elem_ids = |ptr_id: Word, len: usize| {
+                    if let SpirvConst::PtrTo { pointee } =
+                        self.builder.lookup_const_by_id(ptr_id)?
+                    {
+                        if let SpirvConst::Composite(elems) =
+                            self.builder.lookup_const_by_id(pointee)?
                         {
-                            if let SpirvConst::Composite(elems) =
-                                self.builder.lookup_const_by_id(pointee)?
-                            {
-                                if elems.len() == const_u32_as_usize(len_id)? {
-                                    return Some(elems);
-                                }
+                            if elems.len() == len {
+                                return Some(elems);
                             }
                         }
                     }
                     None
                 };
-                let const_str_as_utf8 = |str_ptr_and_len_ids: &[Word]| {
-                    let piece_str_bytes = const_slice_as_elem_ids(str_ptr_and_len_ids)?
+                let const_str_as_utf8 = |&[str_ptr_id, str_len_id]: &[Word; 2]| {
+                    let str_len = const_u32_as_usize(str_len_id)?;
+                    let piece_str_bytes = const_slice_as_elem_ids(str_ptr_id, str_len)?
                         .iter()
                         .map(|&id| u8::try_from(const_u32_as_usize(id)?).ok())
                         .collect::<Option<Vec<u8>>>()?;
@@ -3001,42 +3000,36 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                         "fmt::Arguments::new call: ran out of instructions".into(),
                     )
                 })?;
-                let ((pieces_slice_ptr_id, pieces_len_id), (rt_args_slice_ptr_id, rt_args_count)) =
+                let ((pieces_slice_ptr_id, pieces_len), (rt_args_slice_ptr_id, rt_args_count)) =
                     match fmt_args_new_call_insts[..] {
                         [
                             Inst::Call(call_ret_id, callee_id, ref call_args),
                             Inst::Store(st_dst_id, st_val_id),
                             Inst::Load(ld_val_id, ld_src_id),
-                        ] if self.fmt_args_new_fn_ids.borrow().contains(&callee_id)
-                            && call_ret_id == st_val_id
+                        ] if call_ret_id == st_val_id
                             && st_dst_id == ld_src_id
                             && ld_val_id == format_args_id =>
                         {
                             require_local_var(st_dst_id, "fmt::Arguments::new destination")?;
 
+                            let Some(&(pieces_len, rt_args_count)) =
+                                self.fmt_args_new_fn_ids.borrow().get(&callee_id)
+                            else {
+                                return Err(FormatArgsNotRecognized(
+                                    "fmt::Arguments::new callee not registered".into(),
+                                ));
+                            };
+
                             match call_args[..] {
                                 // `<core::fmt::Arguments>::new_v1`
-                                [
-                                    pieces_slice_ptr_id,
-                                    pieces_len_id,
-                                    rt_args_slice_ptr_id,
-                                    rt_args_len_id,
-                                ] => (
-                                    (pieces_slice_ptr_id, pieces_len_id),
-                                    (
-                                        Some(rt_args_slice_ptr_id),
-                                        const_u32_as_usize(rt_args_len_id).ok_or_else(|| {
-                                            FormatArgsNotRecognized(
-                                                "fmt::Arguments::new: args.len() not constant"
-                                                    .into(),
-                                            )
-                                        })?,
-                                    ),
+                                [pieces_slice_ptr_id, rt_args_slice_ptr_id] => (
+                                    (pieces_slice_ptr_id, pieces_len),
+                                    (Some(rt_args_slice_ptr_id), rt_args_count),
                                 ),
 
                                 // `<core::fmt::Arguments>::new_const`
-                                [pieces_slice_ptr_id, pieces_len_id] => {
-                                    ((pieces_slice_ptr_id, pieces_len_id), (None, 0))
+                                [pieces_slice_ptr_id] if rt_args_count == 0 => {
+                                    ((pieces_slice_ptr_id, pieces_len), (None, rt_args_count))
                                 }
 
                                 _ => {
@@ -3068,21 +3061,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                 // arguments (from e.g. new `assert!`s being added to `core`),
                 // we have to confirm their many instructions for removal.
                 if rt_args_count > 0 {
-                    let rt_args_slice_ptr_id = rt_args_slice_ptr_id.unwrap();
-                    let rt_args_array_ptr_id = match try_rev_take(1).ok_or_else(|| {
-                        FormatArgsNotRecognized(
-                            "&[fmt::rt::Argument] bitcast: ran out of instructions".into(),
-                        )
-                    })?[..]
-                    {
-                        [Inst::Bitcast(out_id, in_id)] if out_id == rt_args_slice_ptr_id => in_id,
-                        _ => {
-                            return Err(FormatArgsNotRecognized(
-                                "&[fmt::rt::Argument] bitcast".into(),
-                            ));
-                        }
-                    };
-                    require_local_var(rt_args_array_ptr_id, "[fmt::rt::Argument; N]")?;
+                    let rt_args_array_ptr_id = rt_args_slice_ptr_id.unwrap();
 
                     // Each runtime argument has 4 instructions to call one of
                     // the `fmt::rt::Argument::new_*` functions (and temporarily
@@ -3162,13 +3141,15 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                     _ => pieces_slice_ptr_id,
                 };
                 decoded_format_args.const_pieces =
-                    const_slice_as_elem_ids(&[pieces_slice_ptr_id, pieces_len_id]).and_then(
+                    const_slice_as_elem_ids(pieces_slice_ptr_id, pieces_len).and_then(
                         |piece_ids| {
                             piece_ids
                                 .iter()
                                 .map(|&piece_id| {
                                     match self.builder.lookup_const_by_id(piece_id)? {
-                                        SpirvConst::Composite(piece) => const_str_as_utf8(piece),
+                                        SpirvConst::Composite(piece) => {
+                                            const_str_as_utf8(piece.try_into().ok()?)
+                                        }
                                         _ => None,
                                     }
                                 })
@@ -3198,7 +3179,9 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                                 .map(|s| Cow::Owned(s.replace('%', "%%")))
                                 .interleave(ref_arg_ids_with_ty_and_spec.iter().map(
                                     |&(ref_id, ty, spec)| {
-                                        use rustc_target::abi::{Integer::*, Primitive::*};
+                                        use rustc_target::abi::{
+                                            Float::*, Integer::*, Primitive::*,
+                                        };
 
                                         let layout = self.layout_of(ty);
 
@@ -3212,7 +3195,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                                             (' ' | '?', Some(Int(I32, false))) => "%u",
                                             ('x', Some(Int(I32, false))) => "%x",
                                             (' ' | '?', Some(Int(I32, true))) => "%i",
-                                            (' ' | '?', Some(F32)) => "%f",
+                                            (' ' | '?', Some(Float(F32))) => "%f",
 
                                             _ => "",
                                         };

crates/rustc_codegen_spirv/src/builder/mod.rs

@@ -42,7 +42,6 @@ pub struct Builder<'a, 'tcx> {
     cx: &'a CodegenCx<'tcx>,
     cursor: BuilderCursor,
     current_fn: <Self as BackendTypes>::Function,
-    basic_block: <Self as BackendTypes>::BasicBlock,
     current_span: Option<Span>,
 }
 

crates/rustc_codegen_spirv/src/codegen_cx/constant.rs

@@ -11,7 +11,7 @@ use rustc_middle::bug;
 use rustc_middle::mir::interpret::{alloc_range, ConstAllocation, GlobalAlloc, Scalar};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_span::{Span, DUMMY_SP};
-use rustc_target::abi::{self, AddressSpace, HasDataLayout, Integer, Primitive, Size};
+use rustc_target::abi::{self, AddressSpace, Float, HasDataLayout, Integer, Primitive, Size};
 
 impl<'tcx> CodegenCx<'tcx> {
     pub fn def_constant(&self, ty: Word, val: SpirvConst<'_, 'tcx>) -> SpirvValue {
@@ -398,8 +398,8 @@ impl<'tcx> CodegenCx<'tcx> {
                 let size = ty_concrete.sizeof(self).unwrap();
                 let primitive = match ty_concrete {
                     SpirvType::Bool => Primitive::Int(Integer::fit_unsigned(0), false),
-                    SpirvType::Integer(int_size, int_signedness) => {
-                        let integer = match int_size {
+                    SpirvType::Integer(int_size, int_signedness) => Primitive::Int(
+                        match int_size {
                             8 => Integer::I8,
                             16 => Integer::I16,
                             32 => Integer::I32,
@@ -410,18 +410,20 @@ impl<'tcx> CodegenCx<'tcx> {
                                     .dcx()
                                     .fatal(format!("invalid size for integer: {other}"));
                             }
-                        };
-                        Primitive::Int(integer, int_signedness)
-                    }
-                    SpirvType::Float(float_size) => match float_size {
-                        32 => Primitive::F32,
-                        64 => Primitive::F64,
+                        },
+                        int_signedness,
+                    ),
+                    SpirvType::Float(float_size) => Primitive::Float(match float_size {
+                        16 => Float::F16,
+                        32 => Float::F32,
+                        64 => Float::F64,
+                        128 => Float::F128,
                         other => {
                             self.tcx
                                 .dcx()
                                 .fatal(format!("invalid size for float: {other}"));
                         }
-                    },
+                    }),
                     SpirvType::Pointer { .. } => Primitive::Pointer(AddressSpace::DATA),
                     unsupported_spirv_type => bug!(
                         "invalid spirv type internal to create_alloc_const2: {:?}",