LLVM  14.0.0git
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 
37  BB->invalidateOrders();
38 }
39 
40 // Explicit instantiation of SymbolTableListTraits since some of the methods
41 // are not in the public header file...
43 
44 BasicBlock::BasicBlock(LLVMContext &C, const Twine &Name, Function *NewParent,
45  BasicBlock *InsertBefore)
46  : Value(Type::getLabelTy(C), Value::BasicBlockVal), Parent(nullptr) {
47 
48  if (NewParent)
49  insertInto(NewParent, InsertBefore);
50  else
51  assert(!InsertBefore &&
52  "Cannot insert block before another block with no function!");
53 
54  setName(Name);
55 }
56 
57 void BasicBlock::insertInto(Function *NewParent, BasicBlock *InsertBefore) {
58  assert(NewParent && "Expected a parent");
59  assert(!Parent && "Already has a parent");
60 
61  if (InsertBefore)
62  NewParent->getBasicBlockList().insert(InsertBefore->getIterator(), this);
63  else
64  NewParent->getBasicBlockList().push_back(this);
65 }
66 
69 
70  // If the address of the block is taken and it is being deleted (e.g. because
71  // it is dead), this means that there is either a dangling constant expr
72  // hanging off the block, or an undefined use of the block (source code
73  // expecting the address of a label to keep the block alive even though there
74  // is no indirect branch). Handle these cases by zapping the BlockAddress
75  // nodes. There are no other possible uses at this point.
76  if (hasAddressTaken()) {
77  assert(!use_empty() && "There should be at least one blockaddress!");
78  Constant *Replacement =
80  while (!use_empty()) {
81  BlockAddress *BA = cast<BlockAddress>(user_back());
83  BA->getType()));
84  BA->destroyConstant();
85  }
86  }
87 
88  assert(getParent() == nullptr && "BasicBlock still linked into the program!");
90  InstList.clear();
91 }
92 
93 void BasicBlock::setParent(Function *parent) {
94  // Set Parent=parent, updating instruction symtab entries as appropriate.
95  InstList.setSymTabObject(&Parent, parent);
96 }
97 
99  std::function<bool(const Instruction &)>>>
100 BasicBlock::instructionsWithoutDebug(bool SkipPseudoOp) const {
101  std::function<bool(const Instruction &)> Fn = [=](const Instruction &I) {
102  return !isa<DbgInfoIntrinsic>(I) &&
103  !(SkipPseudoOp && isa<PseudoProbeInst>(I));
104  };
105  return make_filter_range(*this, Fn);
106 }
107 
111  std::function<bool(Instruction &)> Fn = [=](Instruction &I) {
112  return !isa<DbgInfoIntrinsic>(I) &&
113  !(SkipPseudoOp && isa<PseudoProbeInst>(I));
114  };
115  return make_filter_range(*this, Fn);
116 }
117 
119  std::function<bool(const Instruction &)>>::difference_type
121  return std::distance(instructionsWithoutDebug().begin(),
123 }
124 
126  getParent()->getBasicBlockList().remove(getIterator());
127 }
128 
130  return getParent()->getBasicBlockList().erase(getIterator());
131 }
132 
134  MovePos->getParent()->getBasicBlockList().splice(
135  MovePos->getIterator(), getParent()->getBasicBlockList(), getIterator());
136 }
137 
139  MovePos->getParent()->getBasicBlockList().splice(
140  ++MovePos->getIterator(), getParent()->getBasicBlockList(),
141  getIterator());
142 }
143 
145  return getParent()->getParent();
146 }
147 
149  if (InstList.empty() || !InstList.back().isTerminator())
150  return nullptr;
151  return &InstList.back();
152 }
153 
155  if (InstList.empty())
156  return nullptr;
157  const ReturnInst *RI = dyn_cast<ReturnInst>(&InstList.back());
158  if (!RI || RI == &InstList.front())
159  return nullptr;
160 
161  const Instruction *Prev = RI->getPrevNode();
162  if (!Prev)
163  return nullptr;
164 
165  if (Value *RV = RI->getReturnValue()) {
166  if (RV != Prev)
167  return nullptr;
168 
169  // Look through the optional bitcast.
170  if (auto *BI = dyn_cast<BitCastInst>(Prev)) {
171  RV = BI->getOperand(0);
172  Prev = BI->getPrevNode();
173  if (!Prev || RV != Prev)
174  return nullptr;
175  }
176  }
177 
178  if (auto *CI = dyn_cast<CallInst>(Prev)) {
179  if (CI->isMustTailCall())
180  return CI;
181  }
182  return nullptr;
183 }
184 
186  if (InstList.empty())
187  return nullptr;
188  auto *RI = dyn_cast<ReturnInst>(&InstList.back());
189  if (!RI || RI == &InstList.front())
190  return nullptr;
191 
192  if (auto *CI = dyn_cast_or_null<CallInst>(RI->getPrevNode()))
193  if (Function *F = CI->getCalledFunction())
194  if (F->getIntrinsicID() == Intrinsic::experimental_deoptimize)
195  return CI;
196 
197  return nullptr;
198 }
199 
201  const BasicBlock* BB = this;
203  Visited.insert(BB);
204  while (auto *Succ = BB->getUniqueSuccessor()) {
205  if (!Visited.insert(Succ).second)
206  return nullptr;
207  BB = Succ;
208  }
209  return BB->getTerminatingDeoptimizeCall();
210 }
211 
213  for (const Instruction &I : *this)
214  if (!isa<PHINode>(I))
215  return &I;
216  return nullptr;
217 }
218 
219 const Instruction *BasicBlock::getFirstNonPHIOrDbg(bool SkipPseudoOp) const {
220  for (const Instruction &I : *this) {
221  if (isa<PHINode>(I) || isa<DbgInfoIntrinsic>(I))
222  continue;
223 
224  if (SkipPseudoOp && isa<PseudoProbeInst>(I))
225  continue;
226 
227  return &I;
228  }
229  return nullptr;
230 }
231 
232 const Instruction *
234  for (const Instruction &I : *this) {
235  if (isa<PHINode>(I) || isa<DbgInfoIntrinsic>(I))
236  continue;
237 
238  if (I.isLifetimeStartOrEnd())
239  continue;
240 
241  if (SkipPseudoOp && isa<PseudoProbeInst>(I))
242  continue;
243 
244  return &I;
245  }
246  return nullptr;
247 }
248 
250  const Instruction *FirstNonPHI = getFirstNonPHI();
251  if (!FirstNonPHI)
252  return end();
253 
254  const_iterator InsertPt = FirstNonPHI->getIterator();
255  if (InsertPt->isEHPad()) ++InsertPt;
256  return InsertPt;
257 }
258 
260  for (Instruction &I : *this)
261  I.dropAllReferences();
262 }
263 
265  const_pred_iterator PI = pred_begin(this), E = pred_end(this);
266  if (PI == E) return nullptr; // No preds.
267  const BasicBlock *ThePred = *PI;
268  ++PI;
269  return (PI == E) ? ThePred : nullptr /*multiple preds*/;
270 }
271 
273  const_pred_iterator PI = pred_begin(this), E = pred_end(this);
274  if (PI == E) return nullptr; // No preds.
275  const BasicBlock *PredBB = *PI;
276  ++PI;
277  for (;PI != E; ++PI) {
278  if (*PI != PredBB)
279  return nullptr;
280  // The same predecessor appears multiple times in the predecessor list.
281  // This is OK.
282  }
283  return PredBB;
284 }
285 
286 bool BasicBlock::hasNPredecessors(unsigned N) const {
287  return hasNItems(pred_begin(this), pred_end(this), N);
288 }
289 
290 bool BasicBlock::hasNPredecessorsOrMore(unsigned N) const {
291  return hasNItemsOrMore(pred_begin(this), pred_end(this), N);
292 }
293 
295  const_succ_iterator SI = succ_begin(this), E = succ_end(this);
296  if (SI == E) return nullptr; // no successors
297  const BasicBlock *TheSucc = *SI;
298  ++SI;
299  return (SI == E) ? TheSucc : nullptr /* multiple successors */;
300 }
301 
303  const_succ_iterator SI = succ_begin(this), E = succ_end(this);
304  if (SI == E) return nullptr; // No successors
305  const BasicBlock *SuccBB = *SI;
306  ++SI;
307  for (;SI != E; ++SI) {
308  if (*SI != SuccBB)
309  return nullptr;
310  // The same successor appears multiple times in the successor list.
311  // This is OK.
312  }
313  return SuccBB;
314 }
315 
317  PHINode *P = empty() ? nullptr : dyn_cast<PHINode>(&*begin());
318  return make_range<phi_iterator>(P, nullptr);
319 }
320 
322  bool KeepOneInputPHIs) {
323  // Use hasNUsesOrMore to bound the cost of this assertion for complex CFGs.
324  assert((hasNUsesOrMore(16) || llvm::is_contained(predecessors(this), Pred)) &&
325  "Pred is not a predecessor!");
326 
327  // Return early if there are no PHI nodes to update.
328  if (empty() || !isa<PHINode>(begin()))
329  return;
330 
331  unsigned NumPreds = cast<PHINode>(front()).getNumIncomingValues();
332  for (PHINode &Phi : make_early_inc_range(phis())) {
333  Phi.removeIncomingValue(Pred, !KeepOneInputPHIs);
334  if (KeepOneInputPHIs)
335  continue;
336 
337  // If we have a single predecessor, removeIncomingValue may have erased the
338  // PHI node itself.
339  if (NumPreds == 1)
340  continue;
341 
342  // Try to replace the PHI node with a constant value.
343  if (Value *PhiConstant = Phi.hasConstantValue()) {
344  Phi.replaceAllUsesWith(PhiConstant);
345  Phi.eraseFromParent();
346  }
347  }
348 }
349 
351  const Instruction *FirstNonPHI = getFirstNonPHI();
352  if (isa<LandingPadInst>(FirstNonPHI))
353  return true;
354  // This is perhaps a little conservative because constructs like
355  // CleanupBlockInst are pretty easy to split. However, SplitBlockPredecessors
356  // cannot handle such things just yet.
357  if (FirstNonPHI->isEHPad())
358  return false;
359  return true;
360 }
361 
363  auto *Term = getTerminator();
364  // No terminator means the block is under construction.
365  if (!Term)
366  return true;
367 
368  // If the block has no successors, there can be no instructions to hoist.
369  assert(Term->getNumSuccessors() > 0);
370 
371  // Instructions should not be hoisted across exception handling boundaries.
372  return !Term->isExceptionalTerminator();
373 }
374 
376  const Function *F = getParent();
377  assert(F && "Block must have a parent function to use this API");
378  return this == &F->getEntryBlock();
379 }
380 
382  bool Before) {
383  if (Before)
384  return splitBasicBlockBefore(I, BBName);
385 
386  assert(getTerminator() && "Can't use splitBasicBlock on degenerate BB!");
387  assert(I != InstList.end() &&
388  "Trying to get me to create degenerate basic block!");
389 
391  this->getNextNode());
392 
393  // Save DebugLoc of split point before invalidating iterator.
394  DebugLoc Loc = I->getDebugLoc();
395  // Move all of the specified instructions from the original basic block into
396  // the new basic block.
397  New->getInstList().splice(New->end(), this->getInstList(), I, end());
398 
399  // Add a branch instruction to the newly formed basic block.
400  BranchInst *BI = BranchInst::Create(New, this);
401  BI->setDebugLoc(Loc);
402 
403  // Now we must loop through all of the successors of the New block (which
404  // _were_ the successors of the 'this' block), and update any PHI nodes in
405  // successors. If there were PHI nodes in the successors, then they need to
406  // know that incoming branches will be from New, not from Old (this).
407  //
408  New->replaceSuccessorsPhiUsesWith(this, New);
409  return New;
410 }
411 
413  assert(getTerminator() &&
414  "Can't use splitBasicBlockBefore on degenerate BB!");
415  assert(I != InstList.end() &&
416  "Trying to get me to create degenerate basic block!");
417 
418  assert((!isa<PHINode>(*I) || getSinglePredecessor()) &&
419  "cannot split on multi incoming phis");
420 
421  BasicBlock *New = BasicBlock::Create(getContext(), BBName, getParent(), this);
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(), begin(), I);
427 
428  // Loop through all of the predecessors of the 'this' block (which will be the
429  // predecessors of the New block), replace the specified successor 'this'
430  // block to point at the New block and update any PHI nodes in 'this' block.
431  // If there were PHI nodes in 'this' block, the PHI nodes are updated
432  // to reflect that the incoming branches will be from the New block and not
433  // from predecessors of the 'this' block.
434  for (BasicBlock *Pred : predecessors(this)) {
435  Instruction *TI = Pred->getTerminator();
436  TI->replaceSuccessorWith(this, New);
437  this->replacePhiUsesWith(Pred, New);
438  }
439  // Add a branch instruction from "New" to "this" Block.
440  BranchInst *BI = BranchInst::Create(this, New);
441  BI->setDebugLoc(Loc);
442 
443  return New;
444 }
445 
447  // N.B. This might not be a complete BasicBlock, so don't assume
448  // that it ends with a non-phi instruction.
449  for (iterator II = begin(), IE = end(); II != IE; ++II) {
450  PHINode *PN = dyn_cast<PHINode>(II);
451  if (!PN)
452  break;
453  PN->replaceIncomingBlockWith(Old, New);
454  }
455 }
456 
458  BasicBlock *New) {
459  Instruction *TI = getTerminator();
460  if (!TI)
461  // Cope with being called on a BasicBlock that doesn't have a terminator
462  // yet. Clang's CodeGenFunction::EmitReturnBlock() likes to do this.
463  return;
464  for (BasicBlock *Succ : successors(TI))
465  Succ->replacePhiUsesWith(Old, New);
466 }
467 
469  this->replaceSuccessorsPhiUsesWith(this, New);
470 }
471 
473  return isa<LandingPadInst>(getFirstNonPHI());
474 }
475 
477  return dyn_cast<LandingPadInst>(getFirstNonPHI());
478 }
479 
481  const Instruction *TI = getTerminator();
482  if (MDNode *MDIrrLoopHeader =
483  TI->getMetadata(LLVMContext::MD_irr_loop)) {
484  MDString *MDName = cast<MDString>(MDIrrLoopHeader->getOperand(0));
485  if (MDName->getString().equals("loop_header_weight")) {
486  auto *CI = mdconst::extract<ConstantInt>(MDIrrLoopHeader->getOperand(1));
487  return Optional<uint64_t>(CI->getValue().getZExtValue());
488  }
489  }
490  return Optional<uint64_t>();
491 }
492 
494  while (isa<DbgInfoIntrinsic>(It))
495  ++It;
496  return It;
497 }
498 
500  unsigned Order = 0;
501  for (Instruction &I : *this)
502  I.Order = Order++;
503 
504  // Set the bit to indicate that the instruction order valid and cached.
505  BasicBlockBits Bits = getBasicBlockBits();
506  Bits.InstrOrderValid = true;
507  setBasicBlockBits(Bits);
508 }
509 
510 #ifndef NDEBUG
511 /// In asserts builds, this checks the numbering. In non-asserts builds, it
512 /// is defined as a no-op inline function in BasicBlock.h.
514  if (!isInstrOrderValid())
515  return;
516  const Instruction *Prev = nullptr;
517  for (const Instruction &I : *this) {
518  assert((!Prev || Prev->comesBefore(&I)) &&
519  "cached instruction ordering is incorrect");
520  Prev = &I;
521  }
522 }
523 #endif
llvm::SuccIterator
Definition: CFG.h:139
llvm::BasicBlock::getTerminatingDeoptimizeCall
const CallInst * getTerminatingDeoptimizeCall() const
Returns the call instruction calling @llvm.experimental.deoptimize prior to the terminating return in...
Definition: BasicBlock.cpp:185
llvm::BasicBlock::end
iterator end()
Definition: BasicBlock.h:298
llvm::predecessors
pred_range predecessors(BasicBlock *BB)
Definition: CFG.h:127
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::Instruction::replaceSuccessorWith
void replaceSuccessorWith(BasicBlock *OldBB, BasicBlock *NewBB)
Replace specified successor OldBB to point at the provided block.
Definition: Instruction.cpp:801
llvm::ReturnInst
Return a value (possibly void), from a function.
Definition: Instructions.h:2986
llvm::BasicBlock::getFirstNonPHIOrDbg
const Instruction * getFirstNonPHIOrDbg(bool SkipPseudoOp=false) const
Returns a pointer to the first instruction in this block that is not a PHINode or a debug intrinsic,...
Definition: BasicBlock.cpp:219
llvm::BasicBlock::iterator
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:90
llvm::BasicBlock::getParent
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:107
IntrinsicInst.h
llvm::hasNItems
bool hasNItems(IterTy &&Begin, IterTy &&End, unsigned N, Pred &&ShouldBeCounted=[](const decltype(*std::declval< IterTy >()) &) { return true;}, std::enable_if_t< !std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< std::remove_reference_t< decltype(Begin)>>::iterator_category >::value, void > *=nullptr)
Return true if the sequence [Begin, End) has exactly N items.
Definition: STLExtras.h:2050
llvm::Function::getBasicBlockList
const BasicBlockListType & getBasicBlockList() const
Get the underlying elements of the Function...
Definition: Function.h:710
llvm::succ_end
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:102
llvm::Function
Definition: Function.h:61
llvm::BasicBlock::hasNPredecessorsOrMore
bool hasNPredecessorsOrMore(unsigned N) const
Return true if this block has N predecessors or more.
Definition: BasicBlock.cpp:290
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::ReturnInst::getReturnValue
Value * getReturnValue() const
Convenience accessor. Returns null if there is no return value.
Definition: Instructions.h:3031
llvm::ilist_node_with_parent< BasicBlock, Function >::getNextNode
BasicBlock * getNextNode()
Get the next node, or nullptr for the list tail.
Definition: ilist_node.h:288
llvm::BasicBlock::empty
bool empty() const
Definition: BasicBlock.h:307
llvm::LandingPadInst
The landingpad instruction holds all of the information necessary to generate correct exception handl...
Definition: Instructions.h:2885
llvm::BasicBlock::replaceSuccessorsPhiUsesWith
void replaceSuccessorsPhiUsesWith(BasicBlock *Old, BasicBlock *New)
Update all phi nodes in this basic block's successors to refer to basic block New instead of basic bl...
Definition: BasicBlock.cpp:457
llvm::BasicBlock::sizeWithoutDebug
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:120
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::filter_iterator_impl
Specialization of filter_iterator_base for forward iteration only.
Definition: STLExtras.h:416
llvm::BasicBlock::eraseFromParent
SymbolTableList< BasicBlock >::iterator eraseFromParent()
Unlink 'this' from the containing function and delete it.
Definition: BasicBlock.cpp:129
llvm::tgtok::Bits
@ Bits
Definition: TGLexer.h:50
llvm::BasicBlock::getSingleSuccessor
const BasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
Definition: BasicBlock.cpp:294
llvm::Instruction::comesBefore
bool comesBefore(const Instruction *Other) const
Given an instruction Other in the same basic block as this instruction, return true if this instructi...
Definition: Instruction.cpp:111
llvm::BasicBlock::splitBasicBlock
BasicBlock * splitBasicBlock(iterator I, const Twine &BBName="", bool Before=false)
Split the basic block into two basic blocks at the specified instruction.
Definition: BasicBlock.cpp:381
llvm::Optional< uint64_t >
llvm::SmallPtrSet< const BasicBlock *, 8 >
llvm::BasicBlock::getSinglePredecessor
const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:264
STLExtras.h
llvm::BasicBlock::hasNPredecessors
bool hasNPredecessors(unsigned N) const
Return true if this block has exactly N predecessors.
Definition: BasicBlock.cpp:286
llvm::successors
succ_range successors(Instruction *I)
Definition: CFG.h:262
llvm::BasicBlock::canSplitPredecessors
bool canSplitPredecessors() const
Definition: BasicBlock.cpp:350
llvm::BasicBlock::splitBasicBlockBefore
BasicBlock * splitBasicBlockBefore(iterator I, const Twine &BBName="")
Split the basic block into two basic blocks at the specified instruction and insert the new basic blo...
Definition: BasicBlock.cpp:412
llvm::Type::getInt32Ty
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:203
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::BasicBlock::getUniqueSuccessor
const BasicBlock * getUniqueSuccessor() const
Return the successor of this block if it has a unique successor.
Definition: BasicBlock.cpp:302
llvm::invalidateParentIListOrdering
void invalidateParentIListOrdering(ParentClass *Parent)
Notify basic blocks when an instruction is inserted.
Definition: SymbolTableListTraitsImpl.h:25
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
Constants.h
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::ConstantExpr::getIntToPtr
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2194
llvm::BasicBlock::begin
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:296
llvm::BasicBlock::isLandingPad
bool isLandingPad() const
Return true if this basic block is a landing pad.
Definition: BasicBlock.cpp:472
SymbolTableListTraitsImpl.h
llvm::BasicBlock::getFirstInsertionPt
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:249
llvm::PHINode::replaceIncomingBlockWith
void replaceIncomingBlockWith(const BasicBlock *Old, BasicBlock *New)
Replace every incoming basic block Old to basic block New.
Definition: Instructions.h:2774
llvm::skipDebugIntrinsics
BasicBlock::iterator skipDebugIntrinsics(BasicBlock::iterator It)
Advance It while it points to a debug instruction and return the result.
Definition: BasicBlock.cpp:493
llvm::BasicBlock::getValueSymbolTable
ValueSymbolTable * getValueSymbolTable()
Returns a pointer to the symbol table if one exists.
Definition: BasicBlock.cpp:26
llvm::Instruction
Definition: Instruction.h:45
llvm::BasicBlock::phis
iterator_range< const_phi_iterator > phis() const
Returns a range that iterates over the phis in the basic block.
Definition: BasicBlock.h:354
llvm::ConstantInt::get
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:900
llvm::hasNItemsOrMore
bool hasNItemsOrMore(IterTy &&Begin, IterTy &&End, unsigned N, Pred &&ShouldBeCounted=[](const decltype(*std::declval< IterTy >()) &) { return true;}, std::enable_if_t< !std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< std::remove_reference_t< decltype(Begin)>>::iterator_category >::value, void > *=nullptr)
Return true if the sequence [Begin, End) has N or more items.
Definition: STLExtras.h:2075
llvm::BasicBlock::getModule
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:144
llvm::BasicBlock::getFirstNonPHI
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:212
llvm::M68kBeads::Term
@ Term
Definition: M68kBaseInfo.h:71
llvm::Value::use_empty
bool use_empty() const
Definition: Value.h:345
Type.h
llvm::BasicBlock::getPostdominatingDeoptimizeCall
const CallInst * getPostdominatingDeoptimizeCall() const
Returns the call instruction calling @llvm.experimental.deoptimize that is present either in current ...
Definition: BasicBlock.cpp:200
llvm::BasicBlock::renumberInstructions
void renumberInstructions()
Renumber instructions and mark the ordering as valid.
Definition: BasicBlock.cpp:499
llvm::StringRef::equals
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:187
llvm::Instruction::getMetadata
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:282
CFG.h
llvm::ARM_PROC::IE
@ IE
Definition: ARMBaseInfo.h:27
llvm::BasicBlock::isEntryBlock
bool isEntryBlock() const
Return true if this is the entry block of the containing function.
Definition: BasicBlock.cpp:375
llvm::Value::user_back
User * user_back()
Definition: Value.h:408
llvm::BasicBlock::hasAddressTaken
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches,...
Definition: BasicBlock.h:448
BasicBlock.h
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::SymbolTableListTraits
Definition: GlobalAlias.h:25
llvm::BasicBlock::removeFromParent
void removeFromParent()
Unlink 'this' from the containing function, but do not delete it.
Definition: BasicBlock.cpp:125
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:572
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::Value::hasNUsesOrMore
bool hasNUsesOrMore(unsigned N) const
Return true if this value has N uses or more.
Definition: Value.cpp:153
llvm::BasicBlock::isLegalToHoistInto
bool isLegalToHoistInto() const
Return true if it is legal to hoist instructions into this block.
Definition: BasicBlock.cpp:362
llvm::BranchInst::Create
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
Definition: Instructions.h:3124
llvm::BasicBlock::isInstrOrderValid
bool isInstrOrderValid() const
Returns true if the Order field of child Instructions is valid.
Definition: BasicBlock.h:490
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::succ_begin
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:99
llvm::make_early_inc_range
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
Definition: STLExtras.h:576
llvm::is_contained
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1616
llvm::Instruction::setDebugLoc
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:367
llvm::ilist_node_with_parent::getPrevNode
NodeTy * getPrevNode()
Definition: ilist_node.h:274
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
SI
StandardInstrumentations SI(Debug, VerifyEach)
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:83
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::MDNode
Metadata node.
Definition: Metadata.h:906
llvm::BasicBlock::~BasicBlock
~BasicBlock()
Definition: BasicBlock.cpp:67
llvm::BasicBlock::getFirstNonPHIOrDbgOrLifetime
const Instruction * getFirstNonPHIOrDbgOrLifetime(bool SkipPseudoOp=false) const
Returns a pointer to the first instruction in this block that is not a PHINode, a debug intrinsic,...
Definition: BasicBlock.cpp:233
llvm::BlockAddress
The address of a basic block.
Definition: Constants.h:848
llvm::BasicBlock::instructionsWithoutDebug
iterator_range< filter_iterator< BasicBlock::const_iterator, std::function< bool(const Instruction &)> > > instructionsWithoutDebug(bool SkipPseudoOp=false) const
Return a const iterator range over the instructions in the block, skipping any debug instructions.
Definition: BasicBlock.cpp:100
llvm::BasicBlock::moveAfter
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:138
this
Analysis the ScalarEvolution expression for r is this
Definition: README.txt:8
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:256
llvm::BasicBlock::getUniquePredecessor
const BasicBlock * getUniquePredecessor() const
Return the predecessor of this block if it has a unique predecessor block.
Definition: BasicBlock.cpp:272
llvm::Value::replaceAllUsesWith
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:532
llvm::BasicBlock::Create
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:100
llvm::ilist_node_impl::getIterator
self_iterator getIterator()
Definition: ilist_node.h:81
llvm::BasicBlock::validateInstrOrdering
void validateInstrOrdering() const
Asserts that instruction order numbers are marked invalid, or that they are in ascending order.
Definition: BasicBlock.cpp:513
llvm::PredIterator
Definition: CFG.h:43
llvm::BasicBlock::dropAllReferences
void dropAllReferences()
Cause all subinstructions to "let go" of all the references that said subinstructions are maintaining...
Definition: BasicBlock.cpp:259
llvm::Type::getContext
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:127
llvm::BasicBlock::getTerminator
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:148
llvm::make_filter_range
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:490
llvm::BasicBlock::front
const Instruction & front() const
Definition: BasicBlock.h:308
llvm::BasicBlock::getContext
LLVMContext & getContext() const
Get the context in which this basic block lives.
Definition: BasicBlock.cpp:32
llvm::BasicBlock::replacePhiUsesWith
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:446
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::ilist_iterator
Iterator for intrusive lists based on ilist_node.
Definition: ilist_iterator.h:57
llvm::pred_end
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:112
llvm::Instruction::isEHPad
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
Definition: Instruction.h:661
llvm::pred_begin
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:109
Instructions.h
llvm::BasicBlock::moveBefore
void moveBefore(BasicBlock *MovePos)
Unlink this basic block from its current function and insert it into the function that MovePos lives ...
Definition: BasicBlock.cpp:133
llvm::ValueSymbolTable
This class provides a symbol table of name/value pairs.
Definition: ValueSymbolTable.h:37
N
#define N
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
llvm::PHINode
Definition: Instructions.h:2633
llvm::BasicBlock::removePredecessor
void removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs=false)
Update PHI nodes in this BasicBlock before removal of predecessor Pred.
Definition: BasicBlock.cpp:321
llvm::BasicBlock::getIrrLoopHeaderWeight
Optional< uint64_t > getIrrLoopHeaderWeight() const
Definition: BasicBlock.cpp:480
llvm::BasicBlock::getLandingPadInst
const LandingPadInst * getLandingPadInst() const
Return the landingpad instruction associated with the landing pad.
Definition: BasicBlock.cpp:476
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1475
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
LLVMContext.h
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::User::getOperand
Value * getOperand(unsigned i) const
Definition: User.h:169
llvm::BasicBlock::getTerminatingMustTailCall
const CallInst * getTerminatingMustTailCall() const
Returns the call instruction marked 'musttail' prior to the terminating return instruction of this ba...
Definition: BasicBlock.cpp:154
llvm::MDString::getString
StringRef getString() const
Definition: Metadata.cpp:483
llvm::BranchInst
Conditional or Unconditional Branch instruction.
Definition: Instructions.h:3068
llvm::MDString
A single uniqued string.
Definition: Metadata.h:611
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::Constant::destroyConstant
void destroyConstant()
Called if some element of this constant is no longer valid.
Definition: Constants.cpp:461
llvm::BasicBlock::const_iterator
InstListType::const_iterator const_iterator
Definition: BasicBlock.h:91
llvm::SmallPtrSetImpl::insert
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:364