LLVM  3.7.0
PPCCTRLoops.cpp
Go to the documentation of this file.
1 //===-- PPCCTRLoops.cpp - Identify and generate CTR loops -----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This pass identifies loops where we can generate the PPC branch instructions
11 // that decrement and test the count register (CTR) (bdnz and friends).
12 //
13 // The pattern that defines the induction variable can changed depending on
14 // prior optimizations. For example, the IndVarSimplify phase run by 'opt'
15 // normalizes induction variables, and the Loop Strength Reduction pass
16 // run by 'llc' may also make changes to the induction variable.
17 //
18 // Criteria for CTR loops:
19 // - Countable loops (w/ ind. var for a trip count)
20 // - Try inner-most loops first
21 // - No nested CTR loops.
22 // - No function calls in loops.
23 //
24 //===----------------------------------------------------------------------===//
25 
26 #include "llvm/Transforms/Scalar.h"
27 #include "PPC.h"
28 #include "PPCTargetMachine.h"
29 #include "llvm/ADT/STLExtras.h"
30 #include "llvm/ADT/Statistic.h"
31 #include "llvm/Analysis/LoopInfo.h"
34 #include "llvm/IR/Constants.h"
35 #include "llvm/IR/DerivedTypes.h"
36 #include "llvm/IR/Dominators.h"
37 #include "llvm/IR/InlineAsm.h"
38 #include "llvm/IR/Instructions.h"
39 #include "llvm/IR/IntrinsicInst.h"
40 #include "llvm/IR/Module.h"
41 #include "llvm/IR/ValueHandle.h"
42 #include "llvm/PassSupport.h"
44 #include "llvm/Support/Debug.h"
49 
50 #ifndef NDEBUG
55 #endif
56 
57 #include <algorithm>
58 #include <vector>
59 
60 using namespace llvm;
61 
62 #define DEBUG_TYPE "ctrloops"
63 
64 #ifndef NDEBUG
65 static cl::opt<int> CTRLoopLimit("ppc-max-ctrloop", cl::Hidden, cl::init(-1));
66 #endif
67 
68 STATISTIC(NumCTRLoops, "Number of loops converted to CTR loops");
69 
70 namespace llvm {
72 #ifndef NDEBUG
74 #endif
75 }
76 
77 namespace {
78  struct PPCCTRLoops : public FunctionPass {
79 
80 #ifndef NDEBUG
81  static int Counter;
82 #endif
83 
84  public:
85  static char ID;
86 
87  PPCCTRLoops() : FunctionPass(ID), TM(nullptr) {
89  }
90  PPCCTRLoops(PPCTargetMachine &TM) : FunctionPass(ID), TM(&TM) {
92  }
93 
94  bool runOnFunction(Function &F) override;
95 
96  void getAnalysisUsage(AnalysisUsage &AU) const override {
102  }
103 
104  private:
105  bool mightUseCTR(const Triple &TT, BasicBlock *BB);
106  bool convertToCTRLoop(Loop *L);
107 
108  private:
110  LoopInfo *LI;
111  ScalarEvolution *SE;
112  const DataLayout *DL;
113  DominatorTree *DT;
114  const TargetLibraryInfo *LibInfo;
115  };
116 
117  char PPCCTRLoops::ID = 0;
118 #ifndef NDEBUG
119  int PPCCTRLoops::Counter = 0;
120 #endif
121 
122 #ifndef NDEBUG
123  struct PPCCTRLoopsVerify : public MachineFunctionPass {
124  public:
125  static char ID;
126 
127  PPCCTRLoopsVerify() : MachineFunctionPass(ID) {
129  }
130 
131  void getAnalysisUsage(AnalysisUsage &AU) const override {
134  }
135 
136  bool runOnMachineFunction(MachineFunction &MF) override;
137 
138  private:
140  };
141 
142  char PPCCTRLoopsVerify::ID = 0;
143 #endif // NDEBUG
144 } // end anonymous namespace
145 
146 INITIALIZE_PASS_BEGIN(PPCCTRLoops, "ppc-ctr-loops", "PowerPC CTR Loops",
147  false, false)
151 INITIALIZE_PASS_END(PPCCTRLoops, "ppc-ctr-loops", "PowerPC CTR Loops",
152  false, false)
153 
155  return new PPCCTRLoops(TM);
156 }
157 
158 #ifndef NDEBUG
159 INITIALIZE_PASS_BEGIN(PPCCTRLoopsVerify, "ppc-ctr-loops-verify",
160  "PowerPC CTR Loops Verify", false, false)
162 INITIALIZE_PASS_END(PPCCTRLoopsVerify, "ppc-ctr-loops-verify",
163  "PowerPC CTR Loops Verify", false, false)
164 
166  return new PPCCTRLoopsVerify();
167 }
168 #endif // NDEBUG
169 
170 bool PPCCTRLoops::runOnFunction(Function &F) {
171  LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
172  SE = &getAnalysis<ScalarEvolution>();
173  DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
174  DL = &F.getParent()->getDataLayout();
175  auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
176  LibInfo = TLIP ? &TLIP->getTLI() : nullptr;
177 
178  bool MadeChange = false;
179 
180  for (LoopInfo::iterator I = LI->begin(), E = LI->end();
181  I != E; ++I) {
182  Loop *L = *I;
183  if (!L->getParentLoop())
184  MadeChange |= convertToCTRLoop(L);
185  }
186 
187  return MadeChange;
188 }
189 
190 static bool isLargeIntegerTy(bool Is32Bit, Type *Ty) {
191  if (IntegerType *ITy = dyn_cast<IntegerType>(Ty))
192  return ITy->getBitWidth() > (Is32Bit ? 32U : 64U);
193 
194  return false;
195 }
196 
197 // Determining the address of a TLS variable results in a function call in
198 // certain TLS models.
199 static bool memAddrUsesCTR(const PPCTargetMachine *TM,
200  const llvm::Value *MemAddr) {
201  const auto *GV = dyn_cast<GlobalValue>(MemAddr);
202  if (!GV)
203  return false;
204  if (!GV->isThreadLocal())
205  return false;
206  if (!TM)
207  return true;
209  return Model == TLSModel::GeneralDynamic || Model == TLSModel::LocalDynamic;
210 }
211 
212 bool PPCCTRLoops::mightUseCTR(const Triple &TT, BasicBlock *BB) {
213  for (BasicBlock::iterator J = BB->begin(), JE = BB->end();
214  J != JE; ++J) {
215  if (CallInst *CI = dyn_cast<CallInst>(J)) {
216  if (InlineAsm *IA = dyn_cast<InlineAsm>(CI->getCalledValue())) {
217  // Inline ASM is okay, unless it clobbers the ctr register.
218  InlineAsm::ConstraintInfoVector CIV = IA->ParseConstraints();
219  for (unsigned i = 0, ie = CIV.size(); i < ie; ++i) {
220  InlineAsm::ConstraintInfo &C = CIV[i];
221  if (C.Type != InlineAsm::isInput)
222  for (unsigned j = 0, je = C.Codes.size(); j < je; ++j)
223  if (StringRef(C.Codes[j]).equals_lower("{ctr}"))
224  return true;
225  }
226 
227  continue;
228  }
229 
230  if (!TM)
231  return true;
232  const TargetLowering *TLI =
233  TM->getSubtargetImpl(*BB->getParent())->getTargetLowering();
234 
235  if (Function *F = CI->getCalledFunction()) {
236  // Most intrinsics don't become function calls, but some might.
237  // sin, cos, exp and log are always calls.
238  unsigned Opcode;
240  switch (F->getIntrinsicID()) {
241  default: continue;
242 
243 // VisualStudio defines setjmp as _setjmp
244 #if defined(_MSC_VER) && defined(setjmp) && \
245  !defined(setjmp_undefined_for_msvc)
246 # pragma push_macro("setjmp")
247 # undef setjmp
248 # define setjmp_undefined_for_msvc
249 #endif
250 
251  case Intrinsic::setjmp:
252 
253 #if defined(_MSC_VER) && defined(setjmp_undefined_for_msvc)
254  // let's return it to _setjmp state
255 # pragma pop_macro("setjmp")
256 # undef setjmp_undefined_for_msvc
257 #endif
258 
259  case Intrinsic::longjmp:
260 
261  // Exclude eh_sjlj_setjmp; we don't need to exclude eh_sjlj_longjmp
262  // because, although it does clobber the counter register, the
263  // control can't then return to inside the loop unless there is also
264  // an eh_sjlj_setjmp.
265  case Intrinsic::eh_sjlj_setjmp:
266 
267  case Intrinsic::memcpy:
268  case Intrinsic::memmove:
269  case Intrinsic::memset:
270  case Intrinsic::powi:
271  case Intrinsic::log:
272  case Intrinsic::log2:
273  case Intrinsic::log10:
274  case Intrinsic::exp:
275  case Intrinsic::exp2:
276  case Intrinsic::pow:
277  case Intrinsic::sin:
278  case Intrinsic::cos:
279  return true;
280  case Intrinsic::copysign:
281  if (CI->getArgOperand(0)->getType()->getScalarType()->
282  isPPC_FP128Ty())
283  return true;
284  else
285  continue; // ISD::FCOPYSIGN is never a library call.
286  case Intrinsic::sqrt: Opcode = ISD::FSQRT; break;
287  case Intrinsic::floor: Opcode = ISD::FFLOOR; break;
288  case Intrinsic::ceil: Opcode = ISD::FCEIL; break;
289  case Intrinsic::trunc: Opcode = ISD::FTRUNC; break;
290  case Intrinsic::rint: Opcode = ISD::FRINT; break;
291  case Intrinsic::nearbyint: Opcode = ISD::FNEARBYINT; break;
292  case Intrinsic::round: Opcode = ISD::FROUND; break;
293  }
294  }
295 
296  // PowerPC does not use [US]DIVREM or other library calls for
297  // operations on regular types which are not otherwise library calls
298  // (i.e. soft float or atomics). If adapting for targets that do,
299  // additional care is required here.
300 
302  if (!F->hasLocalLinkage() && F->hasName() && LibInfo &&
303  LibInfo->getLibFunc(F->getName(), Func) &&
304  LibInfo->hasOptimizedCodeGen(Func)) {
305  // Non-read-only functions are never treated as intrinsics.
306  if (!CI->onlyReadsMemory())
307  return true;
308 
309  // Conversion happens only for FP calls.
310  if (!CI->getArgOperand(0)->getType()->isFloatingPointTy())
311  return true;
312 
313  switch (Func) {
314  default: return true;
315  case LibFunc::copysign:
316  case LibFunc::copysignf:
317  continue; // ISD::FCOPYSIGN is never a library call.
318  case LibFunc::copysignl:
319  return true;
320  case LibFunc::fabs:
321  case LibFunc::fabsf:
322  case LibFunc::fabsl:
323  continue; // ISD::FABS is never a library call.
324  case LibFunc::sqrt:
325  case LibFunc::sqrtf:
326  case LibFunc::sqrtl:
327  Opcode = ISD::FSQRT; break;
328  case LibFunc::floor:
329  case LibFunc::floorf:
330  case LibFunc::floorl:
331  Opcode = ISD::FFLOOR; break;
332  case LibFunc::nearbyint:
333  case LibFunc::nearbyintf:
334  case LibFunc::nearbyintl:
335  Opcode = ISD::FNEARBYINT; break;
336  case LibFunc::ceil:
337  case LibFunc::ceilf:
338  case LibFunc::ceill:
339  Opcode = ISD::FCEIL; break;
340  case LibFunc::rint:
341  case LibFunc::rintf:
342  case LibFunc::rintl:
343  Opcode = ISD::FRINT; break;
344  case LibFunc::round:
345  case LibFunc::roundf:
346  case LibFunc::roundl:
347  Opcode = ISD::FROUND; break;
348  case LibFunc::trunc:
349  case LibFunc::truncf:
350  case LibFunc::truncl:
351  Opcode = ISD::FTRUNC; break;
352  }
353 
354  auto &DL = CI->getModule()->getDataLayout();
355  MVT VTy = TLI->getSimpleValueType(DL, CI->getArgOperand(0)->getType(),
356  true);
357  if (VTy == MVT::Other)
358  return true;
359 
360  if (TLI->isOperationLegalOrCustom(Opcode, VTy))
361  continue;
362  else if (VTy.isVector() &&
363  TLI->isOperationLegalOrCustom(Opcode, VTy.getScalarType()))
364  continue;
365 
366  return true;
367  }
368  }
369 
370  return true;
371  } else if (isa<BinaryOperator>(J) &&
372  J->getType()->getScalarType()->isPPC_FP128Ty()) {
373  // Most operations on ppc_f128 values become calls.
374  return true;
375  } else if (isa<UIToFPInst>(J) || isa<SIToFPInst>(J) ||
376  isa<FPToUIInst>(J) || isa<FPToSIInst>(J)) {
377  CastInst *CI = cast<CastInst>(J);
378  if (CI->getSrcTy()->getScalarType()->isPPC_FP128Ty() ||
379  CI->getDestTy()->getScalarType()->isPPC_FP128Ty() ||
382  return true;
383  } else if (isLargeIntegerTy(TT.isArch32Bit(),
384  J->getType()->getScalarType()) &&
385  (J->getOpcode() == Instruction::UDiv ||
386  J->getOpcode() == Instruction::SDiv ||
387  J->getOpcode() == Instruction::URem ||
388  J->getOpcode() == Instruction::SRem)) {
389  return true;
390  } else if (TT.isArch32Bit() &&
391  isLargeIntegerTy(false, J->getType()->getScalarType()) &&
392  (J->getOpcode() == Instruction::Shl ||
393  J->getOpcode() == Instruction::AShr ||
394  J->getOpcode() == Instruction::LShr)) {
395  // Only on PPC32, for 128-bit integers (specifically not 64-bit
396  // integers), these might be runtime calls.
397  return true;
398  } else if (isa<IndirectBrInst>(J) || isa<InvokeInst>(J)) {
399  // On PowerPC, indirect jumps use the counter register.
400  return true;
401  } else if (SwitchInst *SI = dyn_cast<SwitchInst>(J)) {
402  if (!TM)
403  return true;
404  const TargetLowering *TLI =
405  TM->getSubtargetImpl(*BB->getParent())->getTargetLowering();
406 
407  if (SI->getNumCases() + 1 >= (unsigned)TLI->getMinimumJumpTableEntries())
408  return true;
409  }
410  for (Value *Operand : J->operands())
411  if (memAddrUsesCTR(TM, Operand))
412  return true;
413  }
414 
415  return false;
416 }
417 
418 bool PPCCTRLoops::convertToCTRLoop(Loop *L) {
419  bool MadeChange = false;
420 
421  const Triple TT =
422  Triple(L->getHeader()->getParent()->getParent()->getTargetTriple());
423  if (!TT.isArch32Bit() && !TT.isArch64Bit())
424  return MadeChange; // Unknown arch. type.
425 
426  // Process nested loops first.
427  for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I) {
428  MadeChange |= convertToCTRLoop(*I);
429  }
430 
431  // If a nested loop has been converted, then we can't convert this loop.
432  if (MadeChange)
433  return MadeChange;
434 
435 #ifndef NDEBUG
436  // Stop trying after reaching the limit (if any).
437  int Limit = CTRLoopLimit;
438  if (Limit >= 0) {
439  if (Counter >= CTRLoopLimit)
440  return false;
441  Counter++;
442  }
443 #endif
444 
445  // We don't want to spill/restore the counter register, and so we don't
446  // want to use the counter register if the loop contains calls.
447  for (Loop::block_iterator I = L->block_begin(), IE = L->block_end();
448  I != IE; ++I)
449  if (mightUseCTR(TT, *I))
450  return MadeChange;
451 
452  SmallVector<BasicBlock*, 4> ExitingBlocks;
453  L->getExitingBlocks(ExitingBlocks);
454 
455  BasicBlock *CountedExitBlock = nullptr;
456  const SCEV *ExitCount = nullptr;
457  BranchInst *CountedExitBranch = nullptr;
458  for (SmallVectorImpl<BasicBlock *>::iterator I = ExitingBlocks.begin(),
459  IE = ExitingBlocks.end(); I != IE; ++I) {
460  const SCEV *EC = SE->getExitCount(L, *I);
461  DEBUG(dbgs() << "Exit Count for " << *L << " from block " <<
462  (*I)->getName() << ": " << *EC << "\n");
463  if (isa<SCEVCouldNotCompute>(EC))
464  continue;
465  if (const SCEVConstant *ConstEC = dyn_cast<SCEVConstant>(EC)) {
466  if (ConstEC->getValue()->isZero())
467  continue;
468  } else if (!SE->isLoopInvariant(EC, L))
469  continue;
470 
471  if (SE->getTypeSizeInBits(EC->getType()) > (TT.isArch64Bit() ? 64 : 32))
472  continue;
473 
474  // We now have a loop-invariant count of loop iterations (which is not the
475  // constant zero) for which we know that this loop will not exit via this
476  // exisiting block.
477 
478  // We need to make sure that this block will run on every loop iteration.
479  // For this to be true, we must dominate all blocks with backedges. Such
480  // blocks are in-loop predecessors to the header block.
481  bool NotAlways = false;
482  for (pred_iterator PI = pred_begin(L->getHeader()),
483  PIE = pred_end(L->getHeader()); PI != PIE; ++PI) {
484  if (!L->contains(*PI))
485  continue;
486 
487  if (!DT->dominates(*I, *PI)) {
488  NotAlways = true;
489  break;
490  }
491  }
492 
493  if (NotAlways)
494  continue;
495 
496  // Make sure this blocks ends with a conditional branch.
497  Instruction *TI = (*I)->getTerminator();
498  if (!TI)
499  continue;
500 
501  if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
502  if (!BI->isConditional())
503  continue;
504 
505  CountedExitBranch = BI;
506  } else
507  continue;
508 
509  // Note that this block may not be the loop latch block, even if the loop
510  // has a latch block.
511  CountedExitBlock = *I;
512  ExitCount = EC;
513  break;
514  }
515 
516  if (!CountedExitBlock)
517  return MadeChange;
518 
519  BasicBlock *Preheader = L->getLoopPreheader();
520 
521  // If we don't have a preheader, then insert one. If we already have a
522  // preheader, then we can use it (except if the preheader contains a use of
523  // the CTR register because some such uses might be reordered by the
524  // selection DAG after the mtctr instruction).
525  if (!Preheader || mightUseCTR(TT, Preheader))
526  Preheader = InsertPreheaderForLoop(L, this);
527  if (!Preheader)
528  return MadeChange;
529 
530  DEBUG(dbgs() << "Preheader for exit count: " << Preheader->getName() << "\n");
531 
532  // Insert the count into the preheader and replace the condition used by the
533  // selected branch.
534  MadeChange = true;
535 
536  SCEVExpander SCEVE(*SE, Preheader->getModule()->getDataLayout(), "loopcnt");
537  LLVMContext &C = SE->getContext();
538  Type *CountType = TT.isArch64Bit() ? Type::getInt64Ty(C) :
539  Type::getInt32Ty(C);
540  if (!ExitCount->getType()->isPointerTy() &&
541  ExitCount->getType() != CountType)
542  ExitCount = SE->getZeroExtendExpr(ExitCount, CountType);
543  ExitCount = SE->getAddExpr(ExitCount,
544  SE->getConstant(CountType, 1));
545  Value *ECValue = SCEVE.expandCodeFor(ExitCount, CountType,
546  Preheader->getTerminator());
547 
548  IRBuilder<> CountBuilder(Preheader->getTerminator());
549  Module *M = Preheader->getParent()->getParent();
550  Value *MTCTRFunc = Intrinsic::getDeclaration(M, Intrinsic::ppc_mtctr,
551  CountType);
552  CountBuilder.CreateCall(MTCTRFunc, ECValue);
553 
554  IRBuilder<> CondBuilder(CountedExitBranch);
555  Value *DecFunc =
556  Intrinsic::getDeclaration(M, Intrinsic::ppc_is_decremented_ctr_nonzero);
557  Value *NewCond = CondBuilder.CreateCall(DecFunc, {});
558  Value *OldCond = CountedExitBranch->getCondition();
559  CountedExitBranch->setCondition(NewCond);
560 
561  // The false branch must exit the loop.
562  if (!L->contains(CountedExitBranch->getSuccessor(0)))
563  CountedExitBranch->swapSuccessors();
564 
565  // The old condition may be dead now, and may have even created a dead PHI
566  // (the original induction variable).
568  DeleteDeadPHIs(CountedExitBlock);
569 
570  ++NumCTRLoops;
571  return MadeChange;
572 }
573 
574 #ifndef NDEBUG
575 static bool clobbersCTR(const MachineInstr *MI) {
576  for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
577  const MachineOperand &MO = MI->getOperand(i);
578  if (MO.isReg()) {
579  if (MO.isDef() && (MO.getReg() == PPC::CTR || MO.getReg() == PPC::CTR8))
580  return true;
581  } else if (MO.isRegMask()) {
582  if (MO.clobbersPhysReg(PPC::CTR) || MO.clobbersPhysReg(PPC::CTR8))
583  return true;
584  }
585  }
586 
587  return false;
588 }
589 
595  bool CheckPreds;
596 
597  if (I == MBB->begin()) {
598  Visited.insert(MBB);
599  goto queue_preds;
600  } else
601  --I;
602 
603 check_block:
604  Visited.insert(MBB);
605  if (I == MBB->end())
606  goto queue_preds;
607 
608  CheckPreds = true;
609  for (MachineBasicBlock::iterator IE = MBB->begin();; --I) {
610  unsigned Opc = I->getOpcode();
611  if (Opc == PPC::MTCTRloop || Opc == PPC::MTCTR8loop) {
612  CheckPreds = false;
613  break;
614  }
615 
616  if (I != BI && clobbersCTR(I)) {
617  DEBUG(dbgs() << "BB#" << MBB->getNumber() << " (" <<
618  MBB->getFullName() << ") instruction " << *I <<
619  " clobbers CTR, invalidating " << "BB#" <<
620  BI->getParent()->getNumber() << " (" <<
621  BI->getParent()->getFullName() << ") instruction " <<
622  *BI << "\n");
623  return false;
624  }
625 
626  if (I == IE)
627  break;
628  }
629 
630  if (!CheckPreds && Preds.empty())
631  return true;
632 
633  if (CheckPreds) {
634 queue_preds:
635  if (MachineFunction::iterator(MBB) == MBB->getParent()->begin()) {
636  DEBUG(dbgs() << "Unable to find a MTCTR instruction for BB#" <<
637  BI->getParent()->getNumber() << " (" <<
638  BI->getParent()->getFullName() << ") instruction " <<
639  *BI << "\n");
640  return false;
641  }
642 
644  PIE = MBB->pred_end(); PI != PIE; ++PI)
645  Preds.push_back(*PI);
646  }
647 
648  do {
649  MBB = Preds.pop_back_val();
650  if (!Visited.count(MBB)) {
651  I = MBB->getLastNonDebugInstr();
652  goto check_block;
653  }
654  } while (!Preds.empty());
655 
656  return true;
657 }
658 
659 bool PPCCTRLoopsVerify::runOnMachineFunction(MachineFunction &MF) {
660  MDT = &getAnalysis<MachineDominatorTree>();
661 
662  // Verify that all bdnz/bdz instructions are dominated by a loop mtctr before
663  // any other instructions that might clobber the ctr register.
664  for (MachineFunction::iterator I = MF.begin(), IE = MF.end();
665  I != IE; ++I) {
666  MachineBasicBlock *MBB = I;
667  if (!MDT->isReachableFromEntry(MBB))
668  continue;
669 
671  MIIE = MBB->end(); MII != MIIE; ++MII) {
672  unsigned Opc = MII->getOpcode();
673  if (Opc == PPC::BDNZ8 || Opc == PPC::BDNZ ||
674  Opc == PPC::BDZ8 || Opc == PPC::BDZ)
675  if (!verifyCTRBranch(MBB, MII))
676  llvm_unreachable("Invalid PPC CTR loop!");
677  }
678  }
679 
680  return false;
681 }
682 #endif // NDEBUG
683 
const MachineFunction * getParent() const
getParent - Return the MachineFunction containing this basic block.
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
bool hasName() const
Definition: Value.h:228
STATISTIC(NumFunctions,"Total number of functions")
void swapSuccessors()
Swap the successors of this branch instruction.
void initializePPCCTRLoopsVerifyPass(PassRegistry &)
int getNumber() const
getNumber - MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a M...
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
iterator getFirstTerminator()
getFirstTerminator - returns an iterator to the first terminator instruction of this basic block...
ScalarEvolution - This class is the main scalar evolution driver.
CallInst - This class represents a function call, abstracting a target machine's calling convention...
MVT getSimpleValueType(const DataLayout &DL, Type *Ty, bool AllowUnknown=false) const
Return the MVT corresponding to this LLVM type. See getValueType.
LoopT * getParentLoop() const
Definition: LoopInfo.h:97
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:111
F(f)
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:240
static bool memAddrUsesCTR(const PPCTargetMachine *TM, const llvm::Value *MemAddr)
BlockT * getHeader() const
Definition: LoopInfo.h:96
ConstraintCodeVector Codes
Code - The constraint code, either the register name (in braces) or the constraint letter/number...
Definition: InlineAsm.h:148
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
std::vector< LoopT * >::const_iterator iterator
iterator/begin/end - The interface to the top-level loops in the current function.
Definition: LoopInfo.h:528
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:231
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:70
ppc ctr loops PowerPC CTR Loops Verify
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
BasicBlock * InsertPreheaderForLoop(Loop *L, Pass *P)
InsertPreheaderForLoop - Once we discover that a loop doesn't have a preheader, this method is called...
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:389
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr it the function does no...
Definition: BasicBlock.cpp:116
T LLVM_ATTRIBUTE_UNUSED_RESULT pop_back_val()
Definition: SmallVector.h:406
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:75
bool isReg() const
isReg - Tests if this is a MO_Register operand.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:517
void getExitingBlocks(SmallVectorImpl< BlockT * > &ExitingBlocks) const
getExitingBlocks - Return all blocks inside the loop that have successors outside of the loop...
Definition: LoopInfoImpl.h:35
MVT getScalarType() const
getScalarType - If this is a vector type, return the element type, otherwise return this...
static cl::opt< int > CTRLoopLimit("ppc-max-ctrloop", cl::Hidden, cl::init(-1))
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
unsigned getNumOperands() const
Access to explicit operands of the instruction.
Definition: MachineInstr.h:271
bool isArch64Bit() const
Test whether the architecture is 64-bit.
Definition: Triple.cpp:1046
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: SmallVector.h:57
CHAIN = BDNZ CHAIN, DESTBB - These are used to create counter-based loops.
BasicBlock * getSuccessor(unsigned i) const
bool DeleteDeadPHIs(BasicBlock *BB, const TargetLibraryInfo *TLI=nullptr)
DeleteDeadPHIs - Examine each PHI in the given block and delete it if it is dead. ...
FunctionPass * createPPCCTRLoopsVerify()
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=None)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:866
iterator getLastNonDebugInstr()
getLastNonDebugInstr - returns an iterator to the last non-debug instruction in the basic block...
int getMinimumJumpTableEntries() const
Return integer threshold on number of blocks to use jump tables rather than if sequence.
std::vector< MachineBasicBlock * >::iterator pred_iterator
ConstraintPrefix Type
Type - The basic type of the constraint: input/output/clobber.
Definition: InlineAsm.h:120
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:67
bool isPPC_FP128Ty() const
isPPC_FP128Ty - Return true if this is powerpc long double.
Definition: Type.h:155
ppc ctr PowerPC CTR false
bundle_iterator< MachineInstr, instr_iterator > iterator
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:325
iterator begin() const
Definition: LoopInfo.h:131
BlockT * getLoopPreheader() const
getLoopPreheader - If there is a preheader for this loop, return it.
Definition: LoopInfoImpl.h:108
MVT - Machine Value Type.
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:41
Type * getType() const
getType - Return the LLVM type of this SCEV expression.
BranchInst - Conditional or Unconditional Branch instruction.
bool isOperationLegalOrCustom(unsigned Op, EVT VT) const
Return true if the specified operation is legal on this target or can be made legal with custom lower...
bool isVector() const
isVector - Return true if this is a vector value type.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:32
This file contains the declarations for the subclasses of Constant, which represent the different fla...
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:273
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:114
iterator end() const
Definition: LoopInfo.h:132
Represent the analysis usage information of a pass.
bool contains(const LoopT *L) const
contains - Return true if the specified loop is contained within in this loop.
Definition: LoopInfo.h:105
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:294
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:117
Class to represent integer types.
Definition: DerivedTypes.h:37
std::pair< NoneType, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
Definition: SmallSet.h:69
Type * getSrcTy() const
Return the source type, as a convenience.
Definition: InstrTypes.h:654
PPCTargetMachine - Common code between 32-bit and 64-bit PowerPC targets.
static bool clobbersCTR(const MachineInstr *MI)
bool isPointerTy() const
isPointerTy - True if this is an instance of PointerType.
Definition: Type.h:217
bool RecursivelyDeleteTriviallyDeadInstructions(Value *V, const TargetLibraryInfo *TLI=nullptr)
RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a trivially dead instruction...
Definition: Local.cpp:340
INITIALIZE_PASS_BEGIN(PPCCTRLoops,"ppc-ctr-loops","PowerPC CTR Loops", false, false) INITIALIZE_PASS_END(PPCCTRLoops
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
void initializePPCCTRLoopsPass(PassRegistry &)
bool isRegMask() const
isRegMask - Tests if this is a MO_RegisterMask operand.
size_type count(const T &V) const
count - Return 1 if the element is in the set, 0 otherwise.
Definition: SmallSet.h:53
std::string getFullName() const
getFullName - Return a formatted string to identify this block and its parent function.
FunctionPass * createPPCCTRLoops(PPCTargetMachine &TM)
iterator end()
Definition: BasicBlock.h:233
MachineOperand class - Representation of each machine instruction operand.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Module.h This file contains the declarations for the Module class.
Provides information about what library functions are available for the current target.
Type * getDestTy() const
Return the destination type, as a convenience.
Definition: InstrTypes.h:656
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:159
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
static bool clobbersPhysReg(const uint32_t *RegMask, unsigned PhysReg)
clobbersPhysReg - Returns true if this RegMask clobbers PhysReg.
This class uses information about analyze scalars to rewrite expressions in canonical form...
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
std::vector< BlockT * >::const_iterator block_iterator
Definition: LoopInfo.h:140
const Type * getScalarType() const LLVM_READONLY
getScalarType - If this is a vector type, return the element type, otherwise return 'this'...
Definition: Type.cpp:51
block_iterator block_end() const
Definition: LoopInfo.h:142
Representation of each machine instruction.
Definition: MachineInstr.h:51
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:372
Value * getCondition() const
SCEV - This class represents an analyzed expression in the program.
bool equals_lower(StringRef RHS) const
equals_lower - Check for string equality, ignoring case.
Definition: StringRef.h:142
#define I(x, y, z)
Definition: MD5.cpp:54
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
ppc ctr loops
bool hasLocalLinkage() const
Definition: GlobalValue.h:280
void setCondition(Value *V)
TLSModel::Model getTLSModel(const GlobalValue *GV) const
Returns the TLS model which should be used for the given global variable.
SwitchInst - Multiway switch.
unsigned getReg() const
getReg - Returns the register number.
static bool isLargeIntegerTy(bool Is32Bit, Type *Ty)
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:365
LLVM Value Representation.
Definition: Value.h:69
BasicBlockListType::iterator iterator
#define DEBUG(X)
Definition: Debug.h:92
block_iterator block_begin() const
Definition: LoopInfo.h:141
The legacy pass manager's analysis pass to compute loop information.
Definition: LoopInfo.h:737
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
Definition: PassRegistry.h:41
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:203
ppc ctr loops verify
std::vector< LoopT * >::const_iterator iterator
Definition: LoopInfo.h:128
bool isArch32Bit() const
Test whether the architecture is 32-bit.
Definition: Triple.cpp:1050
static bool verifyCTRBranch(MachineBasicBlock *MBB, MachineBasicBlock::iterator I)
std::vector< ConstraintInfo > ConstraintInfoVector
Definition: InlineAsm.h:114
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
ppc ctr PowerPC CTR Loops
SCEVConstant - This class represents a constant integer value.