lib/Analysis/IPA/GlobalsModRef.cpp

   1 //===- GlobalsModRef.cpp - Simple Mod/Ref Analysis for Globals ------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This simple pass provides alias and mod/ref information for global values
  11 // that do not have their address taken, and keeps track of whether functions
  12 // read or write memory (are "pure").  For this simple (but very common) case,
  13 // we can provide pretty accurate and useful information.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #define DEBUG_TYPE "globalsmodref-aa"
  18 #include "llvm/Analysis/Passes.h"
  19 #include "llvm/Module.h"
  20 #include "llvm/Pass.h"
  21 #include "llvm/Instructions.h"
  22 #include "llvm/Constants.h"
  23 #include "llvm/DerivedTypes.h"
  24 #include "llvm/Analysis/AliasAnalysis.h"
  25 #include "llvm/Analysis/CallGraph.h"
  26 #include "llvm/Support/Compiler.h"
  27 #include "llvm/Support/CommandLine.h"
  28 #include "llvm/Support/InstIterator.h"
  29 #include "llvm/ADT/Statistic.h"
  30 #include "llvm/ADT/SCCIterator.h"
  31 #include <set>
  32 using namespace llvm;
  33
  34 STATISTIC(NumNonAddrTakenGlobalVars,
  35           "Number of global vars without address taken");
  36 STATISTIC(NumNonAddrTakenFunctions,"Number of functions without address taken");
  37 STATISTIC(NumNoMemFunctions, "Number of functions that do not access memory");
  38 STATISTIC(NumReadMemFunctions, "Number of functions that only read memory");
  39 STATISTIC(NumIndirectGlobalVars, "Number of indirect global objects");
  40
  41 namespace {
  42   /// FunctionRecord - One instance of this structure is stored for every
  43   /// function in the program.  Later, the entries for these functions are
  44   /// removed if the function is found to call an external function (in which
  45   /// case we know nothing about it.
  46   struct VISIBILITY_HIDDEN FunctionRecord {
  47     /// GlobalInfo - Maintain mod/ref info for all of the globals without
  48     /// addresses taken that are read or written (transitively) by this
  49     /// function.
  50     std::map<GlobalValue*, unsigned> GlobalInfo;
  51
  52     unsigned getInfoForGlobal(GlobalValue *GV) const {
  53       std::map<GlobalValue*, unsigned>::const_iterator I = GlobalInfo.find(GV);
  54       if (I != GlobalInfo.end())
  55         return I->second;
  56       return 0;
  57     }
  58
  59     /// FunctionEffect - Capture whether or not this function reads or writes to
  60     /// ANY memory.  If not, we can do a lot of aggressive analysis on it.
  61     unsigned FunctionEffect;
  62
  63     FunctionRecord() : FunctionEffect(0) {}
  64   };
  65
  66   /// GlobalsModRef - The actual analysis pass.
  67   class VISIBILITY_HIDDEN GlobalsModRef
  68       : public ModulePass, public AliasAnalysis {
  69     /// NonAddressTakenGlobals - The globals that do not have their addresses
  70     /// taken.
  71     std::set<GlobalValue*> NonAddressTakenGlobals;
  72
  73     /// IndirectGlobals - The memory pointed to by this global is known to be
  74     /// 'owned' by the global.
  75     std::set<GlobalValue*> IndirectGlobals;
  76
  77     /// AllocsForIndirectGlobals - If an instruction allocates memory for an
  78     /// indirect global, this map indicates which one.
  79     std::map<Value*, GlobalValue*> AllocsForIndirectGlobals;
  80
  81     /// FunctionInfo - For each function, keep track of what globals are
  82     /// modified or read.
  83     std::map<Function*, FunctionRecord> FunctionInfo;
  84
  85   public:
  86     bool runOnModule(Module &M) {
  87       InitializeAliasAnalysis(this);                 // set up super class
  88       AnalyzeGlobals(M);                          // find non-addr taken globals
  89       AnalyzeCallGraph(getAnalysis<CallGraph>(), M); // Propagate on CG
  90       return false;
  91     }
  92
  93     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  94       AliasAnalysis::getAnalysisUsage(AU);
  95       AU.addRequired<CallGraph>();
  96       AU.setPreservesAll();                         // Does not transform code
  97     }
  98
  99     //------------------------------------------------
 100     // Implement the AliasAnalysis API
 101     //
 102     AliasResult alias(const Value *V1, unsigned V1Size,
 103                       const Value *V2, unsigned V2Size);
 104     ModRefResult getModRefInfo(CallSite CS, Value *P, unsigned Size);
 105     ModRefResult getModRefInfo(CallSite CS1, CallSite CS2) {
 106       return AliasAnalysis::getModRefInfo(CS1,CS2);
 107     }
 108     bool hasNoModRefInfoForCalls() const { return false; }
 109
 110     /// getModRefBehavior - Return the behavior of the specified function if
 111     /// called from the specified call site.  The call site may be null in which
 112     /// case the most generic behavior of this function should be returned.
 113     virtual ModRefBehavior getModRefBehavior(Function *F, CallSite CS,
 114                                          std::vector<PointerAccessInfo> *Info) {
 115       if (FunctionRecord *FR = getFunctionInfo(F))
 116         if (FR->FunctionEffect == 0)
 117           return DoesNotAccessMemory;
 118         else if ((FR->FunctionEffect & Mod) == 0)
 119           return OnlyReadsMemory;
 120       return AliasAnalysis::getModRefBehavior(F, CS, Info);
 121     }
 122
 123     virtual void deleteValue(Value *V);
 124     virtual void copyValue(Value *From, Value *To);
 125
 126   private:
 127     /// getFunctionInfo - Return the function info for the function, or null if
 128     /// the function calls an external function (in which case we don't have
 129     /// anything useful to say about it).
 130     FunctionRecord *getFunctionInfo(Function *F) {
 131       std::map<Function*, FunctionRecord>::iterator I = FunctionInfo.find(F);
 132       if (I != FunctionInfo.end())
 133         return &I->second;
 134       return 0;
 135     }
 136
 137     void AnalyzeGlobals(Module &M);
 138     void AnalyzeCallGraph(CallGraph &CG, Module &M);
 139     void AnalyzeSCC(std::vector<CallGraphNode *> &SCC);
 140     bool AnalyzeUsesOfPointer(Value *V, std::vector<Function*> &Readers,
 141                               std::vector<Function*> &Writers,
 142                               GlobalValue *OkayStoreDest = 0);
 143     bool AnalyzeIndirectGlobalMemory(GlobalValue *GV);
 144   };
 145
 146   RegisterPass<GlobalsModRef> X("globalsmodref-aa",
 147                                 "Simple mod/ref analysis for globals");
 148   RegisterAnalysisGroup<AliasAnalysis> Y(X);
 149 }
 150
 151 Pass *llvm::createGlobalsModRefPass() { return new GlobalsModRef(); }
 152
 153 /// getUnderlyingObject - This traverses the use chain to figure out what object
 154 /// the specified value points to.  If the value points to, or is derived from,
 155 /// a global object, return it.
 156 static Value *getUnderlyingObject(Value *V) {
 157   if (!isa<PointerType>(V->getType())) return V;
 158
 159   // If we are at some type of object... return it.
 160   if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) return GV;
 161
 162   // Traverse through different addressing mechanisms.
 163   if (Instruction *I = dyn_cast<Instruction>(V)) {
 164     if (isa<BitCastInst>(I) || isa<GetElementPtrInst>(I))
 165       return getUnderlyingObject(I->getOperand(0));
 166   } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
 167     if (CE->getOpcode() == Instruction::BitCast ||
 168         CE->getOpcode() == Instruction::GetElementPtr)
 169       return getUnderlyingObject(CE->getOperand(0));
 170   }
 171
 172   // Othewise, we don't know what this is, return it as the base pointer.
 173   return V;
 174 }
 175
 176 /// AnalyzeGlobals - Scan through the users of all of the internal
 177 /// GlobalValue's in the program.  If none of them have their "Address taken"
 178 /// (really, their address passed to something nontrivial), record this fact,
 179 /// and record the functions that they are used directly in.
 180 void GlobalsModRef::AnalyzeGlobals(Module &M) {
 181   std::vector<Function*> Readers, Writers;
 182   for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
 183     if (I->hasInternalLinkage()) {
 184       if (!AnalyzeUsesOfPointer(I, Readers, Writers)) {
 185         // Remember that we are tracking this global.
 186         NonAddressTakenGlobals.insert(I);
 187         ++NumNonAddrTakenFunctions;
 188       }
 189       Readers.clear(); Writers.clear();
 190     }
 191
 192   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
 193        I != E; ++I)
 194     if (I->hasInternalLinkage()) {
 195       if (!AnalyzeUsesOfPointer(I, Readers, Writers)) {
 196         // Remember that we are tracking this global, and the mod/ref fns
 197         NonAddressTakenGlobals.insert(I);
 198         for (unsigned i = 0, e = Readers.size(); i != e; ++i)
 199           FunctionInfo[Readers[i]].GlobalInfo[I] |= Ref;
 200
 201         if (!I->isConstant())  // No need to keep track of writers to constants
 202           for (unsigned i = 0, e = Writers.size(); i != e; ++i)
 203             FunctionInfo[Writers[i]].GlobalInfo[I] |= Mod;
 204         ++NumNonAddrTakenGlobalVars;
 205
 206         // If this global holds a pointer type, see if it is an indirect global.
 207         if (isa<PointerType>(I->getType()->getElementType()) &&
 208             AnalyzeIndirectGlobalMemory(I))
 209           ++NumIndirectGlobalVars;
 210       }
 211       Readers.clear(); Writers.clear();
 212     }
 213 }
 214
 215 /// AnalyzeUsesOfPointer - Look at all of the users of the specified pointer.
 216 /// If this is used by anything complex (i.e., the address escapes), return
 217 /// true.  Also, while we are at it, keep track of those functions that read and
 218 /// write to the value.
 219 ///
 220 /// If OkayStoreDest is non-null, stores into this global are allowed.
 221 bool GlobalsModRef::AnalyzeUsesOfPointer(Value *V,
 222                                          std::vector<Function*> &Readers,
 223                                          std::vector<Function*> &Writers,
 224                                          GlobalValue *OkayStoreDest) {
 225   if (!isa<PointerType>(V->getType())) return true;
 226
 227   for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI != E; ++UI)
 228     if (LoadInst *LI = dyn_cast<LoadInst>(*UI)) {
 229       Readers.push_back(LI->getParent()->getParent());
 230     } else if (StoreInst *SI = dyn_cast<StoreInst>(*UI)) {
 231       if (V == SI->getOperand(1)) {
 232         Writers.push_back(SI->getParent()->getParent());
 233       } else if (SI->getOperand(1) != OkayStoreDest) {
 234         return true;  // Storing the pointer
 235       }
 236     } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(*UI)) {
 237       if (AnalyzeUsesOfPointer(GEP, Readers, Writers)) return true;
 238     } else if (CallInst *CI = dyn_cast<CallInst>(*UI)) {
 239       // Make sure that this is just the function being called, not that it is
 240       // passing into the function.
 241       for (unsigned i = 1, e = CI->getNumOperands(); i != e; ++i)
 242         if (CI->getOperand(i) == V) return true;
 243     } else if (InvokeInst *II = dyn_cast<InvokeInst>(*UI)) {
 244       // Make sure that this is just the function being called, not that it is
 245       // passing into the function.
 246       for (unsigned i = 3, e = II->getNumOperands(); i != e; ++i)
 247         if (II->getOperand(i) == V) return true;
 248     } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(*UI)) {
 249       if (CE->getOpcode() == Instruction::GetElementPtr ||
 250           CE->getOpcode() == Instruction::BitCast) {
 251         if (AnalyzeUsesOfPointer(CE, Readers, Writers))
 252           return true;
 253       } else {
 254         return true;
 255       }
 256     } else if (ICmpInst *ICI = dyn_cast<ICmpInst>(*UI)) {
 257       if (!isa<ConstantPointerNull>(ICI->getOperand(1)))
 258         return true;  // Allow comparison against null.
 259     } else if (FreeInst *F = dyn_cast<FreeInst>(*UI)) {
 260       Writers.push_back(F->getParent()->getParent());
 261     } else {
 262       return true;
 263     }
 264   return false;
 265 }
 266
 267 /// AnalyzeIndirectGlobalMemory - We found an non-address-taken global variable
 268 /// which holds a pointer type.  See if the global always points to non-aliased
 269 /// heap memory: that is, all initializers of the globals are allocations, and
 270 /// those allocations have no use other than initialization of the global.
 271 /// Further, all loads out of GV must directly use the memory, not store the
 272 /// pointer somewhere.  If this is true, we consider the memory pointed to by
 273 /// GV to be owned by GV and can disambiguate other pointers from it.
 274 bool GlobalsModRef::AnalyzeIndirectGlobalMemory(GlobalValue *GV) {
 275   // Keep track of values related to the allocation of the memory, f.e. the
 276   // value produced by the malloc call and any casts.
 277   std::vector<Value*> AllocRelatedValues;
 278
 279   // Walk the user list of the global.  If we find anything other than a direct
 280   // load or store, bail out.
 281   for (Value::use_iterator I = GV->use_begin(), E = GV->use_end(); I != E; ++I){
 282     if (LoadInst *LI = dyn_cast<LoadInst>(*I)) {
 283       // The pointer loaded from the global can only be used in simple ways:
 284       // we allow addressing of it and loading storing to it.  We do *not* allow
 285       // storing the loaded pointer somewhere else or passing to a function.
 286       std::vector<Function*> ReadersWriters;
 287       if (AnalyzeUsesOfPointer(LI, ReadersWriters, ReadersWriters))
 288         return false;  // Loaded pointer escapes.
 289       // TODO: Could try some IP mod/ref of the loaded pointer.
 290     } else if (StoreInst *SI = dyn_cast<StoreInst>(*I)) {
 291       // Storing the global itself.
 292       if (SI->getOperand(0) == GV) return false;
 293
 294       // If storing the null pointer, ignore it.
 295       if (isa<ConstantPointerNull>(SI->getOperand(0)))
 296         continue;
 297
 298       // Check the value being stored.
 299       Value *Ptr = getUnderlyingObject(SI->getOperand(0));
 300
 301       if (isa<MallocInst>(Ptr)) {
 302         // Okay, easy case.
 303       } else if (CallInst *CI = dyn_cast<CallInst>(Ptr)) {
 304         Function *F = CI->getCalledFunction();
 305         if (!F || !F->isDeclaration()) return false;     // Too hard to analyze.
 306         if (F->getName() != "calloc") return false;   // Not calloc.
 307       } else {
 308         return false;  // Too hard to analyze.
 309       }
 310
 311       // Analyze all uses of the allocation.  If any of them are used in a
 312       // non-simple way (e.g. stored to another global) bail out.
 313       std::vector<Function*> ReadersWriters;
 314       if (AnalyzeUsesOfPointer(Ptr, ReadersWriters, ReadersWriters, GV))
 315         return false;  // Loaded pointer escapes.
 316
 317       // Remember that this allocation is related to the indirect global.
 318       AllocRelatedValues.push_back(Ptr);
 319     } else {
 320       // Something complex, bail out.
 321       return false;
 322     }
 323   }
 324
 325   // Okay, this is an indirect global.  Remember all of the allocations for
 326   // this global in AllocsForIndirectGlobals.
 327   while (!AllocRelatedValues.empty()) {
 328     AllocsForIndirectGlobals[AllocRelatedValues.back()] = GV;
 329     AllocRelatedValues.pop_back();
 330   }
 331   IndirectGlobals.insert(GV);
 332   return true;
 333 }
 334
 335 /// AnalyzeCallGraph - At this point, we know the functions where globals are
 336 /// immediately stored to and read from.  Propagate this information up the call
 337 /// graph to all callers and compute the mod/ref info for all memory for each
 338 /// function.
 339 void GlobalsModRef::AnalyzeCallGraph(CallGraph &CG, Module &M) {
 340   // We do a bottom-up SCC traversal of the call graph.  In other words, we
 341   // visit all callees before callers (leaf-first).
 342   for (scc_iterator<CallGraph*> I = scc_begin(&CG), E = scc_end(&CG); I!=E; ++I)
 343     if ((*I).size() != 1) {
 344       AnalyzeSCC(*I);
 345     } else if (Function *F = (*I)[0]->getFunction()) {
 346       if (!F->isDeclaration()) {
 347         // Nonexternal function.
 348         AnalyzeSCC(*I);
 349       } else {
 350         // Otherwise external function.  Handle intrinsics and other special
 351         // cases here.
 352         if (getAnalysis<AliasAnalysis>().doesNotAccessMemory(F))
 353           // If it does not access memory, process the function, causing us to
 354           // realize it doesn't do anything (the body is empty).
 355           AnalyzeSCC(*I);
 356         else {
 357           // Otherwise, don't process it.  This will cause us to conservatively
 358           // assume the worst.
 359         }
 360       }
 361     } else {
 362       // Do not process the external node, assume the worst.
 363     }
 364 }
 365
 366 void GlobalsModRef::AnalyzeSCC(std::vector<CallGraphNode *> &SCC) {
 367   assert(!SCC.empty() && "SCC with no functions?");
 368   FunctionRecord &FR = FunctionInfo[SCC[0]->getFunction()];
 369
 370   bool CallsExternal = false;
 371   unsigned FunctionEffect = 0;
 372
 373   // Collect the mod/ref properties due to called functions.  We only compute
 374   // one mod-ref set
 375   for (unsigned i = 0, e = SCC.size(); i != e && !CallsExternal; ++i)
 376     for (CallGraphNode::iterator CI = SCC[i]->begin(), E = SCC[i]->end();
 377          CI != E; ++CI)
 378       if (Function *Callee = CI->second->getFunction()) {
 379         if (FunctionRecord *CalleeFR = getFunctionInfo(Callee)) {
 380           // Propagate function effect up.
 381           FunctionEffect |= CalleeFR->FunctionEffect;
 382
 383           // Incorporate callee's effects on globals into our info.
 384           for (std::map<GlobalValue*, unsigned>::iterator GI =
 385                  CalleeFR->GlobalInfo.begin(), E = CalleeFR->GlobalInfo.end();
 386                GI != E; ++GI)
 387             FR.GlobalInfo[GI->first] |= GI->second;
 388
 389         } else {
 390           // Okay, if we can't say anything about it, maybe some other alias
 391           // analysis can.
 392           ModRefBehavior MRB =
 393             AliasAnalysis::getModRefBehavior(Callee, CallSite());
 394           if (MRB != DoesNotAccessMemory) {
 395             // FIXME: could make this more aggressive for functions that just
 396             // read memory.  We should just say they read all globals.
 397             CallsExternal = true;
 398             break;
 399           }
 400         }
 401       } else {
 402         CallsExternal = true;
 403         break;
 404       }
 405
 406   // If this SCC calls an external function, we can't say anything about it, so
 407   // remove all SCC functions from the FunctionInfo map.
 408   if (CallsExternal) {
 409     for (unsigned i = 0, e = SCC.size(); i != e; ++i)
 410       FunctionInfo.erase(SCC[i]->getFunction());
 411     return;
 412   }
 413
 414   // Otherwise, unless we already know that this function mod/refs memory, scan
 415   // the function bodies to see if there are any explicit loads or stores.
 416   if (FunctionEffect != ModRef) {
 417     for (unsigned i = 0, e = SCC.size(); i != e && FunctionEffect != ModRef;++i)
 418       for (inst_iterator II = inst_begin(SCC[i]->getFunction()),
 419              E = inst_end(SCC[i]->getFunction());
 420            II != E && FunctionEffect != ModRef; ++II)
 421         if (isa<LoadInst>(*II))
 422           FunctionEffect |= Ref;
 423         else if (isa<StoreInst>(*II))
 424           FunctionEffect |= Mod;
 425         else if (isa<MallocInst>(*II) || isa<FreeInst>(*II))
 426           FunctionEffect |= ModRef;
 427   }
 428
 429   if ((FunctionEffect & Mod) == 0)
 430     ++NumReadMemFunctions;
 431   if (FunctionEffect == 0)
 432     ++NumNoMemFunctions;
 433   FR.FunctionEffect = FunctionEffect;
 434
 435   // Finally, now that we know the full effect on this SCC, clone the
 436   // information to each function in the SCC.
 437   for (unsigned i = 1, e = SCC.size(); i != e; ++i)
 438     FunctionInfo[SCC[i]->getFunction()] = FR;
 439 }
 440
 441
 442
 443 /// alias - If one of the pointers is to a global that we are tracking, and the
 444 /// other is some random pointer, we know there cannot be an alias, because the
 445 /// address of the global isn't taken.
 446 AliasAnalysis::AliasResult
 447 GlobalsModRef::alias(const Value *V1, unsigned V1Size,
 448                      const Value *V2, unsigned V2Size) {
 449   // Get the base object these pointers point to.
 450   Value *UV1 = getUnderlyingObject(const_cast<Value*>(V1));
 451   Value *UV2 = getUnderlyingObject(const_cast<Value*>(V2));
 452
 453   // If either of the underlying values is a global, they may be non-addr-taken
 454   // globals, which we can answer queries about.
 455   GlobalValue *GV1 = dyn_cast<GlobalValue>(UV1);
 456   GlobalValue *GV2 = dyn_cast<GlobalValue>(UV2);
 457   if (GV1 || GV2) {
 458     // If the global's address is taken, pretend we don't know it's a pointer to
 459     // the global.
 460     if (GV1 && !NonAddressTakenGlobals.count(GV1)) GV1 = 0;
 461     if (GV2 && !NonAddressTakenGlobals.count(GV2)) GV2 = 0;
 462
 463     // If the the two pointers are derived from two different non-addr-taken
 464     // globals, or if one is and the other isn't, we know these can't alias.
 465     if ((GV1 || GV2) && GV1 != GV2)
 466       return NoAlias;
 467
 468     // Otherwise if they are both derived from the same addr-taken global, we
 469     // can't know the two accesses don't overlap.
 470   }
 471
 472   // These pointers may be based on the memory owned by an indirect global.  If
 473   // so, we may be able to handle this.  First check to see if the base pointer
 474   // is a direct load from an indirect global.
 475   GV1 = GV2 = 0;
 476   if (LoadInst *LI = dyn_cast<LoadInst>(UV1))
 477     if (GlobalVariable *GV = dyn_cast<GlobalVariable>(LI->getOperand(0)))
 478       if (IndirectGlobals.count(GV))
 479         GV1 = GV;
 480   if (LoadInst *LI = dyn_cast<LoadInst>(UV2))
 481     if (GlobalVariable *GV = dyn_cast<GlobalVariable>(LI->getOperand(0)))
 482       if (IndirectGlobals.count(GV))
 483         GV2 = GV;
 484
 485   // These pointers may also be from an allocation for the indirect global.  If
 486   // so, also handle them.
 487   if (AllocsForIndirectGlobals.count(UV1))
 488     GV1 = AllocsForIndirectGlobals[UV1];
 489   if (AllocsForIndirectGlobals.count(UV2))
 490     GV2 = AllocsForIndirectGlobals[UV2];
 491
 492   // Now that we know whether the two pointers are related to indirect globals,
 493   // use this to disambiguate the pointers.  If either pointer is based on an
 494   // indirect global and if they are not both based on the same indirect global,
 495   // they cannot alias.
 496   if ((GV1 || GV2) && GV1 != GV2)
 497     return NoAlias;
 498
 499   return AliasAnalysis::alias(V1, V1Size, V2, V2Size);
 500 }
 501
 502 AliasAnalysis::ModRefResult
 503 GlobalsModRef::getModRefInfo(CallSite CS, Value *P, unsigned Size) {
 504   unsigned Known = ModRef;
 505
 506   // If we are asking for mod/ref info of a direct call with a pointer to a
 507   // global we are tracking, return information if we have it.
 508   if (GlobalValue *GV = dyn_cast<GlobalValue>(getUnderlyingObject(P)))
 509     if (GV->hasInternalLinkage())
 510       if (Function *F = CS.getCalledFunction())
 511         if (NonAddressTakenGlobals.count(GV))
 512           if (FunctionRecord *FR = getFunctionInfo(F))
 513             Known = FR->getInfoForGlobal(GV);
 514
 515   if (Known == NoModRef)
 516     return NoModRef; // No need to query other mod/ref analyses
 517   return ModRefResult(Known & AliasAnalysis::getModRefInfo(CS, P, Size));
 518 }
 519
 520
 521 //===----------------------------------------------------------------------===//
 522 // Methods to update the analysis as a result of the client transformation.
 523 //
 524 void GlobalsModRef::deleteValue(Value *V) {
 525   if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
 526     if (NonAddressTakenGlobals.erase(GV)) {
 527       // This global might be an indirect global.  If so, remove it and remove
 528       // any AllocRelatedValues for it.
 529       if (IndirectGlobals.erase(GV)) {
 530         // Remove any entries in AllocsForIndirectGlobals for this global.
 531         for (std::map<Value*, GlobalValue*>::iterator
 532              I = AllocsForIndirectGlobals.begin(),
 533              E = AllocsForIndirectGlobals.end(); I != E; ) {
 534           if (I->second == GV) {
 535             AllocsForIndirectGlobals.erase(I++);
 536           } else {
 537             ++I;
 538           }
 539         }
 540       }
 541     }
 542   }
 543
 544   // Otherwise, if this is an allocation related to an indirect global, remove
 545   // it.
 546   AllocsForIndirectGlobals.erase(V);
 547 }
 548
 549 void GlobalsModRef::copyValue(Value *From, Value *To) {
 550 }