LLVM API Documentation
#include <AliasAnalysis.h>
Collaboration diagram for llvm::AliasAnalysis:
Public Types | |
enum | AliasResult { NoAlias = 0, MayAlias = 1, MustAlias = 2 } |
enum | ModRefResult { NoModRef = 0, Ref = 1, Mod = 2, ModRef = 3 } |
Public Member Functions | |
AliasAnalysis () | |
virtual | ~AliasAnalysis () |
const TargetData & | getTargetData () const |
virtual AliasResult | alias (const Value *V1, unsigned V1Size, const Value *V2, unsigned V2Size) |
virtual void | getMustAliases (Value *P, std::vector< Value * > &RetVals) |
virtual bool | pointsToConstantMemory (const Value *P) |
virtual bool | doesNotAccessMemory (Function *F) |
virtual bool | onlyReadsMemory (Function *F) |
virtual ModRefResult | getModRefInfo (CallSite CS, Value *P, unsigned Size) |
virtual ModRefResult | getModRefInfo (CallSite CS1, CallSite CS2) |
virtual bool | hasNoModRefInfoForCalls () const |
ModRefResult | getModRefInfo (LoadInst *L, Value *P, unsigned Size) |
Convenience functions... | |
ModRefResult | getModRefInfo (StoreInst *S, Value *P, unsigned Size) |
ModRefResult | getModRefInfo (CallInst *C, Value *P, unsigned Size) |
ModRefResult | getModRefInfo (InvokeInst *I, Value *P, unsigned Size) |
ModRefResult | getModRefInfo (Instruction *I, Value *P, unsigned Size) |
bool | canBasicBlockModify (const BasicBlock &BB, const Value *P, unsigned Size) |
bool | canInstructionRangeModify (const Instruction &I1, const Instruction &I2, const Value *Ptr, unsigned Size) |
virtual void | deleteValue (Value *V) |
virtual void | copyValue (Value *From, Value *To) |
void | replaceWithNewValue (Value *Old, Value *New) |
Protected Member Functions | |
void | InitializeAliasAnalysis (Pass *P) |
virtual void | getAnalysisUsage (AnalysisUsage &AU) const |
Protected Attributes | |
const TargetData * | TD |
AliasAnalysis * | AA |
Definition at line 42 of file AliasAnalysis.h.
|
Alias analysis result - Either we know for sure that it does not alias, we know for sure it must alias, or we don't know anything: The two pointers _might_ alias. This enum is designed so you can do things like: if (AA.alias(P1, P2)) { ... } to check to see if two pointers might alias. Definition at line 79 of file AliasAnalysis.h. |
|
ModRefResult - Represent the result of a mod/ref query. Mod and Ref are bits which may be or'd together. Definition at line 135 of file AliasAnalysis.h. |
|
Definition at line 60 of file AliasAnalysis.h. |
|
Definition at line 140 of file AliasAnalysis.cpp. |
|
alias - The main low level interface to the alias analysis implementation. Returns a Result indicating whether the two pointers are aliased to each other. This is the interface that must be implemented by specific alias analysis implementations. Definition at line 44 of file AliasAnalysis.cpp. Referenced by alias(), getModRefInfo(), and llvm::AliasSet::mergeSetIn(). |
|
canBasicBlockModify - Return true if it is possible for execution of the specified basic block to modify the value pointed to by Ptr. Definition at line 161 of file AliasAnalysis.cpp. References llvm::BasicBlock::back(), canInstructionRangeModify(), and llvm::BasicBlock::front(). Referenced by isPathTransparentTo(). |
|
canInstructionRangeModify - Return true if it is possible for the execution of the specified instructions to modify the value pointed to by Ptr. The instructions to consider are all of the instructions in the range of [I1,I2] INCLUSIVE. I1 and I2 must be in the same basic block. Definition at line 171 of file AliasAnalysis.cpp. References E, getModRefInfo(), llvm::Instruction::getParent(), I, and Mod. Referenced by canBasicBlockModify(). |
|
copyValue - This method should be used whenever a preexisting value in the program is copied or cloned, introducing a new value. Note that analysis implementations should tolerate clients that use this method to introduce the same value multiple times: if the analysis already knows about a value, it should ignore the request. Definition at line 80 of file AliasAnalysis.cpp. References AA, and copyValue(). Referenced by llvm::AliasSetTracker::copyValue(), copyValue(), and replaceWithNewValue(). |
|
deleteValue - This method should be called whenever an LLVM Value is deleted from the program, for example when an instruction is found to be redundant and is eliminated. Definition at line 75 of file AliasAnalysis.cpp. References AA, and deleteValue(). Referenced by llvm::AliasSetTracker::deleteValue(), deleteValue(), and replaceWithNewValue(). |
|
doesNotAccessMemory - If the specified function is known to never read or write memory, return true. If the function only reads from known-constant memory, it is also legal to return true. Functions that unwind the stack are not legal for this predicate. Many optimizations (such as CSE and LICM) can be performed on calls to it, without worrying about aliasing properties, and many functions have this property (e.g. 'sin' and 'cos'). This property corresponds to the GCC 'const' attribute. Definition at line 60 of file AliasAnalysis.cpp. References AA, and doesNotAccessMemory(). Referenced by llvm::AliasSetTracker::add(), doesNotAccessMemory(), getModRefInfo(), onlyReadsMemory(), and llvm::AliasSetTracker::remove(). |
|
Definition at line 153 of file AliasAnalysis.cpp. References llvm::AnalysisUsage::addRequired(). |
|
Definition at line 172 of file AliasAnalysis.h. References llvm::Instruction::Call, getModRefInfo(), llvm::Instruction::getOpcode(), llvm::Instruction::Load, NoModRef, and llvm::ISD::Store. |
|
Definition at line 169 of file AliasAnalysis.h. References getModRefInfo(). |
|
Definition at line 166 of file AliasAnalysis.h. References getModRefInfo(). |
|
Definition at line 104 of file AliasAnalysis.cpp. References alias(), llvm::User::getOperand(), llvm::Value::getType(), llvm::TargetData::getTypeSize(), Mod, NoModRef, pointsToConstantMemory(), and TD. |
|
Convenience functions...
Definition at line 98 of file AliasAnalysis.cpp. References alias(), llvm::User::getOperand(), llvm::Value::getType(), llvm::TargetData::getTypeSize(), NoModRef, Ref, and TD. |
|
getModRefInfo - Return information about whether two call sites may refer to the same set of memory locations. This function returns NoModRef if the two calls refer to disjoint memory locations, Ref if CS1 reads memory written by CS2, Mod if CS1 writes to memory read or written by CS2, or ModRef if CS1 might read or write memory accessed by CS2. Definition at line 86 of file AliasAnalysis.cpp. References AA, and getModRefInfo(). |
|
getModRefInfo (for call sites) - Return whether information about whether a particular call site modifies or reads the memory specified by the pointer. Definition at line 117 of file AliasAnalysis.cpp. References AA, doesNotAccessMemory(), F, llvm::CallSite::getCalledFunction(), getModRefInfo(), Mod, ModRef, NoModRef, onlyReadsMemory(), pointsToConstantMemory(), and Ref. Referenced by canInstructionRangeModify(), and getModRefInfo(). |
|
getMustAliases - If there are any pointers known that must alias this pointer, return them now. This allows alias-set based alias analyses to perform a form a value numbering (which is exposed by load-vn). If an alias analysis supports this, it should ADD any must aliased pointers to the specified vector. Definition at line 50 of file AliasAnalysis.cpp. References AA, and getMustAliases(). Referenced by getMustAliases(). |
|
getTargetData - Every alias analysis implementation depends on the size of data items in the current Target. This provides a uniform way to handle it. Definition at line 67 of file AliasAnalysis.h. References TD. Referenced by llvm::AliasSetTracker::add(), and llvm::AliasSetTracker::remove(). |
|
hasNoModRefInfoForCalls - Return true if the analysis has no mod/ref information for pairs of function calls (other than "pure" and "const" functions). This can be used by clients to avoid many pointless queries. Remember that if you override this and chain to another analysis, you must make sure that it doesn't have mod/ref info either. Definition at line 70 of file AliasAnalysis.cpp. References AA, and hasNoModRefInfoForCalls(). Referenced by hasNoModRefInfoForCalls(). |
|
InitializeAliasAnalysis - Subclasses must call this method to initialize the AliasAnalysis interface before any other methods are called. This is typically called by the run* methods of these subclasses. This may be called multiple times. Definition at line 145 of file AliasAnalysis.cpp. References AA, llvm::Pass::getAnalysis(), and TD. |
|
onlyReadsMemory - If the specified function is known to only read from non-volatile memory (or not access memory at all), return true. Functions that unwind the stack are not legal for this predicate. This property allows many common optimizations to be performed in the absence of interfering store instructions, such as CSE of strlen calls. This property corresponds to the GCC 'pure' attribute. Definition at line 65 of file AliasAnalysis.cpp. References AA, doesNotAccessMemory(), and onlyReadsMemory(). Referenced by getModRefInfo(), and onlyReadsMemory(). |
|
pointsToConstantMemory - If the specified pointer is known to point into constant global memory, return true. This allows disambiguation of store instructions from constant pointers. Definition at line 55 of file AliasAnalysis.cpp. References AA, and pointsToConstantMemory(). Referenced by getModRefInfo(), and pointsToConstantMemory(). |
|
replaceWithNewValue - This method is the obvious combination of the two above, and it provided as a helper to simplify client code. Definition at line 223 of file AliasAnalysis.h. References copyValue(), and deleteValue(). |
|
Definition at line 45 of file AliasAnalysis.h. Referenced by alias(), copyValue(), deleteValue(), doesNotAccessMemory(), getModRefInfo(), getMustAliases(), hasNoModRefInfoForCalls(), InitializeAliasAnalysis(), onlyReadsMemory(), and pointsToConstantMemory(). |
|
Definition at line 44 of file AliasAnalysis.h. Referenced by getModRefInfo(), getTargetData(), and InitializeAliasAnalysis(). |