diff options
Diffstat (limited to 'backend/lib/CodeGen')
39 files changed, 268 insertions, 659 deletions
diff --git a/backend/lib/CodeGen/CMakeLists.txt b/backend/lib/CodeGen/CMakeLists.txt index 470571d..4488903 100644 --- a/backend/lib/CodeGen/CMakeLists.txt +++ b/backend/lib/CodeGen/CMakeLists.txt @@ -48,7 +48,7 @@ set( MachineMetadata.cpp MachineOperand.cpp MachineOptimizationPipeline.cpp - MachinePass.cpp + MachinePassManager.cpp MachinePseudoExpansion.cpp MachineRegisterInfo.cpp MachineScheduler.cpp @@ -136,7 +136,10 @@ set( "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachineMetadata.h" "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachineOperand.h" "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachineOptimizationPipeline.h" - "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachinePass.h" + "${RCC_BACKEND_SOURCE_DIR}/include/rcc/IR/PassManager.h" + "${RCC_BACKEND_SOURCE_DIR}/include/rcc/IR/PassInstrumentation.h" + "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachineFunctionAnalysisManager.h" + "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachinePassManager.h" "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachinePseudoExpansion.h" "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/PrologueEpilogueInsertion.h" "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/RegisterPressure.h" @@ -262,7 +265,7 @@ rcc_backend_register_format_files( "${CMAKE_CURRENT_SOURCE_DIR}/MachineMetadata.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/MachineOperand.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/MachineOptimizationPipeline.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/MachinePass.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/MachinePassManager.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/MachinePseudoExpansion.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/MachineRegisterInfo.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/MachineScheduler.cpp" @@ -350,7 +353,7 @@ rcc_backend_register_tidy_files( "${CMAKE_CURRENT_SOURCE_DIR}/MachineMetadata.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/MachineOperand.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/MachineOptimizationPipeline.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/MachinePass.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/MachinePassManager.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/MachinePseudoExpansion.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/MachineRegisterInfo.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/MachineScheduler.cpp" diff --git a/backend/lib/CodeGen/GlobalISel/InstructionSelect.cpp b/backend/lib/CodeGen/GlobalISel/InstructionSelect.cpp index ff32eda..344e63e 100644 --- a/backend/lib/CodeGen/GlobalISel/InstructionSelect.cpp +++ b/backend/lib/CodeGen/GlobalISel/InstructionSelect.cpp @@ -194,7 +194,7 @@ const MachinePassContract &InstructionSelect::contract() const noexcept { Expected<MachinePassResult> InstructionSelect::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { if (Info == nullptr) return std::unexpected(passFailure("instruction select has no target behavior interface", ErrorCode::InvalidArgument)); diff --git a/backend/lib/CodeGen/GlobalISel/Legalizer.cpp b/backend/lib/CodeGen/GlobalISel/Legalizer.cpp index 60f388d..7781818 100644 --- a/backend/lib/CodeGen/GlobalISel/Legalizer.cpp +++ b/backend/lib/CodeGen/GlobalISel/Legalizer.cpp @@ -175,7 +175,7 @@ const MachinePassContract &Legalizer::contract() const noexcept { Expected<MachinePassResult> Legalizer::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { if (Info == nullptr) return std::unexpected( passFailure("legalizer has no target behavior interface", ErrorCode::InvalidArgument)); diff --git a/backend/lib/CodeGen/GlobalISel/RegBankSelect.cpp b/backend/lib/CodeGen/GlobalISel/RegBankSelect.cpp index c36c500..041ab74 100644 --- a/backend/lib/CodeGen/GlobalISel/RegBankSelect.cpp +++ b/backend/lib/CodeGen/GlobalISel/RegBankSelect.cpp @@ -122,7 +122,7 @@ const MachinePassContract &RegBankSelect::contract() const noexcept { Expected<MachinePassResult> RegBankSelect::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { if (Info == nullptr) return std::unexpected(passFailure("register-bank select has no target behavior interface", ErrorCode::InvalidArgument)); diff --git a/backend/lib/CodeGen/InlineSpiller.cpp b/backend/lib/CodeGen/InlineSpiller.cpp index 14de321..1d5ba10 100644 --- a/backend/lib/CodeGen/InlineSpiller.cpp +++ b/backend/lib/CodeGen/InlineSpiller.cpp @@ -7,7 +7,7 @@ #include "rcc/CodeGen/MachineIRBuilder.h" #include "rcc/CodeGen/MachineInstr.h" #include "rcc/CodeGen/MachineOperand.h" -#include "rcc/CodeGen/MachinePass.h" +#include "rcc/CodeGen/MachinePassManager.h" #include "rcc/CodeGen/MachineRegisterInfo.h" #include "rcc/CodeGen/Spiller.h" #include "rcc/CodeGen/TargetDescription.h" diff --git a/backend/lib/CodeGen/LiveIntervals.cpp b/backend/lib/CodeGen/LiveIntervals.cpp index d8cb539..5a01693 100644 --- a/backend/lib/CodeGen/LiveIntervals.cpp +++ b/backend/lib/CodeGen/LiveIntervals.cpp @@ -307,12 +307,12 @@ Expected<void> LiveIntervalsAnalysis::Result::shrinkToUses(Register Reg, bool LiveIntervalsAnalysis::Result::invalidate(const MachineFunction &, const PreservedAnalyses &Preserved) const noexcept { - return !Preserved.preserves(MachineAnalysisManager::id<LiveIntervalsAnalysis>()); + return !Preserved.preserves(MachineFunctionAnalysisManager::id<LiveIntervalsAnalysis>()); } Expected<LiveIntervalsAnalysis::Result> LiveIntervalsAnalysis::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { auto Indexes = Analyses.getResult<SlotIndexesAnalysis>(Function, Target); if (!Indexes) return std::unexpected(Indexes.error()); diff --git a/backend/lib/CodeGen/LiveVariables.cpp b/backend/lib/CodeGen/LiveVariables.cpp index 7323e0d..201e09e 100644 --- a/backend/lib/CodeGen/LiveVariables.cpp +++ b/backend/lib/CodeGen/LiveVariables.cpp @@ -884,12 +884,12 @@ bool LiveVariablesAnalysis::Result::isUnitLiveOut(const MachineBasicBlock &Block bool LiveVariablesAnalysis::Result::invalidate(const MachineFunction &, const PreservedAnalyses &Preserved) const noexcept { - return !Preserved.preserves(MachineAnalysisManager::id<LiveVariablesAnalysis>()); + return !Preserved.preserves(MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>()); } -Expected<LiveVariablesAnalysis::Result> LiveVariablesAnalysis::run(MachineFunction &Function, - const TargetDescription &Target, - MachineAnalysisManager &) { +Expected<LiveVariablesAnalysis::Result> +LiveVariablesAnalysis::run(MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &) { return computeLiveVariables(Function, Target); } const MachinePassContract &RebuildMachineLivenessPass::contract() const noexcept { @@ -911,7 +911,7 @@ const MachinePassContract &RebuildMachineLivenessPass::contract() const noexcept Expected<MachinePassResult> RebuildMachineLivenessPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { const MachineFunctionProperties Missing = contract().Requires.missingFrom(Function.properties()); if (!Missing.empty()) { return makeUnexpected(ErrorCode::VerificationError, @@ -976,11 +976,11 @@ Expected<void> verifyTrackedMachineLiveness(const MachineFunction &Function, return {}; } -Expected<void> registerStage11MachineAnalyses(MachineAnalysisManager &Analyses) { +Expected<void> registerStage11MachineAnalyses(MachineFunctionAnalysisManager &Analyses) { const std::array IDs{ - MachineAnalysisManager::id<SlotIndexesAnalysis>(), - MachineAnalysisManager::id<LiveVariablesAnalysis>(), - MachineAnalysisManager::id<LiveIntervalsAnalysis>(), + MachineFunctionAnalysisManager::id<SlotIndexesAnalysis>(), + MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>(), + MachineFunctionAnalysisManager::id<LiveIntervalsAnalysis>(), }; const std::size_t Registered = static_cast<std::size_t>( std::ranges::count_if(IDs, [&Analyses](AnalysisID ID) { return Analyses.isRegistered(ID); })); @@ -994,7 +994,7 @@ Expected<void> registerStage11MachineAnalyses(MachineAnalysisManager &Analyses) auto Candidate = Analyses.forkEmpty(); if (!Candidate) return std::unexpected(Candidate.error()); - MachineAnalysisManager &Staging = **Candidate; + MachineFunctionAnalysisManager &Staging = **Candidate; auto Slots = Staging.registerAnalysis<SlotIndexesAnalysis>({ .Name = "SlotIndexes", .Dependencies = {}, @@ -1015,8 +1015,8 @@ Expected<void> registerStage11MachineAnalyses(MachineAnalysisManager &Analyses) return std::unexpected(Variables.error()); auto Intervals = Staging.registerAnalysis<LiveIntervalsAnalysis>({ .Name = "LiveIntervals", - .Dependencies = {MachineAnalysisManager::id<SlotIndexesAnalysis>(), - MachineAnalysisManager::id<LiveVariablesAnalysis>()}, + .Dependencies = {MachineFunctionAnalysisManager::id<SlotIndexesAnalysis>(), + MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>()}, .InvalidatedBy = {MachinePassChange::Instructions, MachinePassChange::Operands, MachinePassChange::Registers, MachinePassChange::CFG, MachinePassChange::BlockLayout, MachinePassChange::TargetState}, @@ -1024,8 +1024,7 @@ Expected<void> registerStage11MachineAnalyses(MachineAnalysisManager &Analyses) }); if (!Intervals) return std::unexpected(Intervals.error()); - Analyses.Registry = std::move(Staging.Registry); - return {}; + return Analyses.replaceRegistrations(std::move(Staging)); } } // namespace rcc diff --git a/backend/lib/CodeGen/MachineAnalyses.cpp b/backend/lib/CodeGen/MachineAnalyses.cpp index 33dc14f..3f09636 100644 --- a/backend/lib/CodeGen/MachineAnalyses.cpp +++ b/backend/lib/CodeGen/MachineAnalyses.cpp @@ -263,7 +263,7 @@ const MachineBasicBlock *MachineDominatorTreeAnalysis::Result::nearestCommonDomi Expected<MachineDominatorTreeAnalysis::Result> MachineDominatorTreeAnalysis::run(MachineFunction &Function, const TargetDescription &, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { Result ResultValue; auto Built = ResultValue.build(Function); if (!Built) @@ -287,9 +287,9 @@ bool MachineLoopAnalysis::Result::isIrreducible(const MachineBasicBlock &Block) return IrreducibleBlocks.contains(&Block); } -Expected<MachineLoopAnalysis::Result> MachineLoopAnalysis::run(MachineFunction &Function, - const TargetDescription &Target, - MachineAnalysisManager &Analyses) { +Expected<MachineLoopAnalysis::Result> +MachineLoopAnalysis::run(MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &Analyses) { auto Dominators = Analyses.getResult<MachineDominatorTreeAnalysis>(Function, Target); if (!Dominators) return std::unexpected(Dominators.error()); @@ -496,7 +496,7 @@ std::span<const MachineSuccessor> MachineBranchProbabilityAnalysis::Result::succ Expected<MachineBranchProbabilityAnalysis::Result> MachineBranchProbabilityAnalysis::run(MachineFunction &Function, const TargetDescription &, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { Result ResultValue; const std::vector<MachineBasicBlock *> Blocks = linkedBlocks(Function); const auto Order = blockOrder(Blocks); @@ -522,7 +522,7 @@ MachineBlockFrequencyAnalysis::Result::frequency(const MachineBasicBlock &Block) Expected<MachineBlockFrequencyAnalysis::Result> MachineBlockFrequencyAnalysis::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { auto Dominators = Analyses.getResult<MachineDominatorTreeAnalysis>(Function, Target); auto Loops = Analyses.getResult<MachineLoopAnalysis>(Function, Target); auto Probabilities = Analyses.getResult<MachineBranchProbabilityAnalysis>(Function, Target); @@ -628,8 +628,9 @@ MachineAliasAnalysis::Result::alias(const MachineMemOperand &Left, return Distance >= LowerSize ? MachineAliasResult::NoAlias : MachineAliasResult::PartialAlias; } -Expected<MachineAliasAnalysis::Result> -MachineAliasAnalysis::run(MachineFunction &, const TargetDescription &, MachineAnalysisManager &) { +Expected<MachineAliasAnalysis::Result> MachineAliasAnalysis::run(MachineFunction &, + const TargetDescription &, + MachineFunctionAnalysisManager &) { return Result{}; } @@ -659,7 +660,7 @@ std::span<const MachineMemoryDependency> MachineMemoryDependenceAnalysis::Result Expected<MachineMemoryDependenceAnalysis::Result> MachineMemoryDependenceAnalysis::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { auto Alias = Analyses.getResult<MachineAliasAnalysis>(Function, Target); if (!Alias) return std::unexpected(Alias.error()); @@ -766,14 +767,14 @@ MachineMemoryDependenceAnalysis::run(MachineFunction &Function, const TargetDesc return ResultValue; } -Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses) { +Expected<void> registerStage8MachineAnalyses(MachineFunctionAnalysisManager &Analyses) { const std::array IDs{ - MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(), - MachineAnalysisManager::id<MachineLoopAnalysis>(), - MachineAnalysisManager::id<MachineBranchProbabilityAnalysis>(), - MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>(), - MachineAnalysisManager::id<MachineAliasAnalysis>(), - MachineAnalysisManager::id<MachineMemoryDependenceAnalysis>(), + MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(), + MachineFunctionAnalysisManager::id<MachineLoopAnalysis>(), + MachineFunctionAnalysisManager::id<MachineBranchProbabilityAnalysis>(), + MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>(), + MachineFunctionAnalysisManager::id<MachineAliasAnalysis>(), + MachineFunctionAnalysisManager::id<MachineMemoryDependenceAnalysis>(), }; const std::size_t Registered = static_cast<std::size_t>( std::ranges::count_if(IDs, [&Analyses](AnalysisID ID) { return Analyses.isRegistered(ID); })); @@ -787,7 +788,7 @@ Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses) { auto Candidate = Analyses.forkEmpty(); if (!Candidate) return std::unexpected(Candidate.error()); - MachineAnalysisManager &Staging = **Candidate; + MachineFunctionAnalysisManager &Staging = **Candidate; auto Dominators = Staging.registerAnalysis<MachineDominatorTreeAnalysis>({ .Name = "MachineDominatorTree", @@ -799,7 +800,7 @@ Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses) { return std::unexpected(Dominators.error()); auto Loops = Staging.registerAnalysis<MachineLoopAnalysis>({ .Name = "MachineLoopInfo", - .Dependencies = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>()}, + .Dependencies = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>()}, .InvalidatedBy = {MachinePassChange::CFG, MachinePassChange::BlockLayout}, .ThreadSafety = PassThreadSafety::ThreadSafe, }); @@ -815,9 +816,9 @@ Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses) { return std::unexpected(Probabilities.error()); auto Frequencies = Staging.registerAnalysis<MachineBlockFrequencyAnalysis>({ .Name = "MachineBlockFrequency", - .Dependencies = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(), - MachineAnalysisManager::id<MachineLoopAnalysis>(), - MachineAnalysisManager::id<MachineBranchProbabilityAnalysis>()}, + .Dependencies = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(), + MachineFunctionAnalysisManager::id<MachineLoopAnalysis>(), + MachineFunctionAnalysisManager::id<MachineBranchProbabilityAnalysis>()}, .InvalidatedBy = {MachinePassChange::CFG, MachinePassChange::BlockLayout}, .ThreadSafety = PassThreadSafety::ThreadSafe, }); @@ -835,7 +836,7 @@ Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses) { return std::unexpected(Alias.error()); auto MemoryDependence = Staging.registerAnalysis<MachineMemoryDependenceAnalysis>({ .Name = "MachineMemoryDependence", - .Dependencies = {MachineAnalysisManager::id<MachineAliasAnalysis>()}, + .Dependencies = {MachineFunctionAnalysisManager::id<MachineAliasAnalysis>()}, .InvalidatedBy = {MachinePassChange::Instructions, MachinePassChange::Operands, MachinePassChange::CFG, MachinePassChange::BlockLayout, MachinePassChange::Frame, MachinePassChange::ConstantPool, @@ -844,8 +845,7 @@ Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses) { }); if (!MemoryDependence) return std::unexpected(MemoryDependence.error()); - Analyses.Registry = std::move(Staging.Registry); - return {}; + return Analyses.replaceRegistrations(std::move(Staging)); } } // namespace rcc diff --git a/backend/lib/CodeGen/MachineBlockPlacement.cpp b/backend/lib/CodeGen/MachineBlockPlacement.cpp index daccba0..1e563e1 100644 --- a/backend/lib/CodeGen/MachineBlockPlacement.cpp +++ b/backend/lib/CodeGen/MachineBlockPlacement.cpp @@ -37,10 +37,10 @@ enum class PlacementClass : std::uint8_t { .Clears = {}, .RequiredAnalyses = { - MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(), - MachineAnalysisManager::id<MachineBranchProbabilityAnalysis>(), - MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>(), - MachineAnalysisManager::id<MachineLoopAnalysis>(), + MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(), + MachineFunctionAnalysisManager::id<MachineBranchProbabilityAnalysis>(), + MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>(), + MachineFunctionAnalysisManager::id<MachineLoopAnalysis>(), }, .VerificationStage = PipelineStage::Selected, }; @@ -101,9 +101,9 @@ const MachinePassContract &MachineBlockPlacementPass::contract() const noexcept return placementContract(); } -Expected<MachinePassResult> MachineBlockPlacementPass::run(MachineFunction &Function, - const TargetDescription &Target, - MachineAnalysisManager &Analyses) { +Expected<MachinePassResult> +MachineBlockPlacementPass::run(MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "machine block placement requires selected PHI-free MachineIR"); @@ -113,7 +113,7 @@ Expected<MachinePassResult> MachineBlockPlacementPass::run(MachineFunction &Func MachineFunctionCloneOptions{.NewStableID = Function.stableID(), .NewName = std::nullopt}); if (!Trial) return std::unexpected(prefixedError(Trial.error(), "block placement setup failed: ")); - MachineAnalysisManager TrialAnalyses; + MachineFunctionAnalysisManager TrialAnalyses; MachineActionReplay Actions(Analyses, Trial->InstructionStableIDs); auto TrialResult = runImplementation(*Trial->ClonedFunction, Target, TrialAnalyses, Actions); if (!TrialResult) @@ -131,8 +131,8 @@ Expected<MachinePassResult> MachineBlockPlacementPass::run(MachineFunction &Func } Expected<MachinePassResult> MachineBlockPlacementPass::runImplementation( - MachineFunction &Function, const TargetDescription &Target, MachineAnalysisManager &Analyses, - MachineActionReplay &Actions) const { + MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &Analyses, MachineActionReplay &Actions) const { auto Probabilities = Analyses.getResult<MachineBranchProbabilityAnalysis>(Function, Target); if (!Probabilities) return std::unexpected(Probabilities.error()); diff --git a/backend/lib/CodeGen/MachineBranchOptimization.cpp b/backend/lib/CodeGen/MachineBranchOptimization.cpp index 5880dbc..c102931 100644 --- a/backend/lib/CodeGen/MachineBranchOptimization.cpp +++ b/backend/lib/CodeGen/MachineBranchOptimization.cpp @@ -301,7 +301,7 @@ const MachinePassContract &MachineBranchOptimizationPass::contract() const noexc Expected<MachinePassResult> MachineBranchOptimizationPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "branch optimization requires selected PHI-free MachineIR"); diff --git a/backend/lib/CodeGen/MachineBranchRelaxation.cpp b/backend/lib/CodeGen/MachineBranchRelaxation.cpp index 78640f1..c11ed8e 100644 --- a/backend/lib/CodeGen/MachineBranchRelaxation.cpp +++ b/backend/lib/CodeGen/MachineBranchRelaxation.cpp @@ -107,9 +107,9 @@ const MachinePassContract &MachineBranchRelaxationPass::contract() const noexcep return relaxationContract(); } -Expected<MachinePassResult> MachineBranchRelaxationPass::run(MachineFunction &Function, - const TargetDescription &Target, - MachineAnalysisManager &Analyses) { +Expected<MachinePassResult> +MachineBranchRelaxationPass::run(MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "branch relaxation requires finalized frame and tracked liveness"); diff --git a/backend/lib/CodeGen/MachineCSE.cpp b/backend/lib/CodeGen/MachineCSE.cpp index 9d80b4e..92fe1bd 100644 --- a/backend/lib/CodeGen/MachineCSE.cpp +++ b/backend/lib/CodeGen/MachineCSE.cpp @@ -33,7 +33,7 @@ namespace { .Requires = {MachineFunctionProperty::IsSSA, MachineFunctionProperty::Selected}, .Sets = {}, .Clears = {}, - .RequiredAnalyses = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>()}, + .RequiredAnalyses = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>()}, .VerificationStage = PipelineStage::Selected, }; Value.ThreadSafety = PassThreadSafety::ThreadSafe; @@ -314,7 +314,7 @@ const MachinePassContract &MachineCSEPass::contract() const noexcept { Expected<MachinePassResult> MachineCSEPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "machine CSE requires selected SSA MachineIR"); @@ -325,7 +325,7 @@ Expected<MachinePassResult> MachineCSEPass::run(MachineFunction &Function, if (!Trial) { return std::unexpected(prefixedError(Trial.error(), "machine CSE transaction setup failed: ")); } - MachineAnalysisManager TrialAnalyses; + MachineFunctionAnalysisManager TrialAnalyses; auto TrialResult = runImplementation(*Trial->ClonedFunction, Target, TrialAnalyses); if (!TrialResult) return std::unexpected(TrialResult.error()); @@ -338,9 +338,9 @@ Expected<MachinePassResult> MachineCSEPass::run(MachineFunction &Function, return Result; } -Expected<MachinePassResult> MachineCSEPass::runImplementation(MachineFunction &Function, - const TargetDescription &Target, - MachineAnalysisManager &Analyses) { +Expected<MachinePassResult> +MachineCSEPass::runImplementation(MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &Analyses) { auto Dominators = Analyses.getResult<MachineDominatorTreeAnalysis>(Function, Target); if (!Dominators) return std::unexpected(Dominators.error()); diff --git a/backend/lib/CodeGen/MachineCombiner.cpp b/backend/lib/CodeGen/MachineCombiner.cpp index df9c002..c3e9795 100644 --- a/backend/lib/CodeGen/MachineCombiner.cpp +++ b/backend/lib/CodeGen/MachineCombiner.cpp @@ -295,7 +295,7 @@ const MachinePassContract &MachineCombinerPass::contract() const noexcept { Expected<MachinePassResult> MachineCombinerPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "machine combiner input does not satisfy its stage contract"); diff --git a/backend/lib/CodeGen/MachineCopyPropagation.cpp b/backend/lib/CodeGen/MachineCopyPropagation.cpp index 581cb4f..9725399 100644 --- a/backend/lib/CodeGen/MachineCopyPropagation.cpp +++ b/backend/lib/CodeGen/MachineCopyPropagation.cpp @@ -290,9 +290,9 @@ const MachinePassContract &MachineCopyPropagationPass::contract() const noexcept return copyPropagationContract(Stage); } -Expected<MachinePassResult> MachineCopyPropagationPass::run(MachineFunction &Function, - const TargetDescription &Target, - MachineAnalysisManager &Analyses) { +Expected<MachinePassResult> +MachineCopyPropagationPass::run(MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "machine COPY propagation has unmet stage properties"); diff --git a/backend/lib/CodeGen/MachineDCE.cpp b/backend/lib/CodeGen/MachineDCE.cpp index 4dd0e59..1c53c31 100644 --- a/backend/lib/CodeGen/MachineDCE.cpp +++ b/backend/lib/CodeGen/MachineDCE.cpp @@ -115,7 +115,7 @@ const MachinePassContract &MachineDCEPass::contract() const noexcept { Expected<MachinePassResult> MachineDCEPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "machine DCE requires a selected machine function"); diff --git a/backend/lib/CodeGen/MachineFallthrough.cpp b/backend/lib/CodeGen/MachineFallthrough.cpp index 5c58e67..608b703 100644 --- a/backend/lib/CodeGen/MachineFallthrough.cpp +++ b/backend/lib/CodeGen/MachineFallthrough.cpp @@ -26,7 +26,7 @@ namespace { MachineFunctionProperty::NoVRegs, MachineFunctionProperty::TracksLiveness}, .Sets = {}, .Clears = {}, - .RequiredAnalyses = {MachineAnalysisManager::id<LiveVariablesAnalysis>()}, + .RequiredAnalyses = {MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>()}, .VerificationStage = PipelineStage::RegisterAllocated, }; Value.ThreadSafety = PassThreadSafety::ThreadSafe; @@ -120,7 +120,7 @@ const MachinePassContract &MachineFallthroughPass::contract() const noexcept { Expected<MachinePassResult> MachineFallthroughPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "fallthrough normalization requires allocated tracked-liveness MIR"); @@ -130,7 +130,7 @@ Expected<MachinePassResult> MachineFallthroughPass::run(MachineFunction &Functio MachineFunctionCloneOptions{.NewStableID = Function.stableID(), .NewName = std::nullopt}); if (!Trial) return std::unexpected(prefixedError(Trial.error(), "fallthrough setup failed: ")); - MachineAnalysisManager TrialAnalyses; + MachineFunctionAnalysisManager TrialAnalyses; auto TrialLiveness = TrialAnalyses.getResult<LiveVariablesAnalysis>(*Trial->ClonedFunction, Target); if (!TrialLiveness) diff --git a/backend/lib/CodeGen/MachineFinalization.cpp b/backend/lib/CodeGen/MachineFinalization.cpp index 8947b86..c33d857 100644 --- a/backend/lib/CodeGen/MachineFinalization.cpp +++ b/backend/lib/CodeGen/MachineFinalization.cpp @@ -91,7 +91,7 @@ const MachinePassContract &FinalizeEmissionPseudosPass::contract() const noexcep Expected<MachinePassResult> FinalizeEmissionPseudosPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { if (!Function.properties().containsAll(contract().Requires)) return makeUnexpected(ErrorCode::VerificationError, "emission-pseudo finalization requires finalized allocated MIR"); @@ -124,7 +124,7 @@ const MachinePassContract &FinalEncodabilityVerifierPass::contract() const noexc Expected<MachinePassResult> FinalEncodabilityVerifierPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { if (!Function.properties().containsAll(contract().Requires)) return makeUnexpected(ErrorCode::FinalEncodabilityFailed, "final encodability requires NoExecutablePseudos and finalized MIR"); diff --git a/backend/lib/CodeGen/MachineLICM.cpp b/backend/lib/CodeGen/MachineLICM.cpp index 758e13c..31d792b 100644 --- a/backend/lib/CodeGen/MachineLICM.cpp +++ b/backend/lib/CodeGen/MachineLICM.cpp @@ -33,9 +33,9 @@ namespace { .Requires = {MachineFunctionProperty::IsSSA, MachineFunctionProperty::Selected}, .Sets = {}, .Clears = {}, - .RequiredAnalyses = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(), - MachineAnalysisManager::id<MachineLoopAnalysis>(), - MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>()}, + .RequiredAnalyses = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(), + MachineFunctionAnalysisManager::id<MachineLoopAnalysis>(), + MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>()}, .VerificationStage = PipelineStage::Selected, }; Value.ThreadSafety = PassThreadSafety::ThreadSafe; @@ -50,9 +50,9 @@ namespace { MachineFunctionProperty::TracksLiveness}, .Sets = {}, .Clears = {}, - .RequiredAnalyses = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(), - MachineAnalysisManager::id<MachineLoopAnalysis>(), - MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>()}, + .RequiredAnalyses = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(), + MachineFunctionAnalysisManager::id<MachineLoopAnalysis>(), + MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>()}, .VerificationStage = PipelineStage::RegisterAllocated, }; Value.ThreadSafety = PassThreadSafety::ThreadSafe; @@ -332,7 +332,7 @@ const MachinePassContract &MachineLICMPass::contract() const noexcept { Expected<MachinePassResult> MachineLICMPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected( ErrorCode::VerificationError, @@ -346,7 +346,7 @@ Expected<MachinePassResult> MachineLICMPass::run(MachineFunction &Function, if (!Trial) { return std::unexpected(prefixedError(Trial.error(), "machine LICM transaction setup failed: ")); } - MachineAnalysisManager TrialAnalyses; + MachineFunctionAnalysisManager TrialAnalyses; auto TrialResult = runImplementation(*Trial->ClonedFunction, Target, TrialAnalyses); if (!TrialResult) return std::unexpected(TrialResult.error()); @@ -359,9 +359,9 @@ Expected<MachinePassResult> MachineLICMPass::run(MachineFunction &Function, return Result; } -Expected<MachinePassResult> MachineLICMPass::runImplementation(MachineFunction &Function, - const TargetDescription &Target, - MachineAnalysisManager &Analyses) { +Expected<MachinePassResult> +MachineLICMPass::runImplementation(MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &Analyses) { auto Loops = Analyses.getResult<MachineLoopAnalysis>(Function, Target); if (!Loops) return std::unexpected(Loops.error()); diff --git a/backend/lib/CodeGen/MachineMemoryFolding.cpp b/backend/lib/CodeGen/MachineMemoryFolding.cpp index 0e15146..e3d796a 100644 --- a/backend/lib/CodeGen/MachineMemoryFolding.cpp +++ b/backend/lib/CodeGen/MachineMemoryFolding.cpp @@ -185,7 +185,7 @@ const MachinePassContract &MachineMemoryFoldingPass::contract() const noexcept { Expected<MachinePassResult> MachineMemoryFoldingPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "memory folding requires selected SSA MachineIR"); diff --git a/backend/lib/CodeGen/MachineOptimizationPipeline.cpp b/backend/lib/CodeGen/MachineOptimizationPipeline.cpp index 4f116f0..4a9d7f5 100644 --- a/backend/lib/CodeGen/MachineOptimizationPipeline.cpp +++ b/backend/lib/CodeGen/MachineOptimizationPipeline.cpp @@ -32,13 +32,13 @@ namespace rcc { namespace { template <typename Pass, typename... Arguments> -[[nodiscard]] Expected<void> addPass(MachinePassManager &Pipeline, Arguments &&...Values) { +[[nodiscard]] Expected<void> addPass(MachineFunctionPassManager &Pipeline, Arguments &&...Values) { return Pipeline.addPass(std::make_unique<Pass>(std::forward<Arguments>(Values)...)); } } // namespace -Expected<void> registerMachineOptimizationAnalyses(MachineAnalysisManager &Analyses) { +Expected<void> registerMachineOptimizationAnalyses(MachineFunctionAnalysisManager &Analyses) { auto Registered = registerStage8MachineAnalyses(Analyses); if (!Registered) return std::unexpected(Registered.error()); @@ -46,7 +46,7 @@ Expected<void> registerMachineOptimizationAnalyses(MachineAnalysisManager &Analy } Expected<void> -addSelectedSSAOptimizationPipeline(MachinePassManager &Pipeline, +addSelectedSSAOptimizationPipeline(MachineFunctionPassManager &Pipeline, const MachineOptimizationPipelineTargetInfo &TargetInfo) { auto Added = addPass<MachineCombinerPass>(Pipeline, TargetInfo.Combiner, MachineCombinerStage::SelectedSSA); @@ -68,7 +68,7 @@ addSelectedSSAOptimizationPipeline(MachinePassManager &Pipeline, } Expected<void> addPreRegisterAllocationOptimizationPipeline( - MachinePassManager &Pipeline, const MachineOptimizationPipelineTargetInfo &TargetInfo) { + MachineFunctionPassManager &Pipeline, const MachineOptimizationPipelineTargetInfo &TargetInfo) { auto Added = addPass<MachineBranchOptimizationPass>(Pipeline, TargetInfo.InstrInfo); if (!Added) return std::unexpected(Added.error()); @@ -87,7 +87,7 @@ Expected<void> addPreRegisterAllocationOptimizationPipeline( } Expected<void> -addPostRegisterAllocationPipeline(MachinePassManager &Pipeline, +addPostRegisterAllocationPipeline(MachineFunctionPassManager &Pipeline, const MachineOptimizationPipelineTargetInfo &TargetInfo) { auto Added = addPass<MachineStackSlotColoringPass>(Pipeline); if (!Added) diff --git a/backend/lib/CodeGen/MachinePass.cpp b/backend/lib/CodeGen/MachinePassManager.cpp index 0ce6f70..0810965 100644 --- a/backend/lib/CodeGen/MachinePass.cpp +++ b/backend/lib/CodeGen/MachinePassManager.cpp @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-3.0-or-later -#include "rcc/CodeGen/MachinePass.h" +#include "rcc/CodeGen/MachinePassManager.h" #include "rcc/CodeGen/CompilationUnit.h" #include "rcc/CodeGen/MachineBasicBlock.h" @@ -141,6 +141,56 @@ void combineFingerprint(std::uint64_t &State, std::uint64_t Value) noexcept { } // namespace +void AnalysisManagerInstrumentation<MachineFunction, MachinePassInstrumentation>::beforeAnalysis( + MachinePassInstrumentation *Instrumentation, std::string_view Name, + const MachineFunction &Function) { + Instrumentation->beforeAnalysis(Name, Function); +} + +void AnalysisManagerInstrumentation<MachineFunction, MachinePassInstrumentation>::afterAnalysis( + MachinePassInstrumentation *Instrumentation, std::string_view Name, + const MachineFunction &Function, bool CacheHit, std::uint64_t Nanoseconds) { + Instrumentation->afterAnalysis(Name, Function, CacheHit, Nanoseconds); +} + +void AnalysisManagerInstrumentation<MachineFunction, MachinePassInstrumentation>::analysisFailure( + MachinePassInstrumentation *Instrumentation, std::string_view Name, + const MachineFunction &Function, const Error &Failure, std::uint64_t Nanoseconds) { + Instrumentation->analysisFailure(Name, Function, Failure, Nanoseconds); +} + +Expected<bool> +AnalysisManagerInstrumentation<MachineFunction, MachinePassInstrumentation>::requestAction( + MachinePassInstrumentation *Instrumentation, std::string_view Pass, std::string_view Rule, + const MachineFunction &Function, MachineInstrStableID Instruction, std::uint64_t Cost) { + return Instrumentation->requestAction(Pass, Rule, Function, Instruction, Cost); +} + +Expected<bool> +AnalysisManagerInstrumentation<MachineFunction, MachinePassInstrumentation>::requestAction( + MachinePassInstrumentation *Instrumentation, std::string_view Pass, std::string_view Rule, + const MachineFunction &Function, std::nullptr_t, std::uint64_t Cost) { + return Instrumentation->requestAction(Pass, Rule, Function, nullptr, Cost); +} + +void AnalysisManagerInstrumentation<CompilationUnit, MachinePassInstrumentation>::beforeAnalysis( + MachinePassInstrumentation *Instrumentation, std::string_view Name, + const CompilationUnit &Unit) { + Instrumentation->beforeAnalysis(Name, Unit); +} + +void AnalysisManagerInstrumentation<CompilationUnit, MachinePassInstrumentation>::afterAnalysis( + MachinePassInstrumentation *Instrumentation, std::string_view Name, const CompilationUnit &Unit, + bool CacheHit, std::uint64_t Nanoseconds) { + Instrumentation->afterAnalysis(Name, Unit, CacheHit, Nanoseconds); +} + +void AnalysisManagerInstrumentation<CompilationUnit, MachinePassInstrumentation>::analysisFailure( + MachinePassInstrumentation *Instrumentation, std::string_view Name, const CompilationUnit &Unit, + const Error &Failure, std::uint64_t Nanoseconds) { + Instrumentation->analysisFailure(Name, Unit, Failure, Nanoseconds); +} + std::string MachineActionID::toString() const { std::string Result; Result.reserve(Pass.size() + Rule.size() + 48U); @@ -160,7 +210,7 @@ Expected<bool> MachineActionReplay::request(std::string_view Rule, const Machine const auto Position = RecordingInstructionIDs.find(Instruction); const MachineInstrStableID CanonicalInstruction = Position == RecordingInstructionIDs.end() ? Instruction : Position->second; - auto Accepted = Analyses->requestAction(Rule, Function, CanonicalInstruction, Cost); + auto Accepted = Request(Rule, Function, CanonicalInstruction, Cost); if (!Accepted) return std::unexpected(Accepted.error()); Decisions.push_back({ @@ -214,452 +264,6 @@ Expected<void> MachineActionReplay::finishReplay() const { return {}; } -Expected<void> -MachineAnalysisManager::registerAnalysisImpl(MachineAnalysisRegistration Registration, - ErasedRunner Runner, ErasedInvalidator Invalidator) { - if (Registration.ID == nullptr || Registration.Name.empty() || !Runner || !Invalidator) { - return makeUnexpected(ErrorCode::InvalidArgument, - "machine analysis registration is incomplete"); - } - if (hasDuplicateAnalysisIDs(Registration.Dependencies)) { - return makeUnexpected(ErrorCode::InvalidArgument, - "machine analysis dependencies must be non-null and unique"); - } - if (std::ranges::find(Registration.Dependencies, Registration.ID) != - Registration.Dependencies.end()) { - return makeUnexpected(ErrorCode::InvalidArgument, - "machine analysis cannot directly depend on itself"); - } - if (Registry.contains(Registration.ID)) - return makeUnexpected(ErrorCode::InvalidArgument, "machine analysis ID is already registered"); - if (std::ranges::any_of(Registry, [&Registration](const auto &Entry) { - return Entry.second.Info.Name == Registration.Name; - })) { - return makeUnexpected(ErrorCode::InvalidArgument, - "machine analysis name is already registered"); - } - const AnalysisID RegistrationID = Registration.ID; - Registry.emplace(RegistrationID, RegisteredAnalysis{std::move(Registration), std::move(Runner), - std::move(Invalidator)}); - return {}; -} - -bool MachineAnalysisManager::isRegistered(AnalysisID ID) const noexcept { - return ID != nullptr && Registry.contains(ID); -} - -bool MachineAnalysisManager::hasCached(const MachineFunction &Function, - AnalysisID ID) const noexcept { - const auto FunctionPosition = Cache.find(const_cast<MachineFunction *>(&Function)); - if (FunctionPosition == Cache.end()) - return false; - const auto AnalysisPosition = FunctionPosition->second.find(ID); - return AnalysisPosition != FunctionPosition->second.end() && AnalysisPosition->second.Value; -} - -std::size_t -MachineAnalysisManager::cachedResultCount(const MachineFunction &Function) const noexcept { - const auto Position = Cache.find(const_cast<MachineFunction *>(&Function)); - return Position == Cache.end() ? 0 : Position->second.size(); -} - -Expected<void> -MachineAnalysisManager::materializeDependencies(const RegisteredAnalysis &Registration, - MachineFunction &Function, - const TargetDescription &Target) { - for (const AnalysisID Dependency : Registration.Info.Dependencies) { - if (!Registry.contains(Dependency)) { - return makeUnexpected(ErrorCode::InvalidArgument, - "machine analysis depends on an unregistered analysis"); - } - auto Result = getResultImpl(Dependency, Function, Target); - if (!Result) - return std::unexpected(Result.error()); - } - return {}; -} - -Expected<void *> MachineAnalysisManager::getResultImpl(AnalysisID ID, MachineFunction &Function, - const TargetDescription &Target) { - if (ID == nullptr) - return makeUnexpected(ErrorCode::InvalidArgument, "machine analysis ID cannot be null"); - - auto &FunctionCache = Cache[&Function]; - if (const auto Cached = FunctionCache.find(ID); - Cached != FunctionCache.end() && Cached->second.Value) { - const auto Registration = Registry.find(ID); - const std::string_view Name = Registration == Registry.end() - ? std::string_view{"unknown-machine-analysis"} - : std::string_view{Registration->second.Info.Name}; - if (Instrumentation != nullptr) - Instrumentation->afterAnalysis(Name, Function, true, 0); - return Cached->second.Value.get(); - } - - const auto RegistrationPosition = Registry.find(ID); - if (RegistrationPosition == Registry.end()) - return makeUnexpected(ErrorCode::InvalidArgument, "machine analysis ID is not registered"); - const RegisteredAnalysis &Registration = RegistrationPosition->second; - - auto &Stack = ActiveComputations[&Function]; - if (std::ranges::find(Stack, ID) != Stack.end()) { - Error Failure(ErrorCode::InvalidArgument, - "machine analysis dependency cycle reaches '" + Registration.Info.Name + "'"); - if (Instrumentation != nullptr) - Instrumentation->analysisFailure(Registration.Info.Name, Function, Failure, 0); - return std::unexpected(std::move(Failure)); - } - - if (Instrumentation != nullptr) - Instrumentation->beforeAnalysis(Registration.Info.Name, Function); - const Clock::time_point Start = Clock::now(); - Stack.push_back(ID); - auto Dependencies = materializeDependencies(Registration, Function, Target); - if (!Dependencies) { - Stack.pop_back(); - if (Stack.empty()) - ActiveComputations.erase(&Function); - Error Failure = prefixedError(Dependencies.error(), - "machine analysis '" + Registration.Info.Name + "' failed: "); - if (Instrumentation != nullptr) { - Instrumentation->analysisFailure(Registration.Info.Name, Function, Failure, - elapsedNanoseconds(Start)); - } - return std::unexpected(std::move(Failure)); - } - - auto Computed = Registration.Runner(Function, Target, *this); - Stack.pop_back(); - if (Stack.empty()) - ActiveComputations.erase(&Function); - const std::uint64_t Duration = elapsedNanoseconds(Start); - if (!Computed) { - Error Failure = prefixedError(Computed.error(), - "machine analysis '" + Registration.Info.Name + "' failed: "); - if (Instrumentation != nullptr) - Instrumentation->analysisFailure(Registration.Info.Name, Function, Failure, Duration); - return std::unexpected(std::move(Failure)); - } - if (!*Computed) { - Error Failure(ErrorCode::InternalError, - "machine analysis '" + Registration.Info.Name + "' returned a null result"); - if (Instrumentation != nullptr) - Instrumentation->analysisFailure(Registration.Info.Name, Function, Failure, Duration); - return std::unexpected(std::move(Failure)); - } - - void *Result = Computed->get(); - FunctionCache.emplace(ID, CacheEntry{std::move(*Computed), ID}); - if (Instrumentation != nullptr) - Instrumentation->afterAnalysis(Registration.Info.Name, Function, false, Duration); - return Result; -} - -void MachineAnalysisManager::invalidate(MachineFunction &Function, - const PreservedAnalyses &Preserved, - MachinePassChanges Changes) noexcept { - const auto FunctionPosition = Cache.find(&Function); - if (FunctionPosition == Cache.end() || Preserved.preservesAll() || Changes.empty()) - return; - - std::set<AnalysisID> Invalid; - for (auto &[ID, Entry] : FunctionPosition->second) { - if (Preserved.preserves(ID)) - continue; - const auto Registration = Registry.find(ID); - if (Registration == Registry.end() || - Registration->second.Info.InvalidatedBy.intersects(Changes)) { - const bool ShouldInvalidate = - Registration == Registry.end() || !Entry.Value || !Registration->second.Invalidator || - Registration->second.Invalidator(Entry.Value.get(), Function, Preserved); - if (ShouldInvalidate) - Invalid.insert(ID); - } - } - - bool Added = true; - while (Added) { - Added = false; - for (const auto &[ID, Entry] : FunctionPosition->second) { - (void)Entry; - if (Invalid.contains(ID) || Preserved.preserves(ID)) - continue; - const auto Registration = Registry.find(ID); - if (Registration != Registry.end() && - std::ranges::any_of( - Registration->second.Info.Dependencies, - [&Invalid](AnalysisID Dependency) { return Invalid.contains(Dependency); })) { - Added = Invalid.insert(ID).second || Added; - } - } - } - - for (const AnalysisID ID : Invalid) - FunctionPosition->second.erase(ID); - if (FunctionPosition->second.empty()) - Cache.erase(FunctionPosition); -} - -void MachineAnalysisManager::clear(MachineFunction &Function) noexcept { - Cache.erase(&Function); - ActiveComputations.erase(&Function); -} - -void MachineAnalysisManager::clearAll() noexcept { - Cache.clear(); - ActiveComputations.clear(); -} - -Expected<std::unique_ptr<MachineAnalysisManager>> MachineAnalysisManager::forkEmpty() const { - if (!ActiveComputations.empty()) { - return makeUnexpected(ErrorCode::InvalidArgument, - "cannot fork a machine analysis manager during analysis computation"); - } - auto Result = std::make_unique<MachineAnalysisManager>(); - Result->Registry = Registry; - return Result; -} - -Expected<void> MachineAnalysisManager::validateParallelRequirements( - std::span<const AnalysisID> RequiredAnalyses) const { - std::vector<AnalysisID> Worklist(RequiredAnalyses.begin(), RequiredAnalyses.end()); - std::unordered_set<AnalysisID> Visited; - for (std::size_t Index = 0; Index < Worklist.size(); ++Index) { - const AnalysisID ID = Worklist[Index]; - if (ID == nullptr || !Visited.insert(ID).second) - continue; - const auto Position = Registry.find(ID); - if (Position == Registry.end()) { - return makeUnexpected(ErrorCode::InvalidArgument, - "parallel machine pass requires an unregistered analysis"); - } - if (Position->second.Info.ThreadSafety != PassThreadSafety::ThreadSafe) { - return makeUnexpected(ErrorCode::InvalidArgument, - "parallel machine pipeline requires analysis '" + - Position->second.Info.Name + "' to be marked thread-safe"); - } - Worklist.insert(Worklist.end(), Position->second.Info.Dependencies.begin(), - Position->second.Info.Dependencies.end()); - } - return {}; -} - -Expected<bool> MachineAnalysisManager::requestAction(std::string_view Action, - const MachineFunction &Function, - std::uint64_t Cost) { - return requestAction(Action, Function, MachineInstrStableID{}, Cost); -} - -Expected<bool> MachineAnalysisManager::requestAction(std::string_view Rule, - const MachineFunction &Function, - MachineInstrStableID Instruction, - std::uint64_t Cost) { - if (Rule.empty() || Cost == 0) - return makeUnexpected(ErrorCode::InvalidArgument, - "machine action requires a name and nonzero cost"); - if (Instrumentation == nullptr) - return true; - MachineActionID ID{ - .Pass = ActivePass.empty() ? "unscoped" : ActivePass, - .Rule = std::string(Rule), - .Function = Function.stableID(), - .Instruction = Instruction, - }; - return Instrumentation->requestAction(ID, Function, Cost); -} - -Expected<void> CompilationUnitAnalysisManager::registerAnalysisImpl( - CompilationUnitAnalysisRegistration Registration, ErasedRunner Runner, - ErasedInvalidator Invalidator) { - if (Registration.ID == nullptr || Registration.Name.empty() || !Runner || !Invalidator) { - return makeUnexpected(ErrorCode::InvalidArgument, - "compilation-unit analysis registration is incomplete"); - } - if (hasDuplicateAnalysisIDs(Registration.Dependencies)) { - return makeUnexpected(ErrorCode::InvalidArgument, - "compilation-unit analysis dependencies must be non-null and unique"); - } - if (std::ranges::find(Registration.Dependencies, Registration.ID) != - Registration.Dependencies.end()) { - return makeUnexpected(ErrorCode::InvalidArgument, - "compilation-unit analysis cannot directly depend on itself"); - } - if (Registry.contains(Registration.ID)) { - return makeUnexpected(ErrorCode::InvalidArgument, - "compilation-unit analysis ID is already registered"); - } - if (std::ranges::any_of(Registry, [&Registration](const auto &Entry) { - return Entry.second.Info.Name == Registration.Name; - })) { - return makeUnexpected(ErrorCode::InvalidArgument, - "compilation-unit analysis name is already registered"); - } - const AnalysisID RegistrationID = Registration.ID; - Registry.emplace(RegistrationID, RegisteredAnalysis{std::move(Registration), std::move(Runner), - std::move(Invalidator)}); - return {}; -} - -bool CompilationUnitAnalysisManager::isRegistered(AnalysisID ID) const noexcept { - return ID != nullptr && Registry.contains(ID); -} - -bool CompilationUnitAnalysisManager::hasCached(const CompilationUnit &Unit, - AnalysisID ID) const noexcept { - const auto UnitPosition = Cache.find(const_cast<CompilationUnit *>(&Unit)); - if (UnitPosition == Cache.end()) - return false; - const auto AnalysisPosition = UnitPosition->second.find(ID); - return AnalysisPosition != UnitPosition->second.end() && AnalysisPosition->second.Value; -} - -Expected<void> -CompilationUnitAnalysisManager::materializeDependencies(const RegisteredAnalysis &Registration, - CompilationUnit &Unit, - const TargetDescription &Target) { - for (const AnalysisID Dependency : Registration.Info.Dependencies) { - if (!Registry.contains(Dependency)) { - return makeUnexpected(ErrorCode::InvalidArgument, - "compilation-unit analysis depends on an unregistered analysis"); - } - auto Result = getResultImpl(Dependency, Unit, Target); - if (!Result) - return std::unexpected(Result.error()); - } - return {}; -} - -Expected<void *> CompilationUnitAnalysisManager::getResultImpl(AnalysisID ID, CompilationUnit &Unit, - const TargetDescription &Target) { - if (ID == nullptr) - return makeUnexpected(ErrorCode::InvalidArgument, - "compilation-unit analysis ID cannot be null"); - auto &UnitCache = Cache[&Unit]; - if (const auto Cached = UnitCache.find(ID); Cached != UnitCache.end() && Cached->second.Value) { - const auto Registration = Registry.find(ID); - const std::string_view Name = Registration == Registry.end() - ? std::string_view{"unknown-compilation-unit-analysis"} - : std::string_view{Registration->second.Info.Name}; - if (Instrumentation != nullptr) - Instrumentation->afterUnitAnalysis(Name, Unit, true, 0); - return Cached->second.Value.get(); - } - - const auto RegistrationPosition = Registry.find(ID); - if (RegistrationPosition == Registry.end()) { - return makeUnexpected(ErrorCode::InvalidArgument, - "compilation-unit analysis ID is not registered"); - } - const RegisteredAnalysis &Registration = RegistrationPosition->second; - auto &Stack = ActiveComputations[&Unit]; - if (std::ranges::find(Stack, ID) != Stack.end()) { - Error Failure(ErrorCode::InvalidArgument, - "compilation-unit analysis dependency cycle reaches '" + Registration.Info.Name + - "'"); - if (Instrumentation != nullptr) - Instrumentation->unitAnalysisFailure(Registration.Info.Name, Unit, Failure, 0); - return std::unexpected(std::move(Failure)); - } - - if (Instrumentation != nullptr) - Instrumentation->beforeUnitAnalysis(Registration.Info.Name, Unit); - const Clock::time_point Start = Clock::now(); - Stack.push_back(ID); - auto Dependencies = materializeDependencies(Registration, Unit, Target); - if (!Dependencies) { - Stack.pop_back(); - if (Stack.empty()) - ActiveComputations.erase(&Unit); - Error Failure = prefixedError(Dependencies.error(), "compilation-unit analysis '" + - Registration.Info.Name + "' failed: "); - if (Instrumentation != nullptr) { - Instrumentation->unitAnalysisFailure(Registration.Info.Name, Unit, Failure, - elapsedNanoseconds(Start)); - } - return std::unexpected(std::move(Failure)); - } - - auto Computed = Registration.Runner(Unit, Target, *this); - Stack.pop_back(); - if (Stack.empty()) - ActiveComputations.erase(&Unit); - const std::uint64_t Duration = elapsedNanoseconds(Start); - if (!Computed) { - Error Failure = prefixedError(Computed.error(), "compilation-unit analysis '" + - Registration.Info.Name + "' failed: "); - if (Instrumentation != nullptr) - Instrumentation->unitAnalysisFailure(Registration.Info.Name, Unit, Failure, Duration); - return std::unexpected(std::move(Failure)); - } - if (!*Computed) { - Error Failure(ErrorCode::InternalError, "compilation-unit analysis '" + Registration.Info.Name + - "' returned a null result"); - if (Instrumentation != nullptr) - Instrumentation->unitAnalysisFailure(Registration.Info.Name, Unit, Failure, Duration); - return std::unexpected(std::move(Failure)); - } - - void *Result = Computed->get(); - UnitCache.emplace(ID, CacheEntry{std::move(*Computed), ID}); - if (Instrumentation != nullptr) - Instrumentation->afterUnitAnalysis(Registration.Info.Name, Unit, false, Duration); - return Result; -} - -void CompilationUnitAnalysisManager::invalidate(CompilationUnit &Unit, - const PreservedAnalyses &Preserved, - MachinePassChanges Changes) noexcept { - const auto UnitPosition = Cache.find(&Unit); - if (UnitPosition == Cache.end() || Preserved.preservesAll() || Changes.empty()) - return; - - std::set<AnalysisID> Invalid; - for (auto &[ID, Entry] : UnitPosition->second) { - if (Preserved.preserves(ID)) - continue; - const auto Registration = Registry.find(ID); - if (Registration == Registry.end() || - Registration->second.Info.InvalidatedBy.intersects(Changes)) { - const bool ShouldInvalidate = - Registration == Registry.end() || !Entry.Value || !Registration->second.Invalidator || - Registration->second.Invalidator(Entry.Value.get(), Unit, Preserved); - if (ShouldInvalidate) - Invalid.insert(ID); - } - } - - bool Added = true; - while (Added) { - Added = false; - for (const auto &[ID, Entry] : UnitPosition->second) { - (void)Entry; - if (Invalid.contains(ID) || Preserved.preserves(ID)) - continue; - const auto Registration = Registry.find(ID); - if (Registration != Registry.end() && - std::ranges::any_of( - Registration->second.Info.Dependencies, - [&Invalid](AnalysisID Dependency) { return Invalid.contains(Dependency); })) { - Added = Invalid.insert(ID).second || Added; - } - } - } - for (const AnalysisID InvalidID : Invalid) - UnitPosition->second.erase(InvalidID); - if (UnitPosition->second.empty()) - Cache.erase(UnitPosition); -} - -void CompilationUnitAnalysisManager::clear(CompilationUnit &Unit) noexcept { - Cache.erase(&Unit); - ActiveComputations.erase(&Unit); -} - -void CompilationUnitAnalysisManager::clearAll() noexcept { - Cache.clear(); - ActiveComputations.clear(); -} - void MachinePassInstrumentation::addBeforeCallback(BeforeCallback Callback) { if (!Callback) return; @@ -966,9 +570,17 @@ void MachinePassInstrumentation::change(std::string_view Name, const MachineFunc Callback(Name, Function, Changes, FingerprintChanged); } -Expected<bool> MachinePassInstrumentation::requestAction(const MachineActionID &Action, +Expected<bool> MachinePassInstrumentation::requestAction(std::string_view Pass, + std::string_view Rule, const MachineFunction &Function, + MachineInstrStableID Instruction, std::uint64_t Cost) { + MachineActionID Action{ + .Pass = std::string(Pass), + .Rule = std::string(Rule), + .Function = Function.stableID(), + .Instruction = Instruction, + }; if (Action.Pass.empty() || Action.Rule.empty() || Action.Function != Function.stableID() || Cost == 0) { return makeUnexpected(ErrorCode::InvalidArgument, "machine action identity is invalid"); @@ -1000,6 +612,13 @@ Expected<bool> MachinePassInstrumentation::requestAction(const MachineActionID & return true; } +Expected<bool> MachinePassInstrumentation::requestAction(std::string_view Pass, + std::string_view Rule, + const MachineFunction &Function, + std::nullptr_t, std::uint64_t Cost) { + return requestAction(Pass, Rule, Function, MachineInstrStableID{}, Cost); +} + void MachinePassInstrumentation::beforeUnit(std::string_view Name, const CompilationUnit &Unit) const { std::vector<BeforeUnitCallback> Callbacks; @@ -1043,8 +662,8 @@ void MachinePassInstrumentation::unitFailure(std::string_view Name, const Compil Callback(Name, Unit, ErrorValue); } -void MachinePassInstrumentation::beforeUnitAnalysis(std::string_view Name, - const CompilationUnit &Unit) const { +void MachinePassInstrumentation::beforeAnalysis(std::string_view Name, + const CompilationUnit &Unit) const { std::vector<BeforeUnitAnalysisCallback> Callbacks; { std::scoped_lock Lock(Mutex); @@ -1054,9 +673,8 @@ void MachinePassInstrumentation::beforeUnitAnalysis(std::string_view Name, Callback(Name, Unit); } -void MachinePassInstrumentation::afterUnitAnalysis(std::string_view Name, - const CompilationUnit &Unit, bool CacheHit, - std::uint64_t Nanoseconds) const { +void MachinePassInstrumentation::afterAnalysis(std::string_view Name, const CompilationUnit &Unit, + bool CacheHit, std::uint64_t Nanoseconds) const { std::vector<AfterUnitAnalysisCallback> Callbacks; { std::scoped_lock Lock(Mutex); @@ -1070,10 +688,9 @@ void MachinePassInstrumentation::afterUnitAnalysis(std::string_view Name, Callback(Name, Unit, CacheHit, Nanoseconds); } -void MachinePassInstrumentation::unitAnalysisFailure(std::string_view Name, - const CompilationUnit &Unit, - const Error &ErrorValue, - std::uint64_t Nanoseconds) const { +void MachinePassInstrumentation::analysisFailure(std::string_view Name, const CompilationUnit &Unit, + const Error &ErrorValue, + std::uint64_t Nanoseconds) const { std::vector<UnitAnalysisFailureCallback> Callbacks; { std::scoped_lock Lock(Mutex); @@ -1128,14 +745,10 @@ std::vector<MachineActionEvent> MachinePassInstrumentation::actionEvents() const return Result; } -void MachinePassInstrumentation::clearStatistics() { - std::scoped_lock Lock(Mutex); - Statistics.clear(); - ConsumedFuel.clear(); - ActionEvents.clear(); -} - -Expected<void> MachinePassManager::validateContract(const MachinePassContract &Contract) const { +Expected<void> +PassManagerCallbacks<MachineFunction, MachineFunctionPass, MachinePassManagerOptions>::validate( + const MachineFunctionPass &Pass) { + const MachinePassContract &Contract = Pass.contract(); if (Contract.Name.empty()) return makeUnexpected(ErrorCode::InvalidArgument, "machine pass must have a non-empty name"); if (Contract.Sets.intersects(Contract.Clears)) { @@ -1149,20 +762,11 @@ Expected<void> MachinePassManager::validateContract(const MachinePassContract &C return validateParameters(Contract.Parameters); } -Expected<void> MachinePassManager::addPass(std::unique_ptr<MachineFunctionPass> Pass) { - if (!Pass) - return makeUnexpected(ErrorCode::InvalidArgument, - "machine pass manager cannot add a null pass"); - auto Validation = validateContract(Pass->contract()); - if (!Validation) - return std::unexpected(Validation.error()); - Passes.push_back(std::move(Pass)); - return {}; -} - -Expected<void> MachinePassManager::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses, - MachinePassInstrumentation *Instrumentation) const { +Expected<void> +PassManagerCallbacks<MachineFunction, MachineFunctionPass, MachinePassManagerOptions>::run( + const PassList &Passes, const MachinePassManagerOptions &Options, MachineFunction &Function, + const TargetDescription &Target, MachineFunctionAnalysisManager &Analyses, + MachinePassInstrumentation *Instrumentation) { Analyses.setInstrumentation(Instrumentation); for (const std::unique_ptr<MachineFunctionPass> &Pass : Passes) { const MachinePassContract &Contract = Pass->contract(); @@ -1192,7 +796,7 @@ Expected<void> MachinePassManager::run(MachineFunction &Function, const TargetDe } for (const AnalysisID Required : Contract.RequiredAnalyses) { - auto Result = Analyses.getResultImpl(Required, Function, Target); + auto Result = Analyses.getResultByID(Required, Function, Target); if (!Result) { Error Failure = prefixedError(Result.error(), "pass '" + std::string(Name) + @@ -1209,9 +813,9 @@ Expected<void> MachinePassManager::run(MachineFunction &Function, const TargetDe if (Instrumentation != nullptr) Instrumentation->before(Name, Function); const Clock::time_point Start = Clock::now(); - Analyses.ActivePass = std::string(Name); + Analyses.setActivePass(std::string(Name)); auto PassResult = Pass->run(Function, Target, Analyses); - Analyses.ActivePass.clear(); + Analyses.setActivePass({}); const std::uint64_t Duration = elapsedNanoseconds(Start); if (!PassResult) { Error Failure = @@ -1296,11 +900,11 @@ Expected<void> MachinePassManager::run(MachineFunction &Function, const TargetDe return {}; } -Expected<void> MachinePassManager::runFunctions(CompilationUnit &Unit, - const TargetDescription &Target, - const MachineAnalysisManager &AnalysisPrototype, - std::size_t ThreadCount, - MachinePassInstrumentation *Instrumentation) const { +Expected<void> +PassManagerCallbacks<MachineFunction, MachineFunctionPass, MachinePassManagerOptions>::runFunctions( + const PassList &Passes, const MachinePassManagerOptions &Options, CompilationUnit &Unit, + const TargetDescription &Target, const MachineFunctionAnalysisManager &AnalysisPrototype, + std::size_t ThreadCount, MachinePassInstrumentation *Instrumentation) { if (ThreadCount == 0) return makeUnexpected(ErrorCode::InvalidArgument, "machine pass thread count must be nonzero"); auto UnitVerification = verifyCompilationUnit(Unit, Target); @@ -1322,7 +926,7 @@ Expected<void> MachinePassManager::runFunctions(CompilationUnit &Unit, return std::unexpected(AnalysisSafety.error()); } } - std::vector<std::unique_ptr<MachineAnalysisManager>> Managers; + std::vector<std::unique_ptr<MachineFunctionAnalysisManager>> Managers; Managers.reserve(FunctionCount); for (std::size_t Index = 0; Index < FunctionCount; ++Index) { auto Manager = AnalysisPrototype.forkEmpty(); @@ -1347,7 +951,8 @@ Expected<void> MachinePassManager::runFunctions(CompilationUnit &Unit, } if (Instrumentation != nullptr) Instrumentation->beginBuffering(EventBuffers[Index], Target); - auto Result = run(*Function, Target, *Managers[Index], Instrumentation); + auto Result = PassManagerCallbacks::run(Passes, Options, *Function, Target, *Managers[Index], + Instrumentation); if (Instrumentation != nullptr) Instrumentation->endBuffering(); if (!Result) @@ -1374,12 +979,10 @@ Expected<void> MachinePassManager::runFunctions(CompilationUnit &Unit, return {}; } -Expected<void> CompilationUnitPassManager::addPass(std::unique_ptr<CompilationUnitPass> Pass) { - if (!Pass) { - return makeUnexpected(ErrorCode::InvalidArgument, - "compilation-unit pass manager cannot add a null pass"); - } - const CompilationUnitPassContract &Contract = Pass->contract(); +Expected<void> +PassManagerCallbacks<CompilationUnit, CompilationUnitPass, + CompilationUnitPassManagerOptions>::validate(const CompilationUnitPass &Pass) { + const CompilationUnitPassContract &Contract = Pass.contract(); if (Contract.Name.empty()) { return makeUnexpected(ErrorCode::InvalidArgument, "compilation-unit pass must have a non-empty name"); @@ -1391,15 +994,14 @@ Expected<void> CompilationUnitPassManager::addPass(std::unique_ptr<CompilationUn auto Parameters = validateParameters(Contract.Parameters); if (!Parameters) return std::unexpected(Parameters.error()); - Passes.push_back(std::move(Pass)); return {}; } -Expected<void> CompilationUnitPassManager::run(CompilationUnit &Unit, - const TargetDescription &Target, - CompilationUnitAnalysisManager &UnitAnalyses, - MachineAnalysisManager &FunctionAnalyses, - MachinePassInstrumentation *Instrumentation) const { +Expected<void> +PassManagerCallbacks<CompilationUnit, CompilationUnitPass, CompilationUnitPassManagerOptions>::run( + const PassList &Passes, const CompilationUnitPassManagerOptions &Options, CompilationUnit &Unit, + const TargetDescription &Target, CompilationUnitAnalysisManager &UnitAnalyses, + MachineFunctionAnalysisManager &FunctionAnalyses, MachinePassInstrumentation *Instrumentation) { UnitAnalyses.setInstrumentation(Instrumentation); FunctionAnalyses.setInstrumentation(Instrumentation); for (const std::unique_ptr<CompilationUnitPass> &Pass : Passes) { @@ -1421,7 +1023,7 @@ Expected<void> CompilationUnitPassManager::run(CompilationUnit &Unit, } for (const AnalysisID Required : Contract.RequiredAnalyses) { - auto Result = UnitAnalyses.getResultImpl(Required, Unit, Target); + auto Result = UnitAnalyses.getResultByID(Required, Unit, Target); if (!Result) { Error Failure = prefixedError(Result.error(), "compilation-unit pass '" + std::string(Name) + diff --git a/backend/lib/CodeGen/MachinePseudoExpansion.cpp b/backend/lib/CodeGen/MachinePseudoExpansion.cpp index b5afe8e..663b148 100644 --- a/backend/lib/CodeGen/MachinePseudoExpansion.cpp +++ b/backend/lib/CodeGen/MachinePseudoExpansion.cpp @@ -355,7 +355,8 @@ expandImplementation(MachineFunction &Function, const TargetDescription &Target, [[nodiscard]] Expected<MachinePassResult> runPreparationTransaction(MachineFunction &Function, const TargetDescription &Target, - const TargetPseudoExpansionInfo &Info, MachineAnalysisManager &Analyses) { + const TargetPseudoExpansionInfo &Info, + MachineFunctionAnalysisManager &Analyses) { auto Trial = cloneMachineFunction( Function, Target, MachineFunctionCloneOptions{.NewStableID = Function.stableID(), .NewName = std::nullopt}); @@ -380,7 +381,8 @@ runPreparationTransaction(MachineFunction &Function, const TargetDescription &Ta [[nodiscard]] Expected<MachinePassResult> runExpansionTransaction(MachineFunction &Function, const TargetDescription &Target, const TargetPseudoExpansionInfo &Info, MachinePseudoExpansionPhase Phase, - const TargetInstrInfo *BranchInfo, MachineAnalysisManager &Analyses) { + const TargetInstrInfo *BranchInfo, + MachineFunctionAnalysisManager &Analyses) { auto Trial = cloneMachineFunction( Function, Target, MachineFunctionCloneOptions{.NewStableID = Function.stableID(), .NewName = std::nullopt}); @@ -409,9 +411,9 @@ const MachinePassContract &PreparePostRAPseudosPass::contract() const noexcept { return preparationContract(); } -Expected<MachinePassResult> PreparePostRAPseudosPass::run(MachineFunction &Function, - const TargetDescription &Target, - MachineAnalysisManager &Analyses) { +Expected<MachinePassResult> +PreparePostRAPseudosPass::run(MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) return makeUnexpected(ErrorCode::VerificationError, "post-RA pseudo preparation requires selected MachineIR"); @@ -422,9 +424,9 @@ const MachinePassContract &PrePEITargetPseudoExpansionPass::contract() const noe return phaseContract(MachinePseudoExpansionPhase::PrePEI); } -Expected<MachinePassResult> PrePEITargetPseudoExpansionPass::run(MachineFunction &Function, - const TargetDescription &Target, - MachineAnalysisManager &Analyses) { +Expected<MachinePassResult> +PrePEITargetPseudoExpansionPass::run(MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) return makeUnexpected(ErrorCode::VerificationError, "pre-PEI pseudo expansion requires allocated tracked-liveness MIR"); @@ -438,7 +440,7 @@ const MachinePassContract &ExpandPostRAPseudosPass::contract() const noexcept { Expected<MachinePassResult> ExpandPostRAPseudosPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) return makeUnexpected(ErrorCode::VerificationError, "post-RA pseudo expansion requires finalized frame and liveness"); @@ -450,9 +452,9 @@ const MachinePassContract &TargetLatePseudoExpansionPass::contract() const noexc return phaseContract(MachinePseudoExpansionPhase::TargetLate); } -Expected<MachinePassResult> TargetLatePseudoExpansionPass::run(MachineFunction &Function, - const TargetDescription &Target, - MachineAnalysisManager &Analyses) { +Expected<MachinePassResult> +TargetLatePseudoExpansionPass::run(MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) return makeUnexpected(ErrorCode::VerificationError, "target-late pseudo expansion requires finalized allocated MIR"); diff --git a/backend/lib/CodeGen/MachineScheduler.cpp b/backend/lib/CodeGen/MachineScheduler.cpp index e589675..82f0c91 100644 --- a/backend/lib/CodeGen/MachineScheduler.cpp +++ b/backend/lib/CodeGen/MachineScheduler.cpp @@ -37,10 +37,11 @@ namespace { MachineFunctionProperty::TiedOpsRewritten}, .Sets = {}, .Clears = {}, - .RequiredAnalyses = {MachineAnalysisManager::id<LiveVariablesAnalysis>()}, + .RequiredAnalyses = {MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>()}, .VerificationStage = PipelineStage::TiedOpsRewritten, }; - Value.RequiredAnalyses.push_back(MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>()); + Value.RequiredAnalyses.push_back( + MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>()); Value.ThreadSafety = PassThreadSafety::ThreadSafe; Value.DeclaredChanges = {MachinePassChange::Instructions, MachinePassChange::Operands}; return Value; @@ -395,7 +396,7 @@ const MachinePassContract &MachineSchedulerPass::contract() const noexcept { Expected<MachinePassResult> MachineSchedulerPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "pre-RA machine scheduler requires selected, SSA-exited MachineIR"); @@ -407,7 +408,7 @@ Expected<MachinePassResult> MachineSchedulerPass::run(MachineFunction &Function, return std::unexpected( prefixedError(Trial.error(), "machine scheduler transaction setup failed: ")); } - MachineAnalysisManager TrialAnalyses; + MachineFunctionAnalysisManager TrialAnalyses; auto TrialLiveness = TrialAnalyses.getResult<LiveVariablesAnalysis>(*Trial->ClonedFunction, Target); if (!TrialLiveness) diff --git a/backend/lib/CodeGen/MachineShrinkWrapping.cpp b/backend/lib/CodeGen/MachineShrinkWrapping.cpp index aee3323..7c7bc3a 100644 --- a/backend/lib/CodeGen/MachineShrinkWrapping.cpp +++ b/backend/lib/CodeGen/MachineShrinkWrapping.cpp @@ -32,8 +32,8 @@ namespace { MachineFunctionProperty::TracksLiveness}, .Sets = {}, .Clears = {}, - .RequiredAnalyses = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(), - MachineAnalysisManager::id<MachineLoopAnalysis>()}, + .RequiredAnalyses = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(), + MachineFunctionAnalysisManager::id<MachineLoopAnalysis>()}, .VerificationStage = PipelineStage::RegisterAllocated, }; Value.ThreadSafety = PassThreadSafety::ThreadSafe; @@ -66,9 +66,9 @@ const MachinePassContract &MachineShrinkWrappingPass::contract() const noexcept return shrinkWrappingContract(); } -Expected<MachinePassResult> MachineShrinkWrappingPass::run(MachineFunction &Function, - const TargetDescription &Target, - MachineAnalysisManager &Analyses) { +Expected<MachinePassResult> +MachineShrinkWrappingPass::run(MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "shrink wrapping requires allocated tracked-liveness MachineIR"); diff --git a/backend/lib/CodeGen/MachineSink.cpp b/backend/lib/CodeGen/MachineSink.cpp index 21b17f8..176b75a 100644 --- a/backend/lib/CodeGen/MachineSink.cpp +++ b/backend/lib/CodeGen/MachineSink.cpp @@ -34,8 +34,8 @@ namespace { .Requires = {MachineFunctionProperty::IsSSA, MachineFunctionProperty::Selected}, .Sets = {}, .Clears = {}, - .RequiredAnalyses = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(), - MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>()}, + .RequiredAnalyses = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(), + MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>()}, .VerificationStage = PipelineStage::Selected, }; Value.ThreadSafety = PassThreadSafety::ThreadSafe; @@ -50,8 +50,8 @@ namespace { MachineFunctionProperty::TracksLiveness}, .Sets = {}, .Clears = {}, - .RequiredAnalyses = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(), - MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>()}, + .RequiredAnalyses = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(), + MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>()}, .VerificationStage = PipelineStage::RegisterAllocated, }; Value.ThreadSafety = PassThreadSafety::ThreadSafe; @@ -354,7 +354,7 @@ const MachinePassContract &MachineSinkPass::contract() const noexcept { Expected<MachinePassResult> MachineSinkPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected( ErrorCode::VerificationError, @@ -368,7 +368,7 @@ Expected<MachinePassResult> MachineSinkPass::run(MachineFunction &Function, if (!Trial) { return std::unexpected(prefixedError(Trial.error(), "machine sink transaction setup failed: ")); } - MachineAnalysisManager TrialAnalyses; + MachineFunctionAnalysisManager TrialAnalyses; auto TrialResult = runImplementation(*Trial->ClonedFunction, Target, TrialAnalyses); if (!TrialResult) return std::unexpected(TrialResult.error()); @@ -381,9 +381,9 @@ Expected<MachinePassResult> MachineSinkPass::run(MachineFunction &Function, return Result; } -Expected<MachinePassResult> MachineSinkPass::runImplementation(MachineFunction &Function, - const TargetDescription &Target, - MachineAnalysisManager &Analyses) { +Expected<MachinePassResult> +MachineSinkPass::runImplementation(MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &Analyses) { auto Dominators = Analyses.getResult<MachineDominatorTreeAnalysis>(Function, Target); if (!Dominators) return std::unexpected(Dominators.error()); diff --git a/backend/lib/CodeGen/MachineStackSlotColoring.cpp b/backend/lib/CodeGen/MachineStackSlotColoring.cpp index e60a7a2..005872b 100644 --- a/backend/lib/CodeGen/MachineStackSlotColoring.cpp +++ b/backend/lib/CodeGen/MachineStackSlotColoring.cpp @@ -228,7 +228,7 @@ const MachinePassContract &MachineStackSlotColoringPass::contract() const noexce Expected<MachinePassResult> MachineStackSlotColoringPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "stack-slot coloring requires allocated PHI-free MachineIR"); diff --git a/backend/lib/CodeGen/MachineTailDuplication.cpp b/backend/lib/CodeGen/MachineTailDuplication.cpp index 5abd473..8be1eb5 100644 --- a/backend/lib/CodeGen/MachineTailDuplication.cpp +++ b/backend/lib/CodeGen/MachineTailDuplication.cpp @@ -248,7 +248,7 @@ const MachinePassContract &MachineTailDuplicationPass::contract() const noexcept Expected<MachinePassResult> MachineTailDuplicationPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "tail duplication requires finalized allocated tracked-liveness MIR"); diff --git a/backend/lib/CodeGen/MachineTailMerge.cpp b/backend/lib/CodeGen/MachineTailMerge.cpp index c4d6de9..dc07950 100644 --- a/backend/lib/CodeGen/MachineTailMerge.cpp +++ b/backend/lib/CodeGen/MachineTailMerge.cpp @@ -298,7 +298,7 @@ const MachinePassContract &MachineTailMergePass::contract() const noexcept { Expected<MachinePassResult> MachineTailMergePass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "tail merge requires finalized allocated tracked-liveness MIR"); diff --git a/backend/lib/CodeGen/PHIElimination.cpp b/backend/lib/CodeGen/PHIElimination.cpp index 75472f2..6de449f 100644 --- a/backend/lib/CodeGen/PHIElimination.cpp +++ b/backend/lib/CodeGen/PHIElimination.cpp @@ -490,7 +490,7 @@ const MachinePassContract &PHIEliminationPass::contract() const noexcept { Expected<MachinePassResult> PHIEliminationPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { auto Required = requireProperties(Function, contract()); if (!Required) return std::unexpected(Required.error()); diff --git a/backend/lib/CodeGen/PostRAScheduler.cpp b/backend/lib/CodeGen/PostRAScheduler.cpp index f7d6181..b5f7ae9 100644 --- a/backend/lib/CodeGen/PostRAScheduler.cpp +++ b/backend/lib/CodeGen/PostRAScheduler.cpp @@ -37,10 +37,11 @@ namespace { MachineFunctionProperty::TracksLiveness}, .Sets = {}, .Clears = {}, - .RequiredAnalyses = {MachineAnalysisManager::id<LiveVariablesAnalysis>()}, + .RequiredAnalyses = {MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>()}, .VerificationStage = PipelineStage::RegisterAllocated, }; - Value.RequiredAnalyses.push_back(MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>()); + Value.RequiredAnalyses.push_back( + MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>()); Value.ThreadSafety = PassThreadSafety::ThreadSafe; Value.DeclaredChanges = {MachinePassChange::Instructions, MachinePassChange::Operands}; return Value; @@ -61,7 +62,7 @@ const MachinePassContract &PostRASchedulerPass::contract() const noexcept { Expected<MachinePassResult> PostRASchedulerPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { if (!Function.properties().containsAll(contract().Requires)) { return makeUnexpected(ErrorCode::VerificationError, "post-RA scheduler requires allocated tracked-liveness MachineIR"); @@ -73,7 +74,7 @@ Expected<MachinePassResult> PostRASchedulerPass::run(MachineFunction &Function, return std::unexpected( prefixedError(Trial.error(), "post-RA scheduler transaction setup failed: ")); } - MachineAnalysisManager TrialAnalyses; + MachineFunctionAnalysisManager TrialAnalyses; auto TrialLiveness = TrialAnalyses.getResult<LiveVariablesAnalysis>(*Trial->ClonedFunction, Target); if (!TrialLiveness) diff --git a/backend/lib/CodeGen/PrologueEpilogueInsertion.cpp b/backend/lib/CodeGen/PrologueEpilogueInsertion.cpp index 47b74f6..c935d6a 100644 --- a/backend/lib/CodeGen/PrologueEpilogueInsertion.cpp +++ b/backend/lib/CodeGen/PrologueEpilogueInsertion.cpp @@ -49,7 +49,7 @@ const MachinePassContract &PrologueEpilogueInsertionPass::contract() const noexc Expected<MachinePassResult> PrologueEpilogueInsertionPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { if (Info == nullptr) return makeUnexpected(ErrorCode::InvalidArgument, "PrologueEpilogueInsertion requires target frame lowering"); diff --git a/backend/lib/CodeGen/RegAllocBase.h b/backend/lib/CodeGen/RegAllocBase.h index 318a82d..4ef0bb7 100644 --- a/backend/lib/CodeGen/RegAllocBase.h +++ b/backend/lib/CodeGen/RegAllocBase.h @@ -27,8 +27,9 @@ public: protected: RegAllocBase(MachineFunction &Function, const TargetDescription &Target, - const TargetRegisterAllocationInfo &TargetInfo, MachineAnalysisManager &Analyses, - RegisterAllocationOptions Options, MachineActionReplay *Actions = nullptr) noexcept + const TargetRegisterAllocationInfo &TargetInfo, + MachineFunctionAnalysisManager &Analyses, RegisterAllocationOptions Options, + MachineActionReplay *Actions = nullptr) noexcept : Function(Function), Target(Target), TargetInfo(TargetInfo), Analyses(Analyses), Options(Options), Actions(Actions) {} @@ -38,7 +39,7 @@ protected: MachineFunction &Function; const TargetDescription &Target; const TargetRegisterAllocationInfo &TargetInfo; - MachineAnalysisManager &Analyses; + MachineFunctionAnalysisManager &Analyses; RegisterAllocationOptions Options; MachineActionReplay *Actions = nullptr; }; diff --git a/backend/lib/CodeGen/RegAllocBasic.cpp b/backend/lib/CodeGen/RegAllocBasic.cpp index 9d14d15..7f730ca 100644 --- a/backend/lib/CodeGen/RegAllocBasic.cpp +++ b/backend/lib/CodeGen/RegAllocBasic.cpp @@ -18,7 +18,7 @@ class BasicAllocatorEngine final : public RegAllocBase { public: BasicAllocatorEngine(MachineFunction &Function, const TargetDescription &Target, const TargetRegisterAllocationInfo &TargetInfo, - MachineAnalysisManager &Analyses, RegisterAllocationOptions Options) + MachineFunctionAnalysisManager &Analyses, RegisterAllocationOptions Options) : RegAllocBase(Function, Target, TargetInfo, Analyses, Options) {} private: @@ -80,7 +80,7 @@ private: MachineFunctionProperty::TracksLiveness}, .Sets = {MachineFunctionProperty::NoVRegs}, .Clears = {}, - .RequiredAnalyses = {MachineAnalysisManager::id<LiveIntervalsAnalysis>()}, + .RequiredAnalyses = {MachineFunctionAnalysisManager::id<LiveIntervalsAnalysis>()}, .VerificationStage = PipelineStage::RegisterAllocated, }; Value.ThreadSafety = PassThreadSafety::ThreadSafe; @@ -97,7 +97,7 @@ const MachinePassContract &BasicAllocatorPass::contract() const noexcept { Expected<MachinePassResult> BasicAllocatorPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { if (Info == nullptr) return makeUnexpected(ErrorCode::InvalidArgument, "BasicAllocator requires target behavior"); auto Required = regalloc_detail::requireAllocationProperties(Function, contract()); @@ -112,7 +112,7 @@ Expected<MachinePassResult> BasicAllocatorPass::run(MachineFunction &Function, regalloc_detail::reserveFunctionRegisters(*Trial->ClonedFunction, FunctionReserved); if (!TrialReserved) return std::unexpected(TrialReserved.error()); - MachineAnalysisManager TrialAnalyses; + MachineFunctionAnalysisManager TrialAnalyses; auto Registered = registerStage11MachineAnalyses(TrialAnalyses); if (!Registered) return std::unexpected(Registered.error()); diff --git a/backend/lib/CodeGen/RegAllocBasic.h b/backend/lib/CodeGen/RegAllocBasic.h index 8a68f5f..f88c977 100644 --- a/backend/lib/CodeGen/RegAllocBasic.h +++ b/backend/lib/CodeGen/RegAllocBasic.h @@ -19,7 +19,7 @@ public: [[nodiscard]] const MachinePassContract &contract() const noexcept override; [[nodiscard]] Expected<MachinePassResult> run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) override; + MachineFunctionAnalysisManager &Analyses) override; private: const TargetRegisterAllocationInfo *Info; diff --git a/backend/lib/CodeGen/RegAllocFast.cpp b/backend/lib/CodeGen/RegAllocFast.cpp index 1399f10..73c3e1a 100644 --- a/backend/lib/CodeGen/RegAllocFast.cpp +++ b/backend/lib/CodeGen/RegAllocFast.cpp @@ -557,7 +557,7 @@ const MachinePassContract &FastAllocatorPass::contract() const noexcept { MachineFunctionProperty::TracksLiveness}, .Sets = {MachineFunctionProperty::NoVRegs}, .Clears = {}, - .RequiredAnalyses = {MachineAnalysisManager::id<LiveVariablesAnalysis>()}, + .RequiredAnalyses = {MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>()}, .VerificationStage = PipelineStage::RegisterAllocated, }; Value.ThreadSafety = PassThreadSafety::ThreadSafe; @@ -568,7 +568,7 @@ const MachinePassContract &FastAllocatorPass::contract() const noexcept { Expected<MachinePassResult> FastAllocatorPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { if (Info == nullptr) return makeUnexpected(ErrorCode::InvalidArgument, "FastAllocator requires target behavior"); auto Required = regalloc_detail::requireAllocationProperties(Function, contract()); @@ -583,7 +583,7 @@ Expected<MachinePassResult> FastAllocatorPass::run(MachineFunction &Function, regalloc_detail::reserveFunctionRegisters(*Trial->ClonedFunction, FunctionReserved); if (!TrialReserved) return std::unexpected(TrialReserved.error()); - MachineAnalysisManager TrialAnalyses; + MachineFunctionAnalysisManager TrialAnalyses; auto Registered = registerStage11MachineAnalyses(TrialAnalyses); if (!Registered) return std::unexpected(Registered.error()); diff --git a/backend/lib/CodeGen/RegAllocPBQP.cpp b/backend/lib/CodeGen/RegAllocPBQP.cpp index 3b0e684..6706cd5 100644 --- a/backend/lib/CodeGen/RegAllocPBQP.cpp +++ b/backend/lib/CodeGen/RegAllocPBQP.cpp @@ -86,7 +86,7 @@ class PBQPAllocatorEngine final : public RegAllocBase { public: PBQPAllocatorEngine(MachineFunction &Function, const TargetDescription &Target, const TargetRegisterAllocationInfo &TargetInfo, - MachineAnalysisManager &Analyses, RegisterAllocationOptions Options, + MachineFunctionAnalysisManager &Analyses, RegisterAllocationOptions Options, MachineActionReplay *Actions) : RegAllocBase(Function, Target, TargetInfo, Analyses, Options, Actions) {} @@ -277,7 +277,7 @@ private: MachineFunctionProperty::TracksLiveness}, .Sets = {MachineFunctionProperty::NoVRegs}, .Clears = {}, - .RequiredAnalyses = {MachineAnalysisManager::id<LiveIntervalsAnalysis>()}, + .RequiredAnalyses = {MachineFunctionAnalysisManager::id<LiveIntervalsAnalysis>()}, .VerificationStage = PipelineStage::RegisterAllocated, }; Value.ThreadSafety = PassThreadSafety::ThreadSafe; @@ -294,7 +294,7 @@ const MachinePassContract &PBQPAllocatorPass::contract() const noexcept { Expected<MachinePassResult> PBQPAllocatorPass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &Analyses) { + MachineFunctionAnalysisManager &Analyses) { if (Info == nullptr) return makeUnexpected(ErrorCode::InvalidArgument, "PBQPAllocator requires target behavior"); auto Required = regalloc_detail::requireAllocationProperties(Function, contract()); @@ -309,7 +309,7 @@ Expected<MachinePassResult> PBQPAllocatorPass::run(MachineFunction &Function, regalloc_detail::reserveFunctionRegisters(*Trial->ClonedFunction, FunctionReserved); if (!TrialReserved) return std::unexpected(TrialReserved.error()); - MachineAnalysisManager TrialAnalyses; + MachineFunctionAnalysisManager TrialAnalyses; auto Registered = registerStage11MachineAnalyses(TrialAnalyses); if (!Registered) return std::unexpected(Registered.error()); diff --git a/backend/lib/CodeGen/SlotIndexes.cpp b/backend/lib/CodeGen/SlotIndexes.cpp index 57e35b5..4fe753a 100644 --- a/backend/lib/CodeGen/SlotIndexes.cpp +++ b/backend/lib/CodeGen/SlotIndexes.cpp @@ -143,12 +143,12 @@ Expected<void> SlotIndexesAnalysis::Result::renumber(MachineFunction &Function) bool SlotIndexesAnalysis::Result::invalidate(const MachineFunction &, const PreservedAnalyses &Preserved) const noexcept { - return !Preserved.preserves(MachineAnalysisManager::id<SlotIndexesAnalysis>()); + return !Preserved.preserves(MachineFunctionAnalysisManager::id<SlotIndexesAnalysis>()); } Expected<SlotIndexesAnalysis::Result> SlotIndexesAnalysis::run(MachineFunction &Function, const TargetDescription &, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { Result ResultValue; auto Numbered = ResultValue.renumber(Function); if (!Numbered) diff --git a/backend/lib/CodeGen/TwoAddressInstructionPass.cpp b/backend/lib/CodeGen/TwoAddressInstructionPass.cpp index be4db82..b6f2a25 100644 --- a/backend/lib/CodeGen/TwoAddressInstructionPass.cpp +++ b/backend/lib/CodeGen/TwoAddressInstructionPass.cpp @@ -459,9 +459,9 @@ const MachinePassContract &TwoAddressInstructionPass::contract() const noexcept return Contract; } -Expected<MachinePassResult> TwoAddressInstructionPass::run(MachineFunction &Function, - const TargetDescription &Target, - MachineAnalysisManager &Analyses) { +Expected<MachinePassResult> +TwoAddressInstructionPass::run(MachineFunction &Function, const TargetDescription &Target, + MachineFunctionAnalysisManager &Analyses) { auto Required = requireProperties(Function, contract()); if (!Required) return std::unexpected(Required.error()); diff --git a/backend/lib/CodeGen/VirtRegMap.cpp b/backend/lib/CodeGen/VirtRegMap.cpp index a55a486..4f3ae45 100644 --- a/backend/lib/CodeGen/VirtRegMap.cpp +++ b/backend/lib/CodeGen/VirtRegMap.cpp @@ -169,7 +169,7 @@ Expected<bool> rewriteVirtualRegisters(MachineFunction &Function, const TargetDe if (!MappingVerification) return std::unexpected(MappingVerification.error()); - MachineAnalysisManager ValidationAnalyses; + MachineFunctionAnalysisManager ValidationAnalyses; auto Registered = registerStage11MachineAnalyses(ValidationAnalyses); if (!Registered) return std::unexpected(Registered.error()); @@ -282,7 +282,7 @@ const MachinePassContract &VirtualRegisterRewritePass::contract() const noexcept Expected<MachinePassResult> VirtualRegisterRewritePass::run(MachineFunction &Function, const TargetDescription &Target, - MachineAnalysisManager &) { + MachineFunctionAnalysisManager &) { if (Mapping == nullptr) return makeUnexpected(ErrorCode::InvalidArgument, "VirtualRegisterRewrite requires a VirtRegMap"); |