//===- 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;
void removeFromList() {
if (NextInList) NextInList->second.PrevInList = PrevInList;
*PrevInList = NextInList;
+ if (AS->PtrListEnd == &NextInList) {
+ AS->PtrListEnd = PrevInList;
+ assert(*AS->PtrListEnd == 0 && "List not terminated right!");
+ }
}
};
// 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.
HashNodePair *CurNode;
public:
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 removeFromTracker(AliasSetTracker &AST);
- void addPointer(AliasSetTracker &AST, HashNodePair &Entry, unsigned Size);
+ 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)
bool remove(InvokeInst *II) { return remove(CallSite(II)); }
bool remove(Instruction *I);
void remove(AliasSet &AS);
-
-
- /// deleteValue method - This method is used to remove a pointer value from
- /// the AliasSetTracker entirely. It should be used when an instruction is
- /// deleted from the program to update the AST. If you don't use this, you
- /// would have dangling pointers to deleted instructions.
- ///
- void deleteValue(Value *PtrVal);
+
+ void clear() {
+ PointerMap.clear();
+ AliasSets.clear();
+ }
/// getAliasSets - Return the alias sets that are active.
+ ///
const ilist<AliasSet> &getAliasSets() const { return AliasSets; }
/// getAliasSetForPointer - Return the alias set that the specified pointer
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; }
+ /// deleteValue method - This method is used to remove a pointer value from
+ /// the AliasSetTracker entirely. It should be used when an instruction is
+ /// deleted from the program to update the AST. If you don't use this, you
+ /// would have dangling pointers to deleted instructions.
+ ///
+ void deleteValue(Value *PtrVal);
+
+ /// copyValue - This method should be used whenever a preexisting value in the
+ /// program is copied or cloned, introducing a new value. Note that it is ok
+ /// for clients that use this method to introduce the same value multiple
+ /// times: if the tracker already knows about a value, it will ignore the
+ /// request.
+ ///
+ void copyValue(Value *From, Value *To);
+
+
typedef ilist<AliasSet>::iterator iterator;
typedef ilist<AliasSet>::const_iterator const_iterator;
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:
projects / oota-llvm.git / blobdiff