LLVM 20.0.0git
MachineDominators.cpp
Go to the documentation of this file.
1//===- MachineDominators.cpp - Machine Dominator Calculation --------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements simple dominator construction algorithms for finding
10// forward dominators on machine functions.
11//
12//===----------------------------------------------------------------------===//
13
16#include "llvm/CodeGen/Passes.h"
18#include "llvm/Pass.h"
19#include "llvm/PassRegistry.h"
22
23using namespace llvm;
24
25namespace llvm {
26// Always verify dominfo if expensive checking is enabled.
27#ifdef EXPENSIVE_CHECKS
28bool VerifyMachineDomInfo = true;
29#else
31#endif
32} // namespace llvm
33
35 "verify-machine-dom-info", cl::location(VerifyMachineDomInfo), cl::Hidden,
36 cl::desc("Verify machine dominator info (time consuming)"));
37
38namespace llvm {
40template class DominatorTreeBase<MachineBasicBlock, false>; // DomTreeBase
41
42namespace DomTreeBuilder {
43template void Calculate<MBBDomTree>(MBBDomTree &DT);
44template void CalculateWithUpdates<MBBDomTree>(MBBDomTree &DT, MBBUpdates U);
45
46template void InsertEdge<MBBDomTree>(MBBDomTree &DT, MachineBasicBlock *From,
48
49template void DeleteEdge<MBBDomTree>(MBBDomTree &DT, MachineBasicBlock *From,
51
52template void ApplyUpdates<MBBDomTree>(MBBDomTree &DT, MBBDomTreeGraphDiff &,
53 MBBDomTreeGraphDiff *);
54
55template bool Verify<MBBDomTree>(const MBBDomTree &DT,
56 MBBDomTree::VerificationLevel VL);
57} // namespace DomTreeBuilder
58}
59
63 // Check whether the analysis, all analyses on machine functions, or the
64 // machine function's CFG have been preserved.
66 return !PAC.preserved() &&
67 !PAC.preservedSet<AllAnalysesOn<MachineFunction>>() &&
68 !PAC.preservedSet<CFGAnalyses>();
69}
70
71AnalysisKey MachineDominatorTreeAnalysis::Key;
72
76 return MachineDominatorTree(MF);
77}
78
82 OS << "MachineDominatorTree for machine function: " << MF.getName() << '\n';
85}
86
88
90 "MachineDominator Tree Construction", true, true)
91
96}
97
99
102 return false;
103}
104
106
108 if (VerifyMachineDomInfo && DT)
110 report_fatal_error("MachineDominatorTree verification failed!");
111}
112
114 const Module *) const {
115 if (DT)
116 DT->print(OS);
117}
BlockVerifier::State From
Generic dominator tree construction - this file provides routines to construct immediate dominator in...
#define F(x, y, z)
Definition: MD5.cpp:55
static cl::opt< bool, true > VerifyMachineDomInfoX("verify-machine-dom-info", cl::location(VerifyMachineDomInfo), cl::Hidden, cl::desc("Verify machine dominator info (time consuming)"))
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:38
raw_pwrite_stream & OS
This file implements the SmallBitVector class.
This templated class represents "all analyses that operate over <a particular IR unit>" (e....
Definition: Analysis.h:49
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:292
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:253
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:410
Represents analyses that only rely on functions' control flow.
Definition: Analysis.h:72
Base class for the actual dominator tree node.
Core dominator tree base class.
Analysis pass which computes a MachineDominatorTree.
Result run(MachineFunction &MF, MachineFunctionAnalysisManager &)
PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &MFAM)
Analysis pass which computes a MachineDominatorTree.
void verifyAnalysis() const override
verifyAnalysis() - This member can be implemented by a analysis pass to check state of analysis infor...
void print(raw_ostream &OS, const Module *M=nullptr) const override
print - Print out the internal state of the pass.
bool runOnMachineFunction(MachineFunction &MF) override
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
bool invalidate(MachineFunction &, const PreservedAnalyses &PA, MachineFunctionAnalysisManager::Invalidator &)
Handle invalidation explicitly.
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:111
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: Analysis.h:117
PreservedAnalysisChecker getChecker() const
Build a checker for this PreservedAnalyses and the specified analysis type.
Definition: Analysis.h:264
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
LocationClass< Ty > location(Ty &L)
Definition: CommandLine.h:463
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
char & MachineDominatorsID
MachineDominators - This pass is a machine dominators analysis pass.
Printable print(const GCNRegPressure &RP, const GCNSubtarget *ST=nullptr)
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:167
bool VerifyMachineDomInfo
void initializeMachineDominatorTreeWrapperPassPass(PassRegistry &)
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: Analysis.h:28