//===- llvm/Analysis/AliasSetTracker.h - Build Alias Sets -------*- C++ -*-===//
-//
+//
// 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 defines two classes: AliasSetTracker and AliasSet. These interface
// are used to classify a collection of pointer references into a maximal number
// of disjoint sets. Each AliasSet object constructed by the AliasSetTracker
// object refers to memory disjoint from the other sets.
-//
+//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_ALIASSETTRACKER_H
#define LLVM_ANALYSIS_ALIASSETTRACKER_H
#include "llvm/Support/CallSite.h"
+#include "llvm/Support/Streams.h"
#include "llvm/ADT/iterator"
#include "llvm/ADT/hash_map"
#include "llvm/ADT/ilist"
class AliasSet {
friend class AliasSetTracker;
- struct PointerRec;
+ class PointerRec;
typedef std::pair<Value* const, PointerRec> HashNodePair;
class PointerRec {
unsigned getSize() const { return Size; }
- AliasSet *getAliasSet(AliasSetTracker &AST) {
+ AliasSet *getAliasSet(AliasSetTracker &AST) {
assert(AS && "No AliasSet yet!");
if (AS->Forward) {
AliasSet *OldAS = AS;
// Volatile - True if this alias set contains volatile loads or stores.
bool Volatile : 1;
- friend class ilist_traits<AliasSet>;
+ friend struct ilist_traits<AliasSet>;
AliasSet *getPrev() const { return Prev; }
AliasSet *getNext() const { return Next; }
void setPrev(AliasSet *P) { Prev = P; }
/// mergeSetIn - Merge the specified alias set into this alias set...
///
- void mergeSetIn(AliasSet &AS);
+ void mergeSetIn(AliasSet &AS, AliasSetTracker &AST);
// Alias Set iteration - Allow access to all of the pointer which are part of
// this alias set...
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;
}
CurNode = I.CurNode;
return *this;
}
-
+
value_type &operator*() const {
assert(CurNode && "Dereferencing AliasSet.end()!");
return *CurNode;
Value *getPointer() const { return CurNode->first; }
unsigned getSize() const { return CurNode->second.getSize(); }
-
+
iterator& operator++() { // Preincrement
assert(CurNode && "Advancing past AliasSet.end()!");
CurNode = CurNode->second.getNext();
return *this;
}
iterator operator++(int) { // Postincrement
- iterator tmp = *this; ++*this; return tmp;
+ iterator tmp = *this; ++*this; return tmp;
}
};
void addPointer(AliasSetTracker &AST, HashNodePair &Entry, unsigned Size,
bool KnownMustAlias = false);
void addCallSite(CallSite CS, AliasAnalysis &AA);
+ void removeCallSite(CallSite CS) {
+ for (unsigned 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) {}
/// add methods - These methods are used to add different types of
/// instructions to the alias sets. Adding a new instruction can result in
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.
///
return findAliasSetForPointer(P, Size);
}
+ /// containsPointer - Return true if the specified location is represented by
+ /// this alias set, false otherwise. This does not modify the AST object or
+ /// alias sets.
+ bool containsPointer(Value *P, unsigned Size) const;
+
/// getAliasAnalysis - Return the underlying alias analysis object used by
/// this tracker.
AliasAnalysis &getAliasAnalysis() const { return AA; }
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: