Rollup of 12 pull requests

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -2086,7 +2086,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
     }
 
     if name == sym::simd_splat {
-        let (_out_len, out_ty) = require_simd!(ret_ty, SimdReturn);
+        let (out_len, out_ty) = require_simd!(ret_ty, SimdReturn);
 
         require!(
             args[0].layout.ty == out_ty,
@@ -2105,7 +2105,8 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
 
         // `shufflevector <N x elem> v0, <N x elem> poison, <N x i32> zeroinitializer`
         // The masks is all zeros, so this splats lane 0 (which has our element in it).
-        let splat = bx.shuffle_vector(v0, poison_vec, bx.const_null(llret_ty));
+        let mask_ty = bx.type_vector(bx.type_i32(), out_len);
+        let splat = bx.shuffle_vector(v0, poison_vec, bx.const_null(mask_ty));
 
         return Ok(splat);
     }

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -2,7 +2,7 @@ use std::borrow::{Borrow, Cow};
 use std::hash::Hash;
 use std::{fmt, mem};
 
-use rustc_abi::{Align, FIRST_VARIANT, Size};
+use rustc_abi::{Align, FIRST_VARIANT, FieldIdx, Size};
 use rustc_ast::Mutability;
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap, IndexEntry};
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -11,7 +11,7 @@ use rustc_middle::mir::AssertMessage;
 use rustc_middle::mir::interpret::ReportedErrorInfo;
 use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::layout::{HasTypingEnv, TyAndLayout, ValidityRequirement};
-use rustc_middle::ty::{self, FieldInfo, Ty, TyCtxt};
+use rustc_middle::ty::{self, FieldInfo, ScalarInt, Ty, TyCtxt};
 use rustc_middle::{bug, mir, span_bug};
 use rustc_span::{Span, Symbol, sym};
 use rustc_target::callconv::FnAbi;
@@ -605,6 +605,23 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 ecx.write_type_info(ty, dest)?;
             }
 
+            sym::size_of_type_id => {
+                let ty = ecx.read_type_id(&args[0])?;
+                let layout = ecx.layout_of(ty)?;
+                let variant_index = if layout.is_sized() {
+                    let (variant, variant_place) = ecx.project_downcast_named(dest, sym::Some)?;
+                    let size_field_place = ecx.project_field(&variant_place, FieldIdx::ZERO)?;
+                    ecx.write_scalar(
+                        ScalarInt::try_from_target_usize(layout.size.bytes(), ecx.tcx.tcx).unwrap(),
+                        &size_field_place,
+                    )?;
+                    variant
+                } else {
+                    ecx.project_downcast_named(dest, sym::None)?.0
+                };
+                ecx.write_discriminant(variant_index, dest)?;
+            }
+
             sym::field_offset => {
                 let frt_ty = instance.args.type_at(0);
                 ensure_monomorphic_enough(ecx.tcx.tcx, frt_ty)?;

compiler/rustc_const_eval/src/const_eval/type_info.rs

@@ -2,7 +2,7 @@ mod adt;
 
 use std::borrow::Cow;
 
-use rustc_abi::{ExternAbi, FieldIdx, VariantIdx};
+use rustc_abi::{ExternAbi, FieldIdx};
 use rustc_ast::Mutability;
 use rustc_hir::LangItem;
 use rustc_middle::span_bug;
@@ -12,27 +12,11 @@ use rustc_span::{Symbol, sym};
 
 use crate::const_eval::CompileTimeMachine;
 use crate::interpret::{
-    CtfeProvenance, Immediate, InterpCx, InterpResult, MPlaceTy, MemoryKind, Projectable, Scalar,
-    Writeable, interp_ok,
+    CtfeProvenance, Immediate, InterpCx, InterpResult, MPlaceTy, MemoryKind, Scalar, Writeable,
+    interp_ok,
 };
 
 impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
-    /// Equivalent to `project_downcast`, but identifies the variant by name instead of index.
-    fn downcast<'a>(
-        &self,
-        place: &(impl Writeable<'tcx, CtfeProvenance> + 'a),
-        name: Symbol,
-    ) -> InterpResult<'tcx, (VariantIdx, impl Writeable<'tcx, CtfeProvenance> + 'a)> {
-        let variants = place.layout().ty.ty_adt_def().unwrap().variants();
-        let variant_idx = variants
-            .iter_enumerated()
-            .find(|(_idx, var)| var.name == name)
-            .unwrap_or_else(|| panic!("got {name} but expected one of {variants:#?}"))
-            .0;
-
-        interp_ok((variant_idx, self.project_downcast(place, variant_idx)?))
-    }
-
     // A general method to write an array to a static slice place.
     fn allocate_fill_and_write_slice_ptr(
         &mut self,
@@ -83,7 +67,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                     let variant_index = match ty.kind() {
                         ty::Tuple(fields) => {
                             let (variant, variant_place) =
-                                self.downcast(&field_dest, sym::Tuple)?;
+                                self.project_downcast_named(&field_dest, sym::Tuple)?;
                             // project to the single tuple variant field of `type_info::Tuple` struct type
                             let tuple_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
                             assert_eq!(
@@ -102,7 +86,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                         }
                         ty::Array(ty, len) => {
                             let (variant, variant_place) =
-                                self.downcast(&field_dest, sym::Array)?;
+                                self.project_downcast_named(&field_dest, sym::Array)?;
                             let array_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
 
                             self.write_array_type_info(array_place, *ty, *len)?;
@@ -111,7 +95,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                         }
                         ty::Slice(ty) => {
                             let (variant, variant_place) =
-                                self.downcast(&field_dest, sym::Slice)?;
+                                self.project_downcast_named(&field_dest, sym::Slice)?;
                             let slice_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
 
                             self.write_slice_type_info(slice_place, *ty)?;
@@ -123,16 +107,17 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                         }
                         ty::Bool => {
                             let (variant, _variant_place) =
-                                self.downcast(&field_dest, sym::Bool)?;
+                                self.project_downcast_named(&field_dest, sym::Bool)?;
                             variant
                         }
                         ty::Char => {
                             let (variant, _variant_place) =
-                                self.downcast(&field_dest, sym::Char)?;
+                                self.project_downcast_named(&field_dest, sym::Char)?;
                             variant
                         }
                         ty::Int(int_ty) => {
-                            let (variant, variant_place) = self.downcast(&field_dest, sym::Int)?;
+                            let (variant, variant_place) =
+                                self.project_downcast_named(&field_dest, sym::Int)?;
                             let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
                             self.write_int_type_info(
                                 place,
@@ -142,7 +127,8 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                             variant
                         }
                         ty::Uint(uint_ty) => {
-                            let (variant, variant_place) = self.downcast(&field_dest, sym::Int)?;
+                            let (variant, variant_place) =
+                                self.project_downcast_named(&field_dest, sym::Int)?;
                             let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
                             self.write_int_type_info(
                                 place,
@@ -153,18 +139,19 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                         }
                         ty::Float(float_ty) => {
                             let (variant, variant_place) =
-                                self.downcast(&field_dest, sym::Float)?;
+                                self.project_downcast_named(&field_dest, sym::Float)?;
                             let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
                             self.write_float_type_info(place, float_ty.bit_width())?;
                             variant
                         }
                         ty::Str => {
-                            let (variant, _variant_place) = self.downcast(&field_dest, sym::Str)?;
+                            let (variant, _variant_place) =
+                                self.project_downcast_named(&field_dest, sym::Str)?;
                             variant
                         }
                         ty::Ref(_, ty, mutability) => {
                             let (variant, variant_place) =
-                                self.downcast(&field_dest, sym::Reference)?;
+                                self.project_downcast_named(&field_dest, sym::Reference)?;
                             let reference_place =
                                 self.project_field(&variant_place, FieldIdx::ZERO)?;
                             self.write_reference_type_info(reference_place, *ty, *mutability)?;
@@ -173,7 +160,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                         }
                         ty::RawPtr(ty, mutability) => {
                             let (variant, variant_place) =
-                                self.downcast(&field_dest, sym::Pointer)?;
+                                self.project_downcast_named(&field_dest, sym::Pointer)?;
                             let pointer_place =
                                 self.project_field(&variant_place, FieldIdx::ZERO)?;
 
@@ -183,14 +170,14 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                         }
                         ty::Dynamic(predicates, region) => {
                             let (variant, variant_place) =
-                                self.downcast(&field_dest, sym::DynTrait)?;
+                                self.project_downcast_named(&field_dest, sym::DynTrait)?;
                             let dyn_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
                             self.write_dyn_trait_type_info(dyn_place, *predicates, *region)?;
                             variant
                         }
                         ty::FnPtr(sig, fn_header) => {
                             let (variant, variant_place) =
-                                self.downcast(&field_dest, sym::FnPtr)?;
+                                self.project_downcast_named(&field_dest, sym::FnPtr)?;
                             let fn_ptr_place =
                                 self.project_field(&variant_place, FieldIdx::ZERO)?;
 
@@ -214,27 +201,10 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                         | ty::Bound(..)
                         | ty::Placeholder(_)
                         | ty::Infer(..)
-                        | ty::Error(_) => self.downcast(&field_dest, sym::Other)?.0,
+                        | ty::Error(_) => self.project_downcast_named(&field_dest, sym::Other)?.0,
                     };
                     self.write_discriminant(variant_index, &field_dest)?
                 }
-                sym::size => {
-                    let layout = self.layout_of(ty)?;
-                    let variant_index = if layout.is_sized() {
-                        let (variant, variant_place) = self.downcast(&field_dest, sym::Some)?;
-                        let size_field_place =
-                            self.project_field(&variant_place, FieldIdx::ZERO)?;
-                        self.write_scalar(
-                            ScalarInt::try_from_target_usize(layout.size.bytes(), self.tcx.tcx)
-                                .unwrap(),
-                            &size_field_place,
-                        )?;
-                        variant
-                    } else {
-                        self.downcast(&field_dest, sym::None)?.0
-                    };
-                    self.write_discriminant(variant_index, &field_dest)?;
-                }
                 other => span_bug!(self.tcx.span, "unknown `Type` field {other}"),
             }
         }
@@ -433,16 +403,17 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                 sym::abi => match fn_sig_kind.abi() {
                     ExternAbi::C { .. } => {
                         let (rust_variant, _rust_place) =
-                            self.downcast(&field_place, sym::ExternC)?;
+                            self.project_downcast_named(&field_place, sym::ExternC)?;
                         self.write_discriminant(rust_variant, &field_place)?;
                     }
                     ExternAbi::Rust => {
                         let (rust_variant, _rust_place) =
-                            self.downcast(&field_place, sym::ExternRust)?;
+                            self.project_downcast_named(&field_place, sym::ExternRust)?;
                         self.write_discriminant(rust_variant, &field_place)?;
                     }
                     other_abi => {
-                        let (variant, variant_place) = self.downcast(&field_place, sym::Named)?;
+                        let (variant, variant_place) =
+                            self.project_downcast_named(&field_place, sym::Named)?;
                         let str_place = self.allocate_str_dedup(other_abi.as_str())?;
                         let str_ref = self.mplace_to_imm_ptr(&str_place, None)?;
                         let payload = self.project_field(&variant_place, FieldIdx::ZERO)?;

compiler/rustc_const_eval/src/const_eval/type_info/adt.rs

@@ -22,7 +22,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
         let (adt_ty, adt_def) = adt;
         let variant_idx = match adt_def.adt_kind() {
             AdtKind::Struct => {
-                let (variant, variant_place) = self.downcast(place, sym::Struct)?;
+                let (variant, variant_place) = self.project_downcast_named(place, sym::Struct)?;
                 let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
                 self.write_struct_type_info(
                     place,
@@ -32,7 +32,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                 variant
             }
             AdtKind::Union => {
-                let (variant, variant_place) = self.downcast(place, sym::Union)?;
+                let (variant, variant_place) = self.project_downcast_named(place, sym::Union)?;
                 let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
                 self.write_union_type_info(
                     place,
@@ -42,7 +42,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                 variant
             }
             AdtKind::Enum => {
-                let (variant, variant_place) = self.downcast(place, sym::Enum)?;
+                let (variant, variant_place) = self.project_downcast_named(place, sym::Enum)?;
                 let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
                 self.write_enum_type_info(place, adt, generics)?;
                 variant
@@ -219,13 +219,13 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
         _region: Region<'tcx>,
         place: MPlaceTy<'tcx>,
     ) -> InterpResult<'tcx> {
-        let (variant_idx, _) = self.downcast(&place, sym::Lifetime)?;
+        let (variant_idx, _) = self.project_downcast_named(&place, sym::Lifetime)?;
         self.write_discriminant(variant_idx, &place)?;
         interp_ok(())
     }
 
     fn write_generic_type(&mut self, ty: Ty<'tcx>, place: MPlaceTy<'tcx>) -> InterpResult<'tcx> {
-        let (variant_idx, variant_place) = self.downcast(&place, sym::Type)?;
+        let (variant_idx, variant_place) = self.project_downcast_named(&place, sym::Type)?;
         let generic_type_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
 
         for (field_idx, field_def) in generic_type_place
@@ -251,7 +251,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
     fn write_generic_const(&mut self, c: Const<'tcx>, place: MPlaceTy<'tcx>) -> InterpResult<'tcx> {
         let ConstKind::Value(c) = c.kind() else { bug!("expected a computed const, got {c:?}") };
 
-        let (variant_idx, variant_place) = self.downcast(&place, sym::Const)?;
+        let (variant_idx, variant_place) = self.project_downcast_named(&place, sym::Const)?;
         let const_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
 
         for (field_idx, field_def) in const_place

compiler/rustc_const_eval/src/interpret/projection.rs

@@ -14,6 +14,7 @@ use rustc_abi::{self as abi, FieldIdx, Size, VariantIdx};
 use rustc_middle::ty::Ty;
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::{bug, mir, span_bug, ty};
+use rustc_span::Symbol;
 use tracing::{debug, instrument};
 
 use super::{
@@ -227,6 +228,22 @@ where
         base.offset(Size::ZERO, layout, self)
     }
 
+    /// Equivalent to `project_downcast`, but identifies the variant by name instead of index.
+    pub fn project_downcast_named<P: Projectable<'tcx, M::Provenance>>(
+        &self,
+        base: &P,
+        name: Symbol,
+    ) -> InterpResult<'tcx, (VariantIdx, P)> {
+        let variants = base.layout().ty.ty_adt_def().unwrap().variants();
+        let variant_idx = variants
+            .iter_enumerated()
+            .find(|(_idx, var)| var.name == name)
+            .unwrap_or_else(|| panic!("got {name} but expected one of {variants:#?}"))
+            .0;
+
+        interp_ok((variant_idx, self.project_downcast(base, variant_idx)?))
+    }
+
     /// Compute the offset and field layout for accessing the given index.
     pub fn project_index<P: Projectable<'tcx, M::Provenance>>(
         &self,