Auto merge of #127653 - matthiaskrgr:rollup-72bqgvp, r=matthiaskrgr

Rollup of 8 pull requests
Successful merges:
- #124980 (Generalize `fn allocator` for Rc/Arc.)
- #126639 (Add AMX target-features and `x86_amx_intrinsics` feature flag)
- #126827 (Use pidfd_spawn for faster process spawning when a PidFd is requested)
- #127433 (Stabilize const_cstr_from_ptr (CStr::from_ptr, CStr::count_bytes))
- #127552 (remove unnecessary `git` usages)
- #127613 (Update dist-riscv64-linux to binutils 2.40)
- #127627 (generalize search graph to enable fuzzing)
- #127648 (Lower timeout of CI jobs to 4 hours)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

.github/workflows/ci.yml

@@ -65,7 +65,7 @@ jobs:
 defaults:
 run:
 shell: ${{ contains(matrix.os, 'windows') && 'msys2 {0}' || 'bash' }}
-timeout-minutes: 600
+timeout-minutes: 240
 env:
 CI_JOB_NAME: ${{ matrix.image }}
 CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse

compiler/rustc_codegen_ssa/src/target_features.rs

@@ -80,6 +80,7 @@ pub fn from_target_feature(
 Some(sym::loongarch_target_feature) => rust_features.loongarch_target_feature,
 Some(sym::lahfsahf_target_feature) => rust_features.lahfsahf_target_feature,
 Some(sym::prfchw_target_feature) => rust_features.prfchw_target_feature,
+Some(sym::x86_amx_intrinsics) => rust_features.x86_amx_intrinsics,
 Some(name) => bug!("unknown target feature gate {}", name),
 None => true,
 };

compiler/rustc_feature/src/unstable.rs

@@ -640,6 +640,8 @@ declare_features! (
 (unstable, unsized_tuple_coercion,"1.20.0",Some(42877)),
 /// Allows using the `#[used(linker)]` (or `#[used(compiler)]`) attribute.
 (unstable, used_with_arg,"1.60.0",Some(93798)),
+/// Allows use of x86 `AMX` target-feature attributes and intrinsics
+(unstable, x86_amx_intrinsics,"CURRENT_RUSTC_VERSION",Some(126622)),
 /// Allows `do yeet` expressions
 (unstable, yeet_expr,"1.62.0",Some(96373)),
 // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!!

compiler/rustc_middle/src/traits/solve.rs

@@ -8,10 +8,6 @@ use crate::ty::{
 self,FallibleTypeFolder,TyCtxt,TypeFoldable,TypeFolder,TypeVisitable,TypeVisitor,
 };
 
-mod cache;
-
-pubuse cache::EvaluationCache;
-
 pubtypeGoal<'tcx,P> = ir::solve::Goal<TyCtxt<'tcx>,P>;
 pubtypeQueryInput<'tcx,P> = ir::solve::QueryInput<TyCtxt<'tcx>,P>;
 pubtypeQueryResult<'tcx> = ir::solve::QueryResult<TyCtxt<'tcx>>;

compiler/rustc_middle/src/traits/solve/cache.rs

@@ -59,6 +59,7 @@ use rustc_hir::lang_items::LangItem;
 use rustc_hir::{HirId,Node,TraitCandidate};
 use rustc_index::IndexVec;
 use rustc_macros::{HashStable,TyDecodable,TyEncodable};
+use rustc_query_system::cache::WithDepNode;
 use rustc_query_system::dep_graph::DepNodeIndex;
 use rustc_query_system::ich::StableHashingContext;
 use rustc_serialize::opaque::{FileEncodeResult,FileEncoder};
@@ -75,7 +76,7 @@ use rustc_type_ir::fold::TypeFoldable;
 use rustc_type_ir::lang_items::TraitSolverLangItem;
 use rustc_type_ir::solve::SolverMode;
 use rustc_type_ir::TyKind::*;
-use rustc_type_ir::{CollectAndApply,Interner,TypeFlags,WithCachedTypeInfo};
+use rustc_type_ir::{search_graph,CollectAndApply,Interner,TypeFlags,WithCachedTypeInfo};
 use tracing::{debug, instrument};
 
 use std::assert_matches::assert_matches;
@@ -164,12 +165,26 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
 typeClause = Clause<'tcx>;
 typeClauses = ty::Clauses<'tcx>;
 
-typeEvaluationCache = &'tcx solve::EvaluationCache<'tcx>;
+typeTracked<T: fmt::Debug + Clone> = WithDepNode<T>;
+fnmk_tracked<T: fmt::Debug + Clone>(
+self,
+data:T,
+dep_node:DepNodeIndex,
+) -> Self::Tracked<T>{
+WithDepNode::new(dep_node, data)
+}
+fnget_tracked<T: fmt::Debug + Clone>(self,tracked:&Self::Tracked<T>) -> T{
+ tracked.get(self)
+}
 
-fnevaluation_cache(self,mode:SolverMode) -> &'tcx solve::EvaluationCache<'tcx>{
+fnwith_global_cache<R>(
+self,
+mode:SolverMode,
+f:implFnOnce(&mut search_graph::GlobalCache<Self>) -> R,
+) -> R{
 match mode {
-SolverMode::Normal => &self.new_solver_evaluation_cache,
-SolverMode::Coherence => &self.new_solver_coherence_evaluation_cache,
+SolverMode::Normal => f(&mut*self.new_solver_evaluation_cache.lock()),
+SolverMode::Coherence => f(&mut*self.new_solver_coherence_evaluation_cache.lock()),
 }
 }
 
@@ -1283,8 +1298,8 @@ pub struct GlobalCtxt<'tcx> {
 pubevaluation_cache: traits::EvaluationCache<'tcx>,
 
 /// Caches the results of goal evaluation in the new solver.
-pubnew_solver_evaluation_cache:solve::EvaluationCache<'tcx>,
-pubnew_solver_coherence_evaluation_cache:solve::EvaluationCache<'tcx>,
+pubnew_solver_evaluation_cache:Lock<search_graph::GlobalCache<TyCtxt<'tcx>>>,
+pubnew_solver_coherence_evaluation_cache:Lock<search_graph::GlobalCache<TyCtxt<'tcx>>>,
 
 pubcanonical_param_env_cache:CanonicalParamEnvCache<'tcx>,
 

compiler/rustc_middle/src/ty/context.rs

@@ -16,9 +16,9 @@ use crate::delegate::SolverDelegate;
 usecrate::solve::inspect::{self,ProofTreeBuilder};
 usecrate::solve::search_graph::SearchGraph;
 usecrate::solve::{
-search_graph,CanonicalInput,CanonicalResponse,Certainty,Goal,GoalEvaluationKind,
-GoalSource,MaybeCause,NestedNormalizationGoals,NoSolution,PredefinedOpaquesData,
-QueryResult,SolverMode,FIXPOINT_STEP_LIMIT,
+CanonicalInput,CanonicalResponse,Certainty,Goal,GoalEvaluationKind,GoalSource,MaybeCause,
+NestedNormalizationGoals,NoSolution,PredefinedOpaquesData,QueryResult,SolverMode,
+FIXPOINT_STEP_LIMIT,
 };
 
 pub(super)mod canonical;
@@ -72,7 +72,7 @@ where
 /// new placeholders to the caller.
 pub(super)max_input_universe: ty::UniverseIndex,
 
-pub(super)search_graph:&'amutSearchGraph<I>,
+pub(super)search_graph:&'amutSearchGraph<D>,
 
 nested_goals:NestedGoals<I>,
 
@@ -200,7 +200,7 @@ where
 generate_proof_tree:GenerateProofTree,
 f:implFnOnce(&mutEvalCtxt<'_,D>) -> R,
 ) -> (R,Option<inspect::GoalEvaluation<I>>){
-letmut search_graph = search_graph::SearchGraph::new(delegate.solver_mode());
+letmut search_graph = SearchGraph::new(delegate.solver_mode());
 
 letmut ecx = EvalCtxt{
  delegate,
@@ -241,7 +241,7 @@ where
 /// and registering opaques from the canonicalized input.
 fnenter_canonical<R>(
 cx:I,
-search_graph:&'amutsearch_graph::SearchGraph<I>,
+search_graph:&'amutSearchGraph<D>,
 canonical_input:CanonicalInput<I>,
 canonical_goal_evaluation:&mutProofTreeBuilder<D>,
 f:implFnOnce(&mutEvalCtxt<'_,D>,Goal<I,I::Predicate>) -> R,
@@ -296,7 +296,7 @@ where
 #[instrument(level = "debug", skip(cx, search_graph, goal_evaluation), ret)]
 fnevaluate_canonical_goal(
 cx:I,
-search_graph:&'amutsearch_graph::SearchGraph<I>,
+search_graph:&'amutSearchGraph<D>,
 canonical_input:CanonicalInput<I>,
 goal_evaluation:&mutProofTreeBuilder<D>,
 ) -> QueryResult<I>{

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -8,7 +8,7 @@ use std::marker::PhantomData;
 use std::mem;
 
 use rustc_type_ir::inherent::*;
-use rustc_type_ir::{selfas ty,Interner};
+use rustc_type_ir::{selfas ty,search_graph,Interner};
 
 usecrate::delegate::SolverDelegate;
 usecrate::solve::eval_ctxt::canonical;
@@ -38,7 +38,7 @@ use crate::solve::{
 /// trees. At the end of trait solving `ProofTreeBuilder::finalize`
 /// is called to recursively convert the whole structure to a
 /// finished proof tree.
-pub(incrate::solve)structProofTreeBuilder<D,I = <DasSolverDelegate>::Interner>
+pub(crate)structProofTreeBuilder<D,I = <DasSolverDelegate>::Interner>
 where
 D:SolverDelegate<Interner = I>,
 I:Interner,
@@ -321,23 +321,6 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
 })
 }
 
-pubfnfinalize_canonical_goal_evaluation(
-&mutself,
-cx:I,
-) -> Option<I::CanonicalGoalEvaluationStepRef>{
-self.as_mut().map(|this| match this {
-DebugSolver::CanonicalGoalEvaluation(evaluation) => {
-let final_revision = mem::take(&mut evaluation.final_revision).unwrap();
-let final_revision =
- cx.intern_canonical_goal_evaluation_step(final_revision.finalize());
-let kind = WipCanonicalGoalEvaluationKind::Interned{ final_revision };
-assert_eq!(evaluation.kind.replace(kind),None);
- final_revision
-}
- _ => unreachable!(),
-})
-}
-
 pubfncanonical_goal_evaluation(&mutself,canonical_goal_evaluation:ProofTreeBuilder<D>){
 ifletSome(this) = self.as_mut(){
 match(this,*canonical_goal_evaluation.state.unwrap()){
@@ -571,3 +554,51 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
 }
 }
 }
+
+impl<D,I> search_graph::ProofTreeBuilder<I>forProofTreeBuilder<D>
+where
+D:SolverDelegate<Interner = I>,
+I:Interner,
+{
+fntry_apply_proof_tree(
+&mutself,
+proof_tree:Option<I::CanonicalGoalEvaluationStepRef>,
+) -> bool{
+if !self.is_noop(){
+ifletSome(final_revision) = proof_tree {
+let kind = WipCanonicalGoalEvaluationKind::Interned{ final_revision };
+self.canonical_goal_evaluation_kind(kind);
+true
+}else{
+false
+}
+}else{
+true
+}
+}
+
+fnon_provisional_cache_hit(&mutself){
+self.canonical_goal_evaluation_kind(WipCanonicalGoalEvaluationKind::ProvisionalCacheHit);
+}
+
+fnon_cycle_in_stack(&mutself){
+self.canonical_goal_evaluation_kind(WipCanonicalGoalEvaluationKind::CycleInStack);
+}
+
+fnfinalize_canonical_goal_evaluation(
+&mutself,
+tcx:I,
+) -> Option<I::CanonicalGoalEvaluationStepRef>{
+self.as_mut().map(|this| match this {
+DebugSolver::CanonicalGoalEvaluation(evaluation) => {
+let final_revision = mem::take(&mut evaluation.final_revision).unwrap();
+let final_revision =
+ tcx.intern_canonical_goal_evaluation_step(final_revision.finalize());
+let kind = WipCanonicalGoalEvaluationKind::Interned{ final_revision };
+assert_eq!(evaluation.kind.replace(kind),None);
+ final_revision
+}
+ _ => unreachable!(),
+})
+}
+}