LLVM  6.0.0svn
Classes | Namespaces | Functions
Local.h File Reference
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/GetElementPtrTypeIterator.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Operator.h"
Include dependency graph for Local.h:

Go to the source code of this file.

Classes

class  llvm::SmallVectorImpl< T >
 This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter. 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)
 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)
 If the specified value is a trivially dead instruction, delete it. 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)
 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, DominatorTree *DT=nullptr)
 BB is a block with one predecessor and its predecessor is known to have one successor (BB!). More...
 
bool llvm::TryToSimplifyUncondBranchFromEmptyBlock (BasicBlock *BB)
 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, unsigned BonusInstThreshold, AssumptionCache *AC=nullptr, SmallPtrSetImpl< BasicBlock *> *LoopHeaders=nullptr, bool LateSimplifyCFG=false)
 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...
 
static 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...
 
template<typename IRBuilderTy >
Value * llvm::EmitGEPOffset (IRBuilderTy *Builder, const DataLayout &DL, User *GEP, bool NoAssumptions=false)
 Given a getelementptr instruction/constantexpr, emit the code necessary to compute the offset from the base pointer (without adding in the base pointer). More...
 
void llvm::ConvertDebugDeclareToDebugValue (DbgDeclareInst *DDI, StoreInst *SI, DIBuilder &Builder)
 ===---------------------------------------------------------------——===// Dbg Intrinsic utilities More...
 
void llvm::ConvertDebugDeclareToDebugValue (DbgDeclareInst *DDI, LoadInst *LI, DIBuilder &Builder)
 Inserts a llvm.dbg.value intrinsic before a load of an alloca'd value that has an associated llvm.dbg.decl intrinsic. More...
 
void llvm::ConvertDebugDeclareToDebugValue (DbgDeclareInst *DDI, PHINode *LI, DIBuilder &Builder)
 Inserts a llvm.dbg.value intrinsic after a phi of an alloca'd value that has an associated llvm.dbg.decl intrinsic. More...
 
bool llvm::LowerDbgDeclare (Function &F)
 Lowers llvm.dbg.declare intrinsics into appropriate set of llvm.dbg.value intrinsics. More...
 
DbgDeclareInstllvm::FindAllocaDbgDeclare (Value *V)
 Finds the llvm.dbg.declare intrinsic corresponding to an alloca, if any. More...
 
void llvm::findDbgValues (SmallVectorImpl< DbgValueInst *> &DbgValues, Value *V)
 Finds the llvm.dbg.value intrinsics describing a value. More...
 
bool llvm::replaceDbgDeclare (Value *Address, Value *NewAddress, Instruction *InsertBefore, DIBuilder &Builder, bool Deref, int Offset)
 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 Deref, int Offset=0)
 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...
 
void llvm::salvageDebugInfo (Instruction &I)
 Assuming the instruction I is going to be deleted, attempt to salvage any dbg.value intrinsics referring to I by rewriting its effect into a DIExpression. 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)
 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)
 Replace 'BB's terminator with one that does not have an unwind successor block. More...
 
bool llvm::removeUnreachableBlocks (Function &F, LazyValueInfo *LVI=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)
 Combine the metadata of two instructions so that K can replace J. More...
 
void llvm::combineMetadataForCSE (Instruction *K, const Instruction *J)
 Combine the metadata of two instructions so that K can replace J. 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)
 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...
 
bool llvm::recognizeBSwapOrBitReverseIdiom (Instruction *I, bool MatchBSwaps, bool MatchBitReversals, SmallVectorImpl< Instruction *> &InsertedInsts)
 Try and 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...