Rollup of 16 pull requests

compiler/rustc_abi/src/callconv.rs

@@ -1,5 +1,5 @@
 #[cfg(feature = "nightly")]
-use crate::{BackendRepr, FieldsShape, Primitive, Size, TyAbiInterface, TyAndLayout, Variants};
+use crate::{BackendRepr, FieldsShape, Size, TyAbiInterface, TyAndLayout, Variants};
 
 mod reg;
 
@@ -73,10 +73,7 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
         match self.backend_repr {
             // The primitive for this algorithm.
             BackendRepr::Scalar(scalar) => {
-                let kind = match scalar.primitive() {
-                    Primitive::Int(..) | Primitive::Pointer(_) => RegKind::Integer,
-                    Primitive::Float(_) => RegKind::Float,
-                };
+                let kind = RegKind::from_primitive(scalar.primitive());
                 Ok(HomogeneousAggregate::Homogeneous(Reg { kind, size: self.size }))
             }
 

compiler/rustc_abi/src/callconv/reg.rs

@@ -1,13 +1,19 @@
 #[cfg(feature = "nightly")]
 use rustc_macros::StableHash;
 
-use crate::{Align, HasDataLayout, Integer, Primitive, Size};
+use crate::{Align, Float, HasDataLayout, Integer, Primitive, Size};
 
+/// The "kind" of backend type, which combined with a [`Size`] forms a [`Reg`].
 #[cfg_attr(feature = "nightly", derive(StableHash))]
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub enum RegKind {
     Integer,
     Float,
+    /// The IBM extended-precision format: a pair of `f64`s, each passed in its own register.
+    /// This variant is needed to distinguish IEEE f128 and IBM f128 in the backends.
+    ///
+    /// Only used on PowerPC targets.
+    PpcF128,
     Vector {
         /// The `hint_vector_elem` is strictly for optimization purposes. E.g. it can be used by
         /// a codegen backend to prevent extra bitcasts that obscure a pattern. Alternatively,
@@ -20,11 +26,15 @@ impl RegKind {
     pub fn from_primitive(primitive: Primitive) -> Self {
         match primitive {
             Primitive::Int(..) | Primitive::Pointer(_) => RegKind::Integer,
-            Primitive::Float(_) => RegKind::Float,
+            Primitive::Float(Float::PpcF128) => RegKind::PpcF128,
+            Primitive::Float(Float::F16 | Float::F16B | Float::F32 | Float::F64 | Float::F128) => {
+                RegKind::Float
+            }
         }
     }
 }
 
+/// A combination of a [`RegKind`] and a [`Size`] that represents a builtin type in the backend.
 #[cfg_attr(feature = "nightly", derive(StableHash))]
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub struct Reg {
@@ -79,6 +89,7 @@ impl Reg {
                 128 => dl.f128_align,
                 _ => panic!("unsupported float: {self:?}"),
             },
+            RegKind::PpcF128 => dl.f128_align,
             RegKind::Vector { .. } => dl.rust_vector_align(self.size),
         }
     }

compiler/rustc_abi/src/layout/ty.rs

@@ -339,9 +339,9 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
         let primitive = scalar.primitive();
         match primitive {
             Primitive::Int(integer, is_signed) => Some(Numeric::Int(integer, is_signed)),
-            Primitive::Float(float @ (Float::F16 | Float::F32 | Float::F64 | Float::F128)) => {
-                Some(Numeric::Float(float))
-            }
+            Primitive::Float(
+                float @ (Float::F16 | Float::F32 | Float::F64 | Float::F128 | Float::PpcF128),
+            ) => Some(Numeric::Float(float)),
             Primitive::Pointer(..) | Primitive::Float(Float::F16B) => None,
         }
     }

compiler/rustc_abi/src/lib.rs

@@ -1427,6 +1427,10 @@ pub enum Float {
     F32,
     F64,
     F128,
+    /// `ppcf128`. This is not a builtin type in Rust (it is exposed as a lang item),
+    /// but it is a builtin type in LLVM so needs to be explicitly represented
+    /// in the backend.
+    PpcF128,
 }
 
 impl Float {
@@ -1439,6 +1443,7 @@ impl Float {
             F32 => Size::from_bits(32),
             F64 => Size::from_bits(64),
             F128 => Size::from_bits(128),
+            PpcF128 => Size::from_bits(128),
         }
     }
 
@@ -1451,6 +1456,7 @@ impl Float {
             F32 => dl.f32_align,
             F64 => dl.f64_align,
             F128 => dl.f128_align,
+            PpcF128 => dl.f128_align,
         })
     }
 
@@ -1463,6 +1469,7 @@ impl Float {
             F32 => "f32",
             F64 => "f64",
             F128 => "f128",
+            PpcF128 => "ppcf128",
         }
     }
 }
@@ -1487,7 +1494,10 @@ impl Numeric {
     pub fn reg_kind(self) -> RegKind {
         match self {
             Numeric::Int(_, _) => RegKind::Integer,
-            Numeric::Float(_) => RegKind::Float,
+            Numeric::Float(Float::PpcF128) => RegKind::PpcF128,
+            Numeric::Float(Float::F16 | Float::F16B | Float::F32 | Float::F64 | Float::F128) => {
+                RegKind::Float
+            }
         }
     }
 }

compiler/rustc_ast/src/ast.rs

@@ -124,6 +124,11 @@ impl StableHash for Path {
         self.segments.len().stable_hash(hcx, hasher);
         for segment in &self.segments {
             segment.ident.stable_hash(hcx, hasher);
+            if segment.args.is_some() {
+                // This should never happen, because Path::stable_hash is only used for attributes,
+                // which never have generic args. Check that to make sure, though.
+                panic!("Paths with generic args should not appear in incremental state");
+            }
         }
     }
 }
@@ -4072,7 +4077,7 @@ pub struct TestBinderBody {
     pub exists: ThinVec<TestBinderExists>,
     pub constraints: Vec<TestBinderConstraint>,
     /// These are not where clauses, but rather predicates within the body to be proven
-    pub predicates: Vec<WhereClause>,
+    pub predicates: Vec<WherePredicate>,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
@@ -4100,6 +4105,9 @@ pub enum TestBinderConstraint {
     Or {
         items: ThinVec<TestBinderConstraint>,
     },
+    Ambiguity {
+        span: Span,
+    },
     Lifetime {
         #[visitable(extra = LifetimeCtxt::Bound)]
         lhs: Lifetime,

compiler/rustc_ast_lowering/src/delegation/resolution.rs

@@ -4,7 +4,6 @@ use ast::visit::Visitor;
 use hir::def::DefKind;
 use rustc_ast::{self as ast, AssocItemKind, Delegation, DelegationSource, Item, ItemKind, NodeId};
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
-use rustc_data_structures::steal::Steal;
 use rustc_hir as hir;
 use rustc_middle::middle::resolve::{
     self as mid_res, AstOwner, DelegationInherentFnKind, TypeRelativeDelegationRes,
@@ -53,9 +52,10 @@ pub(crate) fn resolve_type_relative_delegations(
             // Also record resolutions for cases when signature is resolved but call path is not.
             mid_res::DelegationResolution::Partial
             | mid_res::DelegationResolution::PartialCall(_) => {
-                let Some(r_and_owner) = ast_index.get(def_id).map(Steal::borrow) else {
-                    unreachable!("ast index must contain delegations");
-                };
+                let r_and_owner = ast_index[def_id]
+                    .as_ref()
+                    .expect("ast index must contain delegations")
+                    .borrow();
 
                 let (r, owner) = &*r_and_owner;
 

compiler/rustc_ast_lowering/src/item.rs

@@ -2003,7 +2003,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let predicates = self.arena.alloc_from_iter(
             body.predicates
                 .iter()
-                .flat_map(|w| &w.predicates)
                 .map(|predicate| self.lower_where_predicate(predicate, &[], &mut dedup_map)),
         );
         hir::TestBinderBody { foralls, exists, constraints, predicates }
@@ -2083,6 +2082,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     items.iter().map(|item| self.lower_test_binder_constraint(item)),
                 ),
             },
+            TestBinderConstraint::Ambiguity { span } => {
+                hir::TestBinderConstraint::Ambiguity { span: self.lower_span(*span) }
+            }
             TestBinderConstraint::Lifetime { lhs, rhs } => {
                 let lhs = self.lower_lifetime(lhs, LifetimeSource::Other, lhs.ident.into());
                 let rhs = self.lower_lifetime(rhs, LifetimeSource::OutlivesBound, rhs.ident.into());

compiler/rustc_ast_lowering/src/lib.rs

@@ -587,7 +587,7 @@ enum TryBlockScope {
 fn index_ast<'tcx>(
     tcx: TyCtxt<'tcx>,
     (): (),
-) -> &'tcx IndexSlice<LocalDefId, Steal<(Arc<ResolverAstLowering<'tcx>>, AstOwner)>> {
+) -> &'tcx IndexSlice<LocalDefId, Option<Steal<(Arc<ResolverAstLowering<'tcx>>, AstOwner)>>> {
     // Queries that borrow `resolver_for_lowering`.
     tcx.ensure_done().output_filenames(());
     tcx.ensure_done().early_lint_checks(());
@@ -610,20 +610,19 @@ fn index_ast<'tcx>(
     let index = indexer.index;
     let resolver = Arc::new(resolver);
     return tcx.arena.alloc_index_slice_from_iter::<LocalDefId, _, _>(
-        index.into_iter().map(|owner| Steal::new((Arc::clone(&resolver), owner))),
+        index.into_iter().map(|owner| owner.map(|o| Steal::new((Arc::clone(&resolver), o)))),
     );
 
     struct Indexer<'s, 'hir> {
         owners: &'s NodeMap<PerOwnerResolverData<'hir>>,
-        index: IndexVec<LocalDefId, AstOwner>,
+        index: IndexVec<LocalDefId, Option<AstOwner>>,
         next_node_id: NodeId,
     }
 
     impl Indexer<'_, '_> {
         fn insert(&mut self, id: NodeId, node: AstOwner) {
             let def_id = self.owners[&id].def_id;
-            self.index.ensure_contains_elem(def_id, || AstOwner::NonOwner);
-            self.index[def_id] = node;
+            self.index.insert(def_id, node);
         }
 
         fn make_dummy<K>(
@@ -705,7 +704,7 @@ fn lower_to_hir(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::MaybeOwner<'_> {
     tcx.ensure_done().resolve_type_relative_delegations(());
 
     let ast_index = tcx.index_ast(());
-    let resolver_and_node = ast_index.get(def_id).map(Steal::steal);
+    let resolver_and_node = ast_index.get(def_id);
 
     let fallback_to_ancestor = || {
         // The item did not exist in the AST, it was created while lowering another item.
@@ -732,10 +731,13 @@ fn lower_to_hir(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::MaybeOwner<'_> {
         })
     };
 
-    let Some((resolver, node)) = resolver_and_node else {
+    let Some(Some(r_and_node)) = resolver_and_node else {
         // `ast_index` does not contain all definitions, only up-to the highest
         // `LocalDefId` which has a non-trivial `AstOwner`. Gracefully handle
         // other definitions, in particular those nested inside this highest definition.
+        // OR
+        // The item existed in the AST, but is not a HIR owner.
+        // Fetch the correct information from its parent.
         return fallback_to_ancestor();
     };
 
@@ -750,6 +752,8 @@ fn lower_to_hir(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::MaybeOwner<'_> {
         hir::MaybeOwner::Owner(lctx.curr_owner.into_owner_info(tcx, item))
     }
 
+    let (resolver, node) = r_and_node.steal();
+
     let item = match &node {
         // The item existed in the AST.
         AstOwner::Crate(c) => with_lctx(tcx, &*resolver, CRATE_NODE_ID, |lctx| {
@@ -770,9 +774,6 @@ fn lower_to_hir(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::MaybeOwner<'_> {
         AstOwner::ForeignItem(item) => with_lctx(tcx, &*resolver, item.id, |lctx| {
             hir::OwnerNode::ForeignItem(lctx.lower_foreign_item(item))
         }),
-        // The item existed in the AST, but is not a HIR owner.
-        // Fetch the correct information from its parent.
-        AstOwner::NonOwner => fallback_to_ancestor(),
     };
 
     tcx.sess.time("drop_ast", || mem::drop(node));

compiler/rustc_attr_ir/src/lang_items.rs

@@ -237,6 +237,7 @@ language_item_table! {
     VaList,                  sym::va_list,             va_list,                    Target::Struct,         GenericRequirement::None;
 
     Complex,                 sym::complex,             complex,                    Target::Struct,         GenericRequirement::Exact(1);
+    PpcF128,                 sym::ppcf128,             ppcf128,                    Target::Struct,         GenericRequirement::None;
 
     Deref,                   sym::deref,               deref_trait,                Target::Trait,          GenericRequirement::Exact(0);
     DerefMut,                sym::deref_mut,           deref_mut_trait,            Target::Trait,          GenericRequirement::Exact(0);

compiler/rustc_codegen_cranelift/src/common.rs

@@ -39,6 +39,7 @@ pub(crate) fn scalar_to_clif_type(tcx: TyCtxt<'_>, scalar: Scalar) -> Type {
             Float::F32 => types::F32,
             Float::F64 => types::F64,
             Float::F128 => types::F128,
+            Float::PpcF128 => bug!("cranelift does not support powerpc"),
         },
         // FIXME(erikdesjardins): handle non-default addrspace ptr sizes
         Primitive::Pointer(_) => pointer_ty(tcx),

compiler/rustc_codegen_gcc/src/abi.rs

@@ -90,6 +90,7 @@ impl GccType for Reg {
                 64 => cx.type_f64(),
                 _ => bug!("unsupported float: {:?}", self),
             },
+            RegKind::PpcF128 => cx.type_ppcf128(),
             RegKind::Vector { hint_vector_elem: _ } => {
                 cx.type_vector(cx.type_i8(), self.size.bytes())
             }

compiler/rustc_codegen_gcc/src/type_.rs

@@ -267,6 +267,12 @@ impl<'gcc, 'tcx> BaseTypeCodegenMethods for CodegenCx<'gcc, 'tcx> {
         bug!("unsupported float width 128")
     }
 
+    fn type_ppcf128(&self) -> Type<'gcc> {
+        // FIXME(ppcf128): The GCC gcc_jit_types enum (which CType is based on) does not
+        // have __ibm128. It does have long double but it may not correspond to ppc f128.
+        bug!("unsupported ppcf128 type")
+    }
+
     fn type_func(&self, params: &[Type<'gcc>], return_type: Type<'gcc>) -> Type<'gcc> {
         self.context.new_function_pointer_type(None, return_type, params, false)
     }

compiler/rustc_codegen_llvm/src/abi.rs

@@ -147,6 +147,7 @@ impl LlvmType for Reg {
                 128 => cx.type_f128(),
                 _ => bug!("unsupported float: {:?}", self),
             },
+            RegKind::PpcF128 => cx.type_ppcf128(),
             RegKind::Vector { hint_vector_elem } => {
                 // NOTE: it is valid to ignore the element type hint (and always pick i8).
                 // But providing a more accurate type means fewer casts in LLVM IR,
@@ -165,6 +166,7 @@ impl LlvmType for Reg {
                         Float::F32 => cx.type_f32(),
                         Float::F64 => cx.type_f64(),
                         Float::F128 => cx.type_f128(),
+                        Float::PpcF128 => bug!("ppcf128 is not a valid vector element type"),
                     },
                     Primitive::Pointer(_) => cx.type_ptr(),
                 };

compiler/rustc_codegen_llvm/src/builder.rs

@@ -2187,9 +2187,8 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
         llfn: &'ll Value,
         fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>,
     ) -> Option<llvm::OperandBundleBox<'ll>> {
-        if self.sess().pointer_authentication_functions().is_none() {
-            return None;
-        }
+        let schema = self.sess().pointer_authentication_functions()?;
+
         // Pointer authentication support is currently limited to extern "C" calls; filter out other
         // ABIs.
         if fn_abi?.conv != CanonAbi::C {
@@ -2207,11 +2206,12 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
         // bundles.
         // Once this is resolved, we should analyze each call and skip direct calls. See the
         // discussion in the rust-lang issue: <https://github.com/rust-lang/rust/issues/152532>
-        let key: u32 = 0;
-        let discriminator: u64 = 0;
         Some(llvm::OperandBundleBox::new(
             "ptrauth",
-            &[self.const_u32(key), self.const_u64(discriminator)],
+            &[
+                self.const_u32(schema.key as u32),
+                self.const_u64(schema.constant_discriminator as u64),
+            ],
         ))
     }
 

compiler/rustc_codegen_llvm/src/consts.rs

@@ -212,7 +212,7 @@ fn check_and_apply_linkage<'ll, 'tcx>(
                 let fn_sig = sig.with(*header);
                 let fn_abi = cx.fn_abi_of_fn_ptr(fn_sig, ty::List::empty());
                 // Decide if the initializer needs to be signed
-                if cx.sess().pointer_authentication()
+                if cx.sess().pointer_authentication_functions().is_some()
                     && matches!(fn_sig.abi(), ExternAbi::C { .. } | ExternAbi::System { .. })
                 {
                     should_sign = true;
@@ -249,13 +249,16 @@ fn check_and_apply_linkage<'ll, 'tcx>(
 
         // Sign the function pointer that is used to initialize the global
         let initializer = if should_sign {
-            let key: u32 = 0;
-            let discriminator: u64 = 0;
+            let schema = cx
+                .tcx
+                .sess
+                .pointer_authentication_functions()
+                .expect("pointer authentication functions must be available when signing");
 
             const_ptr_auth(
                 cx.const_bitcast(g1, llty),
-                key,
-                discriminator,
+                schema.key as u32,
+                schema.constant_discriminator as u64,
                 None, /* address_diversity */
             )
         } else {

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -350,6 +350,10 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                     Primitive::Float(Float::F128) => {
                         // Supported on some targets, especially where long double is IEEE f128.
                     }
+                    Primitive::Float(Float::PpcF128) => {
+                        // FIXME(ppcf128) we should support this.
+                        bug!("the va_arg intrinsic does not currently support `ppcf128`")
+                    }
                 }
 
                 emit_va_arg(self, args[0], result_layout)