LLVM  11.0.0git
FlattenCFG.cpp
Go to the documentation of this file.
1 //===- FlatternCFG.cpp - Code to perform CFG flattening -------------------===//
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 // Reduce conditional branches in CFG.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/ADT/SmallPtrSet.h"
17 #include "llvm/IR/BasicBlock.h"
18 #include "llvm/IR/IRBuilder.h"
19 #include "llvm/IR/InstrTypes.h"
20 #include "llvm/IR/Instruction.h"
21 #include "llvm/IR/Instructions.h"
22 #include "llvm/IR/Value.h"
23 #include "llvm/Support/Casting.h"
24 #include "llvm/Support/Debug.h"
27 #include <cassert>
28 
29 using namespace llvm;
30 
31 #define DEBUG_TYPE "flattencfg"
32 
33 namespace {
34 
35 class FlattenCFGOpt {
36  AliasAnalysis *AA;
37 
38  /// Use parallel-and or parallel-or to generate conditions for
39  /// conditional branches.
40  bool FlattenParallelAndOr(BasicBlock *BB, IRBuilder<> &Builder);
41 
42  /// If \param BB is the merge block of an if-region, attempt to merge
43  /// the if-region with an adjacent if-region upstream if two if-regions
44  /// contain identical instructions.
45  bool MergeIfRegion(BasicBlock *BB, IRBuilder<> &Builder);
46 
47  /// Compare a pair of blocks: \p Block1 and \p Block2, which
48  /// are from two if-regions, where \p Head2 is the entry block of the 2nd
49  /// if-region. \returns true if \p Block1 and \p Block2 contain identical
50  /// instructions, and have no memory reference alias with \p Head2.
51  /// This is used as a legality check for merging if-regions.
52  bool CompareIfRegionBlock(BasicBlock *Block1, BasicBlock *Block2,
53  BasicBlock *Head2);
54 
55 public:
56  FlattenCFGOpt(AliasAnalysis *AA) : AA(AA) {}
57 
58  bool run(BasicBlock *BB);
59 };
60 
61 } // end anonymous namespace
62 
63 /// If \param [in] BB has more than one predecessor that is a conditional
64 /// branch, attempt to use parallel and/or for the branch condition. \returns
65 /// true on success.
66 ///
67 /// Before:
68 /// ......
69 /// %cmp10 = fcmp une float %tmp1, %tmp2
70 /// br i1 %cmp10, label %if.then, label %lor.rhs
71 ///
72 /// lor.rhs:
73 /// ......
74 /// %cmp11 = fcmp une float %tmp3, %tmp4
75 /// br i1 %cmp11, label %if.then, label %ifend
76 ///
77 /// if.end: // the merge block
78 /// ......
79 ///
80 /// if.then: // has two predecessors, both of them contains conditional branch.
81 /// ......
82 /// br label %if.end;
83 ///
84 /// After:
85 /// ......
86 /// %cmp10 = fcmp une float %tmp1, %tmp2
87 /// ......
88 /// %cmp11 = fcmp une float %tmp3, %tmp4
89 /// %cmp12 = or i1 %cmp10, %cmp11 // parallel-or mode.
90 /// br i1 %cmp12, label %if.then, label %ifend
91 ///
92 /// if.end:
93 /// ......
94 ///
95 /// if.then:
96 /// ......
97 /// br label %if.end;
98 ///
99 /// Current implementation handles two cases.
100 /// Case 1: BB is on the else-path.
101 ///
102 /// BB1
103 /// / |
104 /// BB2 |
105 /// / \ |
106 /// BB3 \ | where, BB1, BB2 contain conditional branches.
107 /// \ | / BB3 contains unconditional branch.
108 /// \ | / BB4 corresponds to BB which is also the merge.
109 /// BB => BB4
110 ///
111 ///
112 /// Corresponding source code:
113 ///
114 /// if (a == b && c == d)
115 /// statement; // BB3
116 ///
117 /// Case 2: BB is on the then-path.
118 ///
119 /// BB1
120 /// / |
121 /// | BB2
122 /// \ / | where BB1, BB2 contain conditional branches.
123 /// BB => BB3 | BB3 contains unconditiona branch and corresponds
124 /// \ / to BB. BB4 is the merge.
125 /// BB4
126 ///
127 /// Corresponding source code:
128 ///
129 /// if (a == b || c == d)
130 /// statement; // BB3
131 ///
132 /// In both cases, BB is the common successor of conditional branches.
133 /// In Case 1, BB (BB4) has an unconditional branch (BB3) as
134 /// its predecessor. In Case 2, BB (BB3) only has conditional branches
135 /// as its predecessors.
136 bool FlattenCFGOpt::FlattenParallelAndOr(BasicBlock *BB, IRBuilder<> &Builder) {
137  PHINode *PHI = dyn_cast<PHINode>(BB->begin());
138  if (PHI)
139  return false; // For simplicity, avoid cases containing PHI nodes.
140 
141  BasicBlock *LastCondBlock = nullptr;
142  BasicBlock *FirstCondBlock = nullptr;
143  BasicBlock *UnCondBlock = nullptr;
144  int Idx = -1;
145 
146  // Check predecessors of \param BB.
148  for (SmallPtrSetIterator<BasicBlock *> PI = Preds.begin(), PE = Preds.end();
149  PI != PE; ++PI) {
150  BasicBlock *Pred = *PI;
151  BranchInst *PBI = dyn_cast<BranchInst>(Pred->getTerminator());
152 
153  // All predecessors should terminate with a branch.
154  if (!PBI)
155  return false;
156 
157  BasicBlock *PP = Pred->getSinglePredecessor();
158 
159  if (PBI->isUnconditional()) {
160  // Case 1: Pred (BB3) is an unconditional block, it should
161  // have a single predecessor (BB2) that is also a predecessor
162  // of \param BB (BB4) and should not have address-taken.
163  // There should exist only one such unconditional
164  // branch among the predecessors.
165  if (UnCondBlock || !PP || (Preds.count(PP) == 0) ||
166  Pred->hasAddressTaken())
167  return false;
168 
169  UnCondBlock = Pred;
170  continue;
171  }
172 
173  // Only conditional branches are allowed beyond this point.
174  assert(PBI->isConditional());
175 
176  // Condition's unique use should be the branch instruction.
177  Value *PC = PBI->getCondition();
178  if (!PC || !PC->hasOneUse())
179  return false;
180 
181  if (PP && Preds.count(PP)) {
182  // These are internal condition blocks to be merged from, e.g.,
183  // BB2 in both cases.
184  // Should not be address-taken.
185  if (Pred->hasAddressTaken())
186  return false;
187 
188  // Instructions in the internal condition blocks should be safe
189  // to hoist up.
190  for (BasicBlock::iterator BI = Pred->begin(), BE = PBI->getIterator();
191  BI != BE;) {
192  Instruction *CI = &*BI++;
193  if (isa<PHINode>(CI) || !isSafeToSpeculativelyExecute(CI))
194  return false;
195  }
196  } else {
197  // This is the condition block to be merged into, e.g. BB1 in
198  // both cases.
199  if (FirstCondBlock)
200  return false;
201  FirstCondBlock = Pred;
202  }
203 
204  // Find whether BB is uniformly on the true (or false) path
205  // for all of its predecessors.
206  BasicBlock *PS1 = PBI->getSuccessor(0);
207  BasicBlock *PS2 = PBI->getSuccessor(1);
208  BasicBlock *PS = (PS1 == BB) ? PS2 : PS1;
209  int CIdx = (PS1 == BB) ? 0 : 1;
210 
211  if (Idx == -1)
212  Idx = CIdx;
213  else if (CIdx != Idx)
214  return false;
215 
216  // PS is the successor which is not BB. Check successors to identify
217  // the last conditional branch.
218  if (Preds.count(PS) == 0) {
219  // Case 2.
220  LastCondBlock = Pred;
221  } else {
222  // Case 1
224  if (BPS && BPS->isUnconditional()) {
225  // Case 1: PS(BB3) should be an unconditional branch.
226  LastCondBlock = Pred;
227  }
228  }
229  }
230 
231  if (!FirstCondBlock || !LastCondBlock || (FirstCondBlock == LastCondBlock))
232  return false;
233 
234  Instruction *TBB = LastCondBlock->getTerminator();
235  BasicBlock *PS1 = TBB->getSuccessor(0);
236  BasicBlock *PS2 = TBB->getSuccessor(1);
237  BranchInst *PBI1 = dyn_cast<BranchInst>(PS1->getTerminator());
238  BranchInst *PBI2 = dyn_cast<BranchInst>(PS2->getTerminator());
239 
240  // If PS1 does not jump into PS2, but PS2 jumps into PS1,
241  // attempt branch inversion.
242  if (!PBI1 || !PBI1->isUnconditional() ||
243  (PS1->getTerminator()->getSuccessor(0) != PS2)) {
244  // Check whether PS2 jumps into PS1.
245  if (!PBI2 || !PBI2->isUnconditional() ||
246  (PS2->getTerminator()->getSuccessor(0) != PS1))
247  return false;
248 
249  // Do branch inversion.
250  BasicBlock *CurrBlock = LastCondBlock;
251  bool EverChanged = false;
252  for (; CurrBlock != FirstCondBlock;
253  CurrBlock = CurrBlock->getSinglePredecessor()) {
254  auto *BI = cast<BranchInst>(CurrBlock->getTerminator());
255  auto *CI = dyn_cast<CmpInst>(BI->getCondition());
256  if (!CI)
257  continue;
258 
259  CmpInst::Predicate Predicate = CI->getPredicate();
260  // Canonicalize icmp_ne -> icmp_eq, fcmp_one -> fcmp_oeq
261  if ((Predicate == CmpInst::ICMP_NE) || (Predicate == CmpInst::FCMP_ONE)) {
262  CI->setPredicate(ICmpInst::getInversePredicate(Predicate));
263  BI->swapSuccessors();
264  EverChanged = true;
265  }
266  }
267  return EverChanged;
268  }
269 
270  // PS1 must have a conditional branch.
271  if (!PBI1 || !PBI1->isUnconditional())
272  return false;
273 
274  // PS2 should not contain PHI node.
275  PHI = dyn_cast<PHINode>(PS2->begin());
276  if (PHI)
277  return false;
278 
279  // Do the transformation.
280  BasicBlock *CB;
281  BranchInst *PBI = cast<BranchInst>(FirstCondBlock->getTerminator());
282  bool Iteration = true;
283  IRBuilder<>::InsertPointGuard Guard(Builder);
284  Value *PC = PBI->getCondition();
285 
286  do {
287  CB = PBI->getSuccessor(1 - Idx);
288  // Delete the conditional branch.
289  FirstCondBlock->getInstList().pop_back();
290  FirstCondBlock->getInstList()
291  .splice(FirstCondBlock->end(), CB->getInstList());
292  PBI = cast<BranchInst>(FirstCondBlock->getTerminator());
293  Value *CC = PBI->getCondition();
294  // Merge conditions.
295  Builder.SetInsertPoint(PBI);
296  Value *NC;
297  if (Idx == 0)
298  // Case 2, use parallel or.
299  NC = Builder.CreateOr(PC, CC);
300  else
301  // Case 1, use parallel and.
302  NC = Builder.CreateAnd(PC, CC);
303 
304  PBI->replaceUsesOfWith(CC, NC);
305  PC = NC;
306  if (CB == LastCondBlock)
307  Iteration = false;
308  // Remove internal conditional branches.
309  CB->dropAllReferences();
310  // make CB unreachable and let downstream to delete the block.
311  new UnreachableInst(CB->getContext(), CB);
312  } while (Iteration);
313 
314  LLVM_DEBUG(dbgs() << "Use parallel and/or in:\n" << *FirstCondBlock);
315  return true;
316 }
317 
318 /// Compare blocks from two if-regions, where \param Head2 is the entry of the
319 /// 2nd if-region. \param Block1 is a block in the 1st if-region to compare.
320 /// \param Block2 is a block in the 2nd if-region to compare. \returns true if
321 /// Block1 and Block2 have identical instructions and do not have
322 /// memory reference alias with Head2.
323 bool FlattenCFGOpt::CompareIfRegionBlock(BasicBlock *Block1, BasicBlock *Block2,
324  BasicBlock *Head2) {
325  Instruction *PTI2 = Head2->getTerminator();
326  Instruction *PBI2 = &Head2->front();
327 
328  // Check whether instructions in Block1 and Block2 are identical
329  // and do not alias with instructions in Head2.
330  BasicBlock::iterator iter1 = Block1->begin();
331  BasicBlock::iterator end1 = Block1->getTerminator()->getIterator();
332  BasicBlock::iterator iter2 = Block2->begin();
333  BasicBlock::iterator end2 = Block2->getTerminator()->getIterator();
334 
335  while (true) {
336  if (iter1 == end1) {
337  if (iter2 != end2)
338  return false;
339  break;
340  }
341 
342  if (!iter1->isIdenticalTo(&*iter2))
343  return false;
344 
345  // Illegal to remove instructions with side effects except
346  // non-volatile stores.
347  if (iter1->mayHaveSideEffects()) {
348  Instruction *CurI = &*iter1;
349  StoreInst *SI = dyn_cast<StoreInst>(CurI);
350  if (!SI || SI->isVolatile())
351  return false;
352  }
353 
354  // For simplicity and speed, data dependency check can be
355  // avoided if read from memory doesn't exist.
356  if (iter1->mayReadFromMemory())
357  return false;
358 
359  if (iter1->mayWriteToMemory()) {
360  for (BasicBlock::iterator BI(PBI2), BE(PTI2); BI != BE; ++BI) {
361  if (BI->mayReadFromMemory() || BI->mayWriteToMemory()) {
362  // Check alias with Head2.
363  if (!AA || AA->alias(&*iter1, &*BI))
364  return false;
365  }
366  }
367  }
368  ++iter1;
369  ++iter2;
370  }
371 
372  return true;
373 }
374 
375 /// Check whether \param BB is the merge block of a if-region. If yes, check
376 /// whether there exists an adjacent if-region upstream, the two if-regions
377 /// contain identical instructions and can be legally merged. \returns true if
378 /// the two if-regions are merged.
379 ///
380 /// From:
381 /// if (a)
382 /// statement;
383 /// if (b)
384 /// statement;
385 ///
386 /// To:
387 /// if (a || b)
388 /// statement;
389 ///
390 ///
391 /// And from:
392 /// if (a)
393 /// ;
394 /// else
395 /// statement;
396 /// if (b)
397 /// ;
398 /// else
399 /// statement;
400 ///
401 /// To:
402 /// if (a && b)
403 /// ;
404 /// else
405 /// statement;
406 ///
407 /// We always take the form of the first if-region. This means that if the
408 /// statement in the first if-region, is in the "then-path", while in the second
409 /// if-region it is in the "else-path", then we convert the second to the first
410 /// form, by inverting the condition and the branch successors. The same
411 /// approach goes for the opposite case.
412 bool FlattenCFGOpt::MergeIfRegion(BasicBlock *BB, IRBuilder<> &Builder) {
413  BasicBlock *IfTrue2, *IfFalse2;
414  Value *IfCond2 = GetIfCondition(BB, IfTrue2, IfFalse2);
415  Instruction *CInst2 = dyn_cast_or_null<Instruction>(IfCond2);
416  if (!CInst2)
417  return false;
418 
419  BasicBlock *SecondEntryBlock = CInst2->getParent();
420  if (SecondEntryBlock->hasAddressTaken())
421  return false;
422 
423  BasicBlock *IfTrue1, *IfFalse1;
424  Value *IfCond1 = GetIfCondition(SecondEntryBlock, IfTrue1, IfFalse1);
425  Instruction *CInst1 = dyn_cast_or_null<Instruction>(IfCond1);
426  if (!CInst1)
427  return false;
428 
429  BasicBlock *FirstEntryBlock = CInst1->getParent();
430 
431  // Either then-path or else-path should be empty.
432  bool InvertCond2 = false;
433  BinaryOperator::BinaryOps CombineOp;
434  if (IfFalse1 == FirstEntryBlock) {
435  // The else-path is empty, so we must use "or" operation to combine the
436  // conditions.
437  CombineOp = BinaryOperator::Or;
438  if (IfFalse2 != SecondEntryBlock) {
439  if (IfTrue2 != SecondEntryBlock)
440  return false;
441 
442  InvertCond2 = true;
443  std::swap(IfTrue2, IfFalse2);
444  }
445 
446  if (!CompareIfRegionBlock(IfTrue1, IfTrue2, SecondEntryBlock))
447  return false;
448  } else if (IfTrue1 == FirstEntryBlock) {
449  // The then-path is empty, so we must use "and" operation to combine the
450  // conditions.
451  CombineOp = BinaryOperator::And;
452  if (IfTrue2 != SecondEntryBlock) {
453  if (IfFalse2 != SecondEntryBlock)
454  return false;
455 
456  InvertCond2 = true;
457  std::swap(IfTrue2, IfFalse2);
458  }
459 
460  if (!CompareIfRegionBlock(IfFalse1, IfFalse2, SecondEntryBlock))
461  return false;
462  } else
463  return false;
464 
465  Instruction *PTI2 = SecondEntryBlock->getTerminator();
466  Instruction *PBI2 = &SecondEntryBlock->front();
467 
468  // Check whether \param SecondEntryBlock has side-effect and is safe to
469  // speculate.
470  for (BasicBlock::iterator BI(PBI2), BE(PTI2); BI != BE; ++BI) {
471  Instruction *CI = &*BI;
472  if (isa<PHINode>(CI) || CI->mayHaveSideEffects() ||
474  return false;
475  }
476 
477  // Merge \param SecondEntryBlock into \param FirstEntryBlock.
478  FirstEntryBlock->getInstList().pop_back();
479  FirstEntryBlock->getInstList()
480  .splice(FirstEntryBlock->end(), SecondEntryBlock->getInstList());
481  BranchInst *PBI = cast<BranchInst>(FirstEntryBlock->getTerminator());
482  assert(PBI->getCondition() == IfCond2);
483  BasicBlock *SaveInsertBB = Builder.GetInsertBlock();
484  BasicBlock::iterator SaveInsertPt = Builder.GetInsertPoint();
485  Builder.SetInsertPoint(PBI);
486  if (InvertCond2) {
487  // If this is a "cmp" instruction, only used for branching (and nowhere
488  // else), then we can simply invert the predicate.
489  auto Cmp2 = dyn_cast<CmpInst>(CInst2);
490  if (Cmp2 && Cmp2->hasOneUse())
491  Cmp2->setPredicate(Cmp2->getInversePredicate());
492  else
493  CInst2 = cast<Instruction>(Builder.CreateNot(CInst2));
494  PBI->swapSuccessors();
495  }
496  Value *NC = Builder.CreateBinOp(CombineOp, CInst1, CInst2);
497  PBI->replaceUsesOfWith(IfCond2, NC);
498  Builder.SetInsertPoint(SaveInsertBB, SaveInsertPt);
499 
500  // Handle PHI node to replace its predecessors to FirstEntryBlock.
501  for (BasicBlock *Succ : successors(PBI)) {
502  for (PHINode &Phi : Succ->phis()) {
503  for (unsigned i = 0, e = Phi.getNumIncomingValues(); i != e; ++i) {
504  if (Phi.getIncomingBlock(i) == SecondEntryBlock)
505  Phi.setIncomingBlock(i, FirstEntryBlock);
506  }
507  }
508  }
509 
510  // Remove IfTrue1
511  if (IfTrue1 != FirstEntryBlock) {
512  IfTrue1->dropAllReferences();
513  IfTrue1->eraseFromParent();
514  }
515 
516  // Remove IfFalse1
517  if (IfFalse1 != FirstEntryBlock) {
518  IfFalse1->dropAllReferences();
519  IfFalse1->eraseFromParent();
520  }
521 
522  // Remove \param SecondEntryBlock
523  SecondEntryBlock->dropAllReferences();
524  SecondEntryBlock->eraseFromParent();
525  LLVM_DEBUG(dbgs() << "If conditions merged into:\n" << *FirstEntryBlock);
526  return true;
527 }
528 
529 bool FlattenCFGOpt::run(BasicBlock *BB) {
530  assert(BB && BB->getParent() && "Block not embedded in function!");
531  assert(BB->getTerminator() && "Degenerate basic block encountered!");
532 
533  IRBuilder<> Builder(BB);
534 
535  if (FlattenParallelAndOr(BB, Builder) || MergeIfRegion(BB, Builder))
536  return true;
537  return false;
538 }
539 
540 /// FlattenCFG - This function is used to flatten a CFG. For
541 /// example, it uses parallel-and and parallel-or mode to collapse
542 /// if-conditions and merge if-regions with identical statements.
544  return FlattenCFGOpt(AA).run(BB);
545 }
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:715
LLVM_NODISCARD std::enable_if_t< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type > dyn_cast(const Y &Val)
Definition: Casting.h:334
This class represents lattice values for constants.
Definition: AllocatorList.h:23
void swapSuccessors()
Swap the successors of this branch instruction.
BasicBlock * getSuccessor(unsigned Idx) const
Return the specified successor. This instruction must be a terminator.
BasicBlock * getSuccessor(unsigned i) const
Value * getCondition() const
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...
Definition: BasicBlock.cpp:150
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:725
LLVMContext & getContext() const
Get the context in which this basic block lives.
Definition: BasicBlock.cpp:32
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1316
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:289
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
Definition: InstrTypes.h:824
BasicBlock * GetInsertBlock() const
Definition: IRBuilder.h:155
An instruction for storing to memory.
Definition: Instructions.h:297
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block...
Definition: IRBuilder.h:161
void replaceUsesOfWith(Value *From, Value *To)
Replace uses of one Value with another.
Definition: User.cpp:21
const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:258
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
Conditional or Unconditional Branch instruction.
Value * CreateNot(Value *V, const Twine &Name="")
Definition: IRBuilder.h:1559
This function has undefined behavior.
const Instruction & front() const
Definition: BasicBlock.h:301
bool mayHaveSideEffects() const
Return true if the instruction may have side effects.
Definition: Instruction.h:610
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:112
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:329
constexpr double e
Definition: MathExtras.h:58
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:115
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:375
self_iterator getIterator()
Definition: ilist_node.h:81
assume Assume Builder
SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet.
Definition: SmallPtrSet.h:266
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches, switches, etc.
Definition: BasicBlock.h:412
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:354
Iterator for intrusive lists based on ilist_node.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:439
iterator end()
Definition: BasicBlock.h:291
Predicate
Predicate - These are "(BI << 5) | BO" for various predicates.
Definition: PPCPredicates.h:26
Value * GetIfCondition(BasicBlock *BB, BasicBlock *&IfTrue, BasicBlock *&IfFalse)
Check whether BB is the merge point of a if-region.
bool isConditional() const
#define NC
Definition: regutils.h:42
void setPredicate(Predicate P)
Set the predicate for this instruction to the specified value.
Definition: InstrTypes.h:805
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:962
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:733
bool isVolatile() const
Return true if this is a store to a volatile memory location.
Definition: Instructions.h:332
iterator begin() const
Definition: SmallPtrSet.h:392
Value * CreateOr(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1342
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:107
SymbolTableList< BasicBlock >::iterator eraseFromParent()
Unlink &#39;this&#39; from the containing function and delete it.
Definition: BasicBlock.cpp:127
bool FlattenCFG(BasicBlock *BB, AAResults *AA=nullptr)
This function is used to flatten a CFG.
Definition: FlattenCFG.cpp:543
bool isUnconditional() const
iterator end() const
Definition: SmallPtrSet.h:397
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool isSafeToSpeculativelyExecute(const Value *V, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr)
Return true if the instruction does not have any effects besides calculating the result and does not ...
LLVM Value Representation.
Definition: Value.h:74
succ_range successors(Instruction *I)
Definition: CFG.h:260
BasicBlock::iterator GetInsertPoint() const
Definition: IRBuilder.h:156
Value * CreateBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:1506
void pop_back()
Definition: ilist.h:318
#define LLVM_DEBUG(X)
Definition: Debug.h:122
void dropAllReferences()
Cause all subinstructions to "let go" of all the references that said subinstructions are maintaining...
Definition: BasicBlock.cpp:251
const BasicBlock * getParent() const
Definition: Instruction.h:85