LLVM  13.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  bool Before) {
377  if (Before)
378  return splitBasicBlockBefore(I, BBName);
379 
380  assert(getTerminator() && "Can't use splitBasicBlock on degenerate BB!");
381  assert(I != InstList.end() &&
382  "Trying to get me to create degenerate basic block!");
383 
385  this->getNextNode());
386 
387  // Save DebugLoc of split point before invalidating iterator.
388  DebugLoc Loc = I->getDebugLoc();
389  // Move all of the specified instructions from the original basic block into
390  // the new basic block.
391  New->getInstList().splice(New->end(), this->getInstList(), I, end());
392 
393  // Add a branch instruction to the newly formed basic block.
394  BranchInst *BI = BranchInst::Create(New, this);
395  BI->setDebugLoc(Loc);
396 
397  // Now we must loop through all of the successors of the New block (which
398  // _were_ the successors of the 'this' block), and update any PHI nodes in
399  // successors. If there were PHI nodes in the successors, then they need to
400  // know that incoming branches will be from New, not from Old (this).
401  //
402  New->replaceSuccessorsPhiUsesWith(this, New);
403  return New;
404 }
405 
407  assert(getTerminator() &&
408  "Can't use splitBasicBlockBefore on degenerate BB!");
409  assert(I != InstList.end() &&
410  "Trying to get me to create degenerate basic block!");
411 
412  assert((!isa<PHINode>(*I) || getSinglePredecessor()) &&
413  "cannot split on multi incoming phis");
414 
415  BasicBlock *New = BasicBlock::Create(getContext(), BBName, getParent(), this);
416  // Save DebugLoc of split point before invalidating iterator.
417  DebugLoc Loc = I->getDebugLoc();
418  // Move all of the specified instructions from the original basic block into
419  // the new basic block.
420  New->getInstList().splice(New->end(), this->getInstList(), begin(), I);
421 
422  // Loop through all of the predecessors of the 'this' block (which will be the
423  // predecessors of the New block), replace the specified successor 'this'
424  // block to point at the New block and update any PHI nodes in 'this' block.
425  // If there were PHI nodes in 'this' block, the PHI nodes are updated
426  // to reflect that the incoming branches will be from the New block and not
427  // from predecessors of the 'this' block.
428  for (BasicBlock *Pred : predecessors(this)) {
429  Instruction *TI = Pred->getTerminator();
430  TI->replaceSuccessorWith(this, New);
431  this->replacePhiUsesWith(Pred, New);
432  }
433  // Add a branch instruction from "New" to "this" Block.
434  BranchInst *BI = BranchInst::Create(this, New);
435  BI->setDebugLoc(Loc);
436 
437  return New;
438 }
439 
441  // N.B. This might not be a complete BasicBlock, so don't assume
442  // that it ends with a non-phi instruction.
443  for (iterator II = begin(), IE = end(); II != IE; ++II) {
444  PHINode *PN = dyn_cast<PHINode>(II);
445  if (!PN)
446  break;
447  PN->replaceIncomingBlockWith(Old, New);
448  }
449 }
450 
452  BasicBlock *New) {
453  Instruction *TI = getTerminator();
454  if (!TI)
455  // Cope with being called on a BasicBlock that doesn't have a terminator
456  // yet. Clang's CodeGenFunction::EmitReturnBlock() likes to do this.
457  return;
458  for (BasicBlock *Succ : successors(TI))
459  Succ->replacePhiUsesWith(Old, New);
460 }
461 
463  this->replaceSuccessorsPhiUsesWith(this, New);
464 }
465 
467  return isa<LandingPadInst>(getFirstNonPHI());
468 }
469 
471  return dyn_cast<LandingPadInst>(getFirstNonPHI());
472 }
473 
475  const Instruction *TI = getTerminator();
476  if (MDNode *MDIrrLoopHeader =
477  TI->getMetadata(LLVMContext::MD_irr_loop)) {
478  MDString *MDName = cast<MDString>(MDIrrLoopHeader->getOperand(0));
479  if (MDName->getString().equals("loop_header_weight")) {
480  auto *CI = mdconst::extract<ConstantInt>(MDIrrLoopHeader->getOperand(1));
481  return Optional<uint64_t>(CI->getValue().getZExtValue());
482  }
483  }
484  return Optional<uint64_t>();
485 }
486 
488  while (isa<DbgInfoIntrinsic>(It))
489  ++It;
490  return It;
491 }
492 
494  unsigned Order = 0;
495  for (Instruction &I : *this)
496  I.Order = Order++;
497 
498  // Set the bit to indicate that the instruction order valid and cached.
499  BasicBlockBits Bits = getBasicBlockBits();
500  Bits.InstrOrderValid = true;
501  setBasicBlockBits(Bits);
502 }
503 
504 #ifndef NDEBUG
505 /// In asserts builds, this checks the numbering. In non-asserts builds, it
506 /// is defined as a no-op inline function in BasicBlock.h.
508  if (!isInstrOrderValid())
509  return;
510  const Instruction *Prev = nullptr;
511  for (const Instruction &I : *this) {
512  assert((!Prev || Prev->comesBefore(&I)) &&
513  "cached instruction ordering is incorrect");
514  Prev = &I;
515  }
516 }
517 #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
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:772
llvm::ReturnInst
Return a value (possibly void), from a function.
Definition: Instructions.h:2923
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:1953
llvm::Function::getBasicBlockList
const BasicBlockListType & getBasicBlockList() const
Get the underlying elements of the Function...
Definition: Function.h:745
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:2968
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:2822
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:451
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:46
llvm::filter_iterator_impl
Specialization of filter_iterator_base for forward iteration only.
Definition: STLExtras.h:421
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:375
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:406
llvm::Type::getInt32Ty
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:204
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:2193
llvm::BasicBlock::begin
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:296
SI
@ SI
Definition: SIInstrInfo.cpp:7342
llvm::BasicBlock::isLandingPad
bool isLandingPad() const
Return true if this basic block is a landing pad.
Definition: BasicBlock.cpp:466
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:2711
llvm::skipDebugIntrinsics
BasicBlock::iterator skipDebugIntrinsics(BasicBlock::iterator It)
Advance It while it points to a debug instruction and return the result.
Definition: BasicBlock.cpp:487
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:885
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:1978
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::Value::use_empty
bool use_empty() const
Definition: Value.h:357
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:493
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:190
llvm::Instruction::getMetadata
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:277
CFG.h
llvm::ARM_PROC::IE
@ IE
Definition: ARMBaseInfo.h:27
llvm::Value::user_back
User * user_back()
Definition: Value.h:420
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:154
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:3061
llvm::BasicBlock::isInstrOrderValid
bool isInstrOrderValid() const
Returns true if the Order field of child Instructions is valid.
Definition: BasicBlock.h:486
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:581
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:1570
llvm::Instruction::setDebugLoc
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:362
llvm::ilist_node_with_parent::getPrevNode
NodeTy * getPrevNode()
Definition: ilist_node.h:274
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
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:897
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:847
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::M68kBeads::Term
@ Term
Definition: M68kBaseInfo.h:71
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:526
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:507
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:128
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:495
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:440
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
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:644
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:2572
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:474
llvm::BasicBlock::getLandingPadInst
const LandingPadInst * getLandingPadInst() const
Return the landingpad instruction associated with the landing pad.
Definition: BasicBlock.cpp:470
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1450
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:477
llvm::BranchInst
Conditional or Unconditional Branch instruction.
Definition: Instructions.h:3005
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:458
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