[MemoryBuiltins] [NFC] Rename isAllocationFn

[Bryce-MW]

Summary

There have been a few times now where I have mixed up isAllocationFn with isAllocLikeFn. I've renamed it to isAllocOrReallocLikeFn. I'm open to something else, I juts think having both an isAllocationFn and isAllocLikeFn is confusing. It's als not clear what the difference is just looking at the name.

[reames]

I would consider this a regression in clarity. isAllocationFn is *any* allocation function we know about. isAllocLike is the weird one. If you want to rename something, aim for that one.

Though, I'm hoping to just kill that off entirely in the nearish future. We've only got a handful of places left, it's just those places are getting harder/slower to fix.

llvm/include/llvm/Analysis/MemoryBuiltins.h

 class SelectInst;
 class Type;
 class UndefValue;
 class Value;
 
 /// Tests if a value is a call or invoke to a library function that
 /// allocates or reallocates memory (either malloc, calloc, realloc, or strdup
 /// like).
-bool isAllocationFn(const Value *V, const TargetLibraryInfo *TLI);
-bool isAllocationFn(const Value *V,
-                    function_ref<const TargetLibraryInfo &(Function &)> GetTLI);
+bool isAllocOrReallocLikeFn(const Value *V, const TargetLibraryInfo *TLI);
+bool isAllocOrReallocLikeFn(
+    const Value *V, function_ref<const TargetLibraryInfo &(Function &)> GetTLI);
 
 /// Tests if a value is a call or invoke to a library function that
 /// allocates uninitialized memory (such as malloc).
 bool isMallocLikeFn(const Value *V, const TargetLibraryInfo *TLI);
 bool isMallocLikeFn(const Value *V,
                     function_ref<const TargetLibraryInfo &(Function &)> GetTLI);
 
 /// Tests if a value is a call or invoke to a library function that

llvm/lib/Analysis/GlobalsModRef.cpp

for (auto *Node : SCC) {
       for (Instruction &I : instructions(Node->getFunction())) {
         if (isModAndRefSet(FI.getModRefInfo()))
           break; // The mod/ref lattice saturates here.
 
         // We handle calls specially because the graph-relevant aspects are
         // handled above.
         if (auto *Call = dyn_cast<CallBase>(&I)) {
           auto &TLI = GetTLI(*Node->getFunction());
-          if (isAllocationFn(Call, &TLI) || isFreeCall(Call, &TLI)) {
+          if (isAllocOrReallocLikeFn(Call, &TLI) || isFreeCall(Call, &TLI)) {
             // FIXME: It is completely unclear why this is necessary and not
             // handled by the above graph code.
             FI.addModRefInfo(ModRefInfo::ModRef);
           } else if (Function *Callee = Call->getCalledFunction()) {
             // The callgraph doesn't include intrinsic calls.
             if (Callee->isIntrinsic()) {
               if (isa<DbgInfoIntrinsic>(Call))
                 // Don't let dbg intrinsics affect alias info.

llvm/lib/Analysis/MemoryBuiltins.cpp

static Optional<AllocFnsTy> getAllocationSize(const Value *V,
   // Allocsize has no way to specify an alignment argument
   Result.AlignParam = -1;
   return Result;
 }
 
 /// Tests if a value is a call or invoke to a library function that
 /// allocates or reallocates memory (either malloc, calloc, realloc, or strdup
 /// like).
-bool llvm::isAllocationFn(const Value *V, const TargetLibraryInfo *TLI) {
+bool llvm::isAllocOrReallocLikeFn(const Value *V,
+                                  const TargetLibraryInfo *TLI) {
   return getAllocationData(V, AnyAlloc, TLI).hasValue();
 }
-bool llvm::isAllocationFn(
-    const Value *V, function_ref<const TargetLibraryInfo &(Function &)> GetTLI) {
+bool llvm::isAllocOrReallocLikeFn(
+    const Value *V,
+    function_ref<const TargetLibraryInfo &(Function &)> GetTLI) {
   return getAllocationData(V, AnyAlloc, GetTLI).hasValue();
 }
 
 /// Tests if a value is a call or invoke to a library function that
 /// allocates uninitialized memory (such as malloc).
 bool llvm::isMallocLikeFn(const Value *V, const TargetLibraryInfo *TLI) {
   return getAllocationData(V, MallocOrOpNewLike, TLI).hasValue();
 }

 
 /// Tests if a functions is a call or invoke to a library function that
 /// reallocates memory (e.g., realloc).
 bool llvm::isReallocLikeFn(const Function *F, const TargetLibraryInfo *TLI) {
   return getAllocationDataForFunction(F, ReallocLike, TLI).hasValue();
 }
 
 bool llvm::isAllocRemovable(const CallBase *CB, const TargetLibraryInfo *TLI) {
-  assert(isAllocationFn(CB, TLI));
+  assert(isAllocOrReallocLikeFn(CB, TLI));
 
   // Note: Removability is highly dependent on the source language.  For
   // example, recent C++ requires direct calls to the global allocation
   // [basic.stc.dynamic.allocation] to be observable unless part of a new
   // expression [expr.new paragraph 13].
 
   // Historically we've treated the C family allocation routines as removable
   return isAllocLikeFn(CB, TLI);
 }
 
 Value *llvm::getAllocAlignment(const CallBase *V,
                                const TargetLibraryInfo *TLI) {
-  assert(isAllocationFn(V, TLI));
+  assert(isAllocOrReallocLikeFn(V, TLI));
 
   const Optional<AllocFnsTy> FnData = getAllocationData(V, AnyAlloc, TLI);
   if (!FnData.hasValue() || FnData->AlignParam < 0) {
     return nullptr;
   }
   return V->getOperand(FnData->AlignParam);
 }
 
llvm::getAllocSize(const CallBase *CB,
   if (Overflow)
     return None;
   return Size;
 }
 
 Constant *llvm::getInitialValueOfAllocation(const CallBase *Alloc,
                                             const TargetLibraryInfo *TLI,
                                             Type *Ty) {
-  assert(isAllocationFn(Alloc, TLI));
+  assert(isAllocOrReallocLikeFn(Alloc, TLI));
 
   // malloc and aligned_alloc are uninitialized (undef)
   if (isMallocLikeFn(Alloc, TLI) || isAlignedAllocLikeFn(Alloc, TLI))
     return UndefValue::get(Ty);
 
   // calloc zero initializes
   if (isCallocLikeFn(Alloc, TLI))
     return Constant::getNullValue(Ty);

llvm/lib/Transforms/IPO/Attributor.cpp

auto &NoRecurseAA = A.getAAFor<AANoRecurse>(
       QueryingAA, IRPosition::function(*Scope), DepClassTy::OPTIONAL);
   return NoRecurseAA.isAssumedNoRecurse();
 }
 
 Constant *AA::getInitialValueForObj(Value &Obj, Type &Ty,
                                     const TargetLibraryInfo *TLI) {
   if (isa<AllocaInst>(Obj))
     return UndefValue::get(&Ty);
-  if (isAllocationFn(&Obj, TLI))
+  if (isAllocOrReallocLikeFn(&Obj, TLI))
     return getInitialValueOfAllocation(&cast<CallBase>(Obj), TLI, &Ty);
   auto *GV = dyn_cast<GlobalVariable>(&Obj);
   if (!GV || !GV->hasLocalLinkage())
     return nullptr;
   if (!GV->hasInitializer())
     return UndefValue::get(&Ty);
   return dyn_cast_or_null<Constant>(getWithType(*GV->getInitializer(), Ty));
 }

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

auto AllocationIdentifierCB = [&](Instruction &I) {
         return true;
       if (isFreeCall(CB, TLI)) {
         DeallocationInfos[CB] = new (A.Allocator) DeallocationInfo{CB};
         return true;
       }
       // To do heap to stack, we need to know that the allocation itself is
       // removable once uses are rewritten, and that we can initialize the
       // alloca to the same pattern as the original allocation result.
-      if (isAllocationFn(CB, TLI) && isAllocRemovable(CB, TLI)) {
+      if (isAllocOrReallocLikeFn(CB, TLI) && isAllocRemovable(CB, TLI)) {
         auto *I8Ty = Type::getInt8Ty(CB->getParent()->getContext());
         if (nullptr != getInitialValueOfAllocation(CB, TLI, I8Ty)) {
           AllocationInfo *AI = new (A.Allocator) AllocationInfo{CB};
           AllocationInfos[CB] = AI;
           TLI->getLibFunc(*CB, AI->LibraryFunctionId);
         }
       }
       return true;

llvm/lib/Transforms/IPO/GlobalOpt.cpp

static bool IsSafeComputationToRemove(
   do {
     if (isa<Constant>(V))
       return true;
     if (!V->hasOneUse())
       return false;
     if (isa<LoadInst>(V) || isa<InvokeInst>(V) || isa<Argument>(V) ||
         isa<GlobalValue>(V))
       return false;
-    if (isAllocationFn(V, GetTLI))
+    if (isAllocOrReallocLikeFn(V, GetTLI))
       return true;
 
     Instruction *I = cast<Instruction>(V);
     if (I->mayHaveSideEffects())
       return false;
     if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I)) {
       if (!GEP->hasAllConstantIndices())
         return false;
for (User *U : llvm::make_early_inc_range(GV->users())) {
     }
   }
 
   for (int i = 0, e = Dead.size(); i != e; ++i) {
     if (IsSafeComputationToRemove(Dead[i].first, GetTLI)) {
       Dead[i].second->eraseFromParent();
       Instruction *I = Dead[i].first;
       do {
-        if (isAllocationFn(I, GetTLI))
+        if (isAllocOrReallocLikeFn(I, GetTLI))
           break;
         Instruction *J = dyn_cast<Instruction>(I->getOperand(0));
         if (!J)
           break;
         I->eraseFromParent();
         I = J;
       } while (true);
       I->eraseFromParent();

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

if (llvm::isPowerOf2_64(AlignmentVal)) {
       Call.addRetAttr(Attribute::getWithAlignment(Call.getContext(),
                                                   Align(AlignmentVal)));
     }
   }
 }
 
 /// Improvements for call, callbr and invoke instructions.
 Instruction *InstCombinerImpl::visitCallBase(CallBase &Call) {
-  if (isAllocationFn(&Call, &TLI))
+  if (isAllocOrReallocLikeFn(&Call, &TLI))
     annotateAnyAllocSite(Call, &TLI);
 
   bool Changed = false;
 
   // Mark any parameters that are known to be non-null with the nonnull
   // attribute.  This is helpful for inlining calls to functions with null
   // checks on their arguments.
   SmallVector<unsigned, 4> ArgNos;
if (!Call.use_empty() && !Call.isMustTailCall())
     if (Value *ReturnedArg = Call.getReturnedArgOperand()) {
       Type *CallTy = Call.getType();
       Type *RetArgTy = ReturnedArg->getType();
       if (RetArgTy->canLosslesslyBitCastTo(CallTy))
         return replaceInstUsesWith(
             Call, Builder.CreateBitOrPointerCast(ReturnedArg, CallTy));
     }
 
-  if (isAllocationFn(&Call, &TLI) &&
+  if (isAllocOrReallocLikeFn(&Call, &TLI) &&
       isAllocRemovable(&cast<CallBase>(Call), &TLI))
     return visitAllocSite(Call);
 
   // Handle intrinsics which can be used in both call and invoke context.
   switch (Call.getIntrinsicID()) {
   case Intrinsic::experimental_gc_statepoint: {
     GCStatepointInst &GCSP = *cast<GCStatepointInst>(&Call);
     SmallPtrSet<Value *, 32> LiveGcValues;

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

if (auto *BCI = dyn_cast<BitCastInst>(ASCStrippedPtrOp)) {
 
     // If the bitcast argument is an allocation, The bitcast is for convertion
     // to actual type of allocation. Removing such bitcasts, results in having
     // GEPs with i8* base and pure byte offsets. That means GEP is not aware of
     // struct or array hierarchy.
     // By avoiding such GEPs, phi translation and MemoryDependencyAnalysis have
     // a better chance to succeed.
     if (!isa<BitCastInst>(SrcOp) && GEP.accumulateConstantOffset(DL, Offset) &&
-        !isAllocationFn(SrcOp, &TLI)) {
+        !isAllocOrReallocLikeFn(SrcOp, &TLI)) {
       // If this GEP instruction doesn't move the pointer, just replace the GEP
       // with a bitcast of the real input to the dest type.
       if (!Offset) {
         // If the bitcast is of an allocation, and the allocation will be
         // converted to match the type of the cast, don't touch this.
         if (isa<AllocaInst>(SrcOp)) {
           // See if the bitcast simplifies, if so, don't nuke this GEP yet.
           if (Instruction *I = visitBitCast(*BCI)) {

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

bool storeIsNoop(MemoryDef *Def, const Value *DefUO) {
     else if (MemSet)
       StoredConstant = dyn_cast<Constant>(MemSet->getValue());
     else
       return false;
 
     if (!isRemovable(DefI))
       return false;
 
-    if (StoredConstant && isAllocationFn(DefUO, &TLI)) {
+    if (StoredConstant && isAllocOrReallocLikeFn(DefUO, &TLI)) {
       auto *CB = cast<CallBase>(DefUO);
       auto *InitC = getInitialValueOfAllocation(CB, &TLI,
                                                 StoredConstant->getType());
       if (InitC && InitC == StoredConstant) {
         auto *UnderlyingDef = cast<MemoryDef>(MSSA.getMemoryAccess(CB));
         // If UnderlyingDef is the clobbering access of Def, no instructions
         // between them can modify the memory location.
         auto *ClobberDef =

llvm/lib/Transforms/Scalar/GVN.cpp

bool GVNPass::AnalyzeLoadAvailability(LoadInst *Load, MemDepResult DepInfo,
 
   // Loading the alloca -> undef.
   // Loading immediately after lifetime begin -> undef.
   if (isa<AllocaInst>(DepInst) || isLifetimeStart(DepInst)) {
     Res = AvailableValue::get(UndefValue::get(Load->getType()));
     return true;
   }
 
-  if (isAllocationFn(DepInst, TLI))
+  if (isAllocOrReallocLikeFn(DepInst, TLI))
     if (auto *InitVal = getInitialValueOfAllocation(cast<CallBase>(DepInst),
                                                     TLI, Load->getType())) {
       Res = AvailableValue::get(InitVal);
       return true;
     }
 
   if (StoreInst *S = dyn_cast<StoreInst>(DepInst)) {
     // Reject loads and stores that are to the same address but are of

llvm/lib/Transforms/Scalar/NewGVN.cpp

NewGVN::performSymbolicLoadCoercion(Type *LoadType, Value *LoadPtr,
   if (isa<AllocaInst>(DepInst)) {
     return createConstantExpression(UndefValue::get(LoadType));
   }
   // If this load occurs either right after a lifetime begin,
   // then the loaded value is undefined.
   else if (auto *II = dyn_cast<IntrinsicInst>(DepInst)) {
     if (II->getIntrinsicID() == Intrinsic::lifetime_start)
       return createConstantExpression(UndefValue::get(LoadType));
-  } else if (isAllocationFn(DepInst, TLI))
+  } else if (isAllocOrReallocLikeFn(DepInst, TLI))
     if (auto *InitVal = getInitialValueOfAllocation(cast<CallBase>(DepInst),
                                                     TLI, LoadType))
       return createConstantExpression(InitVal);
 
   return nullptr;
 }
 
 const Expression *NewGVN::performSymbolicLoadEvaluation(Instruction *I) const {

llvm/lib/Transforms/Utils/Local.cpp

if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
     }
 
     if (auto *FPI = dyn_cast<ConstrainedFPIntrinsic>(I)) {
       Optional<fp::ExceptionBehavior> ExBehavior = FPI->getExceptionBehavior();
       return ExBehavior.getValue() != fp::ebStrict;
     }
   }
 
-  if (isAllocationFn(I, TLI) && isAllocRemovable(cast<CallBase>(I), TLI))
+  if (isAllocOrReallocLikeFn(I, TLI) &&
+      isAllocRemovable(cast<CallBase>(I), TLI))
     return true;
 
   if (CallInst *CI = isFreeCall(I, TLI))
     if (Constant *C = dyn_cast<Constant>(CI->getArgOperand(0)))
       return C->isNullValue() || isa<UndefValue>(C);
 
   if (auto *Call = dyn_cast<CallBase>(I))
     if (isMathLibCallNoop(Call, TLI))

llvm/unittests/Analysis/MemoryBuiltinsTest.cpp

std::unique_ptr<CallInst> Caller(
       CallInst::Create(AllocSizeFn, {ConstantInt::get(ArgTy, 100)}));
 
   const TargetLibraryInfo *TLI = nullptr;
   EXPECT_FALSE(isMallocLikeFn(Caller.get(), TLI));
   EXPECT_FALSE(isAllocLikeFn(Caller.get(), TLI));
 
   // FIXME: We might be able to treat allocsize functions as general allocation
   // functions.
-  EXPECT_FALSE(isAllocationFn(Caller.get(), TLI));
+  EXPECT_FALSE(isAllocOrReallocLikeFn(Caller.get(), TLI));
 }
 }