reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/Analysis/CFLSteensAliasAnalysis.h

   75     if (LocA.Ptr == LocB.Ptr)
   75     if (LocA.Ptr == LocB.Ptr)
   83     if (isa<Constant>(LocA.Ptr) && isa<Constant>(LocB.Ptr))
   83     if (isa<Constant>(LocA.Ptr) && isa<Constant>(LocB.Ptr))

include/llvm/Analysis/MemoryLocation.h

  250     Copy.Ptr = NewPtr;
  267     return Ptr == Other.Ptr && Size == Other.Size && AATags == Other.AATags;
  267     return Ptr == Other.Ptr && Size == Other.Size && AATags == Other.AATags;
  297     return DenseMapInfo<const Value *>::getHashValue(Val.Ptr) ^

include/llvm/Analysis/MemorySSA.h

 1222     if (WalkingPhi && Location.Ptr) {
 1224           const_cast<Value *>(Location.Ptr),
 1229         if (Translator.getAddr() != Location.Ptr) {

lib/Analysis/AliasAnalysis.cpp

  446   if (Loc.Ptr) {
  469   if (Loc.Ptr) {
  500   if (Loc.Ptr && pointsToConstantMemory(Loc, AAQI))
  514   if (Loc.Ptr) {
  544   if (Loc.Ptr) {
  564   if (Loc.Ptr) {
  588   if (Loc.Ptr) {
  616   if (Loc.Ptr) {
  647       GetUnderlyingObject(MemLoc.Ptr, I->getModule()->getDataLayout());

lib/Analysis/AliasSetTracker.cpp

  354   Value * const Pointer = const_cast<Value*>(MemLoc.Ptr);

lib/Analysis/BasicAliasAnalysis.cpp

  659   Worklist.push_back(Loc.Ptr);
  842   assert(notDifferentParent(LocA.Ptr, LocB.Ptr) &&
  842   assert(notDifferentParent(LocA.Ptr, LocB.Ptr) &&
  856   AliasResult Alias = aliasCheck(LocA.Ptr, LocA.Size, LocA.AATags, LocB.Ptr,
  856   AliasResult Alias = aliasCheck(LocA.Ptr, LocA.Size, LocA.AATags, LocB.Ptr,
  872   assert(notDifferentParent(Call, Loc.Ptr) &&
  875   const Value *Object = GetUnderlyingObject(Loc.Ptr, DL);

lib/Analysis/CFLAndersAliasAnalysis.cpp

  849   auto *ValA = LocA.Ptr;
  850   auto *ValB = LocB.Ptr;
  882   if (LocA.Ptr == LocB.Ptr)
  882   if (LocA.Ptr == LocB.Ptr)
  890   if (isa<Constant>(LocA.Ptr) && isa<Constant>(LocB.Ptr))
  890   if (isa<Constant>(LocA.Ptr) && isa<Constant>(LocB.Ptr))

lib/Analysis/CFLSteensAliasAnalysis.cpp

  267   auto *ValA = const_cast<Value *>(LocA.Ptr);
  268   auto *ValB = const_cast<Value *>(LocB.Ptr);

lib/Analysis/DependenceAnalysis.cpp

  650   MemoryLocation LocAS(LocA.Ptr, LocationSize::unknown(), LocA.AATags);
  651   MemoryLocation LocBS(LocB.Ptr, LocationSize::unknown(), LocB.AATags);
  656   const Value *AObj = GetUnderlyingObject(LocA.Ptr, DL);
  657   const Value *BObj = GetUnderlyingObject(LocB.Ptr, DL);

lib/Analysis/GlobalsModRef.cpp

  814   const Value *UV1 = GetUnderlyingObject(LocA.Ptr, DL);
  815   const Value *UV2 = GetUnderlyingObject(LocB.Ptr, DL);
  929           dyn_cast<GlobalValue>(GetUnderlyingObject(Loc.Ptr, DL)))

lib/Analysis/LoopAccessAnalysis.cpp

  510     Value *Ptr = const_cast<Value*>(Loc.Ptr);
  519     Value *Ptr = const_cast<Value*>(Loc.Ptr);

lib/Analysis/MemoryDependenceAnalysis.cpp

  204     if (Loc.Ptr) {
  667       const Value *AccessPtr = GetUnderlyingObject(MemLoc.Ptr, DL);
  747     if (MemLoc.Ptr) {
  921   assert(Loc.Ptr->getType()->isPointerTy() &&
  953                                        const_cast<Value *>(Loc.Ptr)));
  957   PHITransAddr Address(const_cast<Value *>(Loc.Ptr), DL, &AC);
  969                                      const_cast<Value *>(Loc.Ptr)));
 1010     ValueIsLoadPair CacheKey(Loc.Ptr, isLoad);
 1037   ValueIsLoadPair CacheKey(Loc.Ptr, isLoad);

lib/Analysis/ObjCARCAliasAnalysis.cpp

   47   const Value *SA = GetRCIdentityRoot(LocA.Ptr);
   48   const Value *SB = GetRCIdentityRoot(LocB.Ptr);
   79   const Value *S = GetRCIdentityRoot(Loc.Ptr);

lib/Analysis/ScalarEvolutionAliasAnalysis.cpp

   33   const SCEV *AS = SE.getSCEV(const_cast<Value *>(LocA.Ptr));
   34   const SCEV *BS = SE.getSCEV(const_cast<Value *>(LocB.Ptr));
   82   if ((AO && AO != LocA.Ptr) || (BO && BO != LocB.Ptr))
   82   if ((AO && AO != LocA.Ptr) || (BO && BO != LocB.Ptr))
   83     if (alias(MemoryLocation(AO ? AO : LocA.Ptr,
   86               MemoryLocation(BO ? BO : LocB.Ptr,

lib/Target/AMDGPU/AMDGPUAliasAnalysis.cpp

   81   unsigned asA = LocA.Ptr->getType()->getPointerAddressSpace();
   82   unsigned asB = LocB.Ptr->getType()->getPointerAddressSpace();
   94   const Value *Base = GetUnderlyingObject(Loc.Ptr, DL);

lib/Transforms/ObjCARC/ObjCARCContract.cpp

  215   auto *LocPtr = Loc.Ptr->stripPointerCasts();

lib/Transforms/Scalar/DeadStoreElimination.cpp

  305   assert(Loc.Ptr &&
  308   return const_cast<Value*>(Loc.Ptr);
  359   const Value *P1 = Earlier.Ptr->stripPointerCasts();
  360   const Value *P2 = Later.Ptr->stripPointerCasts();
  547   if (!InstReadLoc.Ptr)
  572     if (DepReadLoc.Ptr && AA.isMustAlias(InstReadLoc.Ptr, DepReadLoc.Ptr))
  572     if (DepReadLoc.Ptr && AA.isMustAlias(InstReadLoc.Ptr, DepReadLoc.Ptr))
  572     if (DepReadLoc.Ptr && AA.isMustAlias(InstReadLoc.Ptr, DepReadLoc.Ptr))
  720   const Value *UnderlyingPointer = GetUnderlyingObject(LoadedLoc.Ptr, DL);
 1011     const Value *Ptr = Loc.Ptr->stripPointerCasts();
 1125     if (!Loc.Ptr)
 1148       if (!DepLoc.Ptr)
 1160         const Value* Underlying = GetUnderlyingObject(DepLoc.Ptr, DL);

lib/Transforms/Scalar/LICM.cpp

 2269                           << *(MemLoc.Ptr) << "\n");
 2276                           << *(MemLoc.Ptr) << "\n");
 2280   LLVM_DEBUG(dbgs() << "Aliasing okay for " << *(MemLoc.Ptr) << "\n");

lib/Transforms/Vectorize/SLPVectorizer.cpp

 1489     if (Loc1.Ptr && Loc2.Ptr && isSimple(Inst1) && isSimple(Inst2)) {
 1489     if (Loc1.Ptr && Loc2.Ptr && isSimple(Inst1) && isSimple(Inst2)) {