LLVM  10.0.0svn
BasicBlock.cpp
Go to the documentation of this file.
1 //===-- BasicBlock.cpp - Implement BasicBlock related methods -------------===//
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 the BasicBlock class for the IR library.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/IR/BasicBlock.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/IR/CFG.h"
17 #include "llvm/IR/Constants.h"
18 #include "llvm/IR/Instructions.h"
19 #include "llvm/IR/IntrinsicInst.h"
20 #include "llvm/IR/LLVMContext.h"
21 #include "llvm/IR/Type.h"
22 #include <algorithm>
23 
24 using namespace llvm;
25 
27  if (Function *F = getParent())
28  return F->getValueSymbolTable();
29  return nullptr;
30 }
31 
33  return getType()->getContext();
34 }
35 
36 // Explicit instantiation of SymbolTableListTraits since some of the methods
37 // are not in the public header file...
39 
41  BasicBlock *InsertBefore)
42  : Value(Type::getLabelTy(C), Value::BasicBlockVal), Parent(nullptr) {
43 
44  if (NewParent)
45  insertInto(NewParent, InsertBefore);
46  else
47  assert(!InsertBefore &&
48  "Cannot insert block before another block with no function!");
49 
50  setName(Name);
51 }
52 
53 void BasicBlock::insertInto(Function *NewParent, BasicBlock *InsertBefore) {
54  assert(NewParent && "Expected a parent");
55  assert(!Parent && "Already has a parent");
56 
57  if (InsertBefore)
58  NewParent->getBasicBlockList().insert(InsertBefore->getIterator(), this);
59  else
60  NewParent->getBasicBlockList().push_back(this);
61 }
62 
64  // If the address of the block is taken and it is being deleted (e.g. because
65  // it is dead), this means that there is either a dangling constant expr
66  // hanging off the block, or an undefined use of the block (source code
67  // expecting the address of a label to keep the block alive even though there
68  // is no indirect branch). Handle these cases by zapping the BlockAddress
69  // nodes. There are no other possible uses at this point.
70  if (hasAddressTaken()) {
71  assert(!use_empty() && "There should be at least one blockaddress!");
72  Constant *Replacement =
74  while (!use_empty()) {
75  BlockAddress *BA = cast<BlockAddress>(user_back());
77  BA->getType()));
78  BA->destroyConstant();
79  }
80  }
81 
82  assert(getParent() == nullptr && "BasicBlock still linked into the program!");
84  InstList.clear();
85 }
86 
87 void BasicBlock::setParent(Function *parent) {
88  // Set Parent=parent, updating instruction symtab entries as appropriate.
89  InstList.setSymTabObject(&Parent, parent);
90 }
91 
93  std::function<bool(const Instruction &)>>>
95  std::function<bool(const Instruction &)> Fn = [](const Instruction &I) {
96  return !isa<DbgInfoIntrinsic>(I);
97  };
98  return make_filter_range(*this, Fn);
99 }
100 
102  std::function<bool(Instruction &)>>>
104  std::function<bool(Instruction &)> Fn = [](Instruction &I) {
105  return !isa<DbgInfoIntrinsic>(I);
106  };
107  return make_filter_range(*this, Fn);
108 }
109 
111  std::function<bool(const Instruction &)>>::difference_type
113  return std::distance(instructionsWithoutDebug().begin(),
115 }
116 
119 }
120 
123 }
124 
125 /// Unlink this basic block from its current function and
126 /// insert it into the function that MovePos lives in, right before MovePos.
128  MovePos->getParent()->getBasicBlockList().splice(
129  MovePos->getIterator(), getParent()->getBasicBlockList(), getIterator());
130 }
131 
132 /// Unlink this basic block from its current function and
133 /// insert it into the function that MovePos lives in, right after MovePos.
135  MovePos->getParent()->getBasicBlockList().splice(
136  ++MovePos->getIterator(), getParent()->getBasicBlockList(),
137  getIterator());
138 }
139 
141  return getParent()->getParent();
142 }
143 
145  if (InstList.empty() || !InstList.back().isTerminator())
146  return nullptr;
147  return &InstList.back();
148 }
149 
151  if (InstList.empty())
152  return nullptr;
153  const ReturnInst *RI = dyn_cast<ReturnInst>(&InstList.back());
154  if (!RI || RI == &InstList.front())
155  return nullptr;
156 
157  const Instruction *Prev = RI->getPrevNode();
158  if (!Prev)
159  return nullptr;
160 
161  if (Value *RV = RI->getReturnValue()) {
162  if (RV != Prev)
163  return nullptr;
164 
165  // Look through the optional bitcast.
166  if (auto *BI = dyn_cast<BitCastInst>(Prev)) {
167  RV = BI->getOperand(0);
168  Prev = BI->getPrevNode();
169  if (!Prev || RV != Prev)
170  return nullptr;
171  }
172  }
173 
174  if (auto *CI = dyn_cast<CallInst>(Prev)) {
175  if (CI->isMustTailCall())
176  return CI;
177  }
178  return nullptr;
179 }
180 
182  if (InstList.empty())
183  return nullptr;
184  auto *RI = dyn_cast<ReturnInst>(&InstList.back());
185  if (!RI || RI == &InstList.front())
186  return nullptr;
187 
188  if (auto *CI = dyn_cast_or_null<CallInst>(RI->getPrevNode()))
189  if (Function *F = CI->getCalledFunction())
190  if (F->getIntrinsicID() == Intrinsic::experimental_deoptimize)
191  return CI;
192 
193  return nullptr;
194 }
195 
197  for (const Instruction &I : *this)
198  if (!isa<PHINode>(I))
199  return &I;
200  return nullptr;
201 }
202 
204  for (const Instruction &I : *this)
205  if (!isa<PHINode>(I) && !isa<DbgInfoIntrinsic>(I))
206  return &I;
207  return nullptr;
208 }
209 
211  for (const Instruction &I : *this) {
212  if (isa<PHINode>(I) || isa<DbgInfoIntrinsic>(I))
213  continue;
214 
215  if (I.isLifetimeStartOrEnd())
216  continue;
217 
218  return &I;
219  }
220  return nullptr;
221 }
222 
223 BasicBlock::const_iterator BasicBlock::getFirstInsertionPt() const {
224  const Instruction *FirstNonPHI = getFirstNonPHI();
225  if (!FirstNonPHI)
226  return end();
227 
228  const_iterator InsertPt = FirstNonPHI->getIterator();
229  if (InsertPt->isEHPad()) ++InsertPt;
230  return InsertPt;
231 }
232 
234  for (Instruction &I : *this)
235  I.dropAllReferences();
236 }
237 
238 /// If this basic block has a single predecessor block,
239 /// return the block, otherwise return a null pointer.
241  const_pred_iterator PI = pred_begin(this), E = pred_end(this);
242  if (PI == E) return nullptr; // No preds.
243  const BasicBlock *ThePred = *PI;
244  ++PI;
245  return (PI == E) ? ThePred : nullptr /*multiple preds*/;
246 }
247 
248 /// If this basic block has a unique predecessor block,
249 /// return the block, otherwise return a null pointer.
250 /// Note that unique predecessor doesn't mean single edge, there can be
251 /// multiple edges from the unique predecessor to this block (for example
252 /// a switch statement with multiple cases having the same destination).
254  const_pred_iterator PI = pred_begin(this), E = pred_end(this);
255  if (PI == E) return nullptr; // No preds.
256  const BasicBlock *PredBB = *PI;
257  ++PI;
258  for (;PI != E; ++PI) {
259  if (*PI != PredBB)
260  return nullptr;
261  // The same predecessor appears multiple times in the predecessor list.
262  // This is OK.
263  }
264  return PredBB;
265 }
266 
267 bool BasicBlock::hasNPredecessors(unsigned N) const {
268  return hasNItems(pred_begin(this), pred_end(this), N);
269 }
270 
271 bool BasicBlock::hasNPredecessorsOrMore(unsigned N) const {
272  return hasNItemsOrMore(pred_begin(this), pred_end(this), N);
273 }
274 
276  succ_const_iterator SI = succ_begin(this), E = succ_end(this);
277  if (SI == E) return nullptr; // no successors
278  const BasicBlock *TheSucc = *SI;
279  ++SI;
280  return (SI == E) ? TheSucc : nullptr /* multiple successors */;
281 }
282 
284  succ_const_iterator SI = succ_begin(this), E = succ_end(this);
285  if (SI == E) return nullptr; // No successors
286  const BasicBlock *SuccBB = *SI;
287  ++SI;
288  for (;SI != E; ++SI) {
289  if (*SI != SuccBB)
290  return nullptr;
291  // The same successor appears multiple times in the successor list.
292  // This is OK.
293  }
294  return SuccBB;
295 }
296 
298  PHINode *P = empty() ? nullptr : dyn_cast<PHINode>(&*begin());
299  return make_range<phi_iterator>(P, nullptr);
300 }
301 
302 /// This method is used to notify a BasicBlock that the
303 /// specified Predecessor of the block is no longer able to reach it. This is
304 /// actually not used to update the Predecessor list, but is actually used to
305 /// update the PHI nodes that reside in the block. Note that this should be
306 /// called while the predecessor still refers to this block.
307 ///
309  bool KeepOneInputPHIs) {
310  assert((hasNUsesOrMore(16)||// Reduce cost of this assertion for complex CFGs.
311  find(pred_begin(this), pred_end(this), Pred) != pred_end(this)) &&
312  "removePredecessor: BB is not a predecessor!");
313 
314  if (InstList.empty()) return;
315  PHINode *APN = dyn_cast<PHINode>(&front());
316  if (!APN) return; // Quick exit.
317 
318  // If there are exactly two predecessors, then we want to nuke the PHI nodes
319  // altogether. However, we cannot do this, if this in this case:
320  //
321  // Loop:
322  // %x = phi [X, Loop]
323  // %x2 = add %x, 1 ;; This would become %x2 = add %x2, 1
324  // br Loop ;; %x2 does not dominate all uses
325  //
326  // This is because the PHI node input is actually taken from the predecessor
327  // basic block. The only case this can happen is with a self loop, so we
328  // check for this case explicitly now.
329  //
330  unsigned max_idx = APN->getNumIncomingValues();
331  assert(max_idx != 0 && "PHI Node in block with 0 predecessors!?!?!");
332  if (max_idx == 2) {
333  BasicBlock *Other = APN->getIncomingBlock(APN->getIncomingBlock(0) == Pred);
334 
335  // Disable PHI elimination!
336  if (this == Other) max_idx = 3;
337  }
338 
339  // <= Two predecessors BEFORE I remove one?
340  if (max_idx <= 2 && !KeepOneInputPHIs) {
341  // Yup, loop through and nuke the PHI nodes
342  while (PHINode *PN = dyn_cast<PHINode>(&front())) {
343  // Remove the predecessor first.
344  PN->removeIncomingValue(Pred, !KeepOneInputPHIs);
345 
346  // If the PHI _HAD_ two uses, replace PHI node with its now *single* value
347  if (max_idx == 2) {
348  if (PN->getIncomingValue(0) != PN)
349  PN->replaceAllUsesWith(PN->getIncomingValue(0));
350  else
351  // We are left with an infinite loop with no entries: kill the PHI.
352  PN->replaceAllUsesWith(UndefValue::get(PN->getType()));
353  getInstList().pop_front(); // Remove the PHI node
354  }
355 
356  // If the PHI node already only had one entry, it got deleted by
357  // removeIncomingValue.
358  }
359  } else {
360  // Okay, now we know that we need to remove predecessor #pred_idx from all
361  // PHI nodes. Iterate over each PHI node fixing them up
362  PHINode *PN;
363  for (iterator II = begin(); (PN = dyn_cast<PHINode>(II)); ) {
364  ++II;
365  PN->removeIncomingValue(Pred, false);
366  // If all incoming values to the Phi are the same, we can replace the Phi
367  // with that value.
368  Value* PNV = nullptr;
369  if (!KeepOneInputPHIs && (PNV = PN->hasConstantValue()))
370  if (PNV != PN) {
371  PN->replaceAllUsesWith(PNV);
372  PN->eraseFromParent();
373  }
374  }
375  }
376 }
377 
379  const Instruction *FirstNonPHI = getFirstNonPHI();
380  if (isa<LandingPadInst>(FirstNonPHI))
381  return true;
382  // This is perhaps a little conservative because constructs like
383  // CleanupBlockInst are pretty easy to split. However, SplitBlockPredecessors
384  // cannot handle such things just yet.
385  if (FirstNonPHI->isEHPad())
386  return false;
387  return true;
388 }
389 
391  auto *Term = getTerminator();
392  // No terminator means the block is under construction.
393  if (!Term)
394  return true;
395 
396  // If the block has no successors, there can be no instructions to hoist.
397  assert(Term->getNumSuccessors() > 0);
398 
399  // Instructions should not be hoisted across exception handling boundaries.
400  return !Term->isExceptionalTerminator();
401 }
402 
403 /// This splits a basic block into two at the specified
404 /// instruction. Note that all instructions BEFORE the specified iterator stay
405 /// as part of the original basic block, an unconditional branch is added to
406 /// the new BB, and the rest of the instructions in the BB are moved to the new
407 /// BB, including the old terminator. This invalidates the iterator.
408 ///
409 /// Note that this only works on well formed basic blocks (must have a
410 /// terminator), and 'I' must not be the end of instruction list (which would
411 /// cause a degenerate basic block to be formed, having a terminator inside of
412 /// the basic block).
413 ///
415  assert(getTerminator() && "Can't use splitBasicBlock on degenerate BB!");
416  assert(I != InstList.end() &&
417  "Trying to get me to create degenerate basic block!");
418 
420  this->getNextNode());
421 
422  // Save DebugLoc of split point before invalidating iterator.
423  DebugLoc Loc = I->getDebugLoc();
424  // Move all of the specified instructions from the original basic block into
425  // the new basic block.
426  New->getInstList().splice(New->end(), this->getInstList(), I, end());
427 
428  // Add a branch instruction to the newly formed basic block.
429  BranchInst *BI = BranchInst::Create(New, this);
430  BI->setDebugLoc(Loc);
431 
432  // Now we must loop through all of the successors of the New block (which
433  // _were_ the successors of the 'this' block), and update any PHI nodes in
434  // successors. If there were PHI nodes in the successors, then they need to
435  // know that incoming branches will be from New, not from Old (this).
436  //
437  New->replaceSuccessorsPhiUsesWith(this, New);
438  return New;
439 }
440 
442  // N.B. This might not be a complete BasicBlock, so don't assume
443  // that it ends with a non-phi instruction.
444  for (iterator II = begin(), IE = end(); II != IE; ++II) {
445  PHINode *PN = dyn_cast<PHINode>(II);
446  if (!PN)
447  break;
448  PN->replaceIncomingBlockWith(Old, New);
449  }
450 }
451 
453  BasicBlock *New) {
454  Instruction *TI = getTerminator();
455  if (!TI)
456  // Cope with being called on a BasicBlock that doesn't have a terminator
457  // yet. Clang's CodeGenFunction::EmitReturnBlock() likes to do this.
458  return;
459  llvm::for_each(successors(TI), [Old, New](BasicBlock *Succ) {
460  Succ->replacePhiUsesWith(Old, New);
461  });
462 }
463 
465  this->replaceSuccessorsPhiUsesWith(this, New);
466 }
467 
468 /// Return true if this basic block is a landing pad. I.e., it's
469 /// the destination of the 'unwind' edge of an invoke instruction.
471  return isa<LandingPadInst>(getFirstNonPHI());
472 }
473 
474 /// Return the landingpad instruction associated with the landing pad.
477 }
478 
480  const Instruction *TI = getTerminator();
481  if (MDNode *MDIrrLoopHeader =
482  TI->getMetadata(LLVMContext::MD_irr_loop)) {
483  MDString *MDName = cast<MDString>(MDIrrLoopHeader->getOperand(0));
484  if (MDName->getString().equals("loop_header_weight")) {
485  auto *CI = mdconst::extract<ConstantInt>(MDIrrLoopHeader->getOperand(1));
486  return Optional<uint64_t>(CI->getValue().getZExtValue());
487  }
488  }
489  return Optional<uint64_t>();
490 }
491 
493  while (isa<DbgInfoIntrinsic>(It))
494  ++It;
495  return It;
496 }
uint64_t CallInst * C
Return a value (possibly void), from a function.
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks &#39;this&#39; from the containing basic block and deletes it.
Definition: Instruction.cpp:67
bool canSplitPredecessors() const
Definition: BasicBlock.cpp:378
This class provides a symbol table of name/value pairs.
bool hasNPredecessors(unsigned N) const
Return true if this block has exactly N predecessors.
Definition: BasicBlock.cpp:267
void dropAllReferences()
Drop all references to operands.
Definition: User.h:294
BasicBlock * getNextNode()
Get the next node, or nullptr for the list tail.
Definition: ilist_node.h:288
iterator erase(iterator where)
Definition: ilist.h:265
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool isLegalToHoistInto() const
Return true if it is legal to hoist instructions into this block.
Definition: BasicBlock.cpp:390
Various leaf nodes.
Definition: ISDOpcodes.h:59
void insertInto(Function *Parent, BasicBlock *InsertBefore=nullptr)
Insert unlinked basic block into a function.
Definition: BasicBlock.cpp:53
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
void removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs=false)
Notify the BasicBlock that the predecessor Pred is no longer able to reach it.
Definition: BasicBlock.cpp:308
const CallInst * getTerminatingMustTailCall() const
Returns the call instruction marked &#39;musttail&#39; prior to the terminating return instruction of this ba...
Definition: BasicBlock.cpp:150
This class represents a function call, abstracting a target machine&#39;s calling convention.
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:953
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1791
A debug info location.
Definition: DebugLoc.h:33
Metadata node.
Definition: Metadata.h:863
F(f)
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:144
LLVMContext & getContext() const
Get the context in which this basic block lives.
Definition: BasicBlock.cpp:32
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:130
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:273
InstListType::const_iterator const_iterator
Definition: BasicBlock.h:90
The address of a basic block.
Definition: Constants.h:839
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr if the function does no...
Definition: BasicBlock.cpp:140
const CallInst * getTerminatingDeoptimizeCall() const
Returns the call instruction calling @llvm.experimental.deoptimize prior to the terminating return in...
Definition: BasicBlock.cpp:181
Value * removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty=true)
Remove an incoming value.
void replaceIncomingBlockWith(const BasicBlock *Old, BasicBlock *New)
Replace every incoming basic block Old to basic block New.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
void replacePhiUsesWith(BasicBlock *Old, BasicBlock *New)
Update all phi nodes in this basic block to refer to basic block New instead of basic block Old...
Definition: BasicBlock.cpp:441
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:285
void replaceSuccessorsPhiUsesWith(BasicBlock *Old, BasicBlock *New)
Update all phi nodes in this basic block&#39;s successors to refer to basic block New instead of basic bl...
Definition: BasicBlock.cpp:452
filter_iterator< BasicBlock::const_iterator, std::function< bool(const Instruction &)> >::difference_type sizeWithoutDebug() const
Return the size of the basic block ignoring debug instructions.
Definition: BasicBlock.cpp:112
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:102
bool empty() const
Definition: BasicBlock.h:284
const Instruction * getFirstNonPHIOrDbgOrLifetime() const
Returns a pointer to the first instruction in this block that is not a PHINode, a debug intrinsic...
Definition: BasicBlock.cpp:210
static Type * getLabelTy(LLVMContext &C)
Definition: Type.cpp:166
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:246
const BasicBlock * getUniquePredecessor() const
Return the predecessor of this block if it has a unique predecessor block.
Definition: BasicBlock.cpp:253
const BasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
Definition: BasicBlock.cpp:275
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:244
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:429
Value * getOperand(unsigned i) const
Definition: User.h:169
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:105
StringRef getString() const
Definition: Metadata.cpp:463
#define P(N)
bool hasNUsesOrMore(unsigned N) const
Return true if this value has N users or more.
Definition: Value.cpp:135
The landingpad instruction holds all of the information necessary to generate correct exception handl...
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:196
const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
Definition: BasicBlock.cpp:223
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:328
const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:240
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
Conditional or Unconditional Branch instruction.
iterator_range< filter_iterator< BasicBlock::const_iterator, std::function< bool(const Instruction &)> > > instructionsWithoutDebug() const
Return a const iterator range over the instructions in the block, skipping any debug instructions...
Definition: BasicBlock.cpp:94
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:41
This file contains the declarations for the subclasses of Constant, which represent the different fla...
const Instruction & front() const
Definition: BasicBlock.h:285
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 pop_front()
Definition: ilist.h:312
bool isLifetimeStartOrEnd() const
Return true if the instruction is a llvm.lifetime.start or llvm.lifetime.end marker.
void setSymTabObject(TPtr *, TPtr)
setSymTabObject - This is called when (f.e.) the parent of a basic block changes. ...
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:327
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:115
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:99
self_iterator getIterator()
Definition: ilist_node.h:81
bool hasNItemsOrMore(IterTy &&Begin, IterTy &&End, unsigned N, typename std::enable_if< !std::is_same< typename std::iterator_traits< typename std::remove_reference< decltype(Begin)>::type >::iterator_category, std::random_access_iterator_tag >::value, void >::type *=nullptr)
Return true if the sequence [Begin, End) has N or more items.
Definition: STLExtras.h:1549
static UndefValue * get(Type *T)
Static factory methods - Return an &#39;undef&#39; object of the specified type.
Definition: Constants.cpp:1446
Value(Type *Ty, unsigned scid)
Definition: Value.cpp:52
auto find(R &&Range, const T &Val) -> decltype(adl_begin(Range))
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1186
bool isLandingPad() const
Return true if this basic block is a landing pad.
Definition: BasicBlock.cpp:470
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches, switches, etc.
Definition: BasicBlock.h:396
bool hasNPredecessorsOrMore(unsigned N) const
Return true if this block has N predecessors or more.
Definition: BasicBlock.cpp:271
Value * hasConstantValue() const
If the specified PHI node always merges together the same value, return the value, otherwise return null.
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:338
void removeFromParent()
Unlink &#39;this&#39; from the containing function, but do not delete it.
Definition: BasicBlock.cpp:117
Iterator for intrusive lists based on ilist_node.
void moveAfter(BasicBlock *MovePos)
Unlink this basic block from its current function and insert it right after MovePos in the function M...
Definition: BasicBlock.cpp:134
iterator end()
Definition: BasicBlock.h:275
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:653
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
unsigned getNumIncomingValues() const
Return the number of incoming edges.
A range adaptor for a pair of iterators.
void push_back(pointer val)
Definition: ilist.h:311
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:89
LLVM_NODISCARD bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:174
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
pointer remove(iterator &IT)
Definition: ilist.h:249
iterator insert(iterator where, pointer New)
Definition: ilist.h:226
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:180
void clear()
Definition: ilist.h:307
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:106
SymbolTableList< BasicBlock >::iterator eraseFromParent()
Unlink &#39;this&#39; from the containing function and delete it.
Definition: BasicBlock.cpp:121
ValueSymbolTable * getValueSymbolTable()
Returns a pointer to the symbol table if one exists.
Definition: BasicBlock.cpp:26
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
Optional< uint64_t > getIrrLoopHeaderWeight() const
Definition: BasicBlock.cpp:479
LLVM_NODISCARD 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:332
const BasicBlockListType & getBasicBlockList() const
Get the underlying elements of the Function...
Definition: Function.h:657
void destroyConstant()
Called if some element of this constant is no longer valid.
Definition: Constants.cpp:386
iterator_range< const_phi_iterator > phis() const
Returns a range that iterates over the phis in the basic block.
Definition: BasicBlock.h:329
BasicBlock * splitBasicBlock(iterator I, const Twine &BBName="")
Split the basic block into two basic blocks at the specified instruction.
Definition: BasicBlock.cpp:414
Value * getReturnValue() const
Convenience accessor. Returns null if there is no return value.
iterator_range< filter_iterator< detail::IterOfRange< RangeT >, PredicateT > > make_filter_range(RangeT &&Range, PredicateT Pred)
Convenience function that takes a range of elements and a predicate, and return a new filter_iterator...
Definition: STLExtras.h:422
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:575
LLVM Value Representation.
Definition: Value.h:74
succ_range successors(Instruction *I)
Definition: CFG.h:259
bool hasNItems(IterTy &&Begin, IterTy &&End, unsigned N, typename std::enable_if< !std::is_same< typename std::iterator_traits< typename std::remove_reference< decltype(Begin)>::type >::iterator_category, std::random_access_iterator_tag >::value, void >::type *=nullptr)
Return true if the sequence [Begin, End) has exactly N items.
Definition: STLExtras.h:1532
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
Definition: Instruction.h:593
Specialization of filter_iterator_base for forward iteration only.
Definition: STLExtras.h:348
A single uniqued string.
Definition: Metadata.h:603
const LandingPadInst * getLandingPadInst() const
Return the landingpad instruction associated with the landing pad.
Definition: BasicBlock.cpp:475
const Instruction * getFirstNonPHIOrDbg() const
Returns a pointer to the first instruction in this block that is not a PHINode or a debug intrinsic...
Definition: BasicBlock.cpp:203
UnaryPredicate for_each(R &&Range, UnaryPredicate P)
Provide wrappers to std::for_each which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1158
BasicBlock::iterator skipDebugIntrinsics(BasicBlock::iterator It)
Advance It while it points to a debug instruction and return the result.
Definition: BasicBlock.cpp:492
void moveBefore(BasicBlock *MovePos)
Unlink this basic block from its current function and insert it into the function that MovePos lives ...
Definition: BasicBlock.cpp:127
bool use_empty() const
Definition: Value.h:343
void dropAllReferences()
Cause all subinstructions to "let go" of all the references that said subinstructions are maintaining...
Definition: BasicBlock.cpp:233
User * user_back()
Definition: Value.h:406
const BasicBlock * getUniqueSuccessor() const
Return the successor of this block if it has a unique successor.
Definition: BasicBlock.cpp:283