lib/Analysis/GlobalsModRef.cpp

   1 //===- GlobalsModRef.cpp - Simple Mod/Ref Analysis for Globals ------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // 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 #include "llvm/Analysis/GlobalsModRef.h"
  18 #include "llvm/ADT/SCCIterator.h"
  19 #include "llvm/ADT/SmallPtrSet.h"
  20 #include "llvm/ADT/Statistic.h"
  21 #include "llvm/Analysis/MemoryBuiltins.h"
  22 #include "llvm/Analysis/TargetLibraryInfo.h"
  23 #include "llvm/Analysis/ValueTracking.h"
  24 #include "llvm/IR/DerivedTypes.h"
  25 #include "llvm/IR/InstIterator.h"
  26 #include "llvm/IR/Instructions.h"
  27 #include "llvm/IR/IntrinsicInst.h"
  28 #include "llvm/IR/Module.h"
  29 #include "llvm/Pass.h"
  30 #include "llvm/Support/CommandLine.h"
  31 using namespace llvm;
  32
  33 #define DEBUG_TYPE "globalsmodref-aa"
  34
  35 STATISTIC(NumNonAddrTakenGlobalVars,
  36           "Number of global vars without address taken");
  37 STATISTIC(NumNonAddrTakenFunctions,"Number of functions without address taken");
  38 STATISTIC(NumNoMemFunctions, "Number of functions that do not access memory");
  39 STATISTIC(NumReadMemFunctions, "Number of functions that only read memory");
  40 STATISTIC(NumIndirectGlobalVars, "Number of indirect global objects");
  41
  42 // An option to enable unsafe alias results from the GlobalsModRef analysis.
  43 // When enabled, GlobalsModRef will provide no-alias results which in extremely
  44 // rare cases may not be conservatively correct. In particular, in the face of
  45 // transforms which cause assymetry between how effective GetUnderlyingObject
  46 // is for two pointers, it may produce incorrect results.
  47 //
  48 // These unsafe results have been returned by GMR for many years without
  49 // causing significant issues in the wild and so we provide a mechanism to
  50 // re-enable them for users of LLVM that have a particular performance
  51 // sensitivity and no known issues. The option also makes it easy to evaluate
  52 // the performance impact of these results.
  53 static cl::opt<bool> EnableUnsafeGlobalsModRefAliasResults(
  54     "enable-unsafe-globalsmodref-alias-results", cl::init(false), cl::Hidden);
  55
  56 /// The mod/ref information collected for a particular function.
  57 ///
  58 /// We collect information about mod/ref behavior of a function here, both in
  59 /// general and as pertains to specific globals. We only have this detailed
  60 /// information when we know *something* useful about the behavior. If we
  61 /// saturate to fully general mod/ref, we remove the info for the function.
  62 class GlobalsAAResult::FunctionInfo {
  63   typedef SmallDenseMap<const GlobalValue *, ModRefInfo, 16> GlobalInfoMapType;
  64
  65   /// Build a wrapper struct that has 8-byte alignment. All heap allocations
  66   /// should provide this much alignment at least, but this makes it clear we
  67   /// specifically rely on this amount of alignment.
  68   struct LLVM_ALIGNAS(8) AlignedMap {
  69     AlignedMap() {}
  70     AlignedMap(const AlignedMap &Arg) : Map(Arg.Map) {}
  71     GlobalInfoMapType Map;
  72   };
  73
  74   /// Pointer traits for our aligned map.
  75   struct AlignedMapPointerTraits {
  76     static inline void *getAsVoidPointer(AlignedMap *P) { return P; }
  77     static inline AlignedMap *getFromVoidPointer(void *P) {
  78       return (AlignedMap *)P;
  79     }
  80     enum { NumLowBitsAvailable = 3 };
  81     static_assert(AlignOf<AlignedMap>::Alignment >= (1 << NumLowBitsAvailable),
  82                   "AlignedMap insufficiently aligned to have enough low bits.");
  83   };
  84
  85   /// The bit that flags that this function may read any global. This is
  86   /// chosen to mix together with ModRefInfo bits.
  87   enum { MayReadAnyGlobal = 4 };
  88
  89   /// Checks to document the invariants of the bit packing here.
  90   static_assert((MayReadAnyGlobal & MRI_ModRef) == 0,
  91                 "ModRef and the MayReadAnyGlobal flag bits overlap.");
  92   static_assert(((MayReadAnyGlobal | MRI_ModRef) >>
  93                  AlignedMapPointerTraits::NumLowBitsAvailable) == 0,
  94                 "Insufficient low bits to store our flag and ModRef info.");
  95
  96 public:
  97   FunctionInfo() : Info() {}
  98   ~FunctionInfo() {
  99     delete Info.getPointer();
 100   }
 101   // Spell out the copy ond move constructors and assignment operators to get
 102   // deep copy semantics and correct move semantics in the face of the
 103   // pointer-int pair.
 104   FunctionInfo(const FunctionInfo &Arg)
 105       : Info(nullptr, Arg.Info.getInt()) {
 106     if (const auto *ArgPtr = Arg.Info.getPointer())
 107       Info.setPointer(new AlignedMap(*ArgPtr));
 108   }
 109   FunctionInfo(FunctionInfo &&Arg)
 110       : Info(Arg.Info.getPointer(), Arg.Info.getInt()) {
 111     Arg.Info.setPointerAndInt(nullptr, 0);
 112   }
 113   FunctionInfo &operator=(const FunctionInfo &RHS) {
 114     delete Info.getPointer();
 115     Info.setPointerAndInt(nullptr, RHS.Info.getInt());
 116     if (const auto *RHSPtr = RHS.Info.getPointer())
 117       Info.setPointer(new AlignedMap(*RHSPtr));
 118     return *this;
 119   }
 120   FunctionInfo &operator=(FunctionInfo &&RHS) {
 121     delete Info.getPointer();
 122     Info.setPointerAndInt(RHS.Info.getPointer(), RHS.Info.getInt());
 123     RHS.Info.setPointerAndInt(nullptr, 0);
 124     return *this;
 125   }
 126
 127   /// Returns the \c ModRefInfo info for this function.
 128   ModRefInfo getModRefInfo() const {
 129     return ModRefInfo(Info.getInt() & MRI_ModRef);
 130   }
 131
 132   /// Adds new \c ModRefInfo for this function to its state.
 133   void addModRefInfo(ModRefInfo NewMRI) {
 134     Info.setInt(Info.getInt() | NewMRI);
 135   }
 136
 137   /// Returns whether this function may read any global variable, and we don't
 138   /// know which global.
 139   bool mayReadAnyGlobal() const { return Info.getInt() & MayReadAnyGlobal; }
 140
 141   /// Sets this function as potentially reading from any global.
 142   void setMayReadAnyGlobal() { Info.setInt(Info.getInt() | MayReadAnyGlobal); }
 143
 144   /// Returns the \c ModRefInfo info for this function w.r.t. a particular
 145   /// global, which may be more precise than the general information above.
 146   ModRefInfo getModRefInfoForGlobal(const GlobalValue &GV) const {
 147     ModRefInfo GlobalMRI = mayReadAnyGlobal() ? MRI_Ref : MRI_NoModRef;
 148     if (AlignedMap *P = Info.getPointer()) {
 149       auto I = P->Map.find(&GV);
 150       if (I != P->Map.end())
 151         GlobalMRI = ModRefInfo(GlobalMRI | I->second);
 152     }
 153     return GlobalMRI;
 154   }
 155
 156   /// Add mod/ref info from another function into ours, saturating towards
 157   /// MRI_ModRef.
 158   void addFunctionInfo(const FunctionInfo &FI) {
 159     addModRefInfo(FI.getModRefInfo());
 160
 161     if (FI.mayReadAnyGlobal())
 162       setMayReadAnyGlobal();
 163
 164     if (AlignedMap *P = FI.Info.getPointer())
 165       for (const auto &G : P->Map)
 166         addModRefInfoForGlobal(*G.first, G.second);
 167   }
 168
 169   void addModRefInfoForGlobal(const GlobalValue &GV, ModRefInfo NewMRI) {
 170     AlignedMap *P = Info.getPointer();
 171     if (!P) {
 172       P = new AlignedMap();
 173       Info.setPointer(P);
 174     }
 175     auto &GlobalMRI = P->Map[&GV];
 176     GlobalMRI = ModRefInfo(GlobalMRI | NewMRI);
 177   }
 178
 179   /// Clear a global's ModRef info. Should be used when a global is being
 180   /// deleted.
 181   void eraseModRefInfoForGlobal(const GlobalValue &GV) {
 182     if (AlignedMap *P = Info.getPointer())
 183       P->Map.erase(&GV);
 184   }
 185
 186 private:
 187   /// All of the information is encoded into a single pointer, with a three bit
 188   /// integer in the low three bits. The high bit provides a flag for when this
 189   /// function may read any global. The low two bits are the ModRefInfo. And
 190   /// the pointer, when non-null, points to a map from GlobalValue to
 191   /// ModRefInfo specific to that GlobalValue.
 192   PointerIntPair<AlignedMap *, 3, unsigned, AlignedMapPointerTraits> Info;
 193 };
 194
 195 void GlobalsAAResult::DeletionCallbackHandle::deleted() {
 196   Value *V = getValPtr();
 197   if (auto *F = dyn_cast<Function>(V))
 198     GAR->FunctionInfos.erase(F);
 199
 200   if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
 201     if (GAR->NonAddressTakenGlobals.erase(GV)) {
 202       // This global might be an indirect global.  If so, remove it and
 203       // remove any AllocRelatedValues for it.
 204       if (GAR->IndirectGlobals.erase(GV)) {
 205         // Remove any entries in AllocsForIndirectGlobals for this global.
 206         for (auto I = GAR->AllocsForIndirectGlobals.begin(),
 207                   E = GAR->AllocsForIndirectGlobals.end();
 208              I != E; ++I)
 209           if (I->second == GV)
 210             GAR->AllocsForIndirectGlobals.erase(I);
 211       }
 212
 213       // Scan the function info we have collected and remove this global
 214       // from all of them.
 215       for (auto &FIPair : GAR->FunctionInfos)
 216         FIPair.second.eraseModRefInfoForGlobal(*GV);
 217     }
 218   }
 219
 220   // If this is an allocation related to an indirect global, remove it.
 221   GAR->AllocsForIndirectGlobals.erase(V);
 222
 223   // And clear out the handle.
 224   setValPtr(nullptr);
 225   GAR->Handles.erase(I);
 226   // This object is now destroyed!
 227 }
 228
 229 FunctionModRefBehavior GlobalsAAResult::getModRefBehavior(const Function *F) {
 230   FunctionModRefBehavior Min = FMRB_UnknownModRefBehavior;
 231
 232   if (FunctionInfo *FI = getFunctionInfo(F)) {
 233     if (FI->getModRefInfo() == MRI_NoModRef)
 234       Min = FMRB_DoesNotAccessMemory;
 235     else if ((FI->getModRefInfo() & MRI_Mod) == 0)
 236       Min = FMRB_OnlyReadsMemory;
 237   }
 238
 239   return FunctionModRefBehavior(AAResultBase::getModRefBehavior(F) & Min);
 240 }
 241
 242 FunctionModRefBehavior
 243 GlobalsAAResult::getModRefBehavior(ImmutableCallSite CS) {
 244   FunctionModRefBehavior Min = FMRB_UnknownModRefBehavior;
 245
 246   if (const Function *F = CS.getCalledFunction())
 247     if (FunctionInfo *FI = getFunctionInfo(F)) {
 248       if (FI->getModRefInfo() == MRI_NoModRef)
 249         Min = FMRB_DoesNotAccessMemory;
 250       else if ((FI->getModRefInfo() & MRI_Mod) == 0)
 251         Min = FMRB_OnlyReadsMemory;
 252     }
 253
 254   return FunctionModRefBehavior(AAResultBase::getModRefBehavior(CS) & Min);
 255 }
 256
 257 /// Returns the function info for the function, or null if we don't have
 258 /// anything useful to say about it.
 259 GlobalsAAResult::FunctionInfo *
 260 GlobalsAAResult::getFunctionInfo(const Function *F) {
 261   auto I = FunctionInfos.find(F);
 262   if (I != FunctionInfos.end())
 263     return &I->second;
 264   return nullptr;
 265 }
 266
 267 /// AnalyzeGlobals - Scan through the users of all of the internal
 268 /// GlobalValue's in the program.  If none of them have their "address taken"
 269 /// (really, their address passed to something nontrivial), record this fact,
 270 /// and record the functions that they are used directly in.
 271 void GlobalsAAResult::AnalyzeGlobals(Module &M) {
 272   SmallPtrSet<Function *, 64> TrackedFunctions;
 273   for (Function &F : M)
 274     if (F.hasLocalLinkage())
 275       if (!AnalyzeUsesOfPointer(&F)) {
 276         // Remember that we are tracking this global.
 277         NonAddressTakenGlobals.insert(&F);
 278         TrackedFunctions.insert(&F);
 279         Handles.emplace_front(*this, &F);
 280         Handles.front().I = Handles.begin();
 281         ++NumNonAddrTakenFunctions;
 282       }
 283
 284   SmallPtrSet<Function *, 64> Readers, Writers;
 285   for (GlobalVariable &GV : M.globals())
 286     if (GV.hasLocalLinkage()) {
 287       if (!AnalyzeUsesOfPointer(&GV, &Readers,
 288                                 GV.isConstant() ? nullptr : &Writers)) {
 289         // Remember that we are tracking this global, and the mod/ref fns
 290         NonAddressTakenGlobals.insert(&GV);
 291         Handles.emplace_front(*this, &GV);
 292         Handles.front().I = Handles.begin();
 293
 294         for (Function *Reader : Readers) {
 295           if (TrackedFunctions.insert(Reader).second) {
 296             Handles.emplace_front(*this, Reader);
 297             Handles.front().I = Handles.begin();
 298           }
 299           FunctionInfos[Reader].addModRefInfoForGlobal(GV, MRI_Ref);
 300         }
 301
 302         if (!GV.isConstant()) // No need to keep track of writers to constants
 303           for (Function *Writer : Writers) {
 304             if (TrackedFunctions.insert(Writer).second) {
 305               Handles.emplace_front(*this, Writer);
 306               Handles.front().I = Handles.begin();
 307             }
 308             FunctionInfos[Writer].addModRefInfoForGlobal(GV, MRI_Mod);
 309           }
 310         ++NumNonAddrTakenGlobalVars;
 311
 312         // If this global holds a pointer type, see if it is an indirect global.
 313         if (GV.getType()->getElementType()->isPointerTy() &&
 314             AnalyzeIndirectGlobalMemory(&GV))
 315           ++NumIndirectGlobalVars;
 316       }
 317       Readers.clear();
 318       Writers.clear();
 319     }
 320 }
 321
 322 /// AnalyzeUsesOfPointer - Look at all of the users of the specified pointer.
 323 /// If this is used by anything complex (i.e., the address escapes), return
 324 /// true.  Also, while we are at it, keep track of those functions that read and
 325 /// write to the value.
 326 ///
 327 /// If OkayStoreDest is non-null, stores into this global are allowed.
 328 bool GlobalsAAResult::AnalyzeUsesOfPointer(Value *V,
 329                                            SmallPtrSetImpl<Function *> *Readers,
 330                                            SmallPtrSetImpl<Function *> *Writers,
 331                                            GlobalValue *OkayStoreDest) {
 332   if (!V->getType()->isPointerTy())
 333     return true;
 334
 335   for (Use &U : V->uses()) {
 336     User *I = U.getUser();
 337     if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
 338       if (Readers)
 339         Readers->insert(LI->getParent()->getParent());
 340     } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
 341       if (V == SI->getOperand(1)) {
 342         if (Writers)
 343           Writers->insert(SI->getParent()->getParent());
 344       } else if (SI->getOperand(1) != OkayStoreDest) {
 345         return true; // Storing the pointer
 346       }
 347     } else if (Operator::getOpcode(I) == Instruction::GetElementPtr) {
 348       if (AnalyzeUsesOfPointer(I, Readers, Writers))
 349         return true;
 350     } else if (Operator::getOpcode(I) == Instruction::BitCast) {
 351       if (AnalyzeUsesOfPointer(I, Readers, Writers, OkayStoreDest))
 352         return true;
 353     } else if (auto CS = CallSite(I)) {
 354       // Make sure that this is just the function being called, not that it is
 355       // passing into the function.
 356       if (!CS.isCallee(&U)) {
 357         // Detect calls to free.
 358         if (isFreeCall(I, &TLI)) {
 359           if (Writers)
 360             Writers->insert(CS->getParent()->getParent());
 361         } else if (CS.doesNotCapture(CS.getArgumentNo(&U))) {
 362           Function *ParentF = CS->getParent()->getParent();
 363           // A nocapture argument may be read from or written to, but does not
 364           // escape unless the call can somehow recurse.
 365           //
 366           // nocapture "indicates that the callee does not make any copies of
 367           // the pointer that outlive itself". Therefore if we directly or
 368           // indirectly recurse, we must treat the pointer as escaping.
 369           if (FunctionToSCCMap[ParentF] ==
 370               FunctionToSCCMap[CS.getCalledFunction()])
 371             return true;
 372           if (Readers)
 373             Readers->insert(ParentF);
 374           if (Writers)
 375             Writers->insert(ParentF);
 376         } else {
 377           return true; // Argument of an unknown call.
 378         }
 379       }
 380     } else if (ICmpInst *ICI = dyn_cast<ICmpInst>(I)) {
 381       if (!isa<ConstantPointerNull>(ICI->getOperand(1)))
 382         return true; // Allow comparison against null.
 383     } else {
 384       return true;
 385     }
 386   }
 387
 388   return false;
 389 }
 390
 391 /// AnalyzeIndirectGlobalMemory - We found an non-address-taken global variable
 392 /// which holds a pointer type.  See if the global always points to non-aliased
 393 /// heap memory: that is, all initializers of the globals are allocations, and
 394 /// those allocations have no use other than initialization of the global.
 395 /// Further, all loads out of GV must directly use the memory, not store the
 396 /// pointer somewhere.  If this is true, we consider the memory pointed to by
 397 /// GV to be owned by GV and can disambiguate other pointers from it.
 398 bool GlobalsAAResult::AnalyzeIndirectGlobalMemory(GlobalVariable *GV) {
 399   // Keep track of values related to the allocation of the memory, f.e. the
 400   // value produced by the malloc call and any casts.
 401   std::vector<Value *> AllocRelatedValues;
 402
 403   // If the initializer is a valid pointer, bail.
 404   if (Constant *C = GV->getInitializer())
 405     if (!C->isNullValue())
 406       return false;
 407
 408   // Walk the user list of the global.  If we find anything other than a direct
 409   // load or store, bail out.
 410   for (User *U : GV->users()) {
 411     if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
 412       // The pointer loaded from the global can only be used in simple ways:
 413       // we allow addressing of it and loading storing to it.  We do *not* allow
 414       // storing the loaded pointer somewhere else or passing to a function.
 415       if (AnalyzeUsesOfPointer(LI))
 416         return false; // Loaded pointer escapes.
 417       // TODO: Could try some IP mod/ref of the loaded pointer.
 418     } else if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
 419       // Storing the global itself.
 420       if (SI->getOperand(0) == GV)
 421         return false;
 422
 423       // If storing the null pointer, ignore it.
 424       if (isa<ConstantPointerNull>(SI->getOperand(0)))
 425         continue;
 426
 427       // Check the value being stored.
 428       Value *Ptr = GetUnderlyingObject(SI->getOperand(0),
 429                                        GV->getParent()->getDataLayout());
 430
 431       if (!isAllocLikeFn(Ptr, &TLI))
 432         return false; // Too hard to analyze.
 433
 434       // Analyze all uses of the allocation.  If any of them are used in a
 435       // non-simple way (e.g. stored to another global) bail out.
 436       if (AnalyzeUsesOfPointer(Ptr, /*Readers*/ nullptr, /*Writers*/ nullptr,
 437                                GV))
 438         return false; // Loaded pointer escapes.
 439
 440       // Remember that this allocation is related to the indirect global.
 441       AllocRelatedValues.push_back(Ptr);
 442     } else {
 443       // Something complex, bail out.
 444       return false;
 445     }
 446   }
 447
 448   // Okay, this is an indirect global.  Remember all of the allocations for
 449   // this global in AllocsForIndirectGlobals.
 450   while (!AllocRelatedValues.empty()) {
 451     AllocsForIndirectGlobals[AllocRelatedValues.back()] = GV;
 452     Handles.emplace_front(*this, AllocRelatedValues.back());
 453     Handles.front().I = Handles.begin();
 454     AllocRelatedValues.pop_back();
 455   }
 456   IndirectGlobals.insert(GV);
 457   Handles.emplace_front(*this, GV);
 458   Handles.front().I = Handles.begin();
 459   return true;
 460 }
 461
 462 void GlobalsAAResult::CollectSCCMembership(CallGraph &CG) {
 463   // We do a bottom-up SCC traversal of the call graph.  In other words, we
 464   // visit all callees before callers (leaf-first).
 465   unsigned SCCID = 0;
 466   for (scc_iterator<CallGraph *> I = scc_begin(&CG); !I.isAtEnd(); ++I) {
 467     const std::vector<CallGraphNode *> &SCC = *I;
 468     assert(!SCC.empty() && "SCC with no functions?");
 469
 470     for (auto *CGN : SCC)
 471       if (Function *F = CGN->getFunction())
 472         FunctionToSCCMap[F] = SCCID;
 473     ++SCCID;
 474   }
 475 }
 476
 477 /// AnalyzeCallGraph - At this point, we know the functions where globals are
 478 /// immediately stored to and read from.  Propagate this information up the call
 479 /// graph to all callers and compute the mod/ref info for all memory for each
 480 /// function.
 481 void GlobalsAAResult::AnalyzeCallGraph(CallGraph &CG, Module &M) {
 482   // We do a bottom-up SCC traversal of the call graph.  In other words, we
 483   // visit all callees before callers (leaf-first).
 484   for (scc_iterator<CallGraph *> I = scc_begin(&CG); !I.isAtEnd(); ++I) {
 485     const std::vector<CallGraphNode *> &SCC = *I;
 486     assert(!SCC.empty() && "SCC with no functions?");
 487
 488     if (!SCC[0]->getFunction() || SCC[0]->getFunction()->mayBeOverridden()) {
 489       // Calls externally or is weak - can't say anything useful. Remove any existing
 490       // function records (may have been created when scanning globals).
 491       for (auto *Node : SCC)
 492         FunctionInfos.erase(Node->getFunction());
 493       continue;
 494     }
 495
 496     FunctionInfo &FI = FunctionInfos[SCC[0]->getFunction()];
 497     bool KnowNothing = false;
 498
 499     // Collect the mod/ref properties due to called functions.  We only compute
 500     // one mod-ref set.
 501     for (unsigned i = 0, e = SCC.size(); i != e && !KnowNothing; ++i) {
 502       Function *F = SCC[i]->getFunction();
 503       if (!F) {
 504         KnowNothing = true;
 505         break;
 506       }
 507
 508       if (F->isDeclaration()) {
 509         // Try to get mod/ref behaviour from function attributes.
 510         if (F->doesNotAccessMemory()) {
 511           // Can't do better than that!
 512         } else if (F->onlyReadsMemory()) {
 513           FI.addModRefInfo(MRI_Ref);
 514           if (!F->isIntrinsic())
 515             // This function might call back into the module and read a global -
 516             // consider every global as possibly being read by this function.
 517             FI.setMayReadAnyGlobal();
 518         } else {
 519           FI.addModRefInfo(MRI_ModRef);
 520           // Can't say anything useful unless it's an intrinsic - they don't
 521           // read or write global variables of the kind considered here.
 522           KnowNothing = !F->isIntrinsic();
 523         }
 524         continue;
 525       }
 526
 527       for (CallGraphNode::iterator CI = SCC[i]->begin(), E = SCC[i]->end();
 528            CI != E && !KnowNothing; ++CI)
 529         if (Function *Callee = CI->second->getFunction()) {
 530           if (FunctionInfo *CalleeFI = getFunctionInfo(Callee)) {
 531             // Propagate function effect up.
 532             FI.addFunctionInfo(*CalleeFI);
 533           } else {
 534             // Can't say anything about it.  However, if it is inside our SCC,
 535             // then nothing needs to be done.
 536             CallGraphNode *CalleeNode = CG[Callee];
 537             if (std::find(SCC.begin(), SCC.end(), CalleeNode) == SCC.end())
 538               KnowNothing = true;
 539           }
 540         } else {
 541           KnowNothing = true;
 542         }
 543     }
 544
 545     // If we can't say anything useful about this SCC, remove all SCC functions
 546     // from the FunctionInfos map.
 547     if (KnowNothing) {
 548       for (auto *Node : SCC)
 549         FunctionInfos.erase(Node->getFunction());
 550       continue;
 551     }
 552
 553     // Scan the function bodies for explicit loads or stores.
 554     for (auto *Node : SCC) {
 555       if (FI.getModRefInfo() == MRI_ModRef)
 556         break; // The mod/ref lattice saturates here.
 557       for (Instruction &I : instructions(Node->getFunction())) {
 558         if (FI.getModRefInfo() == MRI_ModRef)
 559           break; // The mod/ref lattice saturates here.
 560
 561         // We handle calls specially because the graph-relevant aspects are
 562         // handled above.
 563         if (auto CS = CallSite(&I)) {
 564           if (isAllocationFn(&I, &TLI) || isFreeCall(&I, &TLI)) {
 565             // FIXME: It is completely unclear why this is necessary and not
 566             // handled by the above graph code.
 567             FI.addModRefInfo(MRI_ModRef);
 568           } else if (Function *Callee = CS.getCalledFunction()) {
 569             // The callgraph doesn't include intrinsic calls.
 570             if (Callee->isIntrinsic()) {
 571               FunctionModRefBehavior Behaviour =
 572                   AAResultBase::getModRefBehavior(Callee);
 573               FI.addModRefInfo(ModRefInfo(Behaviour & MRI_ModRef));
 574             }
 575           }
 576           continue;
 577         }
 578
 579         // All non-call instructions we use the primary predicates for whether
 580         // thay read or write memory.
 581         if (I.mayReadFromMemory())
 582           FI.addModRefInfo(MRI_Ref);
 583         if (I.mayWriteToMemory())
 584           FI.addModRefInfo(MRI_Mod);
 585       }
 586     }
 587
 588     if ((FI.getModRefInfo() & MRI_Mod) == 0)
 589       ++NumReadMemFunctions;
 590     if (FI.getModRefInfo() == MRI_NoModRef)
 591       ++NumNoMemFunctions;
 592
 593     // Finally, now that we know the full effect on this SCC, clone the
 594     // information to each function in the SCC.
 595     // FI is a reference into FunctionInfos, so copy it now so that it doesn't
 596     // get invalidated if DenseMap decides to re-hash.
 597     FunctionInfo CachedFI = FI;
 598     for (unsigned i = 1, e = SCC.size(); i != e; ++i)
 599       FunctionInfos[SCC[i]->getFunction()] = CachedFI;
 600   }
 601 }
 602
 603 // GV is a non-escaping global. V is a pointer address that has been loaded from.
 604 // If we can prove that V must escape, we can conclude that a load from V cannot
 605 // alias GV.
 606 static bool isNonEscapingGlobalNoAliasWithLoad(const GlobalValue *GV,
 607                                                const Value *V,
 608                                                int &Depth,
 609                                                const DataLayout &DL) {
 610   SmallPtrSet<const Value *, 8> Visited;
 611   SmallVector<const Value *, 8> Inputs;
 612   Visited.insert(V);
 613   Inputs.push_back(V);
 614   do {
 615     const Value *Input = Inputs.pop_back_val();
 616
 617     if (isa<GlobalValue>(Input) || isa<Argument>(Input) || isa<CallInst>(Input) ||
 618         isa<InvokeInst>(Input))
 619       // Arguments to functions or returns from functions are inherently
 620       // escaping, so we can immediately classify those as not aliasing any
 621       // non-addr-taken globals.
 622       //
 623       // (Transitive) loads from a global are also safe - if this aliased
 624       // another global, its address would escape, so no alias.
 625       continue;
 626
 627     // Recurse through a limited number of selects, loads and PHIs. This is an
 628     // arbitrary depth of 4, lower numbers could be used to fix compile time
 629     // issues if needed, but this is generally expected to be only be important
 630     // for small depths.
 631     if (++Depth > 4)
 632       return false;
 633
 634     if (auto *LI = dyn_cast<LoadInst>(Input)) {
 635       Inputs.push_back(GetUnderlyingObject(LI->getPointerOperand(), DL));
 636       continue;
 637     }
 638     if (auto *SI = dyn_cast<SelectInst>(Input)) {
 639       const Value *LHS = GetUnderlyingObject(SI->getTrueValue(), DL);
 640       const Value *RHS = GetUnderlyingObject(SI->getFalseValue(), DL);
 641       if (Visited.insert(LHS).second)
 642         Inputs.push_back(LHS);
 643       if (Visited.insert(RHS).second)
 644         Inputs.push_back(RHS);
 645       continue;
 646     }
 647     if (auto *PN = dyn_cast<PHINode>(Input)) {
 648       for (const Value *Op : PN->incoming_values()) {
 649         Op = GetUnderlyingObject(Op, DL);
 650         if (Visited.insert(Op).second)
 651           Inputs.push_back(Op);
 652       }
 653       continue;
 654     }
 655
 656     return false;
 657   } while (!Inputs.empty());
 658
 659   // All inputs were known to be no-alias.
 660   return true;
 661 }
 662
 663 // There are particular cases where we can conclude no-alias between
 664 // a non-addr-taken global and some other underlying object. Specifically,
 665 // a non-addr-taken global is known to not be escaped from any function. It is
 666 // also incorrect for a transformation to introduce an escape of a global in
 667 // a way that is observable when it was not there previously. One function
 668 // being transformed to introduce an escape which could possibly be observed
 669 // (via loading from a global or the return value for example) within another
 670 // function is never safe. If the observation is made through non-atomic
 671 // operations on different threads, it is a data-race and UB. If the
 672 // observation is well defined, by being observed the transformation would have
 673 // changed program behavior by introducing the observed escape, making it an
 674 // invalid transform.
 675 //
 676 // This property does require that transformations which *temporarily* escape
 677 // a global that was not previously escaped, prior to restoring it, cannot rely
 678 // on the results of GMR::alias. This seems a reasonable restriction, although
 679 // currently there is no way to enforce it. There is also no realistic
 680 // optimization pass that would make this mistake. The closest example is
 681 // a transformation pass which does reg2mem of SSA values but stores them into
 682 // global variables temporarily before restoring the global variable's value.
 683 // This could be useful to expose "benign" races for example. However, it seems
 684 // reasonable to require that a pass which introduces escapes of global
 685 // variables in this way to either not trust AA results while the escape is
 686 // active, or to be forced to operate as a module pass that cannot co-exist
 687 // with an alias analysis such as GMR.
 688 bool GlobalsAAResult::isNonEscapingGlobalNoAlias(const GlobalValue *GV,
 689                                                  const Value *V) {
 690   // In order to know that the underlying object cannot alias the
 691   // non-addr-taken global, we must know that it would have to be an escape.
 692   // Thus if the underlying object is a function argument, a load from
 693   // a global, or the return of a function, it cannot alias. We can also
 694   // recurse through PHI nodes and select nodes provided all of their inputs
 695   // resolve to one of these known-escaping roots.
 696   SmallPtrSet<const Value *, 8> Visited;
 697   SmallVector<const Value *, 8> Inputs;
 698   Visited.insert(V);
 699   Inputs.push_back(V);
 700   int Depth = 0;
 701   do {
 702     const Value *Input = Inputs.pop_back_val();
 703
 704     if (auto *InputGV = dyn_cast<GlobalValue>(Input)) {
 705       // If one input is the very global we're querying against, then we can't
 706       // conclude no-alias.
 707       if (InputGV == GV)
 708         return false;
 709
 710       // Distinct GlobalVariables never alias, unless overriden or zero-sized.
 711       // FIXME: The condition can be refined, but be conservative for now.
 712       auto *GVar = dyn_cast<GlobalVariable>(GV);
 713       auto *InputGVar = dyn_cast<GlobalVariable>(InputGV);
 714       if (GVar && InputGVar &&
 715           !GVar->isDeclaration() && !InputGVar->isDeclaration() &&
 716           !GVar->mayBeOverridden() && !InputGVar->mayBeOverridden()) {
 717         Type *GVType = GVar->getInitializer()->getType();
 718         Type *InputGVType = InputGVar->getInitializer()->getType();
 719         if (GVType->isSized() && InputGVType->isSized() &&
 720             (DL.getTypeAllocSize(GVType) > 0) &&
 721             (DL.getTypeAllocSize(InputGVType) > 0))
 722           continue;
 723       }
 724
 725       // Conservatively return false, even though we could be smarter
 726       // (e.g. look through GlobalAliases).
 727       return false;
 728     }
 729
 730     if (isa<Argument>(Input) || isa<CallInst>(Input) ||
 731         isa<InvokeInst>(Input)) {
 732       // Arguments to functions or returns from functions are inherently
 733       // escaping, so we can immediately classify those as not aliasing any
 734       // non-addr-taken globals.
 735       continue;
 736     }
 737
 738     // Recurse through a limited number of selects, loads and PHIs. This is an
 739     // arbitrary depth of 4, lower numbers could be used to fix compile time
 740     // issues if needed, but this is generally expected to be only be important
 741     // for small depths.
 742     if (++Depth > 4)
 743       return false;
 744
 745     if (auto *LI = dyn_cast<LoadInst>(Input)) {
 746       // A pointer loaded from a global would have been captured, and we know
 747       // that the global is non-escaping, so no alias.
 748       const Value *Ptr = GetUnderlyingObject(LI->getPointerOperand(), DL);
 749       if (isNonEscapingGlobalNoAliasWithLoad(GV, Ptr, Depth, DL))
 750         // The load does not alias with GV.
 751         continue;
 752       // Otherwise, a load could come from anywhere, so bail.
 753       return false;
 754     }
 755     if (auto *SI = dyn_cast<SelectInst>(Input)) {
 756       const Value *LHS = GetUnderlyingObject(SI->getTrueValue(), DL);
 757       const Value *RHS = GetUnderlyingObject(SI->getFalseValue(), DL);
 758       if (Visited.insert(LHS).second)
 759         Inputs.push_back(LHS);
 760       if (Visited.insert(RHS).second)
 761         Inputs.push_back(RHS);
 762       continue;
 763     }
 764     if (auto *PN = dyn_cast<PHINode>(Input)) {
 765       for (const Value *Op : PN->incoming_values()) {
 766         Op = GetUnderlyingObject(Op, DL);
 767         if (Visited.insert(Op).second)
 768           Inputs.push_back(Op);
 769       }
 770       continue;
 771     }
 772
 773     // FIXME: It would be good to handle other obvious no-alias cases here, but
 774     // it isn't clear how to do so reasonbly without building a small version
 775     // of BasicAA into this code. We could recurse into AAResultBase::alias
 776     // here but that seems likely to go poorly as we're inside the
 777     // implementation of such a query. Until then, just conservatievly retun
 778     // false.
 779     return false;
 780   } while (!Inputs.empty());
 781
 782   // If all the inputs to V were definitively no-alias, then V is no-alias.
 783   return true;
 784 }
 785
 786 /// alias - If one of the pointers is to a global that we are tracking, and the
 787 /// other is some random pointer, we know there cannot be an alias, because the
 788 /// address of the global isn't taken.
 789 AliasResult GlobalsAAResult::alias(const MemoryLocation &LocA,
 790                                    const MemoryLocation &LocB) {
 791   // Get the base object these pointers point to.
 792   const Value *UV1 = GetUnderlyingObject(LocA.Ptr, DL);
 793   const Value *UV2 = GetUnderlyingObject(LocB.Ptr, DL);
 794
 795   // If either of the underlying values is a global, they may be non-addr-taken
 796   // globals, which we can answer queries about.
 797   const GlobalValue *GV1 = dyn_cast<GlobalValue>(UV1);
 798   const GlobalValue *GV2 = dyn_cast<GlobalValue>(UV2);
 799   if (GV1 || GV2) {
 800     // If the global's address is taken, pretend we don't know it's a pointer to
 801     // the global.
 802     if (GV1 && !NonAddressTakenGlobals.count(GV1))
 803       GV1 = nullptr;
 804     if (GV2 && !NonAddressTakenGlobals.count(GV2))
 805       GV2 = nullptr;
 806
 807     // If the two pointers are derived from two different non-addr-taken
 808     // globals we know these can't alias.
 809     if (GV1 && GV2 && GV1 != GV2)
 810       return NoAlias;
 811
 812     // If one is and the other isn't, it isn't strictly safe but we can fake
 813     // this result if necessary for performance. This does not appear to be
 814     // a common problem in practice.
 815     if (EnableUnsafeGlobalsModRefAliasResults)
 816       if ((GV1 || GV2) && GV1 != GV2)
 817         return NoAlias;
 818
 819     // Check for a special case where a non-escaping global can be used to
 820     // conclude no-alias.
 821     if ((GV1 || GV2) && GV1 != GV2) {
 822       const GlobalValue *GV = GV1 ? GV1 : GV2;
 823       const Value *UV = GV1 ? UV2 : UV1;
 824       if (isNonEscapingGlobalNoAlias(GV, UV))
 825         return NoAlias;
 826     }
 827
 828     // Otherwise if they are both derived from the same addr-taken global, we
 829     // can't know the two accesses don't overlap.
 830   }
 831
 832   // These pointers may be based on the memory owned by an indirect global.  If
 833   // so, we may be able to handle this.  First check to see if the base pointer
 834   // is a direct load from an indirect global.
 835   GV1 = GV2 = nullptr;
 836   if (const LoadInst *LI = dyn_cast<LoadInst>(UV1))
 837     if (GlobalVariable *GV = dyn_cast<GlobalVariable>(LI->getOperand(0)))
 838       if (IndirectGlobals.count(GV))
 839         GV1 = GV;
 840   if (const LoadInst *LI = dyn_cast<LoadInst>(UV2))
 841     if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(LI->getOperand(0)))
 842       if (IndirectGlobals.count(GV))
 843         GV2 = GV;
 844
 845   // These pointers may also be from an allocation for the indirect global.  If
 846   // so, also handle them.
 847   if (!GV1)
 848     GV1 = AllocsForIndirectGlobals.lookup(UV1);
 849   if (!GV2)
 850     GV2 = AllocsForIndirectGlobals.lookup(UV2);
 851
 852   // Now that we know whether the two pointers are related to indirect globals,
 853   // use this to disambiguate the pointers. If the pointers are based on
 854   // different indirect globals they cannot alias.
 855   if (GV1 && GV2 && GV1 != GV2)
 856     return NoAlias;
 857
 858   // If one is based on an indirect global and the other isn't, it isn't
 859   // strictly safe but we can fake this result if necessary for performance.
 860   // This does not appear to be a common problem in practice.
 861   if (EnableUnsafeGlobalsModRefAliasResults)
 862     if ((GV1 || GV2) && GV1 != GV2)
 863       return NoAlias;
 864
 865   return AAResultBase::alias(LocA, LocB);
 866 }
 867
 868 ModRefInfo GlobalsAAResult::getModRefInfoForArgument(ImmutableCallSite CS,
 869                                                      const GlobalValue *GV) {
 870   if (CS.doesNotAccessMemory())
 871     return MRI_NoModRef;
 872   ModRefInfo ConservativeResult = CS.onlyReadsMemory() ? MRI_Ref : MRI_ModRef;
 873
 874   // Iterate through all the arguments to the called function. If any argument
 875   // is based on GV, return the conservative result.
 876   for (auto &A : CS.args()) {
 877     SmallVector<Value*, 4> Objects;
 878     GetUnderlyingObjects(A, Objects, DL);
 879
 880     // All objects must be identified.
 881     if (!std::all_of(Objects.begin(), Objects.end(), isIdentifiedObject))
 882       return ConservativeResult;
 883
 884     if (std::find(Objects.begin(), Objects.end(), GV) != Objects.end())
 885       return ConservativeResult;
 886   }
 887
 888   // We identified all objects in the argument list, and none of them were GV.
 889   return MRI_NoModRef;
 890 }
 891
 892 ModRefInfo GlobalsAAResult::getModRefInfo(ImmutableCallSite CS,
 893                                           const MemoryLocation &Loc) {
 894   unsigned Known = MRI_ModRef;
 895
 896   // If we are asking for mod/ref info of a direct call with a pointer to a
 897   // global we are tracking, return information if we have it.
 898   if (const GlobalValue *GV =
 899           dyn_cast<GlobalValue>(GetUnderlyingObject(Loc.Ptr, DL)))
 900     if (GV->hasLocalLinkage())
 901       if (const Function *F = CS.getCalledFunction())
 902         if (NonAddressTakenGlobals.count(GV))
 903           if (const FunctionInfo *FI = getFunctionInfo(F))
 904             Known = FI->getModRefInfoForGlobal(*GV) |
 905               getModRefInfoForArgument(CS, GV);
 906
 907   if (Known == MRI_NoModRef)
 908     return MRI_NoModRef; // No need to query other mod/ref analyses
 909   return ModRefInfo(Known & AAResultBase::getModRefInfo(CS, Loc));
 910 }
 911
 912 GlobalsAAResult::GlobalsAAResult(const DataLayout &DL,
 913                                  const TargetLibraryInfo &TLI)
 914     : AAResultBase(TLI), DL(DL) {}
 915
 916 GlobalsAAResult::GlobalsAAResult(GlobalsAAResult &&Arg)
 917     : AAResultBase(std::move(Arg)), DL(Arg.DL),
 918       NonAddressTakenGlobals(std::move(Arg.NonAddressTakenGlobals)),
 919       IndirectGlobals(std::move(Arg.IndirectGlobals)),
 920       AllocsForIndirectGlobals(std::move(Arg.AllocsForIndirectGlobals)),
 921       FunctionInfos(std::move(Arg.FunctionInfos)),
 922       Handles(std::move(Arg.Handles)) {
 923   // Update the parent for each DeletionCallbackHandle.
 924   for (auto &H : Handles) {
 925     assert(H.GAR == &Arg);
 926     H.GAR = this;
 927   }
 928 }
 929
 930 /*static*/ GlobalsAAResult
 931 GlobalsAAResult::analyzeModule(Module &M, const TargetLibraryInfo &TLI,
 932                                CallGraph &CG) {
 933   GlobalsAAResult Result(M.getDataLayout(), TLI);
 934
 935   // Discover which functions aren't recursive, to feed into AnalyzeGlobals.
 936   Result.CollectSCCMembership(CG);
 937
 938   // Find non-addr taken globals.
 939   Result.AnalyzeGlobals(M);
 940
 941   // Propagate on CG.
 942   Result.AnalyzeCallGraph(CG, M);
 943
 944   return Result;
 945 }
 946
 947 GlobalsAAResult GlobalsAA::run(Module &M, AnalysisManager<Module> *AM) {
 948   return GlobalsAAResult::analyzeModule(M,
 949                                         AM->getResult<TargetLibraryAnalysis>(M),
 950                                         AM->getResult<CallGraphAnalysis>(M));
 951 }
 952
 953 char GlobalsAA::PassID;
 954
 955 char GlobalsAAWrapperPass::ID = 0;
 956 INITIALIZE_PASS_BEGIN(GlobalsAAWrapperPass, "globals-aa",
 957                       "Globals Alias Analysis", false, true)
 958 INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
 959 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 960 INITIALIZE_PASS_END(GlobalsAAWrapperPass, "globals-aa",
 961                     "Globals Alias Analysis", false, true)
 962
 963 ModulePass *llvm::createGlobalsAAWrapperPass() {
 964   return new GlobalsAAWrapperPass();
 965 }
 966
 967 GlobalsAAWrapperPass::GlobalsAAWrapperPass() : ModulePass(ID) {
 968   initializeGlobalsAAWrapperPassPass(*PassRegistry::getPassRegistry());
 969 }
 970
 971 bool GlobalsAAWrapperPass::runOnModule(Module &M) {
 972   Result.reset(new GlobalsAAResult(GlobalsAAResult::analyzeModule(
 973       M, getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(),
 974       getAnalysis<CallGraphWrapperPass>().getCallGraph())));
 975   return false;
 976 }
 977
 978 bool GlobalsAAWrapperPass::doFinalization(Module &M) {
 979   Result.reset();
 980   return false;
 981 }
 982
 983 void GlobalsAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
 984   AU.setPreservesAll();
 985   AU.addRequired<CallGraphWrapperPass>();
 986   AU.addRequired<TargetLibraryInfoWrapperPass>();
 987 }