void AliasSet::addPointer(AliasSetTracker &AST, PointerRec &Entry,
uint64_t Size, const AAMDNodes &AAInfo,
- ModRefInfo MR, bool KnownMustAlias) {
+ bool KnownMustAlias) {
assert(!Entry.hasAliasSet() && "Entry already in set!");
// Check to see if we have to downgrade to _may_ alias.
assert(Result != NoAlias && "Cannot be part of must set!");
}
- // upgrading access if existing UnknownInst has ModRef with new pointer
- Access |= MR;
-
Entry.setAliasSet(this);
Entry.updateSizeAndAAInfo(Size, AAInfo);
addRef(); // Entry points to alias set.
}
-void AliasSet::addUnknownInst(Instruction *I, AliasAnalysis &AA,
- ModRefInfo MR) {
+void AliasSet::addUnknownInst(Instruction *I, AliasAnalysis &AA) {
if (UnknownInsts.empty())
addRef();
UnknownInsts.emplace_back(I);
if (!I->mayWriteToMemory()) {
Alias = SetMayAlias;
- Access |= MRI_Ref;
+ Access |= RefAccess;
return;
}
+ // FIXME: This should use mod/ref information to make this not suck so bad
Alias = SetMayAlias;
- Access |= MR;
-}
-
-namespace {
- /// returns true if there is no request of worst ModRefInfo
- /// (MRcommonPtr is null)
- /// or when achieved maximum ModRefInfo (MRI_ModRef).
- bool processMR(ModRefInfo MR, ModRefInfo* MRcommonPtr, ModRefInfo& MRcommon) {
- MRcommon = ModRefInfo(MRcommon | MR);
- return !MRcommonPtr || (MRcommon == MRI_ModRef);
- }
- bool fillExitMR(ModRefInfo* MRcommonPtr, ModRefInfo& MRcommon) {
- if (MRcommonPtr) *MRcommonPtr = MRcommon;
- return MRcommon != MRI_NoModRef;
- }
+ Access = ModRefAccess;
}
/// aliasesPointer - Return true if the specified pointer "may" (or must)
///
bool AliasSet::aliasesPointer(const Value *Ptr, uint64_t Size,
const AAMDNodes &AAInfo,
- AliasAnalysis &AA,
- ModRefInfo* MRcommonPtr) const {
+ AliasAnalysis &AA) const {
if (Alias == SetMustAlias) {
assert(UnknownInsts.empty() && "Illegal must alias set!");
MemoryLocation(I.getPointer(), I.getSize(), I.getAAInfo())))
return true;
- // to gather worst ModRefInfo
- ModRefInfo MRcommon = MRI_NoModRef;
-
// Check the unknown instructions...
if (!UnknownInsts.empty()) {
for (unsigned i = 0, e = UnknownInsts.size(); i != e; ++i)
- if (processMR(AA.getModRefInfo(UnknownInsts[i],
- MemoryLocation(Ptr, Size, AAInfo)), MRcommonPtr, MRcommon))
- return fillExitMR(MRcommonPtr, MRcommon);
+ if (AA.getModRefInfo(UnknownInsts[i],
+ MemoryLocation(Ptr, Size, AAInfo)) != MRI_NoModRef)
+ return true;
}
- return fillExitMR(MRcommonPtr, MRcommon);
+ return false;
}
bool AliasSet::aliasesUnknownInst(const Instruction *Inst,
- AliasAnalysis &AA,
- ModRefInfo* MRcommonPtr) const {
+ AliasAnalysis &AA) const {
if (!Inst->mayReadOrWriteMemory())
return false;
- // to gather worst ModRefInfo
- ModRefInfo MRcommon = MRI_NoModRef;
-
for (unsigned i = 0, e = UnknownInsts.size(); i != e; ++i) {
ImmutableCallSite C1(getUnknownInst(i)), C2(Inst);
- if (!C1 || !C2 ||
- processMR(AA.getModRefInfo(C1, C2), MRcommonPtr, MRcommon) ||
- processMR(AA.getModRefInfo(C2, C1), MRcommonPtr, MRcommon))
- return fillExitMR(MRcommonPtr, MRcommon);
+ if (!C1 || !C2 || AA.getModRefInfo(C1, C2) != MRI_NoModRef ||
+ AA.getModRefInfo(C2, C1) != MRI_NoModRef)
+ return true;
}
- for (iterator I = begin(), E = end(); I != E; ++I) {
- ModRefInfo MR = AA.getModRefInfo(
- Inst, MemoryLocation(I.getPointer(), I.getSize(), I.getAAInfo()));
- if (processMR(MR, MRcommonPtr, MRcommon))
- return fillExitMR(MRcommonPtr, MRcommon);
- }
- return fillExitMR(MRcommonPtr, MRcommon);
+ for (iterator I = begin(), E = end(); I != E; ++I)
+ if (AA.getModRefInfo(Inst, MemoryLocation(I.getPointer(), I.getSize(),
+ I.getAAInfo())) != MRI_NoModRef)
+ return true;
+
+ return false;
}
void AliasSetTracker::clear() {
///
AliasSet *AliasSetTracker::findAliasSetForPointer(const Value *Ptr,
uint64_t Size,
- const AAMDNodes &AAInfo,
- ModRefInfo* MRcommonPtr) {
+ const AAMDNodes &AAInfo) {
AliasSet *FoundSet = nullptr;
for (iterator I = begin(), E = end(); I != E;) {
iterator Cur = I++;
- ModRefInfo MR = MRI_NoModRef;
- if (Cur->Forward || !Cur->aliasesPointer(Ptr, Size, AAInfo, AA, &MR))
- continue;
- *MRcommonPtr = ModRefInfo(*MRcommonPtr | MR);
+ if (Cur->Forward || !Cur->aliasesPointer(Ptr, Size, AAInfo, AA)) continue;
if (!FoundSet) { // If this is the first alias set ptr can go into.
FoundSet = &*Cur; // Remember it.
return false;
}
-AliasSet *AliasSetTracker::findAliasSetForUnknownInst(Instruction *Inst,
- ModRefInfo* MRcommonPtr) {
+AliasSet *AliasSetTracker::findAliasSetForUnknownInst(Instruction *Inst) {
AliasSet *FoundSet = nullptr;
for (iterator I = begin(), E = end(); I != E;) {
iterator Cur = I++;
- ModRefInfo MR = MRI_NoModRef;
- if (Cur->Forward || !Cur->aliasesUnknownInst(Inst, AA, &MR))
+ if (Cur->Forward || !Cur->aliasesUnknownInst(Inst, AA))
continue;
- *MRcommonPtr = ModRefInfo(*MRcommonPtr | MR);
if (!FoundSet) // If this is the first alias set ptr can go into.
FoundSet = &*Cur; // Remember it.
else if (!Cur->Forward) // Otherwise, we must merge the sets.
return *Entry.getAliasSet(*this)->getForwardedTarget(*this);
}
- ModRefInfo MR = MRI_NoModRef;
- if (AliasSet *AS = findAliasSetForPointer(Pointer, Size, AAInfo, &MR)) {
+ if (AliasSet *AS = findAliasSetForPointer(Pointer, Size, AAInfo)) {
// Add it to the alias set it aliases.
- AS->addPointer(*this, Entry, Size, AAInfo, MR);
+ AS->addPointer(*this, Entry, Size, AAInfo);
return *AS;
}
if (New) *New = true;
// Otherwise create a new alias set to hold the loaded pointer.
AliasSets.push_back(new AliasSet());
- AliasSets.back().addPointer(*this, Entry, Size, AAInfo, MRI_NoModRef);
+ AliasSets.back().addPointer(*this, Entry, Size, AAInfo);
return AliasSets.back();
}
bool AliasSetTracker::add(Value *Ptr, uint64_t Size, const AAMDNodes &AAInfo) {
bool NewPtr;
- addPointer(Ptr, Size, AAInfo, MRI_NoModRef, NewPtr);
+ addPointer(Ptr, Size, AAInfo, AliasSet::NoAccess, NewPtr);
return NewPtr;
}
AAMDNodes AAInfo;
LI->getAAMetadata(AAInfo);
- AliasSet::AccessLattice Access = MRI_Ref;
+ AliasSet::AccessLattice Access = AliasSet::RefAccess;
bool NewPtr;
const DataLayout &DL = LI->getModule()->getDataLayout();
AliasSet &AS = addPointer(LI->getOperand(0),
AAMDNodes AAInfo;
SI->getAAMetadata(AAInfo);
- AliasSet::AccessLattice Access = MRI_Mod;
+ AliasSet::AccessLattice Access = AliasSet::ModAccess;
bool NewPtr;
const DataLayout &DL = SI->getModule()->getDataLayout();
Value *Val = SI->getOperand(0);
bool NewPtr;
addPointer(VAAI->getOperand(0), MemoryLocation::UnknownSize, AAInfo,
- MRI_ModRef, NewPtr);
+ AliasSet::ModRefAccess, NewPtr);
return NewPtr;
}
if (!Inst->mayReadOrWriteMemory())
return true; // doesn't alias anything
- ModRefInfo MR = MRI_NoModRef;
- AliasSet *AS = findAliasSetForUnknownInst(Inst, &MR);
+ AliasSet *AS = findAliasSetForUnknownInst(Inst);
if (AS) {
- AS->addUnknownInst(Inst, AA, MR);
+ AS->addUnknownInst(Inst, AA);
return false;
}
AliasSets.push_back(new AliasSet());
AS = &AliasSets.back();
- AS->addUnknownInst(Inst, AA, MR);
+ AS->addUnknownInst(Inst, AA);
return true;
}
I = PointerMap.find_as(From);
AliasSet *AS = I->second->getAliasSet(*this);
AS->addPointer(*this, Entry, I->second->getSize(),
- I->second->getAAInfo(), MRI_NoModRef,
+ I->second->getAAInfo(),
true);
}
OS << " AliasSet[" << (const void*)this << ", " << RefCount << "] ";
OS << (Alias == SetMustAlias ? "must" : "may") << " alias, ";
switch (Access) {
- case MRI_NoModRef: OS << "No access "; break;
- case MRI_Ref: OS << "Ref "; break;
- case MRI_Mod: OS << "Mod "; break;
- case MRI_ModRef: OS << "Mod/Ref "; break;
+ 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] ";
projects / oota-llvm.git / blobdiff