Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 1 | //===- MemoryDependenceAnalysis.cpp - Mem Deps Implementation --*- C++ -*-===// |
| 2 | // |
| 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. |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file implements an analysis that determines, for a given memory |
| 11 | // operation, what preceding memory operations it depends on. It builds on |
Owen Anderson | 80b1f09 | 2007-08-08 22:01:54 +0000 | [diff] [blame] | 12 | // alias analysis information, and tries to provide a lazy, caching interface to |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 13 | // a common kind of alias information query. |
| 14 | // |
| 15 | //===----------------------------------------------------------------------===// |
| 16 | |
Chris Lattner | 0e575f4 | 2008-11-28 21:45:17 +0000 | [diff] [blame] | 17 | #define DEBUG_TYPE "memdep" |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 18 | #include "llvm/Analysis/MemoryDependenceAnalysis.h" |
Owen Anderson | 7a616a1 | 2007-07-10 17:25:03 +0000 | [diff] [blame] | 19 | #include "llvm/Constants.h" |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 20 | #include "llvm/Instructions.h" |
| 21 | #include "llvm/Function.h" |
| 22 | #include "llvm/Analysis/AliasAnalysis.h" |
Chris Lattner | baad888 | 2008-11-28 22:28:27 +0000 | [diff] [blame] | 23 | #include "llvm/ADT/Statistic.h" |
| 24 | #include "llvm/ADT/STLExtras.h" |
Owen Anderson | 4beedbd | 2007-07-24 21:52:37 +0000 | [diff] [blame] | 25 | #include "llvm/Support/CFG.h" |
Tanya Lattner | 63aa160 | 2008-02-06 00:54:55 +0000 | [diff] [blame] | 26 | #include "llvm/Support/CommandLine.h" |
Chris Lattner | 0e575f4 | 2008-11-28 21:45:17 +0000 | [diff] [blame] | 27 | #include "llvm/Support/Debug.h" |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 28 | #include "llvm/Target/TargetData.h" |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 29 | using namespace llvm; |
| 30 | |
Dan Gohman | 844731a | 2008-05-13 00:00:25 +0000 | [diff] [blame] | 31 | // Control the calculation of non-local dependencies by only examining the |
| 32 | // predecessors if the basic block has less than X amount (50 by default). |
| 33 | static cl::opt<int> |
| 34 | PredLimit("nonlocaldep-threshold", cl::Hidden, cl::init(50), |
| 35 | cl::desc("Control the calculation of non-local" |
| 36 | "dependencies (default = 50)")); |
Tanya Lattner | 63aa160 | 2008-02-06 00:54:55 +0000 | [diff] [blame] | 37 | |
Owen Anderson | 7fad7e3 | 2007-09-09 21:43:49 +0000 | [diff] [blame] | 38 | STATISTIC(NumCacheNonlocal, "Number of cached non-local responses"); |
| 39 | STATISTIC(NumUncacheNonlocal, "Number of uncached non-local responses"); |
| 40 | |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 41 | char MemoryDependenceAnalysis::ID = 0; |
| 42 | |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 43 | // Register this pass... |
Owen Anderson | 776ee1f | 2007-07-10 20:21:08 +0000 | [diff] [blame] | 44 | static RegisterPass<MemoryDependenceAnalysis> X("memdep", |
Chris Lattner | 0e575f4 | 2008-11-28 21:45:17 +0000 | [diff] [blame] | 45 | "Memory Dependence Analysis", false, true); |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 46 | |
Chris Lattner | 0e575f4 | 2008-11-28 21:45:17 +0000 | [diff] [blame] | 47 | /// verifyRemoved - Verify that the specified instruction does not occur |
| 48 | /// in our internal data structures. |
Chris Lattner | 8b589fa | 2008-11-28 21:42:09 +0000 | [diff] [blame] | 49 | void MemoryDependenceAnalysis::verifyRemoved(Instruction *D) const { |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 50 | for (LocalDepMapType::const_iterator I = LocalDeps.begin(), |
| 51 | E = LocalDeps.end(); I != E; ++I) { |
Chris Lattner | 0e575f4 | 2008-11-28 21:45:17 +0000 | [diff] [blame] | 52 | assert(I->first != D && "Inst occurs in data structures"); |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 53 | assert(I->second.getPointer() != D && |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 54 | "Inst occurs in data structures"); |
Owen Anderson | 5fc4aba | 2007-12-08 01:37:09 +0000 | [diff] [blame] | 55 | } |
| 56 | |
Chris Lattner | 8b589fa | 2008-11-28 21:42:09 +0000 | [diff] [blame] | 57 | for (nonLocalDepMapType::const_iterator I = depGraphNonLocal.begin(), |
| 58 | E = depGraphNonLocal.end(); I != E; ++I) { |
Chris Lattner | 0e575f4 | 2008-11-28 21:45:17 +0000 | [diff] [blame] | 59 | assert(I->first != D && "Inst occurs in data structures"); |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 60 | for (DenseMap<BasicBlock*, DepResultTy>::iterator II = I->second.begin(), |
Owen Anderson | d8f34fa | 2008-06-01 20:51:41 +0000 | [diff] [blame] | 61 | EE = I->second.end(); II != EE; ++II) |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 62 | assert(II->second.getPointer() != D && "Inst occurs in data structures"); |
Owen Anderson | 5fc4aba | 2007-12-08 01:37:09 +0000 | [diff] [blame] | 63 | } |
| 64 | |
Chris Lattner | 8b589fa | 2008-11-28 21:42:09 +0000 | [diff] [blame] | 65 | for (reverseDepMapType::const_iterator I = reverseDep.begin(), |
| 66 | E = reverseDep.end(); I != E; ++I) |
| 67 | for (SmallPtrSet<Instruction*, 4>::const_iterator II = I->second.begin(), |
| 68 | EE = I->second.end(); II != EE; ++II) |
Chris Lattner | 0e575f4 | 2008-11-28 21:45:17 +0000 | [diff] [blame] | 69 | assert(*II != D && "Inst occurs in data structures"); |
Owen Anderson | 5fc4aba | 2007-12-08 01:37:09 +0000 | [diff] [blame] | 70 | |
Chris Lattner | 8b589fa | 2008-11-28 21:42:09 +0000 | [diff] [blame] | 71 | for (reverseDepMapType::const_iterator I = reverseDepNonLocal.begin(), |
| 72 | E = reverseDepNonLocal.end(); |
Owen Anderson | 5fc4aba | 2007-12-08 01:37:09 +0000 | [diff] [blame] | 73 | I != E; ++I) |
Chris Lattner | 8b589fa | 2008-11-28 21:42:09 +0000 | [diff] [blame] | 74 | for (SmallPtrSet<Instruction*, 4>::const_iterator II = I->second.begin(), |
| 75 | EE = I->second.end(); II != EE; ++II) |
Chris Lattner | 0e575f4 | 2008-11-28 21:45:17 +0000 | [diff] [blame] | 76 | assert(*II != D && "Inst occurs in data structures"); |
Owen Anderson | 5fc4aba | 2007-12-08 01:37:09 +0000 | [diff] [blame] | 77 | } |
| 78 | |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 79 | /// getAnalysisUsage - Does not modify anything. It uses Alias Analysis. |
| 80 | /// |
| 81 | void MemoryDependenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const { |
| 82 | AU.setPreservesAll(); |
| 83 | AU.addRequiredTransitive<AliasAnalysis>(); |
| 84 | AU.addRequiredTransitive<TargetData>(); |
| 85 | } |
| 86 | |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 87 | /// getCallSiteDependency - Private helper for finding the local dependencies |
| 88 | /// of a call site. |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 89 | MemDepResult MemoryDependenceAnalysis:: |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 90 | getCallSiteDependency(CallSite C, BasicBlock::iterator ScanIt, |
| 91 | BasicBlock *BB) { |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 92 | AliasAnalysis &AA = getAnalysis<AliasAnalysis>(); |
| 93 | TargetData &TD = getAnalysis<TargetData>(); |
Owen Anderson | dbbe816 | 2007-08-07 00:33:45 +0000 | [diff] [blame] | 94 | |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 95 | // Walk backwards through the block, looking for dependencies |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 96 | while (ScanIt != BB->begin()) { |
| 97 | Instruction *Inst = --ScanIt; |
Owen Anderson | 5f32320 | 2007-07-10 17:59:22 +0000 | [diff] [blame] | 98 | |
| 99 | // If this inst is a memory op, get the pointer it accessed |
| 100 | Value* pointer = 0; |
| 101 | uint64_t pointerSize = 0; |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 102 | if (StoreInst* S = dyn_cast<StoreInst>(Inst)) { |
Owen Anderson | 5f32320 | 2007-07-10 17:59:22 +0000 | [diff] [blame] | 103 | pointer = S->getPointerOperand(); |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 104 | pointerSize = TD.getTypeStoreSize(S->getOperand(0)->getType()); |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 105 | } else if (AllocationInst* AI = dyn_cast<AllocationInst>(Inst)) { |
Owen Anderson | 5f32320 | 2007-07-10 17:59:22 +0000 | [diff] [blame] | 106 | pointer = AI; |
| 107 | if (ConstantInt* C = dyn_cast<ConstantInt>(AI->getArraySize())) |
Chris Lattner | 57d4012 | 2008-11-28 21:16:44 +0000 | [diff] [blame] | 108 | pointerSize = C->getZExtValue() * |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 109 | TD.getABITypeSize(AI->getAllocatedType()); |
Owen Anderson | 5f32320 | 2007-07-10 17:59:22 +0000 | [diff] [blame] | 110 | else |
| 111 | pointerSize = ~0UL; |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 112 | } else if (VAArgInst* V = dyn_cast<VAArgInst>(Inst)) { |
Owen Anderson | 06b6e82 | 2007-07-10 18:43:15 +0000 | [diff] [blame] | 113 | pointer = V->getOperand(0); |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 114 | pointerSize = TD.getTypeStoreSize(V->getType()); |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 115 | } else if (FreeInst* F = dyn_cast<FreeInst>(Inst)) { |
Owen Anderson | 5f32320 | 2007-07-10 17:59:22 +0000 | [diff] [blame] | 116 | pointer = F->getPointerOperand(); |
| 117 | |
| 118 | // FreeInsts erase the entire structure |
| 119 | pointerSize = ~0UL; |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 120 | } else if (CallSite::get(Inst).getInstruction() != 0) { |
| 121 | if (AA.getModRefBehavior(CallSite::get(Inst)) != |
| 122 | AliasAnalysis::DoesNotAccessMemory) |
| 123 | return MemDepResult::get(Inst); |
| 124 | continue; |
Owen Anderson | 202da14 | 2007-07-10 20:39:07 +0000 | [diff] [blame] | 125 | } else |
| 126 | continue; |
Owen Anderson | 5f32320 | 2007-07-10 17:59:22 +0000 | [diff] [blame] | 127 | |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 128 | if (AA.getModRefInfo(C, pointer, pointerSize) != AliasAnalysis::NoModRef) |
| 129 | return MemDepResult::get(Inst); |
Owen Anderson | 5f32320 | 2007-07-10 17:59:22 +0000 | [diff] [blame] | 130 | } |
| 131 | |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 132 | // No dependence found. |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 133 | return MemDepResult::getNonLocal(); |
Owen Anderson | 5f32320 | 2007-07-10 17:59:22 +0000 | [diff] [blame] | 134 | } |
| 135 | |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 136 | /// nonLocalHelper - Private helper used to calculate non-local dependencies |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 137 | /// by doing DFS on the predecessors of a block to find its dependencies. |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 138 | void MemoryDependenceAnalysis::nonLocalHelper(Instruction* query, |
Owen Anderson | 0cd3203 | 2007-07-25 19:57:03 +0000 | [diff] [blame] | 139 | BasicBlock* block, |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 140 | DenseMap<BasicBlock*, DepResultTy> &resp) { |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 141 | // Set of blocks that we've already visited in our DFS |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 142 | SmallPtrSet<BasicBlock*, 4> visited; |
Owen Anderson | ce4d88a | 2007-09-21 03:53:52 +0000 | [diff] [blame] | 143 | // If we're updating a dirtied cache entry, we don't need to reprocess |
| 144 | // already computed entries. |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 145 | for (DenseMap<BasicBlock*, DepResultTy>::iterator I = resp.begin(), |
Owen Anderson | ce4d88a | 2007-09-21 03:53:52 +0000 | [diff] [blame] | 146 | E = resp.end(); I != E; ++I) |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 147 | if (I->second.getInt() != Dirty) |
Owen Anderson | ce4d88a | 2007-09-21 03:53:52 +0000 | [diff] [blame] | 148 | visited.insert(I->first); |
| 149 | |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 150 | // Current stack of the DFS |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 151 | SmallVector<BasicBlock*, 4> stack; |
Owen Anderson | f062f10 | 2008-04-10 22:13:32 +0000 | [diff] [blame] | 152 | for (pred_iterator PI = pred_begin(block), PE = pred_end(block); |
| 153 | PI != PE; ++PI) |
| 154 | stack.push_back(*PI); |
Owen Anderson | 4beedbd | 2007-07-24 21:52:37 +0000 | [diff] [blame] | 155 | |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 156 | // Do a basic DFS |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 157 | while (!stack.empty()) { |
| 158 | BasicBlock* BB = stack.back(); |
| 159 | |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 160 | // If we've already visited this block, no need to revist |
Owen Anderson | 1c2763d | 2007-08-02 17:56:05 +0000 | [diff] [blame] | 161 | if (visited.count(BB)) { |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 162 | stack.pop_back(); |
| 163 | continue; |
| 164 | } |
| 165 | |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 166 | // If we find a new block with a local dependency for query, |
| 167 | // then we insert the new dependency and backtrack. |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 168 | if (BB != block) { |
Owen Anderson | 1c2763d | 2007-08-02 17:56:05 +0000 | [diff] [blame] | 169 | visited.insert(BB); |
| 170 | |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 171 | MemDepResult localDep = getDependencyFrom(query, BB->end(), BB); |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 172 | if (!localDep.isNonLocal()) { |
| 173 | resp.insert(std::make_pair(BB, ConvFromResult(localDep))); |
Owen Anderson | 1c2763d | 2007-08-02 17:56:05 +0000 | [diff] [blame] | 174 | stack.pop_back(); |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 175 | continue; |
| 176 | } |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 177 | // If we re-encounter the starting block, we still need to search it |
| 178 | // because there might be a dependency in the starting block AFTER |
| 179 | // the position of the query. This is necessary to get loops right. |
Owen Anderson | f062f10 | 2008-04-10 22:13:32 +0000 | [diff] [blame] | 180 | } else if (BB == block) { |
Owen Anderson | 1c2763d | 2007-08-02 17:56:05 +0000 | [diff] [blame] | 181 | visited.insert(BB); |
| 182 | |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 183 | MemDepResult localDep = getDependencyFrom(query, BB->end(), BB); |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 184 | if (localDep.getInst() != query) |
| 185 | resp.insert(std::make_pair(BB, ConvFromResult(localDep))); |
Owen Anderson | 1c2763d | 2007-08-02 17:56:05 +0000 | [diff] [blame] | 186 | |
| 187 | stack.pop_back(); |
Owen Anderson | 1c2763d | 2007-08-02 17:56:05 +0000 | [diff] [blame] | 188 | continue; |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 189 | } |
| 190 | |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 191 | // If we didn't find anything, recurse on the precessors of this block |
Tanya Lattner | 63aa160 | 2008-02-06 00:54:55 +0000 | [diff] [blame] | 192 | // Only do this for blocks with a small number of predecessors. |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 193 | bool predOnStack = false; |
| 194 | bool inserted = false; |
Tanya Lattner | 63aa160 | 2008-02-06 00:54:55 +0000 | [diff] [blame] | 195 | if (std::distance(pred_begin(BB), pred_end(BB)) <= PredLimit) { |
| 196 | for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); |
| 197 | PI != PE; ++PI) |
| 198 | if (!visited.count(*PI)) { |
| 199 | stack.push_back(*PI); |
| 200 | inserted = true; |
| 201 | } else |
| 202 | predOnStack = true; |
| 203 | } |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 204 | |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 205 | // If we inserted a new predecessor, then we'll come back to this block |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 206 | if (inserted) |
| 207 | continue; |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 208 | // If we didn't insert because we have no predecessors, then this |
| 209 | // query has no dependency at all. |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 210 | else if (!inserted && !predOnStack) { |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 211 | resp.insert(std::make_pair(BB, DepResultTy(0, None))); |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 212 | // If we didn't insert because our predecessors are already on the stack, |
| 213 | // then we might still have a dependency, but it will be discovered during |
| 214 | // backtracking. |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 215 | } else if (!inserted && predOnStack){ |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 216 | resp.insert(std::make_pair(BB, DepResultTy(0, NonLocal))); |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 217 | } |
| 218 | |
| 219 | stack.pop_back(); |
Owen Anderson | 4beedbd | 2007-07-24 21:52:37 +0000 | [diff] [blame] | 220 | } |
Owen Anderson | 4beedbd | 2007-07-24 21:52:37 +0000 | [diff] [blame] | 221 | } |
| 222 | |
Owen Anderson | 80b1f09 | 2007-08-08 22:01:54 +0000 | [diff] [blame] | 223 | /// getNonLocalDependency - Fills the passed-in map with the non-local |
| 224 | /// dependencies of the queries. The map will contain NonLocal for |
| 225 | /// blocks between the query and its dependencies. |
Owen Anderson | 9066020 | 2007-08-01 22:01:54 +0000 | [diff] [blame] | 226 | void MemoryDependenceAnalysis::getNonLocalDependency(Instruction* query, |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 227 | DenseMap<BasicBlock*, MemDepResult> &resp) { |
Owen Anderson | 4d13de4 | 2007-08-16 21:27:05 +0000 | [diff] [blame] | 228 | if (depGraphNonLocal.count(query)) { |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 229 | DenseMap<BasicBlock*, DepResultTy> &cached = depGraphNonLocal[query]; |
Owen Anderson | 7fad7e3 | 2007-09-09 21:43:49 +0000 | [diff] [blame] | 230 | NumCacheNonlocal++; |
Owen Anderson | ce4d88a | 2007-09-21 03:53:52 +0000 | [diff] [blame] | 231 | |
| 232 | SmallVector<BasicBlock*, 4> dirtied; |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 233 | for (DenseMap<BasicBlock*, DepResultTy>::iterator I = cached.begin(), |
Owen Anderson | ce4d88a | 2007-09-21 03:53:52 +0000 | [diff] [blame] | 234 | E = cached.end(); I != E; ++I) |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 235 | if (I->second.getInt() == Dirty) |
Owen Anderson | ce4d88a | 2007-09-21 03:53:52 +0000 | [diff] [blame] | 236 | dirtied.push_back(I->first); |
| 237 | |
| 238 | for (SmallVector<BasicBlock*, 4>::iterator I = dirtied.begin(), |
| 239 | E = dirtied.end(); I != E; ++I) { |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 240 | MemDepResult localDep = getDependencyFrom(query, (*I)->end(), *I); |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 241 | if (!localDep.isNonLocal()) |
| 242 | cached[*I] = ConvFromResult(localDep); |
Owen Anderson | ce4d88a | 2007-09-21 03:53:52 +0000 | [diff] [blame] | 243 | else { |
| 244 | cached.erase(*I); |
| 245 | nonLocalHelper(query, *I, cached); |
| 246 | } |
| 247 | } |
| 248 | |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 249 | // Update the reverse non-local dependency cache. |
| 250 | for (DenseMap<BasicBlock*, DepResultTy>::iterator I = cached.begin(), |
| 251 | E = cached.end(); I != E; ++I) { |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 252 | if (Instruction *Inst = I->second.getPointer()) |
| 253 | reverseDepNonLocal[Inst].insert(query); |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 254 | resp[I->first] = ConvToResult(I->second); |
| 255 | } |
Owen Anderson | 6bd15ce | 2008-06-01 21:03:52 +0000 | [diff] [blame] | 256 | |
Owen Anderson | 4d13de4 | 2007-08-16 21:27:05 +0000 | [diff] [blame] | 257 | return; |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 258 | } |
| 259 | |
| 260 | NumUncacheNonlocal++; |
Owen Anderson | 4d13de4 | 2007-08-16 21:27:05 +0000 | [diff] [blame] | 261 | |
Owen Anderson | 7fad7e3 | 2007-09-09 21:43:49 +0000 | [diff] [blame] | 262 | // If not, go ahead and search for non-local deps. |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 263 | DenseMap<BasicBlock*, DepResultTy> &cached = depGraphNonLocal[query]; |
| 264 | nonLocalHelper(query, query->getParent(), cached); |
| 265 | |
Owen Anderson | 4d13de4 | 2007-08-16 21:27:05 +0000 | [diff] [blame] | 266 | // Update the non-local dependency cache |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 267 | for (DenseMap<BasicBlock*, DepResultTy>::iterator I = cached.begin(), |
| 268 | E = cached.end(); I != E; ++I) { |
| 269 | // FIXME: Merge with the code above! |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 270 | if (Instruction *Inst = I->second.getPointer()) |
| 271 | reverseDepNonLocal[Inst].insert(query); |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 272 | resp[I->first] = ConvToResult(I->second); |
Owen Anderson | 4d13de4 | 2007-08-16 21:27:05 +0000 | [diff] [blame] | 273 | } |
Owen Anderson | 4beedbd | 2007-07-24 21:52:37 +0000 | [diff] [blame] | 274 | } |
| 275 | |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 276 | /// getDependency - Return the instruction on which a memory operation |
Dan Gohman | c04575f | 2008-04-10 23:02:38 +0000 | [diff] [blame] | 277 | /// depends. The local parameter indicates if the query should only |
Owen Anderson | 6b278fc | 2007-07-10 17:08:11 +0000 | [diff] [blame] | 278 | /// evaluate dependencies within the same basic block. |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 279 | /// FIXME: ELIMINATE START/BLOCK and make the caching happen in a higher level |
| 280 | /// METHOD. |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 281 | MemDepResult MemoryDependenceAnalysis:: |
| 282 | getDependencyFrom(Instruction *QueryInst, BasicBlock::iterator ScanIt, |
| 283 | BasicBlock *BB) { |
| 284 | AliasAnalysis &AA = getAnalysis<AliasAnalysis>(); |
| 285 | TargetData &TD = getAnalysis<TargetData>(); |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 286 | |
| 287 | // Get the pointer value for which dependence will be determined |
| 288 | Value* dependee = 0; |
Owen Anderson | 6b278fc | 2007-07-10 17:08:11 +0000 | [diff] [blame] | 289 | uint64_t dependeeSize = 0; |
Owen Anderson | e314eb3 | 2007-07-10 18:11:42 +0000 | [diff] [blame] | 290 | bool queryIsVolatile = false; |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 291 | |
| 292 | if (StoreInst* S = dyn_cast<StoreInst>(QueryInst)) { |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 293 | dependee = S->getPointerOperand(); |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 294 | dependeeSize = TD.getTypeStoreSize(S->getOperand(0)->getType()); |
Owen Anderson | e314eb3 | 2007-07-10 18:11:42 +0000 | [diff] [blame] | 295 | queryIsVolatile = S->isVolatile(); |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 296 | } else if (LoadInst* L = dyn_cast<LoadInst>(QueryInst)) { |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 297 | dependee = L->getPointerOperand(); |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 298 | dependeeSize = TD.getTypeStoreSize(L->getType()); |
Owen Anderson | e314eb3 | 2007-07-10 18:11:42 +0000 | [diff] [blame] | 299 | queryIsVolatile = L->isVolatile(); |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 300 | } else if (VAArgInst* V = dyn_cast<VAArgInst>(QueryInst)) { |
Owen Anderson | 06b6e82 | 2007-07-10 18:43:15 +0000 | [diff] [blame] | 301 | dependee = V->getOperand(0); |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 302 | dependeeSize = TD.getTypeStoreSize(V->getType()); |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 303 | } else if (FreeInst* F = dyn_cast<FreeInst>(QueryInst)) { |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 304 | dependee = F->getPointerOperand(); |
Owen Anderson | 6b278fc | 2007-07-10 17:08:11 +0000 | [diff] [blame] | 305 | // FreeInsts erase the entire structure, not just a field |
| 306 | dependeeSize = ~0UL; |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 307 | } else if (CallSite::get(QueryInst).getInstruction() != 0) |
| 308 | return getCallSiteDependency(CallSite::get(QueryInst), ScanIt, BB); |
Owen Anderson | 7a616a1 | 2007-07-10 17:25:03 +0000 | [diff] [blame] | 309 | else |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 310 | return MemDepResult::getNone(); |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 311 | |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 312 | // Walk backwards through the basic block, looking for dependencies |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 313 | while (ScanIt != BB->begin()) { |
| 314 | Instruction *Inst = --ScanIt; |
Owen Anderson | 6b278fc | 2007-07-10 17:08:11 +0000 | [diff] [blame] | 315 | |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 316 | // If this inst is a memory op, get the pointer it accessed |
| 317 | Value* pointer = 0; |
Owen Anderson | 6b278fc | 2007-07-10 17:08:11 +0000 | [diff] [blame] | 318 | uint64_t pointerSize = 0; |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 319 | if (StoreInst* S = dyn_cast<StoreInst>(Inst)) { |
Owen Anderson | e314eb3 | 2007-07-10 18:11:42 +0000 | [diff] [blame] | 320 | // All volatile loads/stores depend on each other |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 321 | if (queryIsVolatile && S->isVolatile()) |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 322 | return MemDepResult::get(S); |
Owen Anderson | e314eb3 | 2007-07-10 18:11:42 +0000 | [diff] [blame] | 323 | |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 324 | pointer = S->getPointerOperand(); |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 325 | pointerSize = TD.getTypeStoreSize(S->getOperand(0)->getType()); |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 326 | } else if (LoadInst* L = dyn_cast<LoadInst>(Inst)) { |
Owen Anderson | e314eb3 | 2007-07-10 18:11:42 +0000 | [diff] [blame] | 327 | // All volatile loads/stores depend on each other |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 328 | if (queryIsVolatile && L->isVolatile()) |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 329 | return MemDepResult::get(L); |
Owen Anderson | e314eb3 | 2007-07-10 18:11:42 +0000 | [diff] [blame] | 330 | |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 331 | pointer = L->getPointerOperand(); |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 332 | pointerSize = TD.getTypeStoreSize(L->getType()); |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 333 | } else if (AllocationInst* AI = dyn_cast<AllocationInst>(Inst)) { |
Owen Anderson | 6b278fc | 2007-07-10 17:08:11 +0000 | [diff] [blame] | 334 | pointer = AI; |
Owen Anderson | 7a616a1 | 2007-07-10 17:25:03 +0000 | [diff] [blame] | 335 | if (ConstantInt* C = dyn_cast<ConstantInt>(AI->getArraySize())) |
Chris Lattner | 57d4012 | 2008-11-28 21:16:44 +0000 | [diff] [blame] | 336 | pointerSize = C->getZExtValue() * |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 337 | TD.getABITypeSize(AI->getAllocatedType()); |
Owen Anderson | 6b278fc | 2007-07-10 17:08:11 +0000 | [diff] [blame] | 338 | else |
| 339 | pointerSize = ~0UL; |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 340 | } else if (VAArgInst* V = dyn_cast<VAArgInst>(Inst)) { |
Owen Anderson | 06b6e82 | 2007-07-10 18:43:15 +0000 | [diff] [blame] | 341 | pointer = V->getOperand(0); |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 342 | pointerSize = TD.getTypeStoreSize(V->getType()); |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 343 | } else if (FreeInst* F = dyn_cast<FreeInst>(Inst)) { |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 344 | pointer = F->getPointerOperand(); |
Owen Anderson | 6b278fc | 2007-07-10 17:08:11 +0000 | [diff] [blame] | 345 | |
| 346 | // FreeInsts erase the entire structure |
| 347 | pointerSize = ~0UL; |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 348 | } else if (isa<CallInst>(Inst) || isa<InvokeInst>(Inst)) { |
Owen Anderson | 80b1f09 | 2007-08-08 22:01:54 +0000 | [diff] [blame] | 349 | // Call insts need special handling. Check if they can modify our pointer |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 350 | AliasAnalysis::ModRefResult MR = AA.getModRefInfo(CallSite::get(Inst), |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 351 | dependee, dependeeSize); |
Owen Anderson | 8f35315 | 2007-08-06 23:26:03 +0000 | [diff] [blame] | 352 | |
| 353 | if (MR != AliasAnalysis::NoModRef) { |
| 354 | // Loads don't depend on read-only calls |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 355 | if (isa<LoadInst>(QueryInst) && MR == AliasAnalysis::Ref) |
Owen Anderson | 8f35315 | 2007-08-06 23:26:03 +0000 | [diff] [blame] | 356 | continue; |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 357 | return MemDepResult::get(Inst); |
Owen Anderson | 7a616a1 | 2007-07-10 17:25:03 +0000 | [diff] [blame] | 358 | } |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 359 | |
| 360 | continue; |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 361 | } |
| 362 | |
| 363 | // If we found a pointer, check if it could be the same as our pointer |
| 364 | if (pointer) { |
Owen Anderson | 6b278fc | 2007-07-10 17:08:11 +0000 | [diff] [blame] | 365 | AliasAnalysis::AliasResult R = AA.alias(pointer, pointerSize, |
| 366 | dependee, dependeeSize); |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 367 | |
| 368 | if (R != AliasAnalysis::NoAlias) { |
Owen Anderson | 8f35315 | 2007-08-06 23:26:03 +0000 | [diff] [blame] | 369 | // May-alias loads don't depend on each other |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 370 | if (isa<LoadInst>(QueryInst) && isa<LoadInst>(Inst) && |
Owen Anderson | 8f35315 | 2007-08-06 23:26:03 +0000 | [diff] [blame] | 371 | R == AliasAnalysis::MayAlias) |
| 372 | continue; |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 373 | return MemDepResult::get(Inst); |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 374 | } |
| 375 | } |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 376 | } |
| 377 | |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 378 | // If we found nothing, return the non-local flag. |
Chris Lattner | 4c72400 | 2008-11-29 02:29:27 +0000 | [diff] [blame] | 379 | return MemDepResult::getNonLocal(); |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 380 | } |
| 381 | |
Chris Lattner | 5391a1d | 2008-11-29 03:47:00 +0000 | [diff] [blame^] | 382 | /// getDependency - Return the instruction on which a memory operation |
| 383 | /// depends. |
| 384 | MemDepResult MemoryDependenceAnalysis::getDependency(Instruction *QueryInst) { |
| 385 | Instruction *ScanPos = QueryInst; |
| 386 | |
| 387 | // Check for a cached result |
| 388 | DepResultTy &LocalCache = LocalDeps[QueryInst]; |
| 389 | |
| 390 | // If the cached entry is non-dirty, just return it. |
| 391 | if (LocalCache.getInt() != Dirty) |
| 392 | return ConvToResult(LocalCache); |
| 393 | |
| 394 | // Otherwise, if we have a dirty entry, we know we can start the scan at that |
| 395 | // instruction, which may save us some work. |
| 396 | if (Instruction *Inst = LocalCache.getPointer()) |
| 397 | ScanPos = Inst; |
| 398 | |
| 399 | // Do the scan. |
| 400 | MemDepResult Res = |
| 401 | getDependencyFrom(QueryInst, ScanPos, QueryInst->getParent()); |
| 402 | |
| 403 | // Remember the result! |
| 404 | // FIXME: Don't convert back and forth! Make a shared helper function. |
| 405 | LocalCache = ConvFromResult(Res); |
| 406 | if (Instruction *I = Res.getInst()) |
| 407 | reverseDep[I].insert(QueryInst); |
| 408 | |
| 409 | return Res; |
| 410 | } |
| 411 | |
| 412 | |
Owen Anderson | 30b4bd4 | 2008-02-12 21:15:18 +0000 | [diff] [blame] | 413 | /// dropInstruction - Remove an instruction from the analysis, making |
| 414 | /// absolutely conservative assumptions when updating the cache. This is |
| 415 | /// useful, for example when an instruction is changed rather than removed. |
| 416 | void MemoryDependenceAnalysis::dropInstruction(Instruction* drop) { |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 417 | LocalDepMapType::iterator depGraphEntry = LocalDeps.find(drop); |
| 418 | if (depGraphEntry != LocalDeps.end()) |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 419 | if (Instruction *Inst = depGraphEntry->second.getPointer()) |
| 420 | reverseDep[Inst].erase(drop); |
Owen Anderson | 30b4bd4 | 2008-02-12 21:15:18 +0000 | [diff] [blame] | 421 | |
| 422 | // Drop dependency information for things that depended on this instr |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 423 | SmallPtrSet<Instruction*, 4>& set = reverseDep[drop]; |
Owen Anderson | 30b4bd4 | 2008-02-12 21:15:18 +0000 | [diff] [blame] | 424 | for (SmallPtrSet<Instruction*, 4>::iterator I = set.begin(), E = set.end(); |
| 425 | I != E; ++I) |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 426 | LocalDeps.erase(*I); |
Owen Anderson | 30b4bd4 | 2008-02-12 21:15:18 +0000 | [diff] [blame] | 427 | |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 428 | LocalDeps.erase(drop); |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 429 | reverseDep.erase(drop); |
Owen Anderson | 30b4bd4 | 2008-02-12 21:15:18 +0000 | [diff] [blame] | 430 | |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 431 | for (DenseMap<BasicBlock*, DepResultTy>::iterator DI = |
| 432 | depGraphNonLocal[drop].begin(), DE = depGraphNonLocal[drop].end(); |
Owen Anderson | 30b4bd4 | 2008-02-12 21:15:18 +0000 | [diff] [blame] | 433 | DI != DE; ++DI) |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 434 | if (Instruction *Inst = DI->second.getPointer()) |
| 435 | reverseDepNonLocal[Inst].erase(drop); |
Owen Anderson | 30b4bd4 | 2008-02-12 21:15:18 +0000 | [diff] [blame] | 436 | |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 437 | if (reverseDepNonLocal.count(drop)) { |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 438 | SmallPtrSet<Instruction*, 4>& set = |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 439 | reverseDepNonLocal[drop]; |
Owen Anderson | 30b4bd4 | 2008-02-12 21:15:18 +0000 | [diff] [blame] | 440 | for (SmallPtrSet<Instruction*, 4>::iterator I = set.begin(), E = set.end(); |
| 441 | I != E; ++I) |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 442 | for (DenseMap<BasicBlock*, DepResultTy>::iterator DI = |
Owen Anderson | 30b4bd4 | 2008-02-12 21:15:18 +0000 | [diff] [blame] | 443 | depGraphNonLocal[*I].begin(), DE = depGraphNonLocal[*I].end(); |
| 444 | DI != DE; ++DI) |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 445 | if (DI->second == DepResultTy(drop, Normal)) |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 446 | // FIXME: Why not remember the old insertion point?? |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 447 | DI->second = DepResultTy(0, Dirty); |
Owen Anderson | 30b4bd4 | 2008-02-12 21:15:18 +0000 | [diff] [blame] | 448 | } |
| 449 | |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 450 | reverseDepNonLocal.erase(drop); |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 451 | depGraphNonLocal.erase(drop); |
Owen Anderson | 30b4bd4 | 2008-02-12 21:15:18 +0000 | [diff] [blame] | 452 | } |
| 453 | |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 454 | /// removeInstruction - Remove an instruction from the dependence analysis, |
| 455 | /// updating the dependence of instructions that previously depended on it. |
Owen Anderson | 642a9e3 | 2007-08-08 22:26:03 +0000 | [diff] [blame] | 456 | /// This method attempts to keep the cache coherent using the reverse map. |
Chris Lattner | 5f589dc | 2008-11-28 22:04:47 +0000 | [diff] [blame] | 457 | void MemoryDependenceAnalysis::removeInstruction(Instruction *RemInst) { |
Chris Lattner | 5f589dc | 2008-11-28 22:04:47 +0000 | [diff] [blame] | 458 | // Walk through the Non-local dependencies, removing this one as the value |
| 459 | // for any cached queries. |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 460 | for (DenseMap<BasicBlock*, DepResultTy>::iterator DI = |
Chris Lattner | 5f589dc | 2008-11-28 22:04:47 +0000 | [diff] [blame] | 461 | depGraphNonLocal[RemInst].begin(), DE = depGraphNonLocal[RemInst].end(); |
Owen Anderson | 5fc4aba | 2007-12-08 01:37:09 +0000 | [diff] [blame] | 462 | DI != DE; ++DI) |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 463 | if (Instruction *Inst = DI->second.getPointer()) |
| 464 | reverseDepNonLocal[Inst].erase(RemInst); |
Owen Anderson | 5fc4aba | 2007-12-08 01:37:09 +0000 | [diff] [blame] | 465 | |
Chris Lattner | baad888 | 2008-11-28 22:28:27 +0000 | [diff] [blame] | 466 | // Shortly after this, we will look for things that depend on RemInst. In |
| 467 | // order to update these, we'll need a new dependency to base them on. We |
| 468 | // could completely delete any entries that depend on this, but it is better |
| 469 | // to make a more accurate approximation where possible. Compute that better |
| 470 | // approximation if we can. |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 471 | DepResultTy NewDependency; |
Chris Lattner | baad888 | 2008-11-28 22:28:27 +0000 | [diff] [blame] | 472 | |
Chris Lattner | 5f589dc | 2008-11-28 22:04:47 +0000 | [diff] [blame] | 473 | // If we have a cached local dependence query for this instruction, remove it. |
Chris Lattner | baad888 | 2008-11-28 22:28:27 +0000 | [diff] [blame] | 474 | // |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 475 | LocalDepMapType::iterator LocalDepEntry = LocalDeps.find(RemInst); |
| 476 | if (LocalDepEntry != LocalDeps.end()) { |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 477 | DepResultTy LocalDep = LocalDepEntry->second; |
Owen Anderson | 9a8ff8c | 2008-01-30 01:24:05 +0000 | [diff] [blame] | 478 | |
Chris Lattner | baad888 | 2008-11-28 22:28:27 +0000 | [diff] [blame] | 479 | // Remove this local dependency info. |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 480 | LocalDeps.erase(LocalDepEntry); |
Chris Lattner | 5f589dc | 2008-11-28 22:04:47 +0000 | [diff] [blame] | 481 | |
Chris Lattner | baad888 | 2008-11-28 22:28:27 +0000 | [diff] [blame] | 482 | // Remove us from DepInst's reverse set now that the local dep info is gone. |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 483 | if (Instruction *Inst = LocalDep.getPointer()) |
| 484 | reverseDep[Inst].erase(RemInst); |
Chris Lattner | baad888 | 2008-11-28 22:28:27 +0000 | [diff] [blame] | 485 | |
| 486 | // If we have unconfirmed info, don't trust it. |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 487 | if (LocalDep.getInt() != Dirty) { |
Chris Lattner | baad888 | 2008-11-28 22:28:27 +0000 | [diff] [blame] | 488 | // If we have a confirmed non-local flag, use it. |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 489 | if (LocalDep.getInt() == NonLocal || LocalDep.getInt() == None) { |
Chris Lattner | d3d12ec | 2008-11-28 22:51:08 +0000 | [diff] [blame] | 490 | // The only time this dependency is confirmed is if it is non-local. |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 491 | NewDependency = LocalDep; |
Chris Lattner | baad888 | 2008-11-28 22:28:27 +0000 | [diff] [blame] | 492 | } else { |
| 493 | // If we have dep info for RemInst, set them to it. |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 494 | Instruction *NDI = next(BasicBlock::iterator(LocalDep.getPointer())); |
| 495 | if (NDI != RemInst) // Don't use RemInst for the new dependency! |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 496 | NewDependency = DepResultTy(NDI, Dirty); |
Chris Lattner | baad888 | 2008-11-28 22:28:27 +0000 | [diff] [blame] | 497 | } |
David Greene | df46419 | 2007-07-31 20:01:27 +0000 | [diff] [blame] | 498 | } |
Owen Anderson | a8701a6 | 2008-02-05 04:34:03 +0000 | [diff] [blame] | 499 | } |
| 500 | |
Chris Lattner | baad888 | 2008-11-28 22:28:27 +0000 | [diff] [blame] | 501 | // If we don't already have a local dependency answer for this instruction, |
| 502 | // use the immediate successor of RemInst. We use the successor because |
| 503 | // getDependence starts by checking the immediate predecessor of what is in |
| 504 | // the cache. |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 505 | if (NewDependency == DepResultTy(0, Dirty)) |
| 506 | NewDependency = DepResultTy(next(BasicBlock::iterator(RemInst)), Dirty); |
Chris Lattner | baad888 | 2008-11-28 22:28:27 +0000 | [diff] [blame] | 507 | |
Chris Lattner | d3d12ec | 2008-11-28 22:51:08 +0000 | [diff] [blame] | 508 | // Loop over all of the things that depend on the instruction we're removing. |
| 509 | // |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 510 | reverseDepMapType::iterator ReverseDepIt = reverseDep.find(RemInst); |
Chris Lattner | d3d12ec | 2008-11-28 22:51:08 +0000 | [diff] [blame] | 511 | if (ReverseDepIt != reverseDep.end()) { |
| 512 | SmallPtrSet<Instruction*, 4> &ReverseDeps = ReverseDepIt->second; |
| 513 | for (SmallPtrSet<Instruction*, 4>::iterator I = ReverseDeps.begin(), |
| 514 | E = ReverseDeps.end(); I != E; ++I) { |
| 515 | Instruction *InstDependingOnRemInst = *I; |
| 516 | |
| 517 | // If we thought the instruction depended on itself (possible for |
| 518 | // unconfirmed dependencies) ignore the update. |
| 519 | if (InstDependingOnRemInst == RemInst) continue; |
| 520 | |
| 521 | // Insert the new dependencies. |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 522 | LocalDeps[InstDependingOnRemInst] = NewDependency; |
Chris Lattner | d3d12ec | 2008-11-28 22:51:08 +0000 | [diff] [blame] | 523 | |
| 524 | // If our NewDependency is an instruction, make sure to remember that new |
| 525 | // things depend on it. |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 526 | if (Instruction *Inst = NewDependency.getPointer()) |
| 527 | reverseDep[Inst].insert(InstDependingOnRemInst); |
Chris Lattner | d3d12ec | 2008-11-28 22:51:08 +0000 | [diff] [blame] | 528 | } |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 529 | reverseDep.erase(RemInst); |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 530 | } |
Owen Anderson | 4d13de4 | 2007-08-16 21:27:05 +0000 | [diff] [blame] | 531 | |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 532 | ReverseDepIt = reverseDepNonLocal.find(RemInst); |
Chris Lattner | d3d12ec | 2008-11-28 22:51:08 +0000 | [diff] [blame] | 533 | if (ReverseDepIt != reverseDepNonLocal.end()) { |
| 534 | SmallPtrSet<Instruction*, 4>& set = ReverseDepIt->second; |
Owen Anderson | 4d13de4 | 2007-08-16 21:27:05 +0000 | [diff] [blame] | 535 | for (SmallPtrSet<Instruction*, 4>::iterator I = set.begin(), E = set.end(); |
| 536 | I != E; ++I) |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 537 | for (DenseMap<BasicBlock*, DepResultTy>::iterator DI = |
Owen Anderson | ce4d88a | 2007-09-21 03:53:52 +0000 | [diff] [blame] | 538 | depGraphNonLocal[*I].begin(), DE = depGraphNonLocal[*I].end(); |
| 539 | DI != DE; ++DI) |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 540 | if (DI->second == DepResultTy(RemInst, Normal)) |
Chris Lattner | 7f52422 | 2008-11-29 03:22:12 +0000 | [diff] [blame] | 541 | // FIXME: Why not remember the old insertion point?? |
Chris Lattner | 39f372e | 2008-11-29 01:43:36 +0000 | [diff] [blame] | 542 | DI->second = DepResultTy(0, Dirty); |
| 543 | reverseDepNonLocal.erase(ReverseDepIt); |
Owen Anderson | 4d13de4 | 2007-08-16 21:27:05 +0000 | [diff] [blame] | 544 | } |
Owen Anderson | 5fc4aba | 2007-12-08 01:37:09 +0000 | [diff] [blame] | 545 | |
Chris Lattner | 5f589dc | 2008-11-28 22:04:47 +0000 | [diff] [blame] | 546 | depGraphNonLocal.erase(RemInst); |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 547 | |
Chris Lattner | 5f589dc | 2008-11-28 22:04:47 +0000 | [diff] [blame] | 548 | getAnalysis<AliasAnalysis>().deleteValue(RemInst); |
Chris Lattner | 0e575f4 | 2008-11-28 21:45:17 +0000 | [diff] [blame] | 549 | |
Chris Lattner | 5f589dc | 2008-11-28 22:04:47 +0000 | [diff] [blame] | 550 | DEBUG(verifyRemoved(RemInst)); |
Owen Anderson | 78e02f7 | 2007-07-06 23:14:35 +0000 | [diff] [blame] | 551 | } |