MemoryBuiltins: replace most users of isFreeCall with isFreeLikeCall

[durin42]

Summary

With our new attributes-based approach to handling allocator functions,
we need to differentiate between "is this literally free()" and "is this
a function which frees the given pointer." This change introduces the
new function to check for the latter category and moves the easy cases
throughout the codebase to check that instead of literally-free().

[bogner]

This affects tests a bit more than I'd expect - I guess these are test issues where we weren't calling the builtin free for one reason or another. Would it be better to fix up the tests so that they do the right things without this change beforehand to make it obvious that this isn't changing behaviour in a weird way?

[durin42]

In D124425#3582970, @bogner wrote:

This affects tests a bit more than I'd expect - I guess these are test issues where we weren't calling the builtin free for one reason or another. Would it be better to fix up the tests so that they do the right things without this change beforehand to make it obvious that this isn't changing behaviour in a weird way?

Maybe. Do you have some exemplars in mind here that change in ways you don't expect? I've been looking at this patch so long it just seems obviously-the-way-it-is to me now...for good or for ill.

[durin42]

This is obsolete due to work in 46e6dd84b778dd2e30368183fec265beceecdd0f

llvm/include/llvm/Analysis/MemoryBuiltins.h

 
 /// isFreeCall - Returns non-null if the value is a call to the builtin free()
 const CallInst *isFreeCall(const Value *I, const TargetLibraryInfo *TLI);
 
 inline CallInst *isFreeCall(Value *I, const TargetLibraryInfo *TLI) {
   return const_cast<CallInst*>(isFreeCall((const Value*)I, TLI));
 }
 
+/// isFreeLikeFunction - returns true if the function is a builtin free() or a
+/// function marked allockind("free").
+bool isFreeLikeCall(const Value *I, const TargetLibraryInfo *TLI);
+
 //===----------------------------------------------------------------------===//
 //  Properties of allocation functions
 //
 
 /// Return false if the allocation can have side effects on the program state
 /// we are required to preserve beyond the effect of allocating a new object.
 /// Ex: If our allocation routine has a counter for the number of objects
 /// allocated, and the program prints it on exit, can the value change due

llvm/lib/Analysis/CFLGraph.h

void visitCallBase(CallBase &Call) {
       if (Call.getType()->isPointerTy())
         addNode(&Call);
 
       // Check if Inst is a call to a library function that
       // allocates/deallocates on the heap. Those kinds of functions do not
       // introduce any aliases.
       // TODO: address other common library functions such as realloc(),
       // strdup(), etc.
-      if (isMallocOrCallocLikeFn(&Call, &TLI) || isFreeCall(&Call, &TLI))
+      if (isMallocOrCallocLikeFn(&Call, &TLI) || isFreeLikeCall(&Call, &TLI))
         return;
 
       // TODO: Add support for noalias args/all the other fun function
       // attributes that we can tack on.
       SmallVector<Function *, 4> Targets;
       if (getPossibleTargets(Call, Targets))
         if (tryInterproceduralAnalysis(Call, Targets))
           return;

llvm/lib/Analysis/GlobalsModRef.cpp

if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
       if (AnalyzeUsesOfPointer(I, Readers, Writers, OkayStoreDest))
         return true;
     } else if (auto *Call = dyn_cast<CallBase>(I)) {
       // Make sure that this is just the function being called, not that it is
       // passing into the function.
       if (Call->isDataOperand(&U)) {
         // Detect calls to free.
         if (Call->isArgOperand(&U) &&
-            isFreeCall(I, &GetTLI(*Call->getFunction()))) {
+            isFreeLikeCall(I, &GetTLI(*Call->getFunction()))) {
           if (Writers)
             Writers->insert(Call->getParent()->getParent());
         } else {
           return true; // Argument of an unknown call.
         }
       }
     } else if (ICmpInst *ICI = dyn_cast<ICmpInst>(I)) {
       if (!isa<ConstantPointerNull>(ICI->getOperand(1)))
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 (isAllocationFn(Call, &TLI) || llvm::isFreeLikeCall(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

const CallInst *llvm::isFreeCall(const Value *I, const TargetLibraryInfo *TLI) {
 
   LibFunc TLIFn;
   if (!TLI || !TLI->getLibFunc(*Callee, TLIFn) || !TLI->has(TLIFn))
     return nullptr;
 
   return isLibFreeFunction(Callee, TLIFn) ? dyn_cast<CallInst>(I) : nullptr;
 }
 
+/// isFreeLikeFunction - returns true if the function is a builtin free() or a
+/// function marked allockind("free").
+bool llvm::isFreeLikeCall(const Value *I, const TargetLibraryInfo *TLI) {
+  if (checkFnAllocKind(I, AllocFnKind::Free)) {
+    return true;
+  }
+  return isFreeCall(I, TLI);
+}
+
 AllocFnKind llvm::getAllocKind(const CallBase *CB,
                                const TargetLibraryInfo *TLI) {
   const Function *F = CB->getCalledFunction();
   if (!F)
     return AllocFnKind::Unknown;
   Optional<AllocFnsTy> A = getAllocationDataForFunction(F, AnyAlloc, TLI);
   if (A.hasValue())
     return allocKindFromAllocType(A->AllocTy);

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

auto UsePred = [&](const Use &U, bool &Follow) -> bool {
             *StoreI->getValueOperand(), *this, UsedAssumedInformation);
         return handleAccess(A, *StoreI, *CurPtr, Content, AccessKind::AK_WRITE,
                             OffsetInfoMap[CurPtr].Offset, Changed,
                             StoreI->getValueOperand()->getType());
       }
       if (auto *CB = dyn_cast<CallBase>(Usr)) {
         if (CB->isLifetimeStartOrEnd())
           return true;
-        if (TLI && isFreeCall(CB, TLI))
+        if (TLI && isFreeLikeCall(CB, TLI))
           return true;
         if (CB->isArgOperand(&U)) {
           unsigned ArgNo = CB->getArgOperandNo(&U);
           const auto &CSArgPI = A.getAAFor<AAPointerInfo>(
               *this, IRPosition::callsite_argument(*CB, ArgNo),
               DepClassTy::REQUIRED);
           Changed = translateAndAddCalleeState(
                         A, CSArgPI, OffsetInfoMap[CurPtr].Offset, *CB) |
void initialize(Attributor &A) override {
 
     const Function *F = getAnchorScope();
     const auto *TLI = A.getInfoCache().getTargetLibraryInfoForFunction(*F);
 
     auto AllocationIdentifierCB = [&](Instruction &I) {
       CallBase *CB = dyn_cast<CallBase>(&I);
       if (!CB)
         return true;
-      if (isFreeCall(CB, TLI)) {
+      if (llvm::isFreeLikeCall(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)) {
         auto *I8Ty = Type::getInt8Ty(CB->getParent()->getContext());

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

 /// lifting.
 Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
   // Don't try to simplify calls without uses. It will not do anything useful,
   // but will result in the following folds being skipped.
   if (!CI.use_empty())
     if (Value *V = SimplifyCall(&CI, SQ.getWithInstruction(&CI)))
       return replaceInstUsesWith(CI, V);
 
-  if (isFreeCall(&CI, &TLI))
+  if (isFreeLikeCall(&CI, &TLI))
     return visitFree(CI);
 
   // If the caller function (i.e. us, the function that contains this CallInst)
   // is nounwind, mark the call as nounwind, even if the callee isn't.
   if (CI.getFunction()->doesNotThrow() && !CI.doesNotThrow()) {
     CI.setDoesNotThrow();
     return &CI;
   }

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

for (User *U : PI->users()) {
           }
         }
 
         if (isRemovableWrite(*cast<CallBase>(I), PI, TLI)) {
           Users.emplace_back(I);
           continue;
         }
 
-        if (isFreeCall(I, &TLI) && getAllocationFamily(I, &TLI) == Family) {
+        if (isFreeLikeCall(I, &TLI) && getAllocationFamily(I, &TLI) == Family) {
           assert(Family);
           Users.emplace_back(I);
           continue;
         }
 
         if (isReallocLikeFn(I, &TLI) &&
             getAllocationFamily(I, &TLI) == Family) {
           assert(Family);

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

struct DSEState {
   getLocForTerminator(Instruction *I) const {
     uint64_t Len;
     Value *Ptr;
     if (match(I, m_Intrinsic<Intrinsic::lifetime_end>(m_ConstantInt(Len),
                                                       m_Value(Ptr))))
       return {std::make_pair(MemoryLocation(Ptr, Len), false)};
 
     if (auto *CB = dyn_cast<CallBase>(I)) {
-      if (isFreeCall(I, &TLI))
+      if (isFreeLikeCall(I, &TLI))
         return {std::make_pair(MemoryLocation::getAfter(CB->getArgOperand(0)),
                                true)};
     }
 
     return None;
   }
 
   /// Returns true if \p I is a memory terminator instruction like
   /// llvm.lifetime.end or free.
   bool isMemTerminatorInst(Instruction *I) const {
     IntrinsicInst *II = dyn_cast<IntrinsicInst>(I);
     return (II && II->getIntrinsicID() == Intrinsic::lifetime_end) ||
-           isFreeCall(I, &TLI);
+           isFreeLikeCall(I, &TLI);
   }
 
   /// Returns true if \p MaybeTerm is a memory terminator for \p Loc from
   /// instruction \p AccessI.
   bool isMemTerminator(const MemoryLocation &Loc, Instruction *AccessI,
                        Instruction *MaybeTerm) {
     Optional<std::pair<MemoryLocation, bool>> MaybeTermLoc =
         getLocForTerminator(MaybeTerm);

llvm/test/Transforms/Attributor/heap_to_stack.ll

;
   tail call void @sync_func(i8* %1)
   tail call void @free(i8* %1)
   ret void
 }
 
 ; TEST 3 - 1 malloc, 1 free
 
 define void @test3() {
-; IS________OPM: Function Attrs: willreturn
-; IS________OPM-LABEL: define {{[^@]+}}@test3
-; IS________OPM-SAME: () #[[ATTR7]] {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4) #[[ATTR7]]
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) #[[ATTR7]]
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef [[TMP1]]) #[[ATTR9]]
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM: Function Attrs: willreturn
-; IS________NPM-LABEL: define {{[^@]+}}@test3
-; IS________NPM-SAME: () #[[ATTR7]] {
-; IS________NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) #[[ATTR7]]
-; IS________NPM-NEXT:    ret void
+; CHECK: Function Attrs: willreturn
+; CHECK-LABEL: define {{[^@]+}}@test3
+; CHECK-SAME: () #[[ATTR7]] {
+; CHECK-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) #[[ATTR7]]
+; CHECK-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   tail call void @no_sync_func(i8* %1)
   tail call void @free(i8* %1)
   ret void
 }
 
 define void @test3a(i8* %p) {
 ; IS__TUNIT_OPM: Function Attrs: willreturn
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@test3a
 ; IS__TUNIT_OPM-SAME: (i8* nocapture [[P:%.*]]) #[[ATTR7]] {
-; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4) #[[ATTR7]]
+; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
 ; IS__TUNIT_OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree noundef [[TMP1]], i8* nocapture [[P]]) #[[ATTR7]]
-; IS__TUNIT_OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef [[TMP1]]) #[[ATTR9]]
 ; IS__TUNIT_OPM-NEXT:    ret void
 ;
 ; IS__TUNIT_NPM: Function Attrs: willreturn
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@test3a
 ; IS__TUNIT_NPM-SAME: (i8* nocapture [[P:%.*]]) #[[ATTR7]] {
 ; IS__TUNIT_NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
 ; IS__TUNIT_NPM-NEXT:    tail call void @nofree_arg_only(i8* noalias nocapture nofree noundef [[TMP1]], i8* nocapture [[P]]) #[[ATTR7]]
 ; IS__TUNIT_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM: Function Attrs: willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test3a
 ; IS__CGSCC_OPM-SAME: (i8* nocapture noundef [[P:%.*]]) #[[ATTR7]] {
-; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4) #[[ATTR7]]
+; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
 ; IS__CGSCC_OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree noundef [[TMP1]], i8* nocapture noundef [[P]]) #[[ATTR7]]
-; IS__CGSCC_OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef [[TMP1]]) #[[ATTR9]]
 ; IS__CGSCC_OPM-NEXT:    ret void
 ;
 ; IS__CGSCC_NPM: Function Attrs: willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test3a
 ; IS__CGSCC_NPM-SAME: (i8* nocapture noundef [[P:%.*]]) #[[ATTR7]] {
 ; IS__CGSCC_NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
 ; IS__CGSCC_NPM-NEXT:    tail call void @nofree_arg_only(i8* noalias nocapture nofree noundef [[TMP1]], i8* nocapture noundef [[P]]) #[[ATTR7]]
 ; IS__CGSCC_NPM-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   tail call void @nofree_arg_only(i8* %1, i8* %p)
   tail call void @free(i8* %1)
   ret void
 }
 
 declare noalias i8* @aligned_alloc(i64, i64)
 
 define void @test3b(i8* %p) {
 ; IS__TUNIT_OPM: Function Attrs: willreturn
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@test3b
 ; IS__TUNIT_OPM-SAME: (i8* nocapture [[P:%.*]]) #[[ATTR7]] {
-; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 noundef 32, i64 noundef 128) #[[ATTR7]]
+; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 128, align 32
 ; IS__TUNIT_OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree noundef [[TMP1]], i8* nocapture [[P]]) #[[ATTR7]]
-; IS__TUNIT_OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef [[TMP1]]) #[[ATTR9]]
 ; IS__TUNIT_OPM-NEXT:    ret void
 ;
 ; IS__TUNIT_NPM: Function Attrs: willreturn
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@test3b
 ; IS__TUNIT_NPM-SAME: (i8* nocapture [[P:%.*]]) #[[ATTR7]] {
 ; IS__TUNIT_NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 128, align 32
 ; IS__TUNIT_NPM-NEXT:    tail call void @nofree_arg_only(i8* noalias nocapture nofree noundef [[TMP1]], i8* nocapture [[P]]) #[[ATTR7]]
 ; IS__TUNIT_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM: Function Attrs: willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test3b
 ; IS__CGSCC_OPM-SAME: (i8* nocapture noundef [[P:%.*]]) #[[ATTR7]] {
-; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 noundef 32, i64 noundef 128) #[[ATTR7]]
+; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 128, align 32
 ; IS__CGSCC_OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree noundef [[TMP1]], i8* nocapture noundef [[P]]) #[[ATTR7]]
-; IS__CGSCC_OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef [[TMP1]]) #[[ATTR9]]
 ; IS__CGSCC_OPM-NEXT:    ret void
 ;
 ; IS__CGSCC_NPM: Function Attrs: willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test3b
 ; IS__CGSCC_NPM-SAME: (i8* nocapture noundef [[P:%.*]]) #[[ATTR7]] {
 ; IS__CGSCC_NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 128, align 32
 ; IS__CGSCC_NPM-NEXT:    tail call void @nofree_arg_only(i8* noalias nocapture nofree noundef [[TMP1]], i8* nocapture noundef [[P]]) #[[ATTR7]]
 ; IS__CGSCC_NPM-NEXT:    ret void
; CHECK-SAME; (i8* nocapture [[P:%.*]]) {
   tail call void @nofree_arg_only(i8* %1, i8* %p)
   tail call void @free(i8* %1)
   ret void
 }
 
 declare noalias i8* @calloc(i64, i64)
 
 define void @test0() {
-; IS________OPM: Function Attrs: willreturn
-; IS________OPM-LABEL: define {{[^@]+}}@test0
-; IS________OPM-SAME: () #[[ATTR7]] {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @calloc(i64 noundef 2, i64 noundef 4) #[[ATTR7]]
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) #[[ATTR7]]
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef [[TMP1]]) #[[ATTR9]]
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM: Function Attrs: willreturn
-; IS________NPM-LABEL: define {{[^@]+}}@test0
-; IS________NPM-SAME: () #[[ATTR7]] {
-; IS________NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 8, align 1
-; IS________NPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[TMP1]], i8 0, i64 8, i1 false)
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) #[[ATTR7]]
-; IS________NPM-NEXT:    ret void
+; CHECK: Function Attrs: willreturn
+; CHECK-LABEL: define {{[^@]+}}@test0
+; CHECK-SAME: () #[[ATTR7]] {
+; CHECK-NEXT:    [[TMP1:%.*]] = alloca i8, i64 8, align 1
+; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[TMP1]], i8 0, i64 8, i1 false)
+; CHECK-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) #[[ATTR7]]
+; CHECK-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @calloc(i64 2, i64 4)
   tail call void @no_sync_func(i8* %1)
   tail call void @free(i8* %1)
   ret void
 }
 
 ; TEST 4

 
 ; TEST 5 - not all exit paths have a call to free, but all uses of malloc
 ; are in nofree functions and are not captured
 
 define void @test5(i32, i8* %p) {
 ; IS__TUNIT_OPM: Function Attrs: willreturn
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@test5
 ; IS__TUNIT_OPM-SAME: (i32 [[TMP0:%.*]], i8* nocapture [[P:%.*]]) #[[ATTR7]] {
-; IS__TUNIT_OPM-NEXT:    [[TMP2:%.*]] = tail call noalias i8* @malloc(i64 noundef 4) #[[ATTR7]]
+; IS__TUNIT_OPM-NEXT:    [[TMP2:%.*]] = alloca i8, i64 4, align 1
 ; IS__TUNIT_OPM-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
 ; IS__TUNIT_OPM-NEXT:    br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
 ; IS__TUNIT_OPM:       4:
 ; IS__TUNIT_OPM-NEXT:    tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP2]]) #[[ATTR7]]
 ; IS__TUNIT_OPM-NEXT:    br label [[TMP6:%.*]]
 ; IS__TUNIT_OPM:       5:
 ; IS__TUNIT_OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree noundef [[TMP2]], i8* nocapture [[P]]) #[[ATTR7]]
-; IS__TUNIT_OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef [[TMP2]]) #[[ATTR9]]
 ; IS__TUNIT_OPM-NEXT:    br label [[TMP6]]
 ; IS__TUNIT_OPM:       6:
 ; IS__TUNIT_OPM-NEXT:    ret void
 ;
 ; IS__TUNIT_NPM: Function Attrs: willreturn
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@test5
 ; IS__TUNIT_NPM-SAME: (i32 [[TMP0:%.*]], i8* nocapture [[P:%.*]]) #[[ATTR7]] {
 ; IS__TUNIT_NPM-NEXT:    [[TMP2:%.*]] = alloca i8, i64 4, align 1
 ; IS__TUNIT_NPM-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
 ; IS__TUNIT_NPM-NEXT:    br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
 ; IS__TUNIT_NPM:       4:
 ; IS__TUNIT_NPM-NEXT:    tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP2]]) #[[ATTR7]]
 ; IS__TUNIT_NPM-NEXT:    br label [[TMP6:%.*]]
 ; IS__TUNIT_NPM:       5:
 ; IS__TUNIT_NPM-NEXT:    tail call void @nofree_arg_only(i8* noalias nocapture nofree noundef [[TMP2]], i8* nocapture [[P]]) #[[ATTR7]]
 ; IS__TUNIT_NPM-NEXT:    br label [[TMP6]]
 ; IS__TUNIT_NPM:       6:
 ; IS__TUNIT_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM: Function Attrs: willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test5
 ; IS__CGSCC_OPM-SAME: (i32 [[TMP0:%.*]], i8* nocapture [[P:%.*]]) #[[ATTR7]] {
-; IS__CGSCC_OPM-NEXT:    [[TMP2:%.*]] = tail call noalias i8* @malloc(i64 noundef 4) #[[ATTR7]]
+; IS__CGSCC_OPM-NEXT:    [[TMP2:%.*]] = alloca i8, i64 4, align 1
 ; IS__CGSCC_OPM-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
 ; IS__CGSCC_OPM-NEXT:    br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
 ; IS__CGSCC_OPM:       4:
 ; IS__CGSCC_OPM-NEXT:    tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP2]]) #[[ATTR7]]
 ; IS__CGSCC_OPM-NEXT:    br label [[TMP6:%.*]]
 ; IS__CGSCC_OPM:       5:
 ; IS__CGSCC_OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree noundef [[TMP2]], i8* nocapture noundef [[P]]) #[[ATTR7]]
-; IS__CGSCC_OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef [[TMP2]]) #[[ATTR9]]
 ; IS__CGSCC_OPM-NEXT:    br label [[TMP6]]
 ; IS__CGSCC_OPM:       6:
 ; IS__CGSCC_OPM-NEXT:    ret void
 ;
 ; IS__CGSCC_NPM: Function Attrs: willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test5
 ; IS__CGSCC_NPM-SAME: (i32 [[TMP0:%.*]], i8* nocapture [[P:%.*]]) #[[ATTR7]] {
 ; IS__CGSCC_NPM-NEXT:    [[TMP2:%.*]] = alloca i8, i64 4, align 1

 
 6:                                                ; preds = %5, %4
   ret void
 }
 
 ; TEST 6 - all exit paths have a call to free
 
 define void @test6(i32) {
-; IS________OPM: Function Attrs: willreturn
-; IS________OPM-LABEL: define {{[^@]+}}@test6
-; IS________OPM-SAME: (i32 [[TMP0:%.*]]) #[[ATTR7]] {
-; IS________OPM-NEXT:    [[TMP2:%.*]] = tail call noalias i8* @malloc(i64 noundef 4) #[[ATTR7]]
-; IS________OPM-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
-; IS________OPM-NEXT:    br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
-; IS________OPM:       4:
-; IS________OPM-NEXT:    tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP2]]) #[[ATTR7]]
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef [[TMP2]]) #[[ATTR9]]
-; IS________OPM-NEXT:    br label [[TMP6:%.*]]
-; IS________OPM:       5:
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef [[TMP2]]) #[[ATTR9]]
-; IS________OPM-NEXT:    br label [[TMP6]]
-; IS________OPM:       6:
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM: Function Attrs: willreturn
-; IS________NPM-LABEL: define {{[^@]+}}@test6
-; IS________NPM-SAME: (i32 [[TMP0:%.*]]) #[[ATTR7]] {
-; IS________NPM-NEXT:    [[TMP2:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
-; IS________NPM-NEXT:    br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
-; IS________NPM:       4:
-; IS________NPM-NEXT:    tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP2]]) #[[ATTR7]]
-; IS________NPM-NEXT:    br label [[TMP6:%.*]]
-; IS________NPM:       5:
-; IS________NPM-NEXT:    br label [[TMP6]]
-; IS________NPM:       6:
-; IS________NPM-NEXT:    ret void
+; CHECK: Function Attrs: willreturn
+; CHECK-LABEL: define {{[^@]+}}@test6
+; CHECK-SAME: (i32 [[TMP0:%.*]]) #[[ATTR7]] {
+; CHECK-NEXT:    [[TMP2:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
+; CHECK-NEXT:    br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
+; CHECK:       4:
+; CHECK-NEXT:    tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP2]]) #[[ATTR7]]
+; CHECK-NEXT:    br label [[TMP6:%.*]]
+; CHECK:       5:
+; CHECK-NEXT:    br label [[TMP6]]
+; CHECK:       6:
+; CHECK-NEXT:    ret void
 ;
   %2 = tail call noalias i8* @malloc(i64 4)
   %3 = icmp eq i32 %0, 0
   br i1 %3, label %5, label %4
 
 4:                                                ; preds = %1
   tail call void @nofree_func(i8* %2)
   tail call void @free(i8* %2)
   br label %6
 
 5:                                                ; preds = %1
   tail call void @free(i8* %2)
   br label %6
 
 6:                                                ; preds = %5, %4
   ret void
 }
 
 ; TEST 7 - free is dead.
 
 define void @test7() {
-; IS________OPM-LABEL: define {{[^@]+}}@test7() {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4) #[[ATTR7]]
-; IS________OPM-NEXT:    [[TMP2:%.*]] = tail call i32 @no_return_call() #[[ATTR4:[0-9]+]]
-; IS________OPM-NEXT:    unreachable
-;
-; IS________NPM-LABEL: define {{[^@]+}}@test7() {
-; IS________NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    [[TMP2:%.*]] = tail call i32 @no_return_call() #[[ATTR4:[0-9]+]]
-; IS________NPM-NEXT:    unreachable
+; CHECK-LABEL: define {{[^@]+}}@test7() {
+; CHECK-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    [[TMP2:%.*]] = tail call i32 @no_return_call() #[[ATTR4:[0-9]+]]
+; CHECK-NEXT:    unreachable
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   tail call i32 @no_return_call()
   tail call void @free(i8* %1)
   ret void
 }
 
 ; TEST 8 - Negative: bitcast pointer used in capture function
;
   tail call void @foo_nounw(i32* %2)
   tail call void @free(i8* %1)
   ret void
 }
 
 ; TEST 10 - 1 malloc, 1 free
 
 define i32 @test10() {
-; IS________OPM: Function Attrs: willreturn
-; IS________OPM-LABEL: define {{[^@]+}}@test10
-; IS________OPM-SAME: () #[[ATTR7]] {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4) #[[ATTR7]]
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) #[[ATTR7]]
-; IS________OPM-NEXT:    [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; IS________OPM-NEXT:    store i32 10, i32* [[TMP2]], align 4
-; IS________OPM-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]]) #[[ATTR9]]
-; IS________OPM-NEXT:    ret i32 [[TMP3]]
-;
-; IS________NPM: Function Attrs: willreturn
-; IS________NPM-LABEL: define {{[^@]+}}@test10
-; IS________NPM-SAME: () #[[ATTR7]] {
-; IS________NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) #[[ATTR7]]
-; IS________NPM-NEXT:    [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; IS________NPM-NEXT:    store i32 10, i32* [[TMP2]], align 4
-; IS________NPM-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
-; IS________NPM-NEXT:    ret i32 [[TMP3]]
+; CHECK: Function Attrs: willreturn
+; CHECK-LABEL: define {{[^@]+}}@test10
+; CHECK-SAME: () #[[ATTR7]] {
+; CHECK-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) #[[ATTR7]]
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
+; CHECK-NEXT:    store i32 10, i32* [[TMP2]], align 4
+; CHECK-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT:    ret i32 [[TMP3]]
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   tail call void @no_sync_func(i8* %1)
   %2 = bitcast i8* %1 to i32*
   store i32 10, i32* %2
   %3 = load i32, i32* %2
   tail call void @free(i8* %1)
   ret i32 %3
 }
 
 define i32 @test_lifetime() {
-; IS________OPM: Function Attrs: willreturn
-; IS________OPM-LABEL: define {{[^@]+}}@test_lifetime
-; IS________OPM-SAME: () #[[ATTR7]] {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4) #[[ATTR7]]
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) #[[ATTR7]]
-; IS________OPM-NEXT:    call void @llvm.lifetime.start.p0i8(i64 noundef 4, i8* noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[TMP1]]) #[[ATTR7]]
-; IS________OPM-NEXT:    [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; IS________OPM-NEXT:    store i32 10, i32* [[TMP2]], align 4
-; IS________OPM-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]]) #[[ATTR9]]
-; IS________OPM-NEXT:    ret i32 [[TMP3]]
-;
-; IS________NPM: Function Attrs: willreturn
-; IS________NPM-LABEL: define {{[^@]+}}@test_lifetime
-; IS________NPM-SAME: () #[[ATTR7]] {
-; IS________NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) #[[ATTR7]]
-; IS________NPM-NEXT:    call void @llvm.lifetime.start.p0i8(i64 noundef 4, i8* noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[TMP1]]) #[[ATTR7]]
-; IS________NPM-NEXT:    [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; IS________NPM-NEXT:    store i32 10, i32* [[TMP2]], align 4
-; IS________NPM-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
-; IS________NPM-NEXT:    ret i32 [[TMP3]]
+; CHECK: Function Attrs: willreturn
+; CHECK-LABEL: define {{[^@]+}}@test_lifetime
+; CHECK-SAME: () #[[ATTR7]] {
+; CHECK-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) #[[ATTR7]]
+; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 noundef 4, i8* noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[TMP1]]) #[[ATTR7]]
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
+; CHECK-NEXT:    store i32 10, i32* [[TMP2]], align 4
+; CHECK-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT:    ret i32 [[TMP3]]
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   tail call void @no_sync_func(i8* %1)
   call void @llvm.lifetime.start.p0i8(i64 4, i8* %1)
   %2 = bitcast i8* %1 to i32*
   store i32 10, i32* %2
   %3 = load i32, i32* %2
   tail call void @free(i8* %1)
   ret i32 %3
 }
 
 ; TEST 11
 
 define void @test11() {
-; IS________OPM: Function Attrs: nounwind willreturn
-; IS________OPM-LABEL: define {{[^@]+}}@test11
-; IS________OPM-SAME: () #[[ATTR9]] {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4) #[[ATTR7]]
-; IS________OPM-NEXT:    tail call void @sync_will_return(i8* noundef [[TMP1]]) #[[ATTR9]]
-; IS________OPM-NEXT:    tail call void @free(i8* nocapture noundef [[TMP1]]) #[[ATTR9]]
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM: Function Attrs: nounwind willreturn
-; IS________NPM-LABEL: define {{[^@]+}}@test11
-; IS________NPM-SAME: () #[[ATTR9]] {
-; IS________NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    tail call void @sync_will_return(i8* noundef [[TMP1]]) #[[ATTR9]]
-; IS________NPM-NEXT:    ret void
+; CHECK: Function Attrs: nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@test11
+; CHECK-SAME: () #[[ATTR9]] {
+; CHECK-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    tail call void @sync_will_return(i8* noundef [[TMP1]]) #[[ATTR9]]
+; CHECK-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   tail call void @sync_will_return(i8* %1)
   tail call void @free(i8* %1)
   ret void
 }
 
 ; TEST 12
 define i32 @irreducible_cfg(i32 %0) {
-; IS________OPM: Function Attrs: nounwind
-; IS________OPM-LABEL: define {{[^@]+}}@irreducible_cfg
-; IS________OPM-SAME: (i32 [[TMP0:%.*]]) #[[ATTR12]] {
-; IS________OPM-NEXT:    [[TMP2:%.*]] = call noalias nonnull align 4 dereferenceable(4) i8* @malloc(i64 noundef 4)
-; IS________OPM-NEXT:    [[TMP3:%.*]] = bitcast i8* [[TMP2]] to i32*
-; IS________OPM-NEXT:    store i32 10, i32* [[TMP3]], align 4
-; IS________OPM-NEXT:    [[TMP4:%.*]] = icmp eq i32 [[TMP0]], 1
-; IS________OPM-NEXT:    br i1 [[TMP4]], label [[TMP5:%.*]], label [[TMP7:%.*]]
-; IS________OPM:       5:
-; IS________OPM-NEXT:    [[TMP6:%.*]] = add nsw i32 [[TMP0]], 5
-; IS________OPM-NEXT:    br label [[TMP13:%.*]]
-; IS________OPM:       7:
-; IS________OPM-NEXT:    br label [[TMP8:%.*]]
-; IS________OPM:       8:
-; IS________OPM-NEXT:    [[DOT0:%.*]] = phi i32 [ [[TMP14:%.*]], [[TMP13]] ], [ 1, [[TMP7]] ]
-; IS________OPM-NEXT:    [[TMP9:%.*]] = load i32, i32* [[TMP3]], align 4
-; IS________OPM-NEXT:    [[TMP10:%.*]] = add nsw i32 [[TMP9]], -1
-; IS________OPM-NEXT:    store i32 [[TMP10]], i32* [[TMP3]], align 4
-; IS________OPM-NEXT:    [[TMP11:%.*]] = icmp ne i32 [[TMP9]], 0
-; IS________OPM-NEXT:    br i1 [[TMP11]], label [[TMP12:%.*]], label [[TMP15:%.*]]
-; IS________OPM:       12:
-; IS________OPM-NEXT:    br label [[TMP13]]
-; IS________OPM:       13:
-; IS________OPM-NEXT:    [[DOT1:%.*]] = phi i32 [ [[TMP6]], [[TMP5]] ], [ [[DOT0]], [[TMP12]] ]
-; IS________OPM-NEXT:    [[TMP14]] = add nsw i32 [[DOT1]], 1
-; IS________OPM-NEXT:    br label [[TMP8]]
-; IS________OPM:       15:
-; IS________OPM-NEXT:    [[TMP16:%.*]] = bitcast i32* [[TMP3]] to i8*
-; IS________OPM-NEXT:    call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP16]]) #[[ATTR12]]
-; IS________OPM-NEXT:    [[TMP17:%.*]] = load i32, i32* [[TMP3]], align 4
-; IS________OPM-NEXT:    ret i32 [[TMP17]]
-;
-; IS________NPM: Function Attrs: nounwind
-; IS________NPM-LABEL: define {{[^@]+}}@irreducible_cfg
-; IS________NPM-SAME: (i32 [[TMP0:%.*]]) #[[ATTR12]] {
-; IS________NPM-NEXT:    [[TMP2:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    [[TMP3:%.*]] = bitcast i8* [[TMP2]] to i32*
-; IS________NPM-NEXT:    store i32 10, i32* [[TMP3]], align 4
-; IS________NPM-NEXT:    [[TMP4:%.*]] = icmp eq i32 [[TMP0]], 1
-; IS________NPM-NEXT:    br i1 [[TMP4]], label [[TMP5:%.*]], label [[TMP7:%.*]]
-; IS________NPM:       5:
-; IS________NPM-NEXT:    [[TMP6:%.*]] = add nsw i32 [[TMP0]], 5
-; IS________NPM-NEXT:    br label [[TMP13:%.*]]
-; IS________NPM:       7:
-; IS________NPM-NEXT:    br label [[TMP8:%.*]]
-; IS________NPM:       8:
-; IS________NPM-NEXT:    [[DOT0:%.*]] = phi i32 [ [[TMP14:%.*]], [[TMP13]] ], [ 1, [[TMP7]] ]
-; IS________NPM-NEXT:    [[TMP9:%.*]] = load i32, i32* [[TMP3]], align 4
-; IS________NPM-NEXT:    [[TMP10:%.*]] = add nsw i32 [[TMP9]], -1
-; IS________NPM-NEXT:    store i32 [[TMP10]], i32* [[TMP3]], align 4
-; IS________NPM-NEXT:    [[TMP11:%.*]] = icmp ne i32 [[TMP9]], 0
-; IS________NPM-NEXT:    br i1 [[TMP11]], label [[TMP12:%.*]], label [[TMP15:%.*]]
-; IS________NPM:       12:
-; IS________NPM-NEXT:    br label [[TMP13]]
-; IS________NPM:       13:
-; IS________NPM-NEXT:    [[DOT1:%.*]] = phi i32 [ [[TMP6]], [[TMP5]] ], [ [[DOT0]], [[TMP12]] ]
-; IS________NPM-NEXT:    [[TMP14]] = add nsw i32 [[DOT1]], 1
-; IS________NPM-NEXT:    br label [[TMP8]]
-; IS________NPM:       15:
-; IS________NPM-NEXT:    [[TMP16:%.*]] = bitcast i32* [[TMP3]] to i8*
-; IS________NPM-NEXT:    [[TMP17:%.*]] = load i32, i32* [[TMP3]], align 4
-; IS________NPM-NEXT:    ret i32 [[TMP17]]
+; CHECK: Function Attrs: nounwind
+; CHECK-LABEL: define {{[^@]+}}@irreducible_cfg
+; CHECK-SAME: (i32 [[TMP0:%.*]]) #[[ATTR12]] {
+; CHECK-NEXT:    [[TMP2:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    [[TMP3:%.*]] = bitcast i8* [[TMP2]] to i32*
+; CHECK-NEXT:    store i32 10, i32* [[TMP3]], align 4
+; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i32 [[TMP0]], 1
+; CHECK-NEXT:    br i1 [[TMP4]], label [[TMP5:%.*]], label [[TMP7:%.*]]
+; CHECK:       5:
+; CHECK-NEXT:    [[TMP6:%.*]] = add nsw i32 [[TMP0]], 5
+; CHECK-NEXT:    br label [[TMP13:%.*]]
+; CHECK:       7:
+; CHECK-NEXT:    br label [[TMP8:%.*]]
+; CHECK:       8:
+; CHECK-NEXT:    [[DOT0:%.*]] = phi i32 [ [[TMP14:%.*]], [[TMP13]] ], [ 1, [[TMP7]] ]
+; CHECK-NEXT:    [[TMP9:%.*]] = load i32, i32* [[TMP3]], align 4
+; CHECK-NEXT:    [[TMP10:%.*]] = add nsw i32 [[TMP9]], -1
+; CHECK-NEXT:    store i32 [[TMP10]], i32* [[TMP3]], align 4
+; CHECK-NEXT:    [[TMP11:%.*]] = icmp ne i32 [[TMP9]], 0
+; CHECK-NEXT:    br i1 [[TMP11]], label [[TMP12:%.*]], label [[TMP15:%.*]]
+; CHECK:       12:
+; CHECK-NEXT:    br label [[TMP13]]
+; CHECK:       13:
+; CHECK-NEXT:    [[DOT1:%.*]] = phi i32 [ [[TMP6]], [[TMP5]] ], [ [[DOT0]], [[TMP12]] ]
+; CHECK-NEXT:    [[TMP14]] = add nsw i32 [[DOT1]], 1
+; CHECK-NEXT:    br label [[TMP8]]
+; CHECK:       15:
+; CHECK-NEXT:    [[TMP16:%.*]] = bitcast i32* [[TMP3]] to i8*
+; CHECK-NEXT:    [[TMP17:%.*]] = load i32, i32* [[TMP3]], align 4
+; CHECK-NEXT:    ret i32 [[TMP17]]
 ;
   %2 = call noalias i8* @malloc(i64 4)
   %3 = bitcast i8* %2 to i32*
   store i32 10, i32* %3, align 4
   %4 = icmp eq i32 %0, 1
   br i1 %4, label %5, label %7
 
 5:                                                ; preds = %1

 ;
   %1 = tail call noalias i8* @malloc(i64 %S)
   tail call void @no_sync_func(i8* %1)
   tail call void @free(i8* %1)
   ret void
 }
 
 define void @test16a(i8 %v, i8** %P) {
-; IS________OPM: Function Attrs: willreturn
-; IS________OPM-LABEL: define {{[^@]+}}@test16a
-; IS________OPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree readnone [[P:%.*]]) #[[ATTR7]] {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias nonnull dereferenceable(1) i8* @malloc(i64 noundef 4) #[[ATTR7]]
-; IS________OPM-NEXT:    store i8 [[V]], i8* [[TMP1]], align 1
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[TMP1]]) #[[ATTR7]]
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef nonnull dereferenceable(1) [[TMP1]]) #[[ATTR9]]
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM: Function Attrs: willreturn
-; IS________NPM-LABEL: define {{[^@]+}}@test16a
-; IS________NPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree readnone [[P:%.*]]) #[[ATTR7]] {
-; IS________NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    store i8 [[V]], i8* [[TMP1]], align 1
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[TMP1]]) #[[ATTR7]]
-; IS________NPM-NEXT:    ret void
+; CHECK: Function Attrs: willreturn
+; CHECK-LABEL: define {{[^@]+}}@test16a
+; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree readnone [[P:%.*]]) #[[ATTR7]] {
+; CHECK-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    store i8 [[V]], i8* [[TMP1]], align 1
+; CHECK-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[TMP1]]) #[[ATTR7]]
+; CHECK-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   store i8 %v, i8* %1
   tail call void @no_sync_func(i8* %1)
   tail call void @free(i8* nonnull dereferenceable(1) %1)
   ret void
 }
 
;
   %1 = tail call noalias i8* @malloc(i64 4)
   store i8* %1, i8** %P
   tail call void @no_sync_func(i8* %1)
   tail call void @free(i8* %1)
   ret void
 }
 
 define void @test16c(i8 %v, i8** %P) {
-; IS________OPM: Function Attrs: nounwind willreturn
-; IS________OPM-LABEL: define {{[^@]+}}@test16c
-; IS________OPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[P:%.*]]) #[[ATTR9]] {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4) #[[ATTR7]]
-; IS________OPM-NEXT:    store i8* [[TMP1]], i8** [[P]], align 8
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree noundef [[TMP1]]) #[[ATTR9]]
-; IS________OPM-NEXT:    tail call void @free(i8* nocapture noundef [[TMP1]]) #[[ATTR9]]
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM: Function Attrs: nounwind willreturn
-; IS________NPM-LABEL: define {{[^@]+}}@test16c
-; IS________NPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[P:%.*]]) #[[ATTR9]] {
-; IS________NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    store i8* [[TMP1]], i8** [[P]], align 8
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree noundef [[TMP1]]) #[[ATTR9]]
-; IS________NPM-NEXT:    ret void
+; CHECK: Function Attrs: nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@test16c
+; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[P:%.*]]) #[[ATTR9]] {
+; CHECK-NEXT:    [[TMP1:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    store i8* [[TMP1]], i8** [[P]], align 8
+; CHECK-NEXT:    tail call void @no_sync_func(i8* nocapture nofree noundef [[TMP1]]) #[[ATTR9]]
+; CHECK-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   store i8* %1, i8** %P
   tail call void @no_sync_func(i8* %1) nounwind
   tail call void @free(i8* %1)
   ret void
 }
 
 define void @test16d(i8 %v, i8** %P) {
 ; CHECK: Function Attrs: inaccessiblemem_or_argmemonly nofree nounwind willreturn
 ; CHECK-LABEL: define {{[^@]+}}@test16d
 ; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[P:%.*]]) #[[ATTR13:[0-9]+]] {
 ; CHECK-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4) #[[ATTR7]]
 ; CHECK-NEXT:    store i8* [[TMP1]], i8** [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   store i8* %1, i8** %P
   ret void
 }
 ;.
-; IS________OPM: attributes #[[ATTR0:[0-9]+]] = { inaccessiblememonly mustprogress nofree nounwind willreturn allockind("new,uninitialized") allocsize(0) "alloc-family"="malloc" }
-; IS________OPM: attributes #[[ATTR1:[0-9]+]] = { mustprogress nounwind willreturn }
-; IS________OPM: attributes #[[ATTR2:[0-9]+]] = { mustprogress nofree nosync willreturn }
-; IS________OPM: attributes #[[ATTR3]] = { nofree nounwind }
-; IS________OPM: attributes #[[ATTR4]] = { noreturn }
-; IS________OPM: attributes #[[ATTR5:[0-9]+]] = { inaccessiblemem_or_argmemonly mustprogress nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; IS________OPM: attributes #[[ATTR6:[0-9]+]] = { argmemonly mustprogress nocallback nofree nosync nounwind willreturn }
-; IS________OPM: attributes #[[ATTR7]] = { willreturn }
-; IS________OPM: attributes #[[ATTR8:[0-9]+]] = { inaccessiblememonly mustprogress nofree nounwind willreturn allockind("new,uninitialized") allocsize(1) "alloc-family"="malloc" }
-; IS________OPM: attributes #[[ATTR9]] = { nounwind willreturn }
-; IS________OPM: attributes #[[ATTR10:[0-9]+]] = { inaccessiblememonly mustprogress nofree nounwind willreturn allockind("new,zeroed") allocsize(0,1) "alloc-family"="malloc" }
-; IS________OPM: attributes #[[ATTR11]] = { nofree willreturn }
-; IS________OPM: attributes #[[ATTR12]] = { nounwind }
-; IS________OPM: attributes #[[ATTR13]] = { inaccessiblemem_or_argmemonly nofree nounwind willreturn }
-;.
-; IS________NPM: attributes #[[ATTR0:[0-9]+]] = { inaccessiblememonly mustprogress nofree nounwind willreturn allockind("new,uninitialized") allocsize(0) "alloc-family"="malloc" }
-; IS________NPM: attributes #[[ATTR1:[0-9]+]] = { mustprogress nounwind willreturn }
-; IS________NPM: attributes #[[ATTR2:[0-9]+]] = { mustprogress nofree nosync willreturn }
-; IS________NPM: attributes #[[ATTR3]] = { nofree nounwind }
-; IS________NPM: attributes #[[ATTR4]] = { noreturn }
-; IS________NPM: attributes #[[ATTR5:[0-9]+]] = { inaccessiblemem_or_argmemonly mustprogress nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; IS________NPM: attributes #[[ATTR6:[0-9]+]] = { argmemonly mustprogress nocallback nofree nosync nounwind willreturn }
-; IS________NPM: attributes #[[ATTR7]] = { willreturn }
-; IS________NPM: attributes #[[ATTR8:[0-9]+]] = { inaccessiblememonly mustprogress nofree nounwind willreturn allockind("new,uninitialized") allocsize(1) "alloc-family"="malloc" }
-; IS________NPM: attributes #[[ATTR9]] = { nounwind willreturn }
-; IS________NPM: attributes #[[ATTR10:[0-9]+]] = { inaccessiblememonly mustprogress nofree nounwind willreturn allockind("new,zeroed") allocsize(0,1) "alloc-family"="malloc" }
-; IS________NPM: attributes #[[ATTR11]] = { nofree willreturn }
-; IS________NPM: attributes #[[ATTR12]] = { nounwind }
-; IS________NPM: attributes #[[ATTR13]] = { inaccessiblemem_or_argmemonly nofree nounwind willreturn }
-; IS________NPM: attributes #[[ATTR14:[0-9]+]] = { argmemonly nofree nounwind willreturn writeonly }
+; CHECK: attributes #[[ATTR0:[0-9]+]] = { inaccessiblememonly mustprogress nofree nounwind willreturn allockind("new,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; CHECK: attributes #[[ATTR1:[0-9]+]] = { mustprogress nounwind willreturn }
+; CHECK: attributes #[[ATTR2:[0-9]+]] = { mustprogress nofree nosync willreturn }
+; CHECK: attributes #[[ATTR3]] = { nofree nounwind }
+; CHECK: attributes #[[ATTR4]] = { noreturn }
+; CHECK: attributes #[[ATTR5:[0-9]+]] = { inaccessiblemem_or_argmemonly mustprogress nounwind willreturn allockind("free") "alloc-family"="malloc" }
+; CHECK: attributes #[[ATTR6:[0-9]+]] = { argmemonly mustprogress nocallback nofree nosync nounwind willreturn }
+; CHECK: attributes #[[ATTR7]] = { willreturn }
+; CHECK: attributes #[[ATTR8:[0-9]+]] = { inaccessiblememonly mustprogress nofree nounwind willreturn allockind("new,uninitialized") allocsize(1) "alloc-family"="malloc" }
+; CHECK: attributes #[[ATTR9]] = { nounwind willreturn }
+; CHECK: attributes #[[ATTR10:[0-9]+]] = { inaccessiblememonly mustprogress nofree nounwind willreturn allockind("new,zeroed") allocsize(0,1) "alloc-family"="malloc" }
+; CHECK: attributes #[[ATTR11]] = { nofree willreturn }
+; CHECK: attributes #[[ATTR12]] = { nounwind }
+; CHECK: attributes #[[ATTR13]] = { inaccessiblemem_or_argmemonly nofree nounwind willreturn }
+; CHECK: attributes #[[ATTR14:[0-9]+]] = { argmemonly nofree nounwind willreturn writeonly }
 ;.

llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll

for.end:
   ret void
 }
 
 define dso_local i32 @round_trip_malloc(i32 %x) {
 ; IS__TUNIT_OPM: Function Attrs: nounwind willreturn
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@round_trip_malloc
 ; IS__TUNIT_OPM-SAME: (i32 [[X:%.*]]) #[[ATTR10:[0-9]+]] {
 ; IS__TUNIT_OPM-NEXT:  entry:
-; IS__TUNIT_OPM-NEXT:    [[CALL:%.*]] = call noalias nonnull align 4 dereferenceable(4) i8* @malloc(i64 noundef 4) #[[ATTR23:[0-9]+]]
-; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL]] to i32*
-; IS__TUNIT_OPM-NEXT:    store i32 [[X]], i32* [[TMP0]], align 4
-; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 4
-; IS__TUNIT_OPM-NEXT:    call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[CALL]]) #[[ATTR24:[0-9]+]]
-; IS__TUNIT_OPM-NEXT:    ret i32 [[TMP1]]
+; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
+; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
+; IS__TUNIT_OPM-NEXT:    store i32 [[X]], i32* [[TMP1]], align 4
+; IS__TUNIT_OPM-NEXT:    [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
+; IS__TUNIT_OPM-NEXT:    ret i32 [[TMP2]]
 ;
 ; IS__TUNIT_NPM: Function Attrs: nounwind willreturn
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@round_trip_malloc
 ; IS__TUNIT_NPM-SAME: (i32 returned [[X:%.*]]) #[[ATTR8:[0-9]+]] {
 ; IS__TUNIT_NPM-NEXT:  entry:
 ; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
 ; IS__TUNIT_NPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; IS__TUNIT_NPM-NEXT:    store i32 [[X]], i32* [[TMP1]], align 4
 ; IS__TUNIT_NPM-NEXT:    ret i32 [[X]]
 ;
 ; IS__CGSCC_OPM: Function Attrs: nounwind willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@round_trip_malloc
 ; IS__CGSCC_OPM-SAME: (i32 [[X:%.*]]) #[[ATTR11:[0-9]+]] {
 ; IS__CGSCC_OPM-NEXT:  entry:
-; IS__CGSCC_OPM-NEXT:    [[CALL:%.*]] = call noalias nonnull align 4 dereferenceable(4) i8* @malloc(i64 noundef 4) #[[ATTR25:[0-9]+]]
-; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL]] to i32*
-; IS__CGSCC_OPM-NEXT:    store i32 [[X]], i32* [[TMP0]], align 4
-; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 4
-; IS__CGSCC_OPM-NEXT:    call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[CALL]]) #[[ATTR26:[0-9]+]]
-; IS__CGSCC_OPM-NEXT:    ret i32 [[TMP1]]
+; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
+; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
+; IS__CGSCC_OPM-NEXT:    store i32 [[X]], i32* [[TMP1]], align 4
+; IS__CGSCC_OPM-NEXT:    [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
+; IS__CGSCC_OPM-NEXT:    ret i32 [[TMP2]]
 ;
 ; IS__CGSCC_NPM: Function Attrs: nounwind willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@round_trip_malloc
 ; IS__CGSCC_NPM-SAME: (i32 returned [[X:%.*]]) #[[ATTR9:[0-9]+]] {
 ; IS__CGSCC_NPM-NEXT:  entry:
 ; IS__CGSCC_NPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
 ; IS__CGSCC_NPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; IS__CGSCC_NPM-NEXT:    store i32 [[X]], i32* [[TMP1]], align 4
entry:
   ret i32 %1
 }
 
 define dso_local i32 @round_trip_malloc_constant() {
 ; IS__TUNIT_OPM: Function Attrs: nounwind willreturn
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@round_trip_malloc_constant
 ; IS__TUNIT_OPM-SAME: () #[[ATTR10]] {
 ; IS__TUNIT_OPM-NEXT:  entry:
-; IS__TUNIT_OPM-NEXT:    [[CALL:%.*]] = call noalias nonnull align 4 dereferenceable(4) i8* @malloc(i64 noundef 4) #[[ATTR23]]
-; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL]] to i32*
-; IS__TUNIT_OPM-NEXT:    store i32 7, i32* [[TMP0]], align 4
-; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 4
-; IS__TUNIT_OPM-NEXT:    call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[CALL]]) #[[ATTR24]]
-; IS__TUNIT_OPM-NEXT:    ret i32 [[TMP1]]
+; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
+; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
+; IS__TUNIT_OPM-NEXT:    store i32 7, i32* [[TMP1]], align 4
+; IS__TUNIT_OPM-NEXT:    [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
+; IS__TUNIT_OPM-NEXT:    ret i32 [[TMP2]]
 ;
 ; IS__TUNIT_NPM: Function Attrs: nounwind willreturn
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@round_trip_malloc_constant
 ; IS__TUNIT_NPM-SAME: () #[[ATTR8]] {
 ; IS__TUNIT_NPM-NEXT:  entry:
 ; IS__TUNIT_NPM-NEXT:    ret i32 7
 ;
 ; IS__CGSCC_OPM: Function Attrs: nounwind willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@round_trip_malloc_constant
 ; IS__CGSCC_OPM-SAME: () #[[ATTR11]] {
 ; IS__CGSCC_OPM-NEXT:  entry:
-; IS__CGSCC_OPM-NEXT:    [[CALL:%.*]] = call noalias nonnull align 4 dereferenceable(4) i8* @malloc(i64 noundef 4) #[[ATTR25]]
-; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL]] to i32*
-; IS__CGSCC_OPM-NEXT:    store i32 7, i32* [[TMP0]], align 4
-; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 4
-; IS__CGSCC_OPM-NEXT:    call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[CALL]]) #[[ATTR26]]
-; IS__CGSCC_OPM-NEXT:    ret i32 [[TMP1]]
+; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
+; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
+; IS__CGSCC_OPM-NEXT:    store i32 7, i32* [[TMP1]], align 4
+; IS__CGSCC_OPM-NEXT:    [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
+; IS__CGSCC_OPM-NEXT:    ret i32 [[TMP2]]
 ;
 ; IS__CGSCC_NPM: Function Attrs: nounwind willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@round_trip_malloc_constant
 ; IS__CGSCC_NPM-SAME: () #[[ATTR9]] {
 ; IS__CGSCC_NPM-NEXT:  entry:
 ; IS__CGSCC_NPM-NEXT:    ret i32 7
 ;
 entry:

 
 declare noalias i8* @calloc(i64, i64)
 
 define dso_local i32 @conditional_calloc(i32 %x) {
 ; IS__TUNIT_OPM: Function Attrs: nounwind willreturn
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@conditional_calloc
 ; IS__TUNIT_OPM-SAME: (i32 [[X:%.*]]) #[[ATTR10]] {
 ; IS__TUNIT_OPM-NEXT:  entry:
-; IS__TUNIT_OPM-NEXT:    [[CALL:%.*]] = call noalias nonnull align 4 dereferenceable(4) i8* @calloc(i64 noundef 1, i64 noundef 4) #[[ATTR23]]
-; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL]] to i32*
+; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
+; IS__TUNIT_OPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[TMP0]], i8 0, i64 4, i1 false)
+; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; IS__TUNIT_OPM-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[X]], 0
 ; IS__TUNIT_OPM-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
 ; IS__TUNIT_OPM:       if.then:
-; IS__TUNIT_OPM-NEXT:    store i32 [[X]], i32* [[TMP0]], align 4
+; IS__TUNIT_OPM-NEXT:    store i32 [[X]], i32* [[TMP1]], align 4
 ; IS__TUNIT_OPM-NEXT:    br label [[IF_END]]
 ; IS__TUNIT_OPM:       if.end:
-; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 4
-; IS__TUNIT_OPM-NEXT:    [[TMP2:%.*]] = bitcast i32* [[TMP0]] to i8*
-; IS__TUNIT_OPM-NEXT:    call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP2]]) #[[ATTR24]]
-; IS__TUNIT_OPM-NEXT:    ret i32 [[TMP1]]
+; IS__TUNIT_OPM-NEXT:    [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
+; IS__TUNIT_OPM-NEXT:    [[TMP3:%.*]] = bitcast i32* [[TMP1]] to i8*
+; IS__TUNIT_OPM-NEXT:    ret i32 [[TMP2]]
 ;
 ; IS__TUNIT_NPM: Function Attrs: nounwind willreturn
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@conditional_calloc
 ; IS__TUNIT_NPM-SAME: (i32 [[X:%.*]]) #[[ATTR8]] {
 ; IS__TUNIT_NPM-NEXT:  entry:
 ; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
 ; IS__TUNIT_NPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[TMP0]], i8 0, i64 4, i1 false)
 ; IS__TUNIT_NPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; IS__TUNIT_NPM-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[X]], 0
 ; IS__TUNIT_NPM-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
 ; IS__TUNIT_NPM:       if.then:
 ; IS__TUNIT_NPM-NEXT:    store i32 [[X]], i32* [[TMP1]], align 4
 ; IS__TUNIT_NPM-NEXT:    br label [[IF_END]]
 ; IS__TUNIT_NPM:       if.end:
 ; IS__TUNIT_NPM-NEXT:    [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
 ; IS__TUNIT_NPM-NEXT:    ret i32 [[TMP2]]
 ;
 ; IS__CGSCC_OPM: Function Attrs: nounwind willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@conditional_calloc
 ; IS__CGSCC_OPM-SAME: (i32 [[X:%.*]]) #[[ATTR11]] {
 ; IS__CGSCC_OPM-NEXT:  entry:
-; IS__CGSCC_OPM-NEXT:    [[CALL:%.*]] = call noalias nonnull align 4 dereferenceable(4) i8* @calloc(i64 noundef 1, i64 noundef 4) #[[ATTR25]]
-; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL]] to i32*
+; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
+; IS__CGSCC_OPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[TMP0]], i8 0, i64 4, i1 false)
+; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; IS__CGSCC_OPM-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[X]], 0
 ; IS__CGSCC_OPM-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
 ; IS__CGSCC_OPM:       if.then:
-; IS__CGSCC_OPM-NEXT:    store i32 [[X]], i32* [[TMP0]], align 4
+; IS__CGSCC_OPM-NEXT:    store i32 [[X]], i32* [[TMP1]], align 4
 ; IS__CGSCC_OPM-NEXT:    br label [[IF_END]]
 ; IS__CGSCC_OPM:       if.end:
-; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 4
-; IS__CGSCC_OPM-NEXT:    [[TMP2:%.*]] = bitcast i32* [[TMP0]] to i8*
-; IS__CGSCC_OPM-NEXT:    call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP2]]) #[[ATTR26]]
-; IS__CGSCC_OPM-NEXT:    ret i32 [[TMP1]]
+; IS__CGSCC_OPM-NEXT:    [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
+; IS__CGSCC_OPM-NEXT:    [[TMP3:%.*]] = bitcast i32* [[TMP1]] to i8*
+; IS__CGSCC_OPM-NEXT:    ret i32 [[TMP2]]
 ;
 ; IS__CGSCC_NPM: Function Attrs: nounwind willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@conditional_calloc
 ; IS__CGSCC_NPM-SAME: (i32 [[X:%.*]]) #[[ATTR9]] {
 ; IS__CGSCC_NPM-NEXT:  entry:
 ; IS__CGSCC_NPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
 ; IS__CGSCC_NPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[TMP0]], i8 0, i64 4, i1 false)
 ; IS__CGSCC_NPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
if.end:                                           ; preds = %if.then, %entry
   ret i32 %1
 }
 
 define dso_local i32 @conditional_calloc_zero(i1 %c) {
 ; IS__TUNIT_OPM: Function Attrs: nounwind willreturn
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@conditional_calloc_zero
 ; IS__TUNIT_OPM-SAME: (i1 [[C:%.*]]) #[[ATTR10]] {
 ; IS__TUNIT_OPM-NEXT:  entry:
-; IS__TUNIT_OPM-NEXT:    [[CALL:%.*]] = call noalias nonnull align 4 dereferenceable(4) i8* @calloc(i64 noundef 1, i64 noundef 4) #[[ATTR23]]
-; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL]] to i32*
+; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
+; IS__TUNIT_OPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[TMP0]], i8 0, i64 4, i1 false)
+; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; IS__TUNIT_OPM-NEXT:    br i1 [[C]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
 ; IS__TUNIT_OPM:       if.then:
-; IS__TUNIT_OPM-NEXT:    store i32 0, i32* [[TMP0]], align 4
+; IS__TUNIT_OPM-NEXT:    store i32 0, i32* [[TMP1]], align 4
 ; IS__TUNIT_OPM-NEXT:    br label [[IF_END]]
 ; IS__TUNIT_OPM:       if.end:
-; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 4
-; IS__TUNIT_OPM-NEXT:    [[TMP2:%.*]] = bitcast i32* [[TMP0]] to i8*
-; IS__TUNIT_OPM-NEXT:    call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP2]]) #[[ATTR24]]
-; IS__TUNIT_OPM-NEXT:    ret i32 [[TMP1]]
+; IS__TUNIT_OPM-NEXT:    [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
+; IS__TUNIT_OPM-NEXT:    [[TMP3:%.*]] = bitcast i32* [[TMP1]] to i8*
+; IS__TUNIT_OPM-NEXT:    ret i32 [[TMP2]]
 ;
 ; IS__TUNIT_NPM: Function Attrs: nounwind willreturn
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@conditional_calloc_zero
 ; IS__TUNIT_NPM-SAME: (i1 [[C:%.*]]) #[[ATTR8]] {
 ; IS__TUNIT_NPM-NEXT:  entry:
 ; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
 ; IS__TUNIT_NPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[TMP0]], i8 0, i64 4, i1 false)
 ; IS__TUNIT_NPM-NEXT:    br i1 [[C]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
 ; IS__TUNIT_NPM:       if.then:
 ; IS__TUNIT_NPM-NEXT:    br label [[IF_END]]
 ; IS__TUNIT_NPM:       if.end:
 ; IS__TUNIT_NPM-NEXT:    ret i32 0
 ;
 ; IS__CGSCC_OPM: Function Attrs: nounwind willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@conditional_calloc_zero
 ; IS__CGSCC_OPM-SAME: (i1 [[C:%.*]]) #[[ATTR11]] {
 ; IS__CGSCC_OPM-NEXT:  entry:
-; IS__CGSCC_OPM-NEXT:    [[CALL:%.*]] = call noalias nonnull align 4 dereferenceable(4) i8* @calloc(i64 noundef 1, i64 noundef 4) #[[ATTR25]]
-; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL]] to i32*
+; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
+; IS__CGSCC_OPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[TMP0]], i8 0, i64 4, i1 false)
+; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; IS__CGSCC_OPM-NEXT:    br i1 [[C]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
 ; IS__CGSCC_OPM:       if.then:
-; IS__CGSCC_OPM-NEXT:    store i32 0, i32* [[TMP0]], align 4
+; IS__CGSCC_OPM-NEXT:    store i32 0, i32* [[TMP1]], align 4
 ; IS__CGSCC_OPM-NEXT:    br label [[IF_END]]
 ; IS__CGSCC_OPM:       if.end:
-; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 4
-; IS__CGSCC_OPM-NEXT:    [[TMP2:%.*]] = bitcast i32* [[TMP0]] to i8*
-; IS__CGSCC_OPM-NEXT:    call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP2]]) #[[ATTR26]]
-; IS__CGSCC_OPM-NEXT:    ret i32 [[TMP1]]
+; IS__CGSCC_OPM-NEXT:    [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
+; IS__CGSCC_OPM-NEXT:    [[TMP3:%.*]] = bitcast i32* [[TMP1]] to i8*
+; IS__CGSCC_OPM-NEXT:    ret i32 [[TMP2]]
 ;
 ; IS__CGSCC_NPM: Function Attrs: nounwind willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@conditional_calloc_zero
 ; IS__CGSCC_NPM-SAME: (i1 [[C:%.*]]) #[[ATTR9]] {
 ; IS__CGSCC_NPM-NEXT:  entry:
 ; IS__CGSCC_NPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 4, align 1
 ; IS__CGSCC_NPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[TMP0]], i8 0, i64 4, i1 false)
 ; IS__CGSCC_NPM-NEXT:    br i1 [[C]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]

 }
 
 define dso_local i32* @malloc_like(i32 %s) {
 ; IS__TUNIT_OPM: Function Attrs: inaccessiblememonly nofree nounwind willreturn
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@malloc_like
 ; IS__TUNIT_OPM-SAME: (i32 [[S:%.*]]) #[[ATTR15:[0-9]+]] {
 ; IS__TUNIT_OPM-NEXT:  entry:
 ; IS__TUNIT_OPM-NEXT:    [[CONV:%.*]] = sext i32 [[S]] to i64
-; IS__TUNIT_OPM-NEXT:    [[CALL:%.*]] = call noalias noundef i8* @malloc(i64 noundef [[CONV]]) #[[ATTR23]]
+; IS__TUNIT_OPM-NEXT:    [[CALL:%.*]] = call noalias noundef i8* @malloc(i64 noundef [[CONV]]) #[[ATTR23:[0-9]+]]
 ; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL]] to i32*
 ; IS__TUNIT_OPM-NEXT:    ret i32* [[TMP0]]
 ;
 ; IS__TUNIT_NPM: Function Attrs: inaccessiblememonly nofree nounwind willreturn
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@malloc_like
 ; IS__TUNIT_NPM-SAME: (i32 [[S:%.*]]) #[[ATTR13:[0-9]+]] {
 ; IS__TUNIT_NPM-NEXT:  entry:
 ; IS__TUNIT_NPM-NEXT:    [[CONV:%.*]] = sext i32 [[S]] to i64
 ; IS__TUNIT_NPM-NEXT:    [[CALL:%.*]] = call noalias noundef i8* @malloc(i64 noundef [[CONV]]) #[[ATTR20:[0-9]+]]
 ; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL]] to i32*
 ; IS__TUNIT_NPM-NEXT:    ret i32* [[TMP0]]
 ;
 ; IS__CGSCC_OPM: Function Attrs: inaccessiblememonly nofree nounwind willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@malloc_like
 ; IS__CGSCC_OPM-SAME: (i32 [[S:%.*]]) #[[ATTR16:[0-9]+]] {
 ; IS__CGSCC_OPM-NEXT:  entry:
 ; IS__CGSCC_OPM-NEXT:    [[CONV:%.*]] = sext i32 [[S]] to i64
-; IS__CGSCC_OPM-NEXT:    [[CALL:%.*]] = call noalias noundef i8* @malloc(i64 noundef [[CONV]]) #[[ATTR25]]
+; IS__CGSCC_OPM-NEXT:    [[CALL:%.*]] = call noalias noundef i8* @malloc(i64 noundef [[CONV]]) #[[ATTR25:[0-9]+]]
 ; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL]] to i32*
 ; IS__CGSCC_OPM-NEXT:    ret i32* [[TMP0]]
 ;
 ; IS__CGSCC_NPM: Function Attrs: inaccessiblememonly nofree nounwind willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@malloc_like
 ; IS__CGSCC_NPM-SAME: (i32 [[S:%.*]]) #[[ATTR14:[0-9]+]] {
 ; IS__CGSCC_NPM-NEXT:  entry:
 ; IS__CGSCC_NPM-NEXT:    [[CONV:%.*]] = sext i32 [[S]] to i64
 ; IS__CGSCC_NPM-NEXT:    [[CALL:%.*]] = call noalias noundef i8* @malloc(i64 noundef [[CONV]]) #[[ATTR23:[0-9]+]]
 ; IS__CGSCC_NPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL]] to i32*
 ; IS__CGSCC_NPM-NEXT:    ret i32* [[TMP0]]
 ;
 entry:
   %conv = sext i32 %s to i64
   %call = call noalias i8* @malloc(i64 %conv) norecurse
   %0 = bitcast i8* %call to i32*
   ret i32* %0
 }
 
 define dso_local i32 @round_trip_malloc_like(i32 %x) {
 ; IS__TUNIT_OPM: Function Attrs: nounwind willreturn
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@round_trip_malloc_like
 ; IS__TUNIT_OPM-SAME: (i32 [[X:%.*]]) #[[ATTR10]] {
 ; IS__TUNIT_OPM-NEXT:  entry:
-; IS__TUNIT_OPM-NEXT:    [[CALL:%.*]] = call noalias i32* @malloc_like(i32 noundef 4) #[[ATTR25:[0-9]+]]
+; IS__TUNIT_OPM-NEXT:    [[CALL:%.*]] = call noalias i32* @malloc_like(i32 noundef 4) #[[ATTR24:[0-9]+]]
 ; IS__TUNIT_OPM-NEXT:    store i32 [[X]], i32* [[CALL]], align 4
 ; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = load i32, i32* [[CALL]], align 4
 ; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = bitcast i32* [[CALL]] to i8*
-; IS__TUNIT_OPM-NEXT:    call void @free(i8* nocapture noundef [[TMP1]]) #[[ATTR24]]
+; IS__TUNIT_OPM-NEXT:    call void @free(i8* nocapture noundef [[TMP1]]) #[[ATTR25:[0-9]+]]
 ; IS__TUNIT_OPM-NEXT:    ret i32 [[TMP0]]
 ;
 ; IS__TUNIT_NPM: Function Attrs: nounwind willreturn
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@round_trip_malloc_like
 ; IS__TUNIT_NPM-SAME: (i32 [[X:%.*]]) #[[ATTR8]] {
 ; IS__TUNIT_NPM-NEXT:  entry:
 ; IS__TUNIT_NPM-NEXT:    [[CALL:%.*]] = call noalias i32* @malloc_like(i32 noundef 4) #[[ATTR21:[0-9]+]]
 ; IS__TUNIT_NPM-NEXT:    store i32 [[X]], i32* [[CALL]], align 4
 ; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = load i32, i32* [[CALL]], align 4
 ; IS__TUNIT_NPM-NEXT:    [[TMP1:%.*]] = bitcast i32* [[CALL]] to i8*
 ; IS__TUNIT_NPM-NEXT:    call void @free(i8* nocapture noundef [[TMP1]]) #[[ATTR22:[0-9]+]]
 ; IS__TUNIT_NPM-NEXT:    ret i32 [[TMP0]]
 ;
 ; IS__CGSCC_OPM: Function Attrs: nounwind willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@round_trip_malloc_like
 ; IS__CGSCC_OPM-SAME: (i32 [[X:%.*]]) #[[ATTR11]] {
 ; IS__CGSCC_OPM-NEXT:  entry:
-; IS__CGSCC_OPM-NEXT:    [[CALL:%.*]] = call noalias nonnull align 4 dereferenceable(4) i32* @malloc_like(i32 noundef 4) #[[ATTR26]]
+; IS__CGSCC_OPM-NEXT:    [[CALL:%.*]] = call noalias nonnull align 4 dereferenceable(4) i32* @malloc_like(i32 noundef 4) #[[ATTR26:[0-9]+]]
 ; IS__CGSCC_OPM-NEXT:    store i32 [[X]], i32* [[CALL]], align 4
 ; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = load i32, i32* [[CALL]], align 4
 ; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = bitcast i32* [[CALL]] to i8*
 ; IS__CGSCC_OPM-NEXT:    call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]]) #[[ATTR26]]
 ; IS__CGSCC_OPM-NEXT:    ret i32 [[TMP0]]
 ;
 ; IS__CGSCC_NPM: Function Attrs: nounwind willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@round_trip_malloc_like

 ; IS__TUNIT_OPM: attributes #[[ATTR16]] = { nofree norecurse nosync nounwind willreturn uwtable }
 ; IS__TUNIT_OPM: attributes #[[ATTR17]] = { argmemonly nofree norecurse nosync nounwind }
 ; IS__TUNIT_OPM: attributes #[[ATTR18]] = { argmemonly nofree nosync nounwind }
 ; IS__TUNIT_OPM: attributes #[[ATTR19:[0-9]+]] = { argmemonly nofree nounwind willreturn writeonly }
 ; IS__TUNIT_OPM: attributes #[[ATTR20]] = { willreturn }
 ; IS__TUNIT_OPM: attributes #[[ATTR21]] = { nofree nosync nounwind willreturn writeonly }
 ; IS__TUNIT_OPM: attributes #[[ATTR22]] = { nofree nosync nounwind writeonly }
 ; IS__TUNIT_OPM: attributes #[[ATTR23]] = { norecurse willreturn }
-; IS__TUNIT_OPM: attributes #[[ATTR24]] = { norecurse nounwind willreturn }
-; IS__TUNIT_OPM: attributes #[[ATTR25]] = { nofree norecurse nounwind willreturn }
+; IS__TUNIT_OPM: attributes #[[ATTR24]] = { nofree norecurse nounwind willreturn }
+; IS__TUNIT_OPM: attributes #[[ATTR25]] = { norecurse nounwind willreturn }
 ; IS__TUNIT_OPM: attributes #[[ATTR26]] = { norecurse }
 ; IS__TUNIT_OPM: attributes #[[ATTR27]] = { norecurse nounwind }
 ; IS__TUNIT_OPM: attributes #[[ATTR28]] = { nofree nosync nounwind }
 ;.
 ; IS__TUNIT_NPM: attributes #[[ATTR0]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
 ; IS__TUNIT_NPM: attributes #[[ATTR1]] = { argmemonly nofree norecurse nosync nounwind willreturn }
 ; IS__TUNIT_NPM: attributes #[[ATTR2:[0-9]+]] = { argmemonly mustprogress nocallback nofree nosync nounwind willreturn }
 ; IS__TUNIT_NPM: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn }