//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#define LLVM_ANALYSIS_ALIASSETTRACKER_H
#include "llvm/Support/CallSite.h"
-#include "llvm/ADT/iterator"
-#include "llvm/ADT/hash_map"
-#include "llvm/ADT/ilist"
+#include "llvm/Support/Streams.h"
+#include "llvm/ADT/iterator.h"
+#include "llvm/ADT/hash_map.h"
+#include "llvm/ADT/ilist.h"
namespace llvm {
class LoadInst;
class StoreInst;
class FreeInst;
+class VAArgInst;
class AliasSetTracker;
class AliasSet;
bool empty() const { return PtrList == 0; }
void print(std::ostream &OS) const;
+ void print(std::ostream *OS) const { if (OS) print(*OS); }
void dump() const;
/// Define an iterator for alias sets... this is just a forward iterator.
class iterator : public forward_iterator<HashNodePair, ptrdiff_t> {
HashNodePair *CurNode;
public:
- iterator(HashNodePair *CN = 0) : CurNode(CN) {}
+ explicit iterator(HashNodePair *CN = 0) : CurNode(CN) {}
bool operator==(const iterator& x) const {
return CurNode == x.CurNode;
void addPointer(AliasSetTracker &AST, HashNodePair &Entry, unsigned Size,
bool KnownMustAlias = false);
void addCallSite(CallSite CS, AliasAnalysis &AA);
+ void removeCallSite(CallSite CS) {
+ for (size_t i = 0, e = CallSites.size(); i != e; ++i)
+ if (CallSites[i].getInstruction() == CS.getInstruction()) {
+ CallSites[i] = CallSites.back();
+ CallSites.pop_back();
+ }
+ }
void setVolatile() { Volatile = true; }
/// aliasesPointer - Return true if the specified pointer "may" (or must)
/// AliasSetTracker ctor - Create an empty collection of AliasSets, and use
/// the specified alias analysis object to disambiguate load and store
/// addresses.
- AliasSetTracker(AliasAnalysis &aa) : AA(aa) {}
+ explicit AliasSetTracker(AliasAnalysis &aa) : AA(aa) {}
+ ~AliasSetTracker() { clear(); }
/// add methods - These methods are used to add different types of
/// instructions to the alias sets. Adding a new instruction can result in
bool add(LoadInst *LI);
bool add(StoreInst *SI);
bool add(FreeInst *FI);
+ bool add(VAArgInst *VAAI);
bool add(CallSite CS); // Call/Invoke instructions
bool add(CallInst *CI) { return add(CallSite(CI)); }
bool add(InvokeInst *II) { return add(CallSite(II)); }
bool remove(LoadInst *LI);
bool remove(StoreInst *SI);
bool remove(FreeInst *FI);
+ bool remove(VAArgInst *VAAI);
bool remove(CallSite CS);
bool remove(CallInst *CI) { return remove(CallSite(CI)); }
bool remove(InvokeInst *II) { return remove(CallSite(II)); }
bool remove(Instruction *I);
void remove(AliasSet &AS);
+
+ void clear() {
+ PointerMap.clear();
+ AliasSets.clear();
+ }
/// getAliasSets - Return the alias sets that are active.
///
iterator end() { return AliasSets.end(); }
void print(std::ostream &OS) const;
+ void print(std::ostream *OS) const { if (OS) print(*OS); }
void dump() const;
private: