Skip to content

Commit

Permalink
[PM/AA] Rework the names and comments in AliasSetTracker to more
Browse files Browse the repository at this point in the history 
accurately describe what is being tracked.

While these two enums do track mod/ref information and aliasing
information, they don't represent the exact same things as either the
mod/ref enums or the alias result enum in AA. They're definitions are
dominated by the structure of their lattice and the bit's various
semantics. This patch just calls them what they are and tries to spell
out usefully distinct names for these things.

This will clear the path for using a raw unscoped enum to represent some
of these concepts across LLVM's analysis library.

No functionality changed here.

Differential Revision: http://reviews.llvm.org/D10494

llvm-svn: 240254
  • Loading branch information
@chandlerc
chandlerc committed Jun 22, 2015
1 parent ff373d2 commit a561d75
Show file tree
Hide file tree
Showing 2 changed files with 50 additions and 44 deletions.
46 changes: 26 additions & 20 deletions llvm/include/llvm/Analysis/AliasSetTracker.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -117,24 +117,30 @@ class AliasSet : public ilist_node<AliasSet> {
// AliasSets forwarding to it.
unsigned RefCount : 28;

/// AccessType - Keep track of whether this alias set merely refers to the
/// locations of memory, whether it modifies the memory, or whether it does
/// both. The lattice goes from "NoModRef" to either Refs or Mods, then to
/// ModRef as necessary.
/// The kinds of access this alias set models.
///
enum AccessType {
NoModRef = 0, Refs = 1, // Ref = bit 1
Mods = 2, ModRef = 3 // Mod = bit 2
/// We keep track of whether this alias set merely refers to the locations of
/// memory (and not any particular access), whether it modifies or references
/// the memory, or whether it does both. The lattice goes from "NoAccess" to
/// either RefAccess or ModAccess, then to ModRefAccess as necessary.
enum AccessLattice {
NoAccess = 0,
RefAccess = 1,
ModAccess = 2,
ModRefAccess = RefAccess | ModAccess
};
unsigned AccessTy : 2;
unsigned Access : 2;

/// AliasType - Keep track the relationships between the pointers in the set.
/// Lattice goes from MustAlias to MayAlias.
/// The kind of alias relationship between pointers of the set.
///
enum AliasType {
MustAlias = 0, MayAlias = 1
/// These represent conservatively correct alias results between any members
/// of the set. We represent these independently of the values of alias
/// results in order to pack it into a single bit. Lattice goes from
/// MustAlias to MayAlias.
enum AliasLattice {
SetMustAlias = 0, SetMayAlias = 1
};
unsigned AliasTy : 1;
unsigned Alias : 1;

// Volatile - True if this alias set contains volatile loads or stores.
bool Volatile : 1;
Expand All @@ -153,10 +159,10 @@ class AliasSet : public ilist_node<AliasSet> {

public:
/// Accessors...
bool isRef() const { return AccessTy & Refs; }
bool isMod() const { return AccessTy & Mods; }
bool isMustAlias() const { return AliasTy == MustAlias; }
bool isMayAlias() const { return AliasTy == MayAlias; }
bool isRef() const { return Access & RefAccess; }
bool isMod() const { return Access & ModAccess; }
bool isMustAlias() const { return Alias == SetMustAlias; }
bool isMayAlias() const { return Alias == SetMayAlias; }

// isVolatile - Return true if this alias set contains volatile loads or
// stores.
Expand Down Expand Up @@ -218,7 +224,7 @@ class AliasSet : public ilist_node<AliasSet> {
friend struct ilist_sentinel_traits<AliasSet>;
AliasSet()
: PtrList(nullptr), PtrListEnd(&PtrList), Forward(nullptr), RefCount(0),
AccessTy(NoModRef), AliasTy(MustAlias), Volatile(false) {
Access(NoAccess), Alias(SetMustAlias), Volatile(false) {
}

AliasSet(const AliasSet &AS) = delete;
Expand Down Expand Up @@ -419,11 +425,11 @@ class AliasSetTracker {
}

AliasSet &addPointer(Value *P, uint64_t Size, const AAMDNodes &AAInfo,
AliasSet::AccessType E,
AliasSet::AccessLattice E,
bool &NewSet) {
NewSet = false;
AliasSet &AS = getAliasSetForPointer(P, Size, AAInfo, &NewSet);
AS.AccessTy |= E;
AS.Access |= E;
return AS;
}
AliasSet *findAliasSetForPointer(const Value *Ptr, uint64_t Size,
Expand Down
48 changes: 24 additions & 24 deletions llvm/lib/Analysis/AliasSetTracker.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,11 +32,11 @@ void AliasSet::mergeSetIn(AliasSet &AS, AliasSetTracker &AST) {
assert(!Forward && "This set is a forwarding set!!");

// Update the alias and access types of this set...
AccessTy |= AS.AccessTy;
AliasTy |= AS.AliasTy;
Access |= AS.Access;
Alias |= AS.Alias;
Volatile |= AS.Volatile;

if (AliasTy == MustAlias) {
if (Alias == SetMustAlias) {
// Check that these two merged sets really are must aliases. Since both
// used to be must-alias sets, we can just check any pointer from each set
// for aliasing.
Expand All @@ -48,7 +48,7 @@ void AliasSet::mergeSetIn(AliasSet &AS, AliasSetTracker &AST) {
if (AA.alias(MemoryLocation(L->getValue(), L->getSize(), L->getAAInfo()),
MemoryLocation(R->getValue(), R->getSize(), R->getAAInfo())) !=
AliasAnalysis::MustAlias)
AliasTy = MayAlias;
Alias = SetMayAlias;
}

bool ASHadUnknownInsts = !AS.UnknownInsts.empty();
Expand Down Expand Up @@ -105,7 +105,7 @@ void AliasSet::addPointer(AliasSetTracker &AST, PointerRec &Entry,
AA.alias(MemoryLocation(P->getValue(), P->getSize(), P->getAAInfo()),
MemoryLocation(Entry.getValue(), Size, AAInfo));
if (Result != AliasAnalysis::MustAlias)
AliasTy = MayAlias;
Alias = SetMayAlias;
else // First entry of must alias must have maximum size!
P->updateSizeAndAAInfo(Size, AAInfo);
assert(Result != AliasAnalysis::NoAlias && "Cannot be part of must set!");
Expand All @@ -128,14 +128,14 @@ void AliasSet::addUnknownInst(Instruction *I, AliasAnalysis &AA) {
UnknownInsts.emplace_back(I);

if (!I->mayWriteToMemory()) {
AliasTy = MayAlias;
AccessTy |= Refs;
Alias = SetMayAlias;
Access |= RefAccess;
return;
}

// FIXME: This should use mod/ref information to make this not suck so bad
AliasTy = MayAlias;
AccessTy = ModRef;
Alias = SetMayAlias;
Access = ModRefAccess;
}

/// aliasesPointer - Return true if the specified pointer "may" (or must)
Expand All @@ -144,7 +144,7 @@ void AliasSet::addUnknownInst(Instruction *I, AliasAnalysis &AA) {
bool AliasSet::aliasesPointer(const Value *Ptr, uint64_t Size,
const AAMDNodes &AAInfo,
AliasAnalysis &AA) const {
if (AliasTy == MustAlias) {
if (Alias == SetMustAlias) {
assert(UnknownInsts.empty() && "Illegal must alias set!");

// If this is a set of MustAliases, only check to see if the pointer aliases
Expand Down Expand Up @@ -296,7 +296,7 @@ AliasSet &AliasSetTracker::getAliasSetForPointer(Value *Pointer, uint64_t Size,

bool AliasSetTracker::add(Value *Ptr, uint64_t Size, const AAMDNodes &AAInfo) {
bool NewPtr;
addPointer(Ptr, Size, AAInfo, AliasSet::NoModRef, NewPtr);
addPointer(Ptr, Size, AAInfo, AliasSet::NoAccess, NewPtr);
return NewPtr;
}

Expand All @@ -307,11 +307,11 @@ bool AliasSetTracker::add(LoadInst *LI) {
AAMDNodes AAInfo;
LI->getAAMetadata(AAInfo);

AliasSet::AccessType ATy = AliasSet::Refs;
AliasSet::AccessLattice Access = AliasSet::RefAccess;
bool NewPtr;
AliasSet &AS = addPointer(LI->getOperand(0),
AA.getTypeStoreSize(LI->getType()),
AAInfo, ATy, NewPtr);
AAInfo, Access, NewPtr);
if (LI->isVolatile()) AS.setVolatile();
return NewPtr;
}
Expand All @@ -322,12 +322,12 @@ bool AliasSetTracker::add(StoreInst *SI) {
AAMDNodes AAInfo;
SI->getAAMetadata(AAInfo);

AliasSet::AccessType ATy = AliasSet::Mods;
AliasSet::AccessLattice Access = AliasSet::ModAccess;
bool NewPtr;
Value *Val = SI->getOperand(0);
AliasSet &AS = addPointer(SI->getOperand(1),
AA.getTypeStoreSize(Val->getType()),
AAInfo, ATy, NewPtr);
AAInfo, Access, NewPtr);
if (SI->isVolatile()) AS.setVolatile();
return NewPtr;
}
Expand All @@ -338,7 +338,7 @@ bool AliasSetTracker::add(VAArgInst *VAAI) {

bool NewPtr;
addPointer(VAAI->getOperand(0), MemoryLocation::UnknownSize, AAInfo,
AliasSet::ModRef, NewPtr);
AliasSet::ModRefAccess, NewPtr);
return NewPtr;
}

Expand Down Expand Up @@ -397,7 +397,7 @@ void AliasSetTracker::add(const AliasSetTracker &AST) {
for (AliasSet::iterator ASI = AS.begin(), E = AS.end(); ASI != E; ++ASI) {
AliasSet &NewAS = addPointer(ASI.getPointer(), ASI.getSize(),
ASI.getAAInfo(),
(AliasSet::AccessType)AS.AccessTy, X);
(AliasSet::AccessLattice)AS.Access, X);
if (AS.isVolatile()) NewAS.setVolatile();
}
}
Expand Down Expand Up @@ -572,13 +572,13 @@ void AliasSetTracker::copyValue(Value *From, Value *To) {

void AliasSet::print(raw_ostream &OS) const {
OS << " AliasSet[" << (const void*)this << ", " << RefCount << "] ";
OS << (AliasTy == MustAlias ? "must" : "may") << " alias, ";
switch (AccessTy) {
case NoModRef: OS << "No access "; break;
case Refs : OS << "Ref "; break;
case Mods : OS << "Mod "; break;
case ModRef : OS << "Mod/Ref "; break;
default: llvm_unreachable("Bad value for AccessTy!");
OS << (Alias == SetMustAlias ? "must" : "may") << " alias, ";
switch (Access) {
case NoAccess: OS << "No access "; break;
case RefAccess: OS << "Ref "; break;
case ModAccess: OS << "Mod "; break;
case ModRefAccess: OS << "Mod/Ref "; break;
default: llvm_unreachable("Bad value for Access!");
}
if (isVolatile()) OS << "[volatile] ";
if (Forward)
Expand Down

0 comments on commit a561d75

Please sign in to comment.