LLVM  8.0.0svn
Classes | Namespaces | Functions
Local.h File Reference
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/TinyPtrVector.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/Utils/Local.h"
#include "llvm/IR/CallSite.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DomTreeUpdater.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/GetElementPtrTypeIterator.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/User.h"
#include "llvm/IR/Value.h"
#include "llvm/Support/Casting.h"
#include <cstdint>
#include <limits>
Include dependency graph for Local.h:

Go to the source code of this file.

Classes

struct  llvm::SimplifyCFGOptions
 A set of parameters used to control the transforms in the SimplifyCFG pass. More...
 

Namespaces

 llvm
 Compute iterated dominance frontiers using a linear time algorithm.
 

Functions

bool llvm::ConstantFoldTerminator (BasicBlock *BB, bool DeleteDeadConditions=false, const TargetLibraryInfo *TLI=nullptr, DomTreeUpdater *DTU=nullptr)
 If a terminator instruction is predicated on a constant value, convert it into an unconditional branch to the constant destination. More...
 
bool llvm::isInstructionTriviallyDead (Instruction *I, const TargetLibraryInfo *TLI=nullptr)
 Return true if the result produced by the instruction is not used, and the instruction has no side effects. More...
 
bool llvm::wouldInstructionBeTriviallyDead (Instruction *I, const TargetLibraryInfo *TLI=nullptr)
 Return true if the result produced by the instruction would have no side effects if it was not used. More...
 
bool llvm::RecursivelyDeleteTriviallyDeadInstructions (Value *V, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr)
 If the specified value is a trivially dead instruction, delete it. More...
 
void llvm::RecursivelyDeleteTriviallyDeadInstructions (SmallVectorImpl< Instruction *> &DeadInsts, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr)
 Delete all of the instructions in DeadInsts, and all other instructions that deleting these in turn causes to be trivially dead. More...
 
bool llvm::RecursivelyDeleteDeadPHINode (PHINode *PN, const TargetLibraryInfo *TLI=nullptr)
 If the specified value is an effectively dead PHI node, due to being a def-use chain of single-use nodes that either forms a cycle or is terminated by a trivially dead instruction, delete it. More...
 
bool llvm::SimplifyInstructionsInBlock (BasicBlock *BB, const TargetLibraryInfo *TLI=nullptr)
 Scan the specified basic block and try to simplify any instructions in it and recursively delete dead instructions. More...
 
void llvm::RemovePredecessorAndSimplify (BasicBlock *BB, BasicBlock *Pred, DomTreeUpdater *DTU=nullptr)
 Like BasicBlock::removePredecessor, this method is called when we're about to delete Pred as a predecessor of BB. More...
 
void llvm::MergeBasicBlockIntoOnlyPred (BasicBlock *BB, DomTreeUpdater *DTU=nullptr)
 BB is a block with one predecessor and its predecessor is known to have one successor (BB!). More...
 
bool llvm::TryToSimplifyUncondBranchFromEmptyBlock (BasicBlock *BB, DomTreeUpdater *DTU=nullptr)
 BB is known to contain an unconditional branch, and contains no instructions other than PHI nodes, potential debug intrinsics and the branch. More...
 
bool llvm::EliminateDuplicatePHINodes (BasicBlock *BB)
 Check for and eliminate duplicate PHI nodes in this block. More...
 
bool llvm::simplifyCFG (BasicBlock *BB, const TargetTransformInfo &TTI, const SimplifyCFGOptions &Options={}, SmallPtrSetImpl< BasicBlock *> *LoopHeaders=nullptr)
 This function is used to do simplification of a CFG. More...
 
bool llvm::FlattenCFG (BasicBlock *BB, AliasAnalysis *AA=nullptr)
 This function is used to flatten a CFG. More...
 
bool llvm::FoldBranchToCommonDest (BranchInst *BI, unsigned BonusInstThreshold=1)
 If this basic block is ONLY a setcc and a branch, and if a predecessor branches to us and one of our successors, fold the setcc into the predecessor and use logical operations to pick the right destination. More...
 
AllocaInstllvm::DemoteRegToStack (Instruction &X, bool VolatileLoads=false, Instruction *AllocaPoint=nullptr)
 This function takes a virtual register computed by an Instruction and replaces it with a slot in the stack frame, allocated via alloca. More...
 
AllocaInstllvm::DemotePHIToStack (PHINode *P, Instruction *AllocaPoint=nullptr)
 This function takes a virtual register computed by a phi node and replaces it with a slot in the stack frame, allocated via alloca. More...
 
unsigned llvm::getOrEnforceKnownAlignment (Value *V, unsigned PrefAlign, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
 Try to ensure that the alignment of V is at least PrefAlign bytes. More...
 
unsigned llvm::getKnownAlignment (Value *V, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
 Try to infer an alignment for the specified pointer. More...
 
void llvm::ConvertDebugDeclareToDebugValue (DbgVariableIntrinsic *DII, StoreInst *SI, DIBuilder &Builder)
 ===---------------------------------------------------------------——===// Dbg Intrinsic utilities More...
 
void llvm::ConvertDebugDeclareToDebugValue (DbgVariableIntrinsic *DII, LoadInst *LI, DIBuilder &Builder)
 Inserts a llvm.dbg.value intrinsic before a load of an alloca'd value that has an associated llvm.dbg.declare or llvm.dbg.addr intrinsic. More...
 
void llvm::ConvertDebugDeclareToDebugValue (DbgVariableIntrinsic *DII, PHINode *LI, DIBuilder &Builder)
 Inserts a llvm.dbg.value intrinsic after a phi that has an associated llvm.dbg.declare or llvm.dbg.addr intrinsic. More...
 
bool llvm::LowerDbgDeclare (Function &F)
 Lowers llvm.dbg.declare intrinsics into appropriate set of llvm.dbg.value intrinsics. More...
 
void llvm::insertDebugValuesForPHIs (BasicBlock *BB, SmallVectorImpl< PHINode *> &InsertedPHIs)
 Propagate dbg.value intrinsics through the newly inserted PHIs. More...
 
TinyPtrVector< DbgVariableIntrinsic * > llvm::FindDbgAddrUses (Value *V)
 Finds all intrinsics declaring local variables as living in the memory that 'V' points to. More...
 
void llvm::findDbgValues (SmallVectorImpl< DbgValueInst *> &DbgValues, Value *V)
 Finds the llvm.dbg.value intrinsics describing a value. More...
 
void llvm::findDbgUsers (SmallVectorImpl< DbgVariableIntrinsic *> &DbgInsts, Value *V)
 Finds the debug info intrinsics describing a value. More...
 
bool llvm::replaceDbgDeclare (Value *Address, Value *NewAddress, Instruction *InsertBefore, DIBuilder &Builder, bool DerefBefore, int Offset, bool DerefAfter)
 Replaces llvm.dbg.declare instruction when the address it describes is replaced with a new value. More...
 
bool llvm::replaceDbgDeclareForAlloca (AllocaInst *AI, Value *NewAllocaAddress, DIBuilder &Builder, bool DerefBefore, int Offset, bool DerefAfter)
 Replaces llvm.dbg.declare instruction when the alloca it describes is replaced with a new value. More...
 
void llvm::replaceDbgValueForAlloca (AllocaInst *AI, Value *NewAllocaAddress, DIBuilder &Builder, int Offset=0)
 Replaces multiple llvm.dbg.value instructions when the alloca it describes is replaced with a new value. More...
 
bool llvm::salvageDebugInfo (Instruction &I)
 Assuming the instruction I is going to be deleted, attempt to salvage debug users of I by writing the effect of I in a DIExpression. More...
 
bool llvm::replaceAllDbgUsesWith (Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT)
 Point debug users of From to To or salvage them. More...
 
unsigned llvm::removeAllNonTerminatorAndEHPadInstructions (BasicBlock *BB)
 Remove all instructions from a basic block other than it's terminator and any present EH pad instructions. More...
 
unsigned llvm::changeToUnreachable (Instruction *I, bool UseLLVMTrap, bool PreserveLCSSA=false, DomTreeUpdater *DTU=nullptr)
 Insert an unreachable instruction before the specified instruction, making it and the rest of the code in the block dead. More...
 
BasicBlockllvm::changeToInvokeAndSplitBasicBlock (CallInst *CI, BasicBlock *UnwindEdge)
 Convert the CallInst to InvokeInst with the specified unwind edge basic block. More...
 
void llvm::removeUnwindEdge (BasicBlock *BB, DomTreeUpdater *DTU=nullptr)
 Replace 'BB's terminator with one that does not have an unwind successor block. More...
 
bool llvm::removeUnreachableBlocks (Function &F, LazyValueInfo *LVI=nullptr, DomTreeUpdater *DTU=nullptr, MemorySSAUpdater *MSSAU=nullptr)
 Remove all blocks that can not be reached from the function's entry. More...
 
void llvm::combineMetadata (Instruction *K, const Instruction *J, ArrayRef< unsigned > KnownIDs, bool DoesKMove)
 Combine the metadata of two instructions so that K can replace J. More...
 
void llvm::combineMetadataForCSE (Instruction *K, const Instruction *J, bool DoesKMove)
 Combine the metadata of two instructions so that K can replace J. More...
 
void llvm::patchReplacementInstruction (Instruction *I, Value *Repl)
 Patch the replacement so that it is not more restrictive than the value being replaced. More...
 
unsigned llvm::replaceNonLocalUsesWith (Instruction *From, Value *To)
 
unsigned llvm::replaceDominatedUsesWith (Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Edge)
 Replace each use of 'From' with 'To' if that use is dominated by the given edge. More...
 
unsigned llvm::replaceDominatedUsesWith (Value *From, Value *To, DominatorTree &DT, const BasicBlock *BB)
 Replace each use of 'From' with 'To' if that use is dominated by the end of the given BasicBlock. More...
 
bool llvm::callsGCLeafFunction (ImmutableCallSite CS, const TargetLibraryInfo &TLI)
 Return true if the CallSite CS calls a gc leaf function. More...
 
void llvm::copyNonnullMetadata (const LoadInst &OldLI, MDNode *N, LoadInst &NewLI)
 Copy a nonnull metadata node to a new load instruction. More...
 
void llvm::copyRangeMetadata (const DataLayout &DL, const LoadInst &OldLI, MDNode *N, LoadInst &NewLI)
 Copy a range metadata node to a new load instruction. More...
 
void llvm::dropDebugUsers (Instruction &I)
 Remove the debug intrinsic instructions for the given instruction. More...
 
void llvm::hoistAllInstructionsInto (BasicBlock *DomBlock, Instruction *InsertPt, BasicBlock *BB)
 Hoist all of the instructions in the IfBlock to the dominant block DomBlock, by moving its instructions to the insertion point InsertPt. More...
 
bool llvm::recognizeBSwapOrBitReverseIdiom (Instruction *I, bool MatchBSwaps, bool MatchBitReversals, SmallVectorImpl< Instruction *> &InsertedInsts)
 Try to match a bswap or bitreverse idiom. More...
 
void llvm::maybeMarkSanitizerLibraryCallNoBuiltin (CallInst *CI, const TargetLibraryInfo *TLI)
 Given a CallInst, check if it calls a string function known to CodeGen, and mark it with NoBuiltin if so. More...
 
bool llvm::canReplaceOperandWithVariable (const Instruction *I, unsigned OpIdx)
 Given an instruction, is it legal to set operand OpIdx to a non-constant value? More...