[BasicAA/MDA] Sink aliasing rules for malloc and calloc into BasicAA

[reames]

Summary

MemoryDependenceAnalysis had a hard-coded exception to the general aliasing rules for malloc and calloc. The reasoning that applied there is equally valid in BasicAA and clarifies the remaining logic in MDA.

In principal, this can expose slightly more optimization opportunities, but since essentially all of our aliasing aware memory optimization passes go through MDA, this will likely be NFC in practice.

[reames]

ping

[• dberlin]

LGTM

lib/Analysis/BasicAliasAnalysis.cpp

744

What happens to alloca here?

[reames]

lib/Analysis/BasicAliasAnalysis.cpp

744

Nothing, it's not a call site.

I think what you're getting at is whether we need alloca handling in MDA. The flow there is unchanged. The mustalias (early def) case is exactly the same and Alloca's don't modify memory so we explicitly skip over them. The previous code would have either early continued or hit the NoModRef case inside getModRefInfo(Instruction*, MemLoc); in either case, we skip the alloca.

Actually, that points out the isa<AllocaInst> check I added in MDA is completely redundant. I'll; remove that.

[• dberlin]

Sorry. I realized exactly what you said and thought i removed the comment,
but apparently not :)

lib/Analysis/BasicAliasAnalysis.cpp

for (ImmutableCallSite::arg_iterator CI = CS.arg_begin(), CE = CS.arg_end();
         break;
       }
     }
 
     if (!PassedAsArg)
       return MRI_NoModRef;
   }
 
+  // If the CallSite is to malloc or calloc, we can assume that it doesn't
+  // modify any IR visible value.  This is only valid because we assume these
+  // routines do not read values visible in the IR.  TODO: Consider special
+  // casing realloc and strdup routines which access only their arguments as
+  // well.  Or alternatively, replace all of this with inaccessiblememonly once
+  // that's implemented fully. 
+  auto *Inst = CS.getInstruction();
+  if (isMallocLikeFn(Inst, &TLI) || isCallocLikeFn(Inst, &TLI)) {
+    // Be conservative if the accessed pointer may alias the allocation -
+    // fallback to the generic handling below.
+    if (getBestAAResults().alias(MemoryLocation(Inst), Loc) == NoAlias)
+      return MRI_NoModRef;
+  }
+
   // While the assume intrinsic is marked as arbitrarily writing so that
   // proper control dependencies will be maintained, it never aliases any
   // particular memory location.
   if (isAssumeIntrinsic(CS))
     return MRI_NoModRef;
 
   // The AAResultBase base class has some smarts, lets use them.
   return AAResultBase::getModRefInfo(CS, Loc);

lib/Analysis/MemoryDependenceAnalysis.cpp

if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
       if (isInvariantLoad)
        continue;
       return MemDepResult::getClobber(Inst);
     }
 
     // If this is an allocation, and if we know that the accessed pointer is to
     // the allocation, return Def.  This means that there is no dependence and
     // the access can be optimized based on that.  For example, a load could
-    // turn into undef.
-    // Note: Only determine this to be a malloc if Inst is the malloc call, not
-    // a subsequent bitcast of the malloc call result.  There can be stores to
-    // the malloced memory between the malloc call and its bitcast uses, and we
-    // need to continue scanning until the malloc call.
+    // turn into undef.  Note that we can bypass the allocation itself when
+    // looking for a clobber in many cases; that's an alias property and is
+    // handled by BasicAA.
     if (isa<AllocaInst>(Inst) || isNoAliasFn(Inst, TLI)) {
       const Value *AccessPtr = GetUnderlyingObject(MemLoc.Ptr, DL);
-
       if (AccessPtr == Inst || AA->isMustAlias(Inst, AccessPtr))
         return MemDepResult::getDef(Inst);
-      if (isInvariantLoad)
-        continue;
-      // Be conservative if the accessed pointer may alias the allocation -
-      // fallback to the generic handling below.
-      if ((AA->alias(Inst, AccessPtr) == NoAlias) &&
-          // If the allocation is not aliased and does not read memory (like
-          // strdup), it is safe to ignore.
-          (isa<AllocaInst>(Inst) || isMallocLikeFn(Inst, TLI) ||
-           isCallocLikeFn(Inst, TLI)))
-        continue;
     }
 
+    // Alloca's don't modify memory.
+    if (isa<AllocaInst>(Inst))
+      continue;
+
     if (isInvariantLoad)
        continue;
 
     // See if this instruction (e.g. a call or vaarg) mod/ref's the pointer.
     ModRefInfo MR = AA->getModRefInfo(Inst, MemLoc);
     // If necessary, perform additional analysis.
     if (MR == MRI_ModRef)
       MR = AA->callCapturesBefore(Inst, MemLoc, DT, &OBB);