#define LLVM_ANALYSIS_ALIAS_ANALYSIS_H
#include "llvm/Support/CallSite.h"
-#include "llvm/System/IncludeFile.h"
#include <vector>
namespace llvm {
/// UnknownSize - This is a special value which can be used with the
/// size arguments in alias queries to indicate that the caller does not
/// know the sizes of the potential memory references.
- static unsigned const UnknownSize = ~0u;
+ static uint64_t const UnknownSize = ~UINT64_C(0);
/// getTargetData - Return a pointer to the current TargetData object, or
/// null if no TargetData object is available.
/// getTypeStoreSize - Return the TargetData store size for the given type,
/// if known, or a conservative value otherwise.
///
- unsigned getTypeStoreSize(const Type *Ty);
+ uint64_t getTypeStoreSize(const Type *Ty);
//===--------------------------------------------------------------------===//
/// Alias Queries...
/// Ptr - The address of the start of the location.
const Value *Ptr;
/// Size - The size of the location.
- unsigned Size;
+ uint64_t Size;
/// TBAATag - The metadata node which describes the TBAA type of
/// the location, or null if there is no (unique) tag.
const MDNode *TBAATag;
explicit Location(const Value *P = 0,
- unsigned S = UnknownSize,
+ uint64_t S = UnknownSize,
const MDNode *N = 0)
: Ptr(P), Size(S), TBAATag(N) {}
virtual AliasResult alias(const Location &LocA, const Location &LocB);
/// alias - A convenience wrapper.
- AliasResult alias(const Value *V1, unsigned V1Size,
- const Value *V2, unsigned V2Size) {
+ AliasResult alias(const Value *V1, uint64_t V1Size,
+ const Value *V2, uint64_t V2Size) {
return alias(Location(V1, V1Size), Location(V2, V2Size));
}
}
/// isNoAlias - A convenience wrapper.
- bool isNoAlias(const Value *V1, unsigned V1Size,
- const Value *V2, unsigned V2Size) {
+ bool isNoAlias(const Value *V1, uint64_t V1Size,
+ const Value *V2, uint64_t V2Size) {
return isNoAlias(Location(V1, V1Size), Location(V2, V2Size));
}
/// getModRefInfo - A convenience wrapper.
ModRefResult getModRefInfo(const Instruction *I,
- const Value *P, unsigned Size) {
+ const Value *P, uint64_t Size) {
return getModRefInfo(I, Location(P, Size));
}
/// getModRefInfo (for call sites) - A convenience wrapper.
ModRefResult getModRefInfo(ImmutableCallSite CS,
- const Value *P, unsigned Size) {
+ const Value *P, uint64_t Size) {
return getModRefInfo(CS, Location(P, Size));
}
}
/// getModRefInfo (for calls) - A convenience wrapper.
- ModRefResult getModRefInfo(const CallInst *C, const Value *P, unsigned Size) {
+ ModRefResult getModRefInfo(const CallInst *C, const Value *P, uint64_t Size) {
return getModRefInfo(C, Location(P, Size));
}
/// getModRefInfo (for invokes) - A convenience wrapper.
ModRefResult getModRefInfo(const InvokeInst *I,
- const Value *P, unsigned Size) {
+ const Value *P, uint64_t Size) {
return getModRefInfo(I, Location(P, Size));
}
ModRefResult getModRefInfo(const LoadInst *L, const Location &Loc);
/// getModRefInfo (for loads) - A convenience wrapper.
- ModRefResult getModRefInfo(const LoadInst *L, const Value *P, unsigned Size) {
+ ModRefResult getModRefInfo(const LoadInst *L, const Value *P, uint64_t Size) {
return getModRefInfo(L, Location(P, Size));
}
ModRefResult getModRefInfo(const StoreInst *S, const Location &Loc);
/// getModRefInfo (for stores) - A convenience wrapper.
- ModRefResult getModRefInfo(const StoreInst *S, const Value *P, unsigned Size) {
+ ModRefResult getModRefInfo(const StoreInst *S, const Value *P, uint64_t Size) {
return getModRefInfo(S, Location(P, Size));
}
ModRefResult getModRefInfo(const VAArgInst* I, const Location &Loc);
/// getModRefInfo (for va_args) - A convenience wrapper.
- ModRefResult getModRefInfo(const VAArgInst* I, const Value* P, unsigned Size) {
+ ModRefResult getModRefInfo(const VAArgInst* I, const Value* P, uint64_t Size) {
return getModRefInfo(I, Location(P, Size));
}
bool canBasicBlockModify(const BasicBlock &BB, const Location &Loc);
/// canBasicBlockModify - A convenience wrapper.
- bool canBasicBlockModify(const BasicBlock &BB, const Value *P, unsigned Size){
+ bool canBasicBlockModify(const BasicBlock &BB, const Value *P, uint64_t Size){
return canBasicBlockModify(BB, Location(P, Size));
}
/// canInstructionRangeModify - A convenience wrapper.
bool canInstructionRangeModify(const Instruction &I1, const Instruction &I2,
- const Value *Ptr, unsigned Size) {
+ const Value *Ptr, uint64_t Size) {
return canInstructionRangeModify(I1, I2, Location(Ptr, Size));
}
} // End llvm namespace
-// Because of the way .a files work, we must force the BasicAA implementation to
-// be pulled in if the AliasAnalysis header is included. Otherwise we run
-// the risk of AliasAnalysis being used, but the default implementation not
-// being linked into the tool that uses it.
-FORCE_DEFINING_FILE_TO_BE_LINKED(AliasAnalysis)
-FORCE_DEFINING_FILE_TO_BE_LINKED(BasicAliasAnalysis)
-
#endif