Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 1 | //===- AliasSetTracker.cpp - Alias Sets Tracker implementation-------------===// |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 2 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 4ee451d | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 7 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 9 | // |
| 10 | // This file implements the AliasSetTracker and AliasSet classes. |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 11 | // |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #include "llvm/Analysis/AliasSetTracker.h" |
| 15 | #include "llvm/Analysis/AliasAnalysis.h" |
Misha Brukman | 47b14a4 | 2004-07-29 17:30:56 +0000 | [diff] [blame] | 16 | #include "llvm/Instructions.h" |
Zhou Sheng | 7e4286e | 2009-03-03 06:02:04 +0000 | [diff] [blame] | 17 | #include "llvm/IntrinsicInst.h" |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 18 | #include "llvm/Pass.h" |
Chris Lattner | 5b3a455 | 2005-03-17 15:38:16 +0000 | [diff] [blame] | 19 | #include "llvm/Type.h" |
Chris Lattner | 31a9d18 | 2003-02-26 22:11:00 +0000 | [diff] [blame] | 20 | #include "llvm/Target/TargetData.h" |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 21 | #include "llvm/Assembly/Writer.h" |
David Greene | 43c48ac | 2009-12-23 19:27:59 +0000 | [diff] [blame] | 22 | #include "llvm/Support/Debug.h" |
Torok Edwin | c25e758 | 2009-07-11 20:10:48 +0000 | [diff] [blame] | 23 | #include "llvm/Support/ErrorHandling.h" |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 24 | #include "llvm/Support/InstIterator.h" |
Chris Lattner | 791102f | 2009-08-23 05:17:37 +0000 | [diff] [blame] | 25 | #include "llvm/Support/raw_ostream.h" |
Chris Lattner | e260924 | 2003-12-14 04:52:11 +0000 | [diff] [blame] | 26 | using namespace llvm; |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 27 | |
Chris Lattner | cc8d524 | 2004-11-27 18:37:42 +0000 | [diff] [blame] | 28 | /// mergeSetIn - Merge the specified alias set into this alias set. |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 29 | /// |
Chris Lattner | cc8d524 | 2004-11-27 18:37:42 +0000 | [diff] [blame] | 30 | void AliasSet::mergeSetIn(AliasSet &AS, AliasSetTracker &AST) { |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 31 | assert(!AS.Forward && "Alias set is already forwarding!"); |
| 32 | assert(!Forward && "This set is a forwarding set!!"); |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 33 | |
| 34 | // Update the alias and access types of this set... |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 35 | AccessTy |= AS.AccessTy; |
| 36 | AliasTy |= AS.AliasTy; |
Chris Lattner | fedac7d | 2010-08-29 04:14:47 +0000 | [diff] [blame] | 37 | Volatile |= AS.Volatile; |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 38 | |
Chris Lattner | cc8d524 | 2004-11-27 18:37:42 +0000 | [diff] [blame] | 39 | if (AliasTy == MustAlias) { |
| 40 | // Check that these two merged sets really are must aliases. Since both |
| 41 | // used to be must-alias sets, we can just check any pointer from each set |
| 42 | // for aliasing. |
| 43 | AliasAnalysis &AA = AST.getAliasAnalysis(); |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 44 | PointerRec *L = getSomePointer(); |
| 45 | PointerRec *R = AS.getSomePointer(); |
Chris Lattner | cc8d524 | 2004-11-27 18:37:42 +0000 | [diff] [blame] | 46 | |
| 47 | // If the pointers are not a must-alias pair, this set becomes a may alias. |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 48 | if (AA.alias(L->getValue(), L->getSize(), R->getValue(), R->getSize()) |
Chris Lattner | cc8d524 | 2004-11-27 18:37:42 +0000 | [diff] [blame] | 49 | != AliasAnalysis::MustAlias) |
| 50 | AliasTy = MayAlias; |
| 51 | } |
| 52 | |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 53 | if (CallSites.empty()) { // Merge call sites... |
| 54 | if (!AS.CallSites.empty()) |
| 55 | std::swap(CallSites, AS.CallSites); |
| 56 | } else if (!AS.CallSites.empty()) { |
| 57 | CallSites.insert(CallSites.end(), AS.CallSites.begin(), AS.CallSites.end()); |
| 58 | AS.CallSites.clear(); |
| 59 | } |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 60 | |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 61 | AS.Forward = this; // Forward across AS now... |
Chris Lattner | b8a31ac | 2004-07-22 07:58:18 +0000 | [diff] [blame] | 62 | addRef(); // AS is now pointing to us... |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 63 | |
| 64 | // Merge the list of constituent pointers... |
Chris Lattner | 2cffeec | 2003-12-18 08:11:56 +0000 | [diff] [blame] | 65 | if (AS.PtrList) { |
| 66 | *PtrListEnd = AS.PtrList; |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 67 | AS.PtrList->setPrevInList(PtrListEnd); |
Chris Lattner | 2cffeec | 2003-12-18 08:11:56 +0000 | [diff] [blame] | 68 | PtrListEnd = AS.PtrListEnd; |
| 69 | |
| 70 | AS.PtrList = 0; |
| 71 | AS.PtrListEnd = &AS.PtrList; |
Chris Lattner | 3080b60 | 2004-09-15 16:59:47 +0000 | [diff] [blame] | 72 | assert(*AS.PtrListEnd == 0 && "End of list is not null?"); |
Chris Lattner | 2cffeec | 2003-12-18 08:11:56 +0000 | [diff] [blame] | 73 | } |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 74 | } |
| 75 | |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 76 | void AliasSetTracker::removeAliasSet(AliasSet *AS) { |
Chris Lattner | b8a31ac | 2004-07-22 07:58:18 +0000 | [diff] [blame] | 77 | if (AliasSet *Fwd = AS->Forward) { |
| 78 | Fwd->dropRef(*this); |
| 79 | AS->Forward = 0; |
| 80 | } |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 81 | AliasSets.erase(AS); |
| 82 | } |
| 83 | |
| 84 | void AliasSet::removeFromTracker(AliasSetTracker &AST) { |
| 85 | assert(RefCount == 0 && "Cannot remove non-dead alias set from tracker!"); |
| 86 | AST.removeAliasSet(this); |
| 87 | } |
| 88 | |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 89 | void AliasSet::addPointer(AliasSetTracker &AST, PointerRec &Entry, |
Chris Lattner | b66e648 | 2004-09-14 19:15:32 +0000 | [diff] [blame] | 90 | unsigned Size, bool KnownMustAlias) { |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 91 | assert(!Entry.hasAliasSet() && "Entry already in set!"); |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 92 | |
Chris Lattner | b66e648 | 2004-09-14 19:15:32 +0000 | [diff] [blame] | 93 | // Check to see if we have to downgrade to _may_ alias. |
| 94 | if (isMustAlias() && !KnownMustAlias) |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 95 | if (PointerRec *P = getSomePointer()) { |
Chris Lattner | 3080b60 | 2004-09-15 16:59:47 +0000 | [diff] [blame] | 96 | AliasAnalysis &AA = AST.getAliasAnalysis(); |
Chris Lattner | 31a9d18 | 2003-02-26 22:11:00 +0000 | [diff] [blame] | 97 | AliasAnalysis::AliasResult Result = |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 98 | AA.alias(P->getValue(), P->getSize(), Entry.getValue(), Size); |
Chris Lattner | 31a9d18 | 2003-02-26 22:11:00 +0000 | [diff] [blame] | 99 | if (Result == AliasAnalysis::MayAlias) |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 100 | AliasTy = MayAlias; |
Chris Lattner | 31a9d18 | 2003-02-26 22:11:00 +0000 | [diff] [blame] | 101 | else // First entry of must alias must have maximum size! |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 102 | P->updateSize(Size); |
Chris Lattner | 31a9d18 | 2003-02-26 22:11:00 +0000 | [diff] [blame] | 103 | assert(Result != AliasAnalysis::NoAlias && "Cannot be part of must set!"); |
| 104 | } |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 105 | |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 106 | Entry.setAliasSet(this); |
| 107 | Entry.updateSize(Size); |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 108 | |
| 109 | // Add it to the end of the list... |
Chris Lattner | 2cffeec | 2003-12-18 08:11:56 +0000 | [diff] [blame] | 110 | assert(*PtrListEnd == 0 && "End of list is not null?"); |
| 111 | *PtrListEnd = &Entry; |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 112 | PtrListEnd = Entry.setPrevInList(PtrListEnd); |
Chris Lattner | 3080b60 | 2004-09-15 16:59:47 +0000 | [diff] [blame] | 113 | assert(*PtrListEnd == 0 && "End of list is not null?"); |
Chris Lattner | 9476d74 | 2010-08-29 04:13:43 +0000 | [diff] [blame] | 114 | addRef(); // Entry points to alias set. |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 115 | } |
| 116 | |
Chris Lattner | 5b5f7c1 | 2004-03-15 04:08:36 +0000 | [diff] [blame] | 117 | void AliasSet::addCallSite(CallSite CS, AliasAnalysis &AA) { |
Chris Lattner | cb7f653 | 2010-08-29 18:42:23 +0000 | [diff] [blame] | 118 | CallSites.push_back(CS.getInstruction()); |
Chris Lattner | 5b5f7c1 | 2004-03-15 04:08:36 +0000 | [diff] [blame] | 119 | |
Duncan Sands | dff6710 | 2007-12-01 07:51:45 +0000 | [diff] [blame] | 120 | AliasAnalysis::ModRefBehavior Behavior = AA.getModRefBehavior(CS); |
| 121 | if (Behavior == AliasAnalysis::DoesNotAccessMemory) |
| 122 | return; |
| 123 | else if (Behavior == AliasAnalysis::OnlyReadsMemory) { |
| 124 | AliasTy = MayAlias; |
| 125 | AccessTy |= Refs; |
| 126 | return; |
Chris Lattner | 5b5f7c1 | 2004-03-15 04:08:36 +0000 | [diff] [blame] | 127 | } |
| 128 | |
| 129 | // FIXME: This should use mod/ref information to make this not suck so bad |
| 130 | AliasTy = MayAlias; |
Chris Lattner | 577385e | 2003-05-03 03:42:08 +0000 | [diff] [blame] | 131 | AccessTy = ModRef; |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 132 | } |
| 133 | |
| 134 | /// aliasesPointer - Return true if the specified pointer "may" (or must) |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 135 | /// alias one of the members in the set. |
| 136 | /// |
Chris Lattner | 31a9d18 | 2003-02-26 22:11:00 +0000 | [diff] [blame] | 137 | bool AliasSet::aliasesPointer(const Value *Ptr, unsigned Size, |
| 138 | AliasAnalysis &AA) const { |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 139 | if (AliasTy == MustAlias) { |
Chris Lattner | fcead4f | 2004-03-15 06:28:07 +0000 | [diff] [blame] | 140 | assert(CallSites.empty() && "Illegal must alias set!"); |
| 141 | |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 142 | // If this is a set of MustAliases, only check to see if the pointer aliases |
Chris Lattner | 9476d74 | 2010-08-29 04:13:43 +0000 | [diff] [blame] | 143 | // SOME value in the set. |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 144 | PointerRec *SomePtr = getSomePointer(); |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 145 | assert(SomePtr && "Empty must-alias set??"); |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 146 | return AA.alias(SomePtr->getValue(), SomePtr->getSize(), Ptr, Size); |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 147 | } |
| 148 | |
| 149 | // If this is a may-alias set, we have to check all of the pointers in the set |
| 150 | // to be sure it doesn't alias the set... |
| 151 | for (iterator I = begin(), E = end(); I != E; ++I) |
Chris Lattner | b8a31ac | 2004-07-22 07:58:18 +0000 | [diff] [blame] | 152 | if (AA.alias(Ptr, Size, I.getPointer(), I.getSize())) |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 153 | return true; |
| 154 | |
| 155 | // Check the call sites list and invoke list... |
Chris Lattner | efe30ef | 2004-07-27 02:20:26 +0000 | [diff] [blame] | 156 | if (!CallSites.empty()) { |
Chris Lattner | efe30ef | 2004-07-27 02:20:26 +0000 | [diff] [blame] | 157 | for (unsigned i = 0, e = CallSites.size(); i != e; ++i) |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 158 | if (AA.getModRefInfo(CallSites[i], Ptr, Size) != AliasAnalysis::NoModRef) |
Chris Lattner | efe30ef | 2004-07-27 02:20:26 +0000 | [diff] [blame] | 159 | return true; |
| 160 | } |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 161 | |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 162 | return false; |
| 163 | } |
| 164 | |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 165 | bool AliasSet::aliasesCallSite(CallSite CS, AliasAnalysis &AA) const { |
Duncan Sands | dff6710 | 2007-12-01 07:51:45 +0000 | [diff] [blame] | 166 | if (AA.doesNotAccessMemory(CS)) |
| 167 | return false; |
Chris Lattner | 5b5f7c1 | 2004-03-15 04:08:36 +0000 | [diff] [blame] | 168 | |
Chris Lattner | cb7f653 | 2010-08-29 18:42:23 +0000 | [diff] [blame] | 169 | for (unsigned i = 0, e = CallSites.size(); i != e; ++i) { |
| 170 | if (AA.getModRefInfo(getCallSite(i), CS) != AliasAnalysis::NoModRef || |
| 171 | AA.getModRefInfo(CS, getCallSite(i)) != AliasAnalysis::NoModRef) |
Chris Lattner | efe30ef | 2004-07-27 02:20:26 +0000 | [diff] [blame] | 172 | return true; |
Chris Lattner | cb7f653 | 2010-08-29 18:42:23 +0000 | [diff] [blame] | 173 | } |
Chris Lattner | efe30ef | 2004-07-27 02:20:26 +0000 | [diff] [blame] | 174 | |
| 175 | for (iterator I = begin(), E = end(); I != E; ++I) |
| 176 | if (AA.getModRefInfo(CS, I.getPointer(), I.getSize()) != |
| 177 | AliasAnalysis::NoModRef) |
| 178 | return true; |
| 179 | |
| 180 | return false; |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 181 | } |
| 182 | |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 183 | void AliasSetTracker::clear() { |
| 184 | // Delete all the PointerRec entries. |
Dan Gohman | b5b56ba | 2009-07-30 20:21:41 +0000 | [diff] [blame] | 185 | for (PointerMapType::iterator I = PointerMap.begin(), E = PointerMap.end(); |
| 186 | I != E; ++I) |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 187 | I->second->eraseFromList(); |
| 188 | |
| 189 | PointerMap.clear(); |
| 190 | |
| 191 | // The alias sets should all be clear now. |
| 192 | AliasSets.clear(); |
| 193 | } |
| 194 | |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 195 | |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 196 | /// findAliasSetForPointer - Given a pointer, find the one alias set to put the |
| 197 | /// instruction referring to the pointer into. If there are multiple alias sets |
| 198 | /// that may alias the pointer, merge them together and return the unified set. |
| 199 | /// |
Chris Lattner | 31a9d18 | 2003-02-26 22:11:00 +0000 | [diff] [blame] | 200 | AliasSet *AliasSetTracker::findAliasSetForPointer(const Value *Ptr, |
| 201 | unsigned Size) { |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 202 | AliasSet *FoundSet = 0; |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 203 | for (iterator I = begin(), E = end(); I != E; ++I) { |
| 204 | if (I->Forward || !I->aliasesPointer(Ptr, Size, AA)) continue; |
| 205 | |
| 206 | if (FoundSet == 0) { // If this is the first alias set ptr can go into. |
| 207 | FoundSet = I; // Remember it. |
| 208 | } else { // Otherwise, we must merge the sets. |
| 209 | FoundSet->mergeSetIn(*I, *this); // Merge in contents. |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 210 | } |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 211 | } |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 212 | |
| 213 | return FoundSet; |
| 214 | } |
| 215 | |
Chris Lattner | 07bfa52 | 2004-11-26 21:36:25 +0000 | [diff] [blame] | 216 | /// containsPointer - Return true if the specified location is represented by |
| 217 | /// this alias set, false otherwise. This does not modify the AST object or |
| 218 | /// alias sets. |
| 219 | bool AliasSetTracker::containsPointer(Value *Ptr, unsigned Size) const { |
| 220 | for (const_iterator I = begin(), E = end(); I != E; ++I) |
| 221 | if (!I->Forward && I->aliasesPointer(Ptr, Size, AA)) |
| 222 | return true; |
| 223 | return false; |
| 224 | } |
| 225 | |
| 226 | |
| 227 | |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 228 | AliasSet *AliasSetTracker::findAliasSetForCallSite(CallSite CS) { |
| 229 | AliasSet *FoundSet = 0; |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 230 | for (iterator I = begin(), E = end(); I != E; ++I) { |
| 231 | if (I->Forward || !I->aliasesCallSite(CS, AA)) |
| 232 | continue; |
| 233 | |
Chris Lattner | cb7f653 | 2010-08-29 18:42:23 +0000 | [diff] [blame] | 234 | if (FoundSet == 0) // If this is the first alias set ptr can go into. |
| 235 | FoundSet = I; // Remember it. |
| 236 | else if (!I->Forward) // Otherwise, we must merge the sets. |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 237 | FoundSet->mergeSetIn(*I, *this); // Merge in contents. |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 238 | } |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 239 | return FoundSet; |
| 240 | } |
| 241 | |
| 242 | |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 243 | |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 244 | |
| 245 | /// getAliasSetForPointer - Return the alias set that the specified pointer |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 246 | /// lives in. |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 247 | AliasSet &AliasSetTracker::getAliasSetForPointer(Value *Pointer, unsigned Size, |
| 248 | bool *New) { |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 249 | AliasSet::PointerRec &Entry = getEntryFor(Pointer); |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 250 | |
Chris Lattner | 9476d74 | 2010-08-29 04:13:43 +0000 | [diff] [blame] | 251 | // Check to see if the pointer is already known. |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 252 | if (Entry.hasAliasSet()) { |
| 253 | Entry.updateSize(Size); |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 254 | // Return the set! |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 255 | return *Entry.getAliasSet(*this)->getForwardedTarget(*this); |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 256 | } |
| 257 | |
| 258 | if (AliasSet *AS = findAliasSetForPointer(Pointer, Size)) { |
Chris Lattner | 9476d74 | 2010-08-29 04:13:43 +0000 | [diff] [blame] | 259 | // Add it to the alias set it aliases. |
Chris Lattner | 31a9d18 | 2003-02-26 22:11:00 +0000 | [diff] [blame] | 260 | AS->addPointer(*this, Entry, Size); |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 261 | return *AS; |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 262 | } |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 263 | |
| 264 | if (New) *New = true; |
Chris Lattner | 9476d74 | 2010-08-29 04:13:43 +0000 | [diff] [blame] | 265 | // Otherwise create a new alias set to hold the loaded pointer. |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 266 | AliasSets.push_back(new AliasSet()); |
| 267 | AliasSets.back().addPointer(*this, Entry, Size); |
| 268 | return AliasSets.back(); |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 269 | } |
| 270 | |
Chris Lattner | 61d4627 | 2004-07-26 05:50:23 +0000 | [diff] [blame] | 271 | bool AliasSetTracker::add(Value *Ptr, unsigned Size) { |
| 272 | bool NewPtr; |
| 273 | addPointer(Ptr, Size, AliasSet::NoModRef, NewPtr); |
| 274 | return NewPtr; |
| 275 | } |
| 276 | |
| 277 | |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 278 | bool AliasSetTracker::add(LoadInst *LI) { |
| 279 | bool NewPtr; |
| 280 | AliasSet &AS = addPointer(LI->getOperand(0), |
Dan Gohman | fc2a3ed | 2009-07-25 00:48:42 +0000 | [diff] [blame] | 281 | AA.getTypeStoreSize(LI->getType()), |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 282 | AliasSet::Refs, NewPtr); |
Chris Lattner | e260924 | 2003-12-14 04:52:11 +0000 | [diff] [blame] | 283 | if (LI->isVolatile()) AS.setVolatile(); |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 284 | return NewPtr; |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 285 | } |
| 286 | |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 287 | bool AliasSetTracker::add(StoreInst *SI) { |
| 288 | bool NewPtr; |
| 289 | Value *Val = SI->getOperand(0); |
| 290 | AliasSet &AS = addPointer(SI->getOperand(1), |
Dan Gohman | fc2a3ed | 2009-07-25 00:48:42 +0000 | [diff] [blame] | 291 | AA.getTypeStoreSize(Val->getType()), |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 292 | AliasSet::Mods, NewPtr); |
Chris Lattner | e260924 | 2003-12-14 04:52:11 +0000 | [diff] [blame] | 293 | if (SI->isVolatile()) AS.setVolatile(); |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 294 | return NewPtr; |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 295 | } |
| 296 | |
Dan Gohman | 235fc57 | 2008-04-14 18:34:50 +0000 | [diff] [blame] | 297 | bool AliasSetTracker::add(VAArgInst *VAAI) { |
| 298 | bool NewPtr; |
Chris Lattner | 05a24e5 | 2008-05-22 03:23:06 +0000 | [diff] [blame] | 299 | addPointer(VAAI->getOperand(0), ~0, AliasSet::ModRef, NewPtr); |
Dan Gohman | 235fc57 | 2008-04-14 18:34:50 +0000 | [diff] [blame] | 300 | return NewPtr; |
| 301 | } |
| 302 | |
Chris Lattner | e260924 | 2003-12-14 04:52:11 +0000 | [diff] [blame] | 303 | |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 304 | bool AliasSetTracker::add(CallSite CS) { |
Zhou Sheng | 7e4286e | 2009-03-03 06:02:04 +0000 | [diff] [blame] | 305 | if (isa<DbgInfoIntrinsic>(CS.getInstruction())) |
| 306 | return true; // Ignore DbgInfo Intrinsics. |
Duncan Sands | dff6710 | 2007-12-01 07:51:45 +0000 | [diff] [blame] | 307 | if (AA.doesNotAccessMemory(CS)) |
| 308 | return true; // doesn't alias anything |
Chris Lattner | fcead4f | 2004-03-15 06:28:07 +0000 | [diff] [blame] | 309 | |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 310 | AliasSet *AS = findAliasSetForCallSite(CS); |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 311 | if (AS) { |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 312 | AS->addCallSite(CS, AA); |
| 313 | return false; |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 314 | } |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 315 | AliasSets.push_back(new AliasSet()); |
| 316 | AS = &AliasSets.back(); |
| 317 | AS->addCallSite(CS, AA); |
| 318 | return true; |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 319 | } |
| 320 | |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 321 | bool AliasSetTracker::add(Instruction *I) { |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 322 | // Dispatch to one of the other add methods. |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 323 | if (LoadInst *LI = dyn_cast<LoadInst>(I)) |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 324 | return add(LI); |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 325 | if (StoreInst *SI = dyn_cast<StoreInst>(I)) |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 326 | return add(SI); |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 327 | if (CallInst *CI = dyn_cast<CallInst>(I)) |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 328 | return add(CI); |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 329 | if (InvokeInst *II = dyn_cast<InvokeInst>(I)) |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 330 | return add(II); |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 331 | if (VAArgInst *VAAI = dyn_cast<VAArgInst>(I)) |
Dan Gohman | 235fc57 | 2008-04-14 18:34:50 +0000 | [diff] [blame] | 332 | return add(VAAI); |
Chris Lattner | 12c1155 | 2004-07-21 05:18:04 +0000 | [diff] [blame] | 333 | return true; |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 334 | } |
| 335 | |
Chris Lattner | 319d05b | 2003-03-03 23:28:05 +0000 | [diff] [blame] | 336 | void AliasSetTracker::add(BasicBlock &BB) { |
| 337 | for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I) |
| 338 | add(I); |
| 339 | } |
| 340 | |
| 341 | void AliasSetTracker::add(const AliasSetTracker &AST) { |
| 342 | assert(&AA == &AST.AA && |
| 343 | "Merging AliasSetTracker objects with different Alias Analyses!"); |
| 344 | |
| 345 | // Loop over all of the alias sets in AST, adding the pointers contained |
| 346 | // therein into the current alias sets. This can cause alias sets to be |
| 347 | // merged together in the current AST. |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 348 | for (const_iterator I = AST.begin(), E = AST.end(); I != E; ++I) { |
| 349 | if (I->Forward) continue; // Ignore forwarding alias sets |
| 350 | |
| 351 | AliasSet &AS = const_cast<AliasSet&>(*I); |
Chris Lattner | 319d05b | 2003-03-03 23:28:05 +0000 | [diff] [blame] | 352 | |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 353 | // If there are any call sites in the alias set, add them to this AST. |
| 354 | for (unsigned i = 0, e = AS.CallSites.size(); i != e; ++i) |
| 355 | add(AS.CallSites[i]); |
Chris Lattner | 319d05b | 2003-03-03 23:28:05 +0000 | [diff] [blame] | 356 | |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 357 | // Loop over all of the pointers in this alias set. |
| 358 | bool X; |
| 359 | for (AliasSet::iterator ASI = AS.begin(), E = AS.end(); ASI != E; ++ASI) { |
| 360 | AliasSet &NewAS = addPointer(ASI.getPointer(), ASI.getSize(), |
| 361 | (AliasSet::AccessType)AS.AccessTy, X); |
| 362 | if (AS.isVolatile()) NewAS.setVolatile(); |
Chris Lattner | 319d05b | 2003-03-03 23:28:05 +0000 | [diff] [blame] | 363 | } |
Chris Lattner | 6e1f510 | 2010-08-29 04:06:55 +0000 | [diff] [blame] | 364 | } |
Chris Lattner | 319d05b | 2003-03-03 23:28:05 +0000 | [diff] [blame] | 365 | } |
| 366 | |
Chris Lattner | 6d4b0d7 | 2004-07-21 07:04:26 +0000 | [diff] [blame] | 367 | /// remove - Remove the specified (potentially non-empty) alias set from the |
| 368 | /// tracker. |
| 369 | void AliasSetTracker::remove(AliasSet &AS) { |
Chris Lattner | f299857 | 2006-06-27 23:48:59 +0000 | [diff] [blame] | 370 | // Drop all call sites. |
| 371 | AS.CallSites.clear(); |
| 372 | |
| 373 | // Clear the alias set. |
| 374 | unsigned NumRefs = 0; |
| 375 | while (!AS.empty()) { |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 376 | AliasSet::PointerRec *P = AS.PtrList; |
| 377 | |
| 378 | Value *ValToRemove = P->getValue(); |
Chris Lattner | f299857 | 2006-06-27 23:48:59 +0000 | [diff] [blame] | 379 | |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 380 | // Unlink and delete entry from the list of values. |
| 381 | P->eraseFromList(); |
Chris Lattner | f299857 | 2006-06-27 23:48:59 +0000 | [diff] [blame] | 382 | |
| 383 | // Remember how many references need to be dropped. |
| 384 | ++NumRefs; |
Chris Lattner | 6d4b0d7 | 2004-07-21 07:04:26 +0000 | [diff] [blame] | 385 | |
Chris Lattner | f299857 | 2006-06-27 23:48:59 +0000 | [diff] [blame] | 386 | // Finally, remove the entry. |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 387 | PointerMap.erase(ValToRemove); |
Chris Lattner | f299857 | 2006-06-27 23:48:59 +0000 | [diff] [blame] | 388 | } |
| 389 | |
| 390 | // Stop using the alias set, removing it. |
Chris Lattner | 356d8c2 | 2006-06-27 23:56:13 +0000 | [diff] [blame] | 391 | AS.RefCount -= NumRefs; |
| 392 | if (AS.RefCount == 0) |
| 393 | AS.removeFromTracker(*this); |
Chris Lattner | 6d4b0d7 | 2004-07-21 07:04:26 +0000 | [diff] [blame] | 394 | } |
| 395 | |
Chris Lattner | 61d4627 | 2004-07-26 05:50:23 +0000 | [diff] [blame] | 396 | bool AliasSetTracker::remove(Value *Ptr, unsigned Size) { |
| 397 | AliasSet *AS = findAliasSetForPointer(Ptr, Size); |
| 398 | if (!AS) return false; |
| 399 | remove(*AS); |
| 400 | return true; |
| 401 | } |
Chris Lattner | 6d4b0d7 | 2004-07-21 07:04:26 +0000 | [diff] [blame] | 402 | |
| 403 | bool AliasSetTracker::remove(LoadInst *LI) { |
Dan Gohman | fc2a3ed | 2009-07-25 00:48:42 +0000 | [diff] [blame] | 404 | unsigned Size = AA.getTypeStoreSize(LI->getType()); |
Chris Lattner | 6d4b0d7 | 2004-07-21 07:04:26 +0000 | [diff] [blame] | 405 | AliasSet *AS = findAliasSetForPointer(LI->getOperand(0), Size); |
| 406 | if (!AS) return false; |
| 407 | remove(*AS); |
| 408 | return true; |
| 409 | } |
| 410 | |
| 411 | bool AliasSetTracker::remove(StoreInst *SI) { |
Dan Gohman | fc2a3ed | 2009-07-25 00:48:42 +0000 | [diff] [blame] | 412 | unsigned Size = AA.getTypeStoreSize(SI->getOperand(0)->getType()); |
Chris Lattner | 6d4b0d7 | 2004-07-21 07:04:26 +0000 | [diff] [blame] | 413 | AliasSet *AS = findAliasSetForPointer(SI->getOperand(1), Size); |
| 414 | if (!AS) return false; |
| 415 | remove(*AS); |
| 416 | return true; |
| 417 | } |
| 418 | |
Dan Gohman | 235fc57 | 2008-04-14 18:34:50 +0000 | [diff] [blame] | 419 | bool AliasSetTracker::remove(VAArgInst *VAAI) { |
| 420 | AliasSet *AS = findAliasSetForPointer(VAAI->getOperand(0), ~0); |
| 421 | if (!AS) return false; |
| 422 | remove(*AS); |
| 423 | return true; |
| 424 | } |
| 425 | |
Chris Lattner | 6d4b0d7 | 2004-07-21 07:04:26 +0000 | [diff] [blame] | 426 | bool AliasSetTracker::remove(CallSite CS) { |
Duncan Sands | dff6710 | 2007-12-01 07:51:45 +0000 | [diff] [blame] | 427 | if (AA.doesNotAccessMemory(CS)) |
| 428 | return false; // doesn't alias anything |
Chris Lattner | 6d4b0d7 | 2004-07-21 07:04:26 +0000 | [diff] [blame] | 429 | |
| 430 | AliasSet *AS = findAliasSetForCallSite(CS); |
| 431 | if (!AS) return false; |
| 432 | remove(*AS); |
| 433 | return true; |
| 434 | } |
| 435 | |
| 436 | bool AliasSetTracker::remove(Instruction *I) { |
| 437 | // Dispatch to one of the other remove methods... |
| 438 | if (LoadInst *LI = dyn_cast<LoadInst>(I)) |
| 439 | return remove(LI); |
Chris Lattner | 9476d74 | 2010-08-29 04:13:43 +0000 | [diff] [blame] | 440 | if (StoreInst *SI = dyn_cast<StoreInst>(I)) |
Chris Lattner | 6d4b0d7 | 2004-07-21 07:04:26 +0000 | [diff] [blame] | 441 | return remove(SI); |
Chris Lattner | 9476d74 | 2010-08-29 04:13:43 +0000 | [diff] [blame] | 442 | if (CallInst *CI = dyn_cast<CallInst>(I)) |
Chris Lattner | 6d4b0d7 | 2004-07-21 07:04:26 +0000 | [diff] [blame] | 443 | return remove(CI); |
Chris Lattner | 9476d74 | 2010-08-29 04:13:43 +0000 | [diff] [blame] | 444 | if (VAArgInst *VAAI = dyn_cast<VAArgInst>(I)) |
Dan Gohman | 235fc57 | 2008-04-14 18:34:50 +0000 | [diff] [blame] | 445 | return remove(VAAI); |
Chris Lattner | 6d4b0d7 | 2004-07-21 07:04:26 +0000 | [diff] [blame] | 446 | return true; |
| 447 | } |
| 448 | |
Chris Lattner | 2cffeec | 2003-12-18 08:11:56 +0000 | [diff] [blame] | 449 | |
Chris Lattner | c43e0ae | 2004-05-23 21:10:58 +0000 | [diff] [blame] | 450 | // deleteValue method - This method is used to remove a pointer value from the |
Chris Lattner | 2cffeec | 2003-12-18 08:11:56 +0000 | [diff] [blame] | 451 | // AliasSetTracker entirely. It should be used when an instruction is deleted |
| 452 | // from the program to update the AST. If you don't use this, you would have |
| 453 | // dangling pointers to deleted instructions. |
| 454 | // |
Chris Lattner | c43e0ae | 2004-05-23 21:10:58 +0000 | [diff] [blame] | 455 | void AliasSetTracker::deleteValue(Value *PtrVal) { |
Chris Lattner | b66e648 | 2004-09-14 19:15:32 +0000 | [diff] [blame] | 456 | // Notify the alias analysis implementation that this value is gone. |
| 457 | AA.deleteValue(PtrVal); |
| 458 | |
Chris Lattner | 959e321 | 2006-06-26 19:20:48 +0000 | [diff] [blame] | 459 | // If this is a call instruction, remove the callsite from the appropriate |
Chris Lattner | cb7f653 | 2010-08-29 18:42:23 +0000 | [diff] [blame] | 460 | // AliasSet (if present). |
| 461 | if (CallSite CS = PtrVal) { |
| 462 | if (!AA.doesNotAccessMemory(CS)) { |
| 463 | // Scan all the alias sets to see if this call site is contained. |
| 464 | for (iterator I = begin(), E = end(); I != E; ++I) { |
| 465 | if (I->Forward) continue; |
| 466 | |
| 467 | I->removeCallSite(CS); |
| 468 | } |
| 469 | } |
| 470 | } |
Chris Lattner | 959e321 | 2006-06-26 19:20:48 +0000 | [diff] [blame] | 471 | |
Chris Lattner | b66e648 | 2004-09-14 19:15:32 +0000 | [diff] [blame] | 472 | // First, look up the PointerRec for this pointer. |
Dan Gohman | b5b56ba | 2009-07-30 20:21:41 +0000 | [diff] [blame] | 473 | PointerMapType::iterator I = PointerMap.find(PtrVal); |
Chris Lattner | 2cffeec | 2003-12-18 08:11:56 +0000 | [diff] [blame] | 474 | if (I == PointerMap.end()) return; // Noop |
| 475 | |
| 476 | // If we found one, remove the pointer from the alias set it is in. |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 477 | AliasSet::PointerRec *PtrValEnt = I->second; |
| 478 | AliasSet *AS = PtrValEnt->getAliasSet(*this); |
Chris Lattner | 2cffeec | 2003-12-18 08:11:56 +0000 | [diff] [blame] | 479 | |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 480 | // Unlink and delete from the list of values. |
| 481 | PtrValEnt->eraseFromList(); |
| 482 | |
| 483 | // Stop using the alias set. |
Chris Lattner | b8a31ac | 2004-07-22 07:58:18 +0000 | [diff] [blame] | 484 | AS->dropRef(*this); |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 485 | |
Chris Lattner | 2cffeec | 2003-12-18 08:11:56 +0000 | [diff] [blame] | 486 | PointerMap.erase(I); |
| 487 | } |
| 488 | |
Chris Lattner | b66e648 | 2004-09-14 19:15:32 +0000 | [diff] [blame] | 489 | // copyValue - This method should be used whenever a preexisting value in the |
| 490 | // program is copied or cloned, introducing a new value. Note that it is ok for |
| 491 | // clients that use this method to introduce the same value multiple times: if |
| 492 | // the tracker already knows about a value, it will ignore the request. |
| 493 | // |
| 494 | void AliasSetTracker::copyValue(Value *From, Value *To) { |
| 495 | // Notify the alias analysis implementation that this value is copied. |
| 496 | AA.copyValue(From, To); |
| 497 | |
| 498 | // First, look up the PointerRec for this pointer. |
Dan Gohman | b5b56ba | 2009-07-30 20:21:41 +0000 | [diff] [blame] | 499 | PointerMapType::iterator I = PointerMap.find(From); |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 500 | if (I == PointerMap.end()) |
Chris Lattner | b66e648 | 2004-09-14 19:15:32 +0000 | [diff] [blame] | 501 | return; // Noop |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 502 | assert(I->second->hasAliasSet() && "Dead entry?"); |
Chris Lattner | b66e648 | 2004-09-14 19:15:32 +0000 | [diff] [blame] | 503 | |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 504 | AliasSet::PointerRec &Entry = getEntryFor(To); |
| 505 | if (Entry.hasAliasSet()) return; // Already in the tracker! |
Chris Lattner | b66e648 | 2004-09-14 19:15:32 +0000 | [diff] [blame] | 506 | |
| 507 | // Add it to the alias set it aliases... |
Devang Patel | 6d9a2df | 2009-03-30 18:34:47 +0000 | [diff] [blame] | 508 | I = PointerMap.find(From); |
Chris Lattner | d7168dd | 2009-03-09 05:11:09 +0000 | [diff] [blame] | 509 | AliasSet *AS = I->second->getAliasSet(*this); |
| 510 | AS->addPointer(*this, Entry, I->second->getSize(), true); |
Chris Lattner | b66e648 | 2004-09-14 19:15:32 +0000 | [diff] [blame] | 511 | } |
| 512 | |
| 513 | |
Chris Lattner | 2cffeec | 2003-12-18 08:11:56 +0000 | [diff] [blame] | 514 | |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 515 | //===----------------------------------------------------------------------===// |
| 516 | // AliasSet/AliasSetTracker Printing Support |
| 517 | //===----------------------------------------------------------------------===// |
| 518 | |
Chris Lattner | 791102f | 2009-08-23 05:17:37 +0000 | [diff] [blame] | 519 | void AliasSet::print(raw_ostream &OS) const { |
Benjamin Kramer | 0339274 | 2010-08-30 14:46:53 +0000 | [diff] [blame^] | 520 | OS << " AliasSet[" << (void*)this << ", " << RefCount << "] "; |
Dan Gohman | 92c7b65 | 2008-04-21 19:48:48 +0000 | [diff] [blame] | 521 | OS << (AliasTy == MustAlias ? "must" : "may") << " alias, "; |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 522 | switch (AccessTy) { |
| 523 | case NoModRef: OS << "No access "; break; |
| 524 | case Refs : OS << "Ref "; break; |
| 525 | case Mods : OS << "Mod "; break; |
| 526 | case ModRef : OS << "Mod/Ref "; break; |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 527 | default: llvm_unreachable("Bad value for AccessTy!"); |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 528 | } |
Chris Lattner | e260924 | 2003-12-14 04:52:11 +0000 | [diff] [blame] | 529 | if (isVolatile()) OS << "[volatile] "; |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 530 | if (Forward) |
| 531 | OS << " forwarding to " << (void*)Forward; |
| 532 | |
| 533 | |
Dan Gohman | cb406c2 | 2007-10-03 19:26:29 +0000 | [diff] [blame] | 534 | if (!empty()) { |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 535 | OS << "Pointers: "; |
| 536 | for (iterator I = begin(), E = end(); I != E; ++I) { |
| 537 | if (I != begin()) OS << ", "; |
Chris Lattner | b8a31ac | 2004-07-22 07:58:18 +0000 | [diff] [blame] | 538 | WriteAsOperand(OS << "(", I.getPointer()); |
| 539 | OS << ", " << I.getSize() << ")"; |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 540 | } |
| 541 | } |
| 542 | if (!CallSites.empty()) { |
| 543 | OS << "\n " << CallSites.size() << " Call Sites: "; |
| 544 | for (unsigned i = 0, e = CallSites.size(); i != e; ++i) { |
| 545 | if (i) OS << ", "; |
Chris Lattner | cb7f653 | 2010-08-29 18:42:23 +0000 | [diff] [blame] | 546 | WriteAsOperand(OS, CallSites[i]); |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 547 | } |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 548 | } |
| 549 | OS << "\n"; |
| 550 | } |
| 551 | |
Chris Lattner | 791102f | 2009-08-23 05:17:37 +0000 | [diff] [blame] | 552 | void AliasSetTracker::print(raw_ostream &OS) const { |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 553 | OS << "Alias Set Tracker: " << AliasSets.size() << " alias sets for " |
| 554 | << PointerMap.size() << " pointer values.\n"; |
| 555 | for (const_iterator I = begin(), E = end(); I != E; ++I) |
| 556 | I->print(OS); |
| 557 | OS << "\n"; |
| 558 | } |
| 559 | |
David Greene | 43c48ac | 2009-12-23 19:27:59 +0000 | [diff] [blame] | 560 | void AliasSet::dump() const { print(dbgs()); } |
| 561 | void AliasSetTracker::dump() const { print(dbgs()); } |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 562 | |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 563 | //===----------------------------------------------------------------------===// |
Dan Gohman | b5b56ba | 2009-07-30 20:21:41 +0000 | [diff] [blame] | 564 | // ASTCallbackVH Class Implementation |
| 565 | //===----------------------------------------------------------------------===// |
| 566 | |
| 567 | void AliasSetTracker::ASTCallbackVH::deleted() { |
| 568 | assert(AST && "ASTCallbackVH called with a null AliasSetTracker!"); |
| 569 | AST->deleteValue(getValPtr()); |
| 570 | // this now dangles! |
| 571 | } |
| 572 | |
| 573 | AliasSetTracker::ASTCallbackVH::ASTCallbackVH(Value *V, AliasSetTracker *ast) |
Dan Gohman | a818c30 | 2009-07-31 18:21:48 +0000 | [diff] [blame] | 574 | : CallbackVH(V), AST(ast) {} |
| 575 | |
| 576 | AliasSetTracker::ASTCallbackVH & |
| 577 | AliasSetTracker::ASTCallbackVH::operator=(Value *V) { |
| 578 | return *this = ASTCallbackVH(V, AST); |
| 579 | } |
Dan Gohman | b5b56ba | 2009-07-30 20:21:41 +0000 | [diff] [blame] | 580 | |
| 581 | //===----------------------------------------------------------------------===// |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 582 | // AliasSetPrinter Pass |
| 583 | //===----------------------------------------------------------------------===// |
| 584 | |
| 585 | namespace { |
Nick Lewycky | 6726b6d | 2009-10-25 06:33:48 +0000 | [diff] [blame] | 586 | class AliasSetPrinter : public FunctionPass { |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 587 | AliasSetTracker *Tracker; |
| 588 | public: |
Nick Lewycky | ecd94c8 | 2007-05-06 13:37:16 +0000 | [diff] [blame] | 589 | static char ID; // Pass identification, replacement for typeid |
Owen Anderson | 90c579d | 2010-08-06 18:33:48 +0000 | [diff] [blame] | 590 | AliasSetPrinter() : FunctionPass(ID) {} |
Devang Patel | 794fd75 | 2007-05-01 21:15:47 +0000 | [diff] [blame] | 591 | |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 592 | virtual void getAnalysisUsage(AnalysisUsage &AU) const { |
| 593 | AU.setPreservesAll(); |
| 594 | AU.addRequired<AliasAnalysis>(); |
| 595 | } |
| 596 | |
| 597 | virtual bool runOnFunction(Function &F) { |
| 598 | Tracker = new AliasSetTracker(getAnalysis<AliasAnalysis>()); |
| 599 | |
| 600 | for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) |
Chris Lattner | 6ffe551 | 2004-04-27 15:13:33 +0000 | [diff] [blame] | 601 | Tracker->add(&*I); |
David Greene | 4850a89 | 2009-12-23 22:49:57 +0000 | [diff] [blame] | 602 | Tracker->print(errs()); |
Chris Lattner | 4983cf7 | 2006-01-03 06:05:22 +0000 | [diff] [blame] | 603 | delete Tracker; |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 604 | return false; |
| 605 | } |
Chris Lattner | 9971ac4 | 2003-02-24 20:37:56 +0000 | [diff] [blame] | 606 | }; |
Chris Lattner | 009cc3d | 2002-09-26 21:49:07 +0000 | [diff] [blame] | 607 | } |
Dan Gohman | 844731a | 2008-05-13 00:00:25 +0000 | [diff] [blame] | 608 | |
| 609 | char AliasSetPrinter::ID = 0; |
Owen Anderson | d13db2c | 2010-07-21 22:09:45 +0000 | [diff] [blame] | 610 | INITIALIZE_PASS(AliasSetPrinter, "print-alias-sets", |
| 611 | "Alias Set Printer", false, true); |