From 12c1155403fd2dbd3a24e3748e7d80bbaa27c7f6 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Wed, 21 Jul 2004 05:18:04 +0000 Subject: [PATCH] Make the AST interface a bit richer by returning whether an insertion caused an insertion or not (because the pointer set already existed). git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@15064 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/AliasSetTracker.h | 27 ++++++++----- lib/Analysis/AliasSetTracker.cpp | 51 ++++++++++++++++--------- 2 files changed, 49 insertions(+), 29 deletions(-) diff --git a/include/llvm/Analysis/AliasSetTracker.h b/include/llvm/Analysis/AliasSetTracker.h index 4996f5a4cf9..3d4d99f0349 100644 --- a/include/llvm/Analysis/AliasSetTracker.h +++ b/include/llvm/Analysis/AliasSetTracker.h @@ -255,12 +255,15 @@ public: /// 3. If the instruction aliases multiple sets, merge the sets, and add /// the instruction to the result. /// - void add(LoadInst *LI); - void add(StoreInst *SI); - void add(CallSite CS); // Call/Invoke instructions - void add(CallInst *CI) { add(CallSite(CI)); } - void add(InvokeInst *II) { add(CallSite(II)); } - void add(Instruction *I); // Dispatch to one of the other add methods... + /// These methods return true if inserting the instruction resulted in the + /// addition of a new alias set (i.e., the pointer did not alias anything). + /// + bool add(LoadInst *LI); + bool add(StoreInst *SI); + bool add(CallSite CS); // Call/Invoke instructions + bool add(CallInst *CI) { return add(CallSite(CI)); } + bool add(InvokeInst *II) { return add(CallSite(II)); } + bool add(Instruction *I); // Dispatch to one of the other add methods... void add(BasicBlock &BB); // Add all instructions in basic block void add(const AliasSetTracker &AST); // Add alias relations from another AST @@ -275,8 +278,10 @@ public: const ilist &getAliasSets() const { return AliasSets; } /// getAliasSetForPointer - Return the alias set that the specified pointer - /// lives in... - AliasSet &getAliasSetForPointer(Value *P, unsigned Size); + /// lives in. If the New argument is non-null, this method sets the value to + /// true if a new alias set is created to contain the pointer (because the + /// pointer didn't alias anything). + AliasSet &getAliasSetForPointer(Value *P, unsigned Size, bool *New = 0); /// getAliasAnalysis - Return the underlying alias analysis object used by /// this tracker. @@ -305,8 +310,10 @@ private: AliasSet::PointerRec())).first; } - AliasSet &addPointer(Value *P, unsigned Size, AliasSet::AccessType E) { - AliasSet &AS = getAliasSetForPointer(P, Size); + AliasSet &addPointer(Value *P, unsigned Size, AliasSet::AccessType E, + bool &NewSet) { + NewSet = false; + AliasSet &AS = getAliasSetForPointer(P, Size, &NewSet); AS.AccessTy |= E; return AS; } diff --git a/lib/Analysis/AliasSetTracker.cpp b/lib/Analysis/AliasSetTracker.cpp index 190a5a97557..359ea2c4f2c 100644 --- a/lib/Analysis/AliasSetTracker.cpp +++ b/lib/Analysis/AliasSetTracker.cpp @@ -189,7 +189,8 @@ AliasSet *AliasSetTracker::findAliasSetForCallSite(CallSite CS) { /// getAliasSetForPointer - Return the alias set that the specified pointer /// lives in... -AliasSet &AliasSetTracker::getAliasSetForPointer(Value *Pointer, unsigned Size){ +AliasSet &AliasSetTracker::getAliasSetForPointer(Value *Pointer, unsigned Size, + bool *New) { AliasSet::HashNodePair &Entry = getEntryFor(Pointer); // Check to see if the pointer is already known... @@ -201,6 +202,7 @@ AliasSet &AliasSetTracker::getAliasSetForPointer(Value *Pointer, unsigned Size){ AS->addPointer(*this, Entry, Size); return *AS; } else { + if (New) *New = true; // Otherwise create a new alias set to hold the loaded pointer... AliasSets.push_back(AliasSet()); AliasSets.back().addPointer(*this, Entry, Size); @@ -208,45 +210,55 @@ AliasSet &AliasSetTracker::getAliasSetForPointer(Value *Pointer, unsigned Size){ } } -void AliasSetTracker::add(LoadInst *LI) { - AliasSet &AS = - addPointer(LI->getOperand(0), - AA.getTargetData().getTypeSize(LI->getType()), AliasSet::Refs); +bool AliasSetTracker::add(LoadInst *LI) { + bool NewPtr; + AliasSet &AS = addPointer(LI->getOperand(0), + AA.getTargetData().getTypeSize(LI->getType()), + AliasSet::Refs, NewPtr); if (LI->isVolatile()) AS.setVolatile(); + return NewPtr; } -void AliasSetTracker::add(StoreInst *SI) { - AliasSet &AS = - addPointer(SI->getOperand(1), - AA.getTargetData().getTypeSize(SI->getOperand(0)->getType()), - AliasSet::Mods); +bool AliasSetTracker::add(StoreInst *SI) { + bool NewPtr; + Value *Val = SI->getOperand(0); + AliasSet &AS = addPointer(SI->getOperand(1), + AA.getTargetData().getTypeSize(Val->getType()), + AliasSet::Mods, NewPtr); if (SI->isVolatile()) AS.setVolatile(); + return NewPtr; } -void AliasSetTracker::add(CallSite CS) { +bool AliasSetTracker::add(CallSite CS) { + bool NewPtr; if (Function *F = CS.getCalledFunction()) if (AA.doesNotAccessMemory(F)) - return; + return true; // doesn't alias anything AliasSet *AS = findAliasSetForCallSite(CS); if (!AS) { AliasSets.push_back(AliasSet()); AS = &AliasSets.back(); + AS->addCallSite(CS, AA); + return true; + } else { + AS->addCallSite(CS, AA); + return false; } - AS->addCallSite(CS, AA); } -void AliasSetTracker::add(Instruction *I) { +bool AliasSetTracker::add(Instruction *I) { // Dispatch to one of the other add methods... if (LoadInst *LI = dyn_cast(I)) - add(LI); + return add(LI); else if (StoreInst *SI = dyn_cast(I)) - add(SI); + return add(SI); else if (CallInst *CI = dyn_cast(I)) - add(CI); + return add(CI); else if (InvokeInst *II = dyn_cast(I)) - add(II); + return add(II); + return true; } void AliasSetTracker::add(BasicBlock &BB) { @@ -271,9 +283,10 @@ void AliasSetTracker::add(const AliasSetTracker &AST) { // Loop over all of the pointers in this alias set... AliasSet::iterator I = AS.begin(), E = AS.end(); + bool X; for (; I != E; ++I) addPointer(I->first, I->second.getSize(), - (AliasSet::AccessType)AS.AccessTy); + (AliasSet::AccessType)AS.AccessTy, X); } }