Rollup of 14 pull requests

compiler/rustc/Cargo.toml

@@ -35,7 +35,7 @@ features = ['override_allocator_on_supported_platforms']
 [features]
 # tidy-alphabetical-start
 check_only = ['rustc_driver_impl/check_only']
-jemalloc = ['dep:tikv-jemalloc-sys']
+jemalloc = ['dep:tikv-jemalloc-sys', 'rustc_driver_impl/jemalloc']
 llvm = ['rustc_driver_impl/llvm']
 llvm_offload = ['rustc_driver_impl/llvm_offload']
 max_level_info = ['rustc_driver_impl/max_level_info']

compiler/rustc/src/main.rs

@@ -7,11 +7,8 @@ use std::process::ExitCode;
 
 // A note about jemalloc: rustc uses jemalloc when built for CI and
 // distribution. The obvious way to do this is with the `#[global_allocator]`
-// mechanism. However, for complicated reasons (see
-// https://github.com/rust-lang/rust/pull/81782#issuecomment-784438001 for some
-// details) that mechanism doesn't work here. Also, we'd like to use a
-// consistent allocator across the rustc <-> llvm boundary, and
-// `#[global_allocator]` wouldn't provide that.
+// mechanism. However, that would not affect LLVM's C / C++ allocations and we also want
+// to use a single allocator in the process to reduce memory usage.
 //
 // Instead, we use a lower-level mechanism, namely the
 // `"override_allocator_on_supported_platforms"` Cargo feature of jemalloc-sys.
@@ -20,15 +17,14 @@ use std::process::ExitCode;
 // of `malloc`, `free`, etc.. This means that Rust's `System` allocator, which
 // calls `libc::malloc()` et al., is actually calling into jemalloc.
 //
+// This override happens for the entire process, ensuring that there's no mixup
+// of C allocators across dylibs / binaries, notably the rustc <-> llvm boundary.
+//
 // A consequence of not using `GlobalAlloc` (and the `tikv-jemallocator` crate
 // provides an impl of that trait, which is called `Jemalloc`) is that we
 // cannot use the sized deallocation APIs (`sdallocx`) that jemalloc provides.
 // It's unclear how much performance is lost because of this.
 //
-// NOTE: Even though Cargo passes `--extern` with `tikv_jemalloc_sys`, we still need to `use` the
-// crate for the compiler to see the `#[used]`, see https://github.com/rust-lang/rust/issues/64402.
-// This is similarly required if we used a crate with `#[global_allocator]`.
-//
 // NOTE: if you are reading this comment because you want to set a custom `global_allocator` for
 // benchmarking, consider using the benchmarks in the `rustc-perf` collector suite instead:
 // https://github.com/rust-lang/rustc-perf/blob/master/collector/README.md#profiling
@@ -37,8 +33,7 @@ use std::process::ExitCode;
 // to compare their performance, see
 // https://github.com/rust-lang/rust/commit/b90cfc887c31c3e7a9e6d462e2464db1fe506175#diff-43914724af6e464c1da2171e4a9b6c7e607d5bc1203fa95c0ab85be4122605ef
 // for an example of how to do so.
-#[cfg(feature = "jemalloc")]
-use tikv_jemalloc_sys as _;
+rustc_driver::override_c_allocator_in_binary!();
 
 fn main() -> ExitCode {
     rustc_driver::main()

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -1086,62 +1086,76 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
                 }
             }
         }
-        if let Some(body) = tcx.hir_maybe_body_owned_by(self.mir_def_id())
-            && let Block(block, _) = body.value.kind
+        let Some(body) = tcx.hir_maybe_body_owned_by(self.mir_def_id()) else { return };
+        let Block(block, _) = body.value.kind else { return };
+        // `span` corresponds to the expression being iterated, find the `for`-loop desugared
+        // expression with that span in order to identify potential fixes when encountering a
+        // read-only iterator that should be mutable.
+        let mut expr = if let ControlFlow::Break(expr) = (Finder { span }).visit_block(block)
+            && let Call(_, [expr]) = expr.kind
         {
-            // `span` corresponds to the expression being iterated, find the `for`-loop desugared
-            // expression with that span in order to identify potential fixes when encountering a
-            // read-only iterator that should be mutable.
-            if let ControlFlow::Break(expr) = (Finder { span }).visit_block(block)
-                && let Call(_, [expr]) = expr.kind
-            {
-                match expr.kind {
-                    MethodCall(path_segment, _, _, span) => {
-                        // We have `for _ in iter.read_only_iter()`, try to
-                        // suggest `for _ in iter.mutable_iter()` instead.
-                        let opt_suggestions = tcx
-                            .typeck(path_segment.hir_id.owner.def_id)
-                            .type_dependent_def_id(expr.hir_id)
-                            .and_then(|def_id| tcx.impl_of_assoc(def_id))
-                            .map(|def_id| tcx.associated_items(def_id))
-                            .map(|assoc_items| {
-                                assoc_items
-                                    .in_definition_order()
-                                    .map(|assoc_item_def| assoc_item_def.ident(tcx))
-                                    .filter(|&ident| {
-                                        let original_method_ident = path_segment.ident;
-                                        original_method_ident != ident
-                                            && ident.as_str().starts_with(
-                                                &original_method_ident.name.to_string(),
-                                            )
-                                    })
-                                    .map(|ident| format!("{ident}()"))
-                                    .peekable()
-                            });
+            expr
+        } else {
+            return;
+        };
+        loop {
+            match expr.kind {
+                MethodCall(path_segment, _, _, span) => {
+                    // We have `for _ in iter.read_only_iter()`, try to
+                    // suggest `for _ in iter.mutable_iter()` instead.
+                    let opt_suggestions = tcx
+                        .typeck(path_segment.hir_id.owner.def_id)
+                        .type_dependent_def_id(expr.hir_id)
+                        .and_then(|def_id| tcx.impl_of_assoc(def_id))
+                        .map(|def_id| tcx.associated_items(def_id))
+                        .map(|assoc_items| {
+                            assoc_items
+                                .in_definition_order()
+                                .map(|assoc_item_def| assoc_item_def.ident(tcx))
+                                .filter(|&ident| {
+                                    let original_method_ident = path_segment.ident;
+                                    original_method_ident != ident
+                                        && ident
+                                            .as_str()
+                                            .starts_with(&original_method_ident.name.to_string())
+                                })
+                                .map(|ident| format!("{ident}()"))
+                                .peekable()
+                        });
 
-                        if let Some(mut suggestions) = opt_suggestions
-                            && suggestions.peek().is_some()
-                        {
-                            err.span_suggestions(
-                                span,
-                                "use mutable method",
-                                suggestions,
-                                Applicability::MaybeIncorrect,
-                            );
-                        }
-                    }
-                    AddrOf(BorrowKind::Ref, Mutability::Not, expr) => {
-                        // We have `for _ in &i`, suggest `for _ in &mut i`.
-                        err.span_suggestion_verbose(
-                            expr.span.shrink_to_lo(),
-                            "use a mutable iterator instead",
-                            "mut ",
-                            Applicability::MachineApplicable,
+                    if let Some(mut suggestions) = opt_suggestions
+                        && suggestions.peek().is_some()
+                    {
+                        err.span_suggestions(
+                            span,
+                            "use mutable method",
+                            suggestions,
+                            Applicability::MaybeIncorrect,
                         );
                     }
-                    _ => {}
                 }
+                AddrOf(BorrowKind::Ref, Mutability::Not, expr) => {
+                    // We have `for _ in &i`, suggest `for _ in &mut i`.
+                    err.span_suggestion_verbose(
+                        expr.span.shrink_to_lo(),
+                        "use a mutable iterator instead",
+                        "mut ",
+                        Applicability::MachineApplicable,
+                    );
+                }
+                ExprKind::Path(hir::QPath::Resolved(None, path))
+                    if let hir::def::Res::Local(hir_id) = path.res
+                        && let hir::Node::LetStmt(stmt) =
+                            self.infcx.tcx.parent_hir_node(hir_id)
+                        && let Some(init) = stmt.init =>
+                {
+                    // We're iterating over a binding, try to suggest changing the binding's expr.
+                    expr = init;
+                    continue;
+                }
+                _ => {}
             }
+            break;
         }
     }
 

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -479,10 +479,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             let projected_ty = curr_projected_ty.projection_ty_core(
                 tcx,
                 proj,
-                |ty| self.normalize(ty::Unnormalized::new_wip(ty), locations),
-                |ty, variant_index, field, ()| {
-                    PlaceTy::field_ty(tcx, ty, variant_index, field).skip_norm_wip()
-                },
+                |ty| self.normalize(ty, locations),
+                |()| None,
                 |_| unreachable!(),
             );
             curr_projected_ty = projected_ty;

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -379,6 +379,19 @@ impl<'b, 'tcx> TypeRelation<TyCtxt<'tcx>> for NllTypeRelating<'_, 'b, 'tcx> {
                 );
             }
 
+            (&ty::Alias(ty::IsRigid::No, _), _) | (_, &ty::Alias(ty::IsRigid::No, _))
+                if infcx.next_trait_solver() =>
+            {
+                // NOTE(khyperia): If this turns out to be possible, either the caller should
+                // normalize the alias, or we should normalize the alias here. See the PR that
+                // introduced this comment for how to do so, which normalizes aliases in other
+                // relations.
+                span_bug!(
+                    self.span(),
+                    "it should not be possible to encounter unnormalized aliases in borrowck"
+                );
+            }
+
             (&ty::Infer(ty::TyVar(a_vid)), _) => {
                 infcx.instantiate_ty_var(self, true, a_vid, self.ambient_variance, b)?
             }
@@ -590,8 +603,4 @@ impl<'b, 'tcx> PredicateEmittingRelation<InferCtxt<'tcx>> for NllTypeRelating<'_
             },
         );
     }
-
-    fn ambient_variance(&self) -> ty::Variance {
-        self.ambient_variance
-    }
 }

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -100,14 +100,17 @@ fn write_output_file<'ll>(
     result.into_result().unwrap_or_else(|()| llvm_err(dcx, LlvmError::WriteOutput { path: output }))
 }
 
+/// If `for_cfg` is `true` then we are creating this machine for the purpose of populating
+/// [`rustc_codegen_ssa::TargetConfig`] based on what LLVM actually enables in this configuration.
+/// `-Ctarget-feature` should be ignored in that case since it is already processed separately.
 pub(crate) fn create_informational_target_machine(
     sess: &Session,
-    only_base_features: bool,
+    for_cfg: bool,
 ) -> OwnedTargetMachine {
     let config = TargetMachineFactoryConfig { split_dwarf_file: None, output_obj_file: None };
     // Can't use query system here quite yet because this function is invoked before the query
     // system/tcx is set up.
-    let features = llvm_util::global_llvm_features(sess, only_base_features);
+    let features = llvm_util::global_llvm_features(sess, for_cfg);
     target_machine_factory(sess, config::OptLevel::No, &features)(sess.dcx(), config)
 }
 

compiler/rustc_codegen_llvm/src/diagnostics.rs

@@ -245,3 +245,10 @@ pub(crate) struct IntrinsicWrongArch<'a> {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag("ignoring feature with missing prefix in `-Zllvm-target-feature`: `{$feature}`")]
+#[note("features must begin with a `+` to enable or `-` to disable it")]
+pub(crate) struct UnknownLlvmTargetFeaturePrefix<'a> {
+    pub feature: &'a str,
+}

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -646,7 +646,11 @@ fn llvm_features_by_flags(sess: &Session, features: &mut Vec<String>) {
 
 /// The list of LLVM features computed from CLI flags (`-Ctarget-cpu`, `-Ctarget-feature`,
 /// `--target` and similar).
-pub(crate) fn global_llvm_features(sess: &Session, only_base_features: bool) -> Vec<String> {
+///
+/// If `for_cfg` is `true` then we are assembling the feature list for the purpose of populating
+/// [`rustc_codegen_ssa::TargetConfig`] based on what LLVM actually enables in this configuration.
+/// `-Ctarget-feature` should be ignored in that case since it is already processed separately.
+pub(crate) fn global_llvm_features(sess: &Session, for_cfg: bool) -> Vec<String> {
     // Features that come earlier are overridden by conflicting features later in the string.
     // Typically we'll want more explicit settings to override the implicit ones, so:
     //
@@ -725,14 +729,33 @@ pub(crate) fn global_llvm_features(sess: &Session, only_base_features: bool) ->
     // Features implied by an implicit or explicit `--target`.
     target_features::target_spec_to_backend_features(sess, &mut extend_backend_features);
 
-    // -Ctarget-features
-    if !only_base_features {
+    // -Ctarget-features. Skipped for `cfg` as there we parse -Ctarget-features directly instead of
+    // going via an LLVM target machine (which avoids accidentally picking up LLVM-level target
+    // feature implications that we do not want).
+    if !for_cfg {
         target_features::flag_to_backend_features(sess, extend_backend_features);
     }
 
     // We add this in the "base target" so that these show up in `sess.unstable_target_features`.
     llvm_features_by_flags(sess, &mut features);
 
+    // `-Zllvm-target-features`, all the way at the end to overwrite everything.
+    // Should be picked up by `cfg` (e.g. if someone enables AVX this way).
+    for feature in sess.opts.unstable_opts.llvm_target_feature.split(',') {
+        if feature.is_empty() {
+            continue;
+        }
+        if feature.starts_with('+') || feature.starts_with('-') {
+            features.push(feature.to_owned());
+        } else {
+            // LLVM seems to silently ignore entries without leading `+`/`-`. Let's emit a warning
+            // to avoid confusion. But only emit this warning once, under `for_cfg`.
+            if for_cfg {
+                sess.dcx().emit_warn(diagnostics::UnknownLlvmTargetFeaturePrefix { feature });
+            }
+        }
+    }
+
     features
 }
 

compiler/rustc_codegen_ssa/src/diagnostics.rs

@@ -1198,7 +1198,7 @@ pub(crate) struct XcrunSdkPathWarning {
 pub(crate) struct Aarch64SoftfloatNeon;
 
 #[derive(Diagnostic)]
-#[diag("unknown feature specified for `-Ctarget-feature`: `{$feature}`")]
+#[diag("ignoring feature with missing prefix in `-Ctarget-feature`: `{$feature}`")]
 #[note("features must begin with a `+` to enable or `-` to disable it")]
 pub(crate) struct UnknownCTargetFeaturePrefix<'a> {
     pub feature: &'a str,

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -21,9 +21,9 @@ use super::error::*;
 use crate::diagnostics::{LongRunning, LongRunningWarn};
 use crate::interpret::{
     self, AllocId, AllocInit, AllocRange, ConstAllocation, CtfeProvenance, FnArg, Frame,
-    GlobalAlloc, ImmTy, InterpCx, InterpResult, OpTy, PlaceTy, Pointer, RangeSet, RetagMode,
-    Scalar, compile_time_machine, ensure_monomorphic_enough, err_inval, interp_ok, throw_exhaust,
-    throw_inval, throw_ub, throw_ub_format, throw_unsup, throw_unsup_format,
+    GlobalAlloc, ImmTy, Immediate, InterpCx, InterpResult, OpTy, PlaceTy, Pointer, RangeSet,
+    RetagMode, Scalar, compile_time_machine, ensure_monomorphic_enough, err_inval, interp_ok,
+    throw_exhaust, throw_inval, throw_ub, throw_ub_format, throw_unsup, throw_unsup_format,
     type_implements_dyn_trait,
 };
 
@@ -712,6 +712,47 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 ecx.write_scalar(Scalar::from_target_usize(offset, ecx), dest)?;
             }
 
+            sym::field_representing_type_name => {
+                let frt_ty = ecx.read_type_id(&args[0])?;
+
+                let field_name = if let ty::Adt(def, args) = frt_ty.kind()
+                    && let Some(FieldInfo { name, .. }) =
+                        def.field_representing_type_info(ecx.tcx.tcx, args)
+                {
+                    name
+                } else {
+                    span_bug!(ecx.cur_span(), "expected field representing type, got {frt_ty}")
+                };
+                let ptr = ecx.allocate_bytes_dedup(field_name.as_str().as_bytes())?;
+                ecx.write_immediate(
+                    Immediate::ScalarPair(
+                        Scalar::from_pointer(ptr, ecx),
+                        Scalar::from_target_usize(field_name.as_str().len() as u64, ecx),
+                    ),
+                    dest,
+                )?;
+            }
+
+            sym::field_representing_type_offset => {
+                let frt_ty = ecx.read_type_id(&args[0])?;
+
+                let (ty, variant, field) = if let ty::Adt(def, args) = frt_ty.kind()
+                    && let Some(FieldInfo { base, variant_idx, field_idx, .. }) =
+                        def.field_representing_type_info(ecx.tcx.tcx, args)
+                {
+                    (base, variant_idx, field_idx)
+                } else {
+                    span_bug!(ecx.cur_span(), "expected field representing type, got {frt_ty}")
+                };
+                let layout = ecx.layout_of(ty)?;
+                let cx = ty::layout::LayoutCx::new(ecx.tcx.tcx, ecx.typing_env());
+
+                let layout = layout.for_variant(&cx, variant);
+                let offset = layout.fields.offset(field.index()).bytes();
+
+                ecx.write_scalar(Scalar::from_target_usize(offset, ecx), dest)?;
+            }
+
             sym::field_representing_type_actual_type_id => {
                 let frt_ty = ecx.read_type_id(&args[0])?;
 
@@ -726,6 +767,28 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 ecx.write_type_id(field_ty, dest)?;
             }
 
+            sym::type_id_generics => {
+                let ty = ecx.read_type_id(&args[0])?;
+                ecx.write_type_id_generics(dest, ty)?;
+            }
+
+            sym::non_exhaustive => {
+                let ty = ecx.read_type_id(&args[0])?;
+
+                // FIXME(reflection): need a way to obtain non-exhaustiveness of a variant's fields.
+                let non_exhaustive = if let ty::Adt(def, _) = ty.kind() {
+                    if def.is_enum() {
+                        def.is_variant_list_non_exhaustive()
+                    } else {
+                        def.non_enum_variant().is_field_list_non_exhaustive()
+                    }
+                } else {
+                    false
+                };
+
+                ecx.write_scalar(Scalar::from_bool(non_exhaustive), dest)?;
+            }
+
             _ => {
                 // We haven't handled the intrinsic, let's see if we can use a fallback body.
                 if ecx.tcx.intrinsic(instance.def_id()).unwrap().must_be_overridden {