MachineLoopInfo.cpp Source File (original) (raw)

21#include "llvm/Config/llvm-config.h"

27using namespace llvm;

39}

44 OS << "Machine loop info for machine function '" << MF.getName() << "':\n";

47}

53}

55 "Machine Natural Loop Construction", true, true)

63 LI.calculate(getAnalysis().getDomTree());

64 return false;

65}

73 return !PAC.preserved() &&

76}

81}

87}

95 TopMBB = PriorMBB;

97 break;

98 PriorMBB = &*std::prev(TopMBB->getIterator());

99 }

100 }

101 return TopMBB;

102}

103

110 BotMBB = NextMBB;

111 if (BotMBB == &*std::next(BotMBB->getIterator()))

112 break;

113 NextMBB = &*std::next(BotMBB->getIterator());

114 }

115 }

116 return BotMBB;

117}

118

122 return Latch;

123 else

125 }

126 return nullptr;

127}

128

130

132 if (const BasicBlock *PHeadBB = PHeadMBB->getBasicBlock())

133 if (DebugLoc DL = PHeadBB->getTerminator()->getDebugLoc())

134 return DL;

135

136

137

139 if (const BasicBlock *HeadBB = HeadMBB->getBasicBlock())

140 return HeadBB->getTerminator()->getDebugLoc();

141

143}

144

147 bool FindMultiLoopPreheader) const {

149 return PB;

150

151 if (!SpeculativePreheader)

152 return nullptr;

153

156 return nullptr;

157

160 if (P == LB)

161 continue;

162

163 if (Preheader)

164 return nullptr;

165 Preheader = P;

166 }

167

168

169

170 if (!FindMultiLoopPreheader) {

172 if (S == HB)

173 continue;

175 if (T && T->getHeader() == S)

176 return nullptr;

177 }

178 }

179 return Preheader;

180}

181

183 MDNode *LoopID = nullptr;

185

186

188 if (!BB)

189 return nullptr;

190 if (const auto *TI = BB->getTerminator())

191 LoopID = TI->getMetadata(LLVMContext::MD_loop);

193

194

195

197

198 for (const auto *MBB : this->blocks()) {

200 if (!BB)

201 return nullptr;

203 if (!TI)

204 return nullptr;

205 MDNode *MD = nullptr;

206

207 for (const auto *Succ : successors(TI)) {

208 if (Succ == Header) {

209

210 MD = TI->getMetadata(LLVMContext::MD_loop);

211 break;

212 }

213 }

214 if (!MD)

215 continue;

216 if (!LoopID)

217 LoopID = MD;

218 else if (MD != LoopID)

219 return nullptr;

220 }

221 }

222 }

223 if (LoopID &&

225 LoopID = nullptr;

226 return LoopID;

227}

228

229bool MachineLoop::isLoopInvariantImplicitPhysReg(Register Reg) const {

232

233 if (MRI->isConstantPhysReg(Reg))

234 return true;

235

239 return false;

240

242 MRI->def_instructions(Reg),

243 [this](const MachineInstr &MI) { return this->contains(&MI); });

244}

245

247 const Register ExcludeReg) const {

253

254

256 if (!MO.isReg())

257 continue;

258

260 if (Reg == 0) continue;

261

262 if (ExcludeReg == Reg)

263 continue;

264

265

266

267 if (Reg.isPhysical()) {

268 if (MO.isUse()) {

269

270

271

272

273

274 if (!isLoopInvariantImplicitPhysReg(Reg) &&

275 !(TRI->isCallerPreservedPhysReg(Reg.asMCReg(), *I.getMF())) &&

276 TII ->isIgnorableUse(MO))

277 return false;

278

279 continue;

280 } else if (!MO.isDead()) {

281

282 return false;

283 } else if (getHeader()->isLiveIn(Reg)) {

284

285

286 return false;

287 }

288 }

289

290 if (!MO.readsReg())

291 continue;

292

294 "Machine instr not mapped for this vreg?!");

295

296

297

299 return false;

300 }

301

302

303 return true;

304}

305

306#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

309}

310#endif

unsigned const MachineRegisterInfo * MRI

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

COFF::MachineTypes Machine

#define LLVM_DUMP_METHOD

Mark debug helper function definitions like dump() that should not be stripped from debug builds.

Dominance Frontier Construction

const HexagonInstrInfo * TII

unsigned const TargetRegisterInfo * TRI

PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)

#define INITIALIZE_PASS_DEPENDENCY(depName)

#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)

#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

This templated class represents "all analyses that operate over " (e....

API to communicate dependencies between analyses during invalidation.

A container for analyses that lazily runs them and caches their results.

PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)

Get the result of an analysis pass for a given IR unit.

Represent the analysis usage information of a pass.

AnalysisUsage & addRequired()

void setPreservesAll()

Set by analyses that do not transform their input at all.

LLVM Basic Block Representation.

const Instruction * getTerminator() const LLVM_READONLY

Returns the terminator instruction if the block is well formed or null if the block is not well forme...

Represents analyses that only rely on functions' control flow.

Instances of this class are used to represent loops that are detected in the flow graph.

bool contains(const MachineLoop *L) const

Return true if the specified loop is contained within in this loop.

MachineBasicBlock * getLoopLatch() const

If there is a single latch block for this loop, return it.

MachineBasicBlock * getHeader() const

void print(raw_ostream &OS, bool Verbose=false, bool PrintNested=true, unsigned Depth=0) const

Print loop with all the BBs inside it.

iterator_range< block_iterator > blocks() const

MachineBasicBlock * getLoopPreheader() const

If there is a preheader for this loop, return it.

MachineBasicBlock * getExitingBlock() const

If getExitingBlocks would return exactly one block, return that block.

bool isLoopExiting(const MachineBasicBlock *BB) const

True if terminator in the block can branch to another block that is outside of the current loop.

This class builds and contains all of the top-level loop structures in the specified function.

void analyze(const DominatorTreeBase< MachineBasicBlock, false > &DomTree)

Create the loop forest using a stable algorithm.

MachineLoop * getLoopFor(const MachineBasicBlock *BB) const

Return the inner most loop that BB lives in.

Represents a single loop in the control flow graph.

const MDOperand & getOperand(unsigned I) const

unsigned getNumOperands() const

Return number of MDNode operands.

unsigned pred_size() const

const BasicBlock * getBasicBlock() const

Return the LLVM basic block that this instance corresponded to originally.

bool hasAddressTaken() const

Test whether this block is used as something other than the target of a terminator,...

const MachineFunction * getParent() const

Return the MachineFunction containing this basic block.

iterator_range< succ_iterator > successors()

iterator_range< pred_iterator > predecessors()

Analysis pass which computes a MachineDominatorTree.

DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...

MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...

void getAnalysisUsage(AnalysisUsage &AU) const override

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.

const TargetSubtargetInfo & getSubtarget() const

getSubtarget - Return the subtarget for which this machine code is being compiled.

StringRef getName() const

getName - Return the name of the corresponding LLVM function.

MachineRegisterInfo & getRegInfo()

getRegInfo - Return information about the registers currently in use.

Representation of each machine instruction.

Analysis pass that exposes the MachineLoopInfo for a machine function.

Result run(MachineFunction &MF, MachineFunctionAnalysisManager &MFAM)

MachineLoopInfoWrapperPass()

void getAnalysisUsage(AnalysisUsage &AU) const override

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.

void calculate(MachineDominatorTree &MDT)

Calculate the natural loop information.

bool invalidate(MachineFunction &, const PreservedAnalyses &PA, MachineFunctionAnalysisManager::Invalidator &)

Handle invalidation explicitly.

MachineBasicBlock * findLoopPreheader(MachineLoop *L, bool SpeculativePreheader=false, bool FindMultiLoopPreheader=false) const

Find the block that either is the loop preheader, or could speculatively be used as the preheader.

PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &MFAM)

MachineBasicBlock * findLoopControlBlock() const

Find the block that contains the loop control variable and the loop test.

MDNode * getLoopID() const

Find the llvm.loop metadata for this loop.

DebugLoc getStartLoc() const

Return the debug location of the start of this loop.

MachineBasicBlock * getBottomBlock()

Return the "bottom" block in the loop, which is the last block in the linear layout,...

bool isLoopInvariant(MachineInstr &I, const Register ExcludeReg=0) const

Returns true if the instruction is loop invariant.

MachineBasicBlock * getTopBlock()

Return the "top" block in the loop, which is the first block in the linear layout,...

MachineOperand class - Representation of each machine instruction operand.

MachineRegisterInfo - Keep track of information for virtual and physical registers,...

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.

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

PreservedAnalysisChecker getChecker() const

Build a checker for this PreservedAnalyses and the specified analysis type.

Wrapper class representing virtual and physical registers.

TargetInstrInfo - Interface to description of machine instruction set.

TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...

virtual bool shouldAnalyzePhysregInMachineLoopInfo(MCRegister R) const

Returns true if MachineLoopInfo should analyze the given physreg for loop invariance.

TargetSubtargetInfo - Generic base class for all target subtargets.

virtual const TargetRegisterInfo * getRegisterInfo() const

getRegisterInfo - If register information is available, return it.

self_iterator getIterator()

This is an optimization pass for GlobalISel generic memory operations.

auto successors(const MachineBasicBlock *BB)

void initializeMachineLoopInfoWrapperPassPass(PassRegistry &)

Printable print(const GCNRegPressure &RP, const GCNSubtarget *ST=nullptr)

char & MachineLoopInfoID

MachineLoopInfo - This pass is a loop analysis pass.

bool any_of(R &&range, UnaryPredicate P)

Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.

raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

A special type used by analysis passes to provide an address that identifies that particular analysis...