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)) {
-          if (Function *Callee = Call->getCalledFunction()) {
+          auto &TLI = GetTLI(*Node->getFunction());
+          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.
                 continue;
 
               FunctionModRefBehavior Behaviour =
                   AAResultBase::getModRefBehavior(Callee);

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 = translateAndAddState(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

 ; IS________OPM-NEXT:    br i1 false, label [[DEAD:%.*]], label [[F2:%.*]]
 ; IS________OPM:       f:
 ; IS________OPM-NEXT:    br label [[J:%.*]]
 ; IS________OPM:       f2:
 ; IS________OPM-NEXT:    [[C1:%.*]] = bitcast i8* [[M_H2S]] to i32*
 ; IS________OPM-NEXT:    [[C2:%.*]] = bitcast i32* [[C1]] to i8*
 ; IS________OPM-NEXT:    [[L:%.*]] = load i8, i8* [[C2]], align 16
 ; IS________OPM-NEXT:    call void @usei8(i8 [[L]])
-; IS________OPM-NEXT:    call void @no_sync_func(i8* nocapture nofree noundef align 16 [[C2]]) #[[ATTR9:[0-9]+]]
+; IS________OPM-NEXT:    call void @no_sync_func(i8* nocapture nofree noundef align 16 [[C2]]) #[[ATTR10:[0-9]+]]
 ; IS________OPM-NEXT:    br label [[J]]
 ; IS________OPM:       dead:
 ; IS________OPM-NEXT:    unreachable
 ; IS________OPM:       j:
 ; IS________OPM-NEXT:    [[PHI:%.*]] = phi i8* [ [[M_H2S]], [[F]] ], [ null, [[F2]] ]
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree noundef align 16 [[PHI]]) #[[ATTR9]]
+; IS________OPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree noundef align 16 [[PHI]]) #[[ATTR10]]
 ; IS________OPM-NEXT:    ret void
 ;
 ; IS________NPM-LABEL: define {{[^@]+}}@h2s_value_simplify_interaction
 ; IS________NPM-SAME: (i1 [[C:%.*]], i8* nocapture nofree readnone [[A:%.*]]) {
 ; IS________NPM-NEXT:  entry:
 ; IS________NPM-NEXT:    [[M_H2S:%.*]] = alloca i8, i64 4, align 16
 ; IS________NPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
 ; IS________NPM:       t:
;
   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-LABEL: define {{[^@]+}}@test3() {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture [[TMP1]])
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM-LABEL: define {{[^@]+}}@test3() {
-; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree [[DOTH2S]])
-; IS________NPM-NEXT:    ret void
+; CHECK-LABEL: define {{[^@]+}}@test3() {
+; CHECK-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree [[DOTH2S]])
+; 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________OPM-LABEL: define {{[^@]+}}@test3a
 ; IS________OPM-SAME: (i8* nocapture [[P:%.*]]) {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; IS________OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree [[TMP1]], i8* nocapture [[P]])
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture [[TMP1]])
+; IS________OPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
+; IS________OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree [[DOTH2S]], i8* nocapture [[P]])
 ; IS________OPM-NEXT:    ret void
 ;
 ; IS________NPM-LABEL: define {{[^@]+}}@test3a
 ; IS________NPM-SAME: (i8* nocapture [[P:%.*]]) {
 ; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
 ; IS________NPM-NEXT:    tail call void @nofree_arg_only(i8* noalias nocapture nofree [[DOTH2S]], i8* nocapture [[P]])
 ; IS________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) allockind("alloc,uninitialized,aligned") allocsize(1)
 
 define void @test3b(i8* %p) {
 ; IS________OPM-LABEL: define {{[^@]+}}@test3b
 ; IS________OPM-SAME: (i8* nocapture [[P:%.*]]) {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 noundef 32, i64 noundef 128)
-; IS________OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree [[TMP1]], i8* nocapture [[P]])
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture [[TMP1]])
+; IS________OPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 128, align 1
+; IS________OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree [[DOTH2S]], i8* nocapture [[P]])
 ; IS________OPM-NEXT:    ret void
 ;
 ; IS________NPM-LABEL: define {{[^@]+}}@test3b
 ; IS________NPM-SAME: (i8* nocapture [[P:%.*]]) {
 ; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 128, align 1
 ; IS________NPM-NEXT:    tail call void @nofree_arg_only(i8* noalias nocapture nofree [[DOTH2S]], i8* nocapture [[P]])
 ; IS________NPM-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @aligned_alloc(i64 32, i64 128)
   tail call void @nofree_arg_only(i8* %1, i8* %p)
   tail call void @free(i8* %1)
   ret void
 }
 
 ; leave alone non-constant alignments.
 define void @test3c(i64 %alignment) {
-; IS________OPM-LABEL: define {{[^@]+}}@test3c
-; IS________OPM-SAME: (i64 [[ALIGNMENT:%.*]]) {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 [[ALIGNMENT]], i64 noundef 128)
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture [[TMP1]])
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM-LABEL: define {{[^@]+}}@test3c
-; IS________NPM-SAME: (i64 [[ALIGNMENT:%.*]]) {
-; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 128, align 1
-; IS________NPM-NEXT:    ret void
+; CHECK-LABEL: define {{[^@]+}}@test3c
+; CHECK-SAME: (i64 [[ALIGNMENT:%.*]]) {
+; CHECK-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 128, align 1
+; CHECK-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @aligned_alloc(i64 %alignment, i64 128)
   tail call void @free(i8* %1)
   ret void
 }
 
 ; leave alone a constant-but-invalid alignment
 define void @test3d(i8* %p) {
 ; IS________OPM-LABEL: define {{[^@]+}}@test3d
 ; IS________OPM-SAME: (i8* nocapture [[P:%.*]]) {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 noundef 33, i64 noundef 128)
-; IS________OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree [[TMP1]], i8* nocapture [[P]])
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture [[TMP1]])
+; IS________OPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 128, align 1
+; IS________OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree [[DOTH2S]], i8* nocapture [[P]])
 ; IS________OPM-NEXT:    ret void
 ;
 ; IS________NPM-LABEL: define {{[^@]+}}@test3d
 ; IS________NPM-SAME: (i8* nocapture [[P:%.*]]) {
 ; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 128, align 1
 ; IS________NPM-NEXT:    tail call void @nofree_arg_only(i8* noalias nocapture nofree [[DOTH2S]], i8* nocapture [[P]])
 ; IS________NPM-NEXT:    ret void
 ;
 ; CHECK-SAME; (i8* nocapture [[P:%.*]]) {
   %1 = tail call noalias i8* @aligned_alloc(i64 33, i64 128)
   tail call void @nofree_arg_only(i8* %1, i8* %p)
   tail call void @free(i8* %1)
   ret void
 }
 
 declare noalias i8* @calloc(i64, i64) allockind("alloc,zeroed") allocsize(0,1)
 
 define void @test0() {
-; IS________OPM-LABEL: define {{[^@]+}}@test0() {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @calloc(i64 noundef 2, i64 noundef 4)
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture [[TMP1]])
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM-LABEL: define {{[^@]+}}@test0() {
-; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 8, align 1
-; IS________NPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[DOTH2S]], i8 0, i64 8, i1 false)
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree [[DOTH2S]])
-; IS________NPM-NEXT:    ret void
+; CHECK-LABEL: define {{[^@]+}}@test0() {
+; CHECK-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 8, align 1
+; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[DOTH2S]], i8 0, i64 8, i1 false)
+; CHECK-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree [[DOTH2S]])
+; 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________OPM-LABEL: define {{[^@]+}}@test5
 ; IS________OPM-SAME: (i32 [[TMP0:%.*]], i8* nocapture [[P:%.*]]) {
-; IS________OPM-NEXT:    [[TMP2:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; IS________OPM-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
-; IS________OPM-NEXT:    br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
+; IS________OPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
+; IS________OPM-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0]], 0
+; IS________OPM-NEXT:    br i1 [[TMP2]], label [[TMP4:%.*]], label [[TMP3:%.*]]
+; IS________OPM:       3:
+; IS________OPM-NEXT:    tail call void @nofree_func(i8* noalias nocapture nofree [[DOTH2S]])
+; IS________OPM-NEXT:    br label [[TMP5:%.*]]
 ; IS________OPM:       4:
-; IS________OPM-NEXT:    tail call void @nofree_func(i8* noalias nocapture nofree [[TMP2]])
-; IS________OPM-NEXT:    br label [[TMP6:%.*]]
+; IS________OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree [[DOTH2S]], i8* nocapture [[P]])
+; IS________OPM-NEXT:    br label [[TMP5]]
 ; IS________OPM:       5:
-; IS________OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree [[TMP2]], i8* nocapture [[P]])
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture [[TMP2]])
-; IS________OPM-NEXT:    br label [[TMP6]]
-; IS________OPM:       6:
 ; IS________OPM-NEXT:    ret void
 ;
 ; IS________NPM-LABEL: define {{[^@]+}}@test5
 ; IS________NPM-SAME: (i32 [[TMP0:%.*]], i8* nocapture [[P:%.*]]) {
 ; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
 ; IS________NPM-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0]], 0
 ; IS________NPM-NEXT:    br i1 [[TMP2]], label [[TMP4:%.*]], label [[TMP3:%.*]]
 ; IS________NPM:       3:

 
 6:                                                ; preds = %5, %4
   ret void
 }
 
 ; TEST 6 - all exit paths have a call to free
 
 define void @test6(i32) {
-; IS________OPM-LABEL: define {{[^@]+}}@test6
-; IS________OPM-SAME: (i32 [[TMP0:%.*]]) {
-; IS________OPM-NEXT:    [[TMP2:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; 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 [[TMP2]])
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture [[TMP2]])
-; IS________OPM-NEXT:    br label [[TMP6:%.*]]
-; IS________OPM:       5:
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture [[TMP2]])
-; IS________OPM-NEXT:    br label [[TMP6]]
-; IS________OPM:       6:
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM-LABEL: define {{[^@]+}}@test6
-; IS________NPM-SAME: (i32 [[TMP0:%.*]]) {
-; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0]], 0
-; IS________NPM-NEXT:    br i1 [[TMP2]], label [[TMP4:%.*]], label [[TMP3:%.*]]
-; IS________NPM:       3:
-; IS________NPM-NEXT:    tail call void @nofree_func(i8* noalias nocapture nofree [[DOTH2S]])
-; IS________NPM-NEXT:    br label [[TMP5:%.*]]
-; IS________NPM:       4:
-; IS________NPM-NEXT:    br label [[TMP5]]
-; IS________NPM:       5:
-; IS________NPM-NEXT:    ret void
+; CHECK-LABEL: define {{[^@]+}}@test6
+; CHECK-SAME: (i32 [[TMP0:%.*]]) {
+; CHECK-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0]], 0
+; CHECK-NEXT:    br i1 [[TMP2]], label [[TMP4:%.*]], label [[TMP3:%.*]]
+; CHECK:       3:
+; CHECK-NEXT:    tail call void @nofree_func(i8* noalias nocapture nofree [[DOTH2S]])
+; CHECK-NEXT:    br label [[TMP5:%.*]]
+; CHECK:       4:
+; CHECK-NEXT:    br label [[TMP5]]
+; CHECK:       5:
+; 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)
-; 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:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    [[TMP1:%.*]] = tail call i32 @no_return_call() #[[ATTR4:[0-9]+]]
-; IS________NPM-NEXT:    unreachable
+; CHECK-LABEL: define {{[^@]+}}@test7() {
+; CHECK-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    [[TMP1:%.*]] = 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
;
   %3 = load i32, i32* %2
   tail call void @foo(i32* %2)
   tail call void @free(i8* %1)
   ret void
 }
 
 ; TEST 9 - FIXME: malloc should be converted.
 define void @test9() {
-; IS________OPM-LABEL: define {{[^@]+}}@test9() {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree [[TMP1]])
-; IS________OPM-NEXT:    [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; IS________OPM-NEXT:    store i32 10, i32* [[TMP2]], align 4
-; IS________OPM-NEXT:    tail call void @foo_nounw(i32* nofree noundef align 4 [[TMP2]]) #[[ATTR9]]
-; IS________OPM-NEXT:    tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM-LABEL: define {{[^@]+}}@test9() {
-; IS________NPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree [[TMP1]])
-; IS________NPM-NEXT:    [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; IS________NPM-NEXT:    store i32 10, i32* [[TMP2]], align 4
-; IS________NPM-NEXT:    tail call void @foo_nounw(i32* nofree noundef align 4 [[TMP2]]) #[[ATTR10]]
-; IS________NPM-NEXT:    tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
-; IS________NPM-NEXT:    ret void
+; CHECK-LABEL: define {{[^@]+}}@test9() {
+; CHECK-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT:    tail call void @no_sync_func(i8* nocapture nofree [[TMP1]])
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
+; CHECK-NEXT:    store i32 10, i32* [[TMP2]], align 4
+; CHECK-NEXT:    tail call void @foo_nounw(i32* nofree noundef align 4 [[TMP2]]) #[[ATTR10:[0-9]+]]
+; CHECK-NEXT:    tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
+; CHECK-NEXT:    ret void
 ;
   %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 @foo_nounw(i32* %2)
   tail call void @free(i8* %1)
   ret void
 }
 
 ; TEST 10 - 1 malloc, 1 free
 
 define i32 @test10() {
-; IS________OPM-LABEL: define {{[^@]+}}@test10() {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; 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]])
-; IS________OPM-NEXT:    ret i32 [[TMP3]]
-;
-; IS________NPM-LABEL: define {{[^@]+}}@test10() {
-; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree [[DOTH2S]])
-; IS________NPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[DOTH2S]] to i32*
-; IS________NPM-NEXT:    store i32 10, i32* [[TMP1]], align 4
-; IS________NPM-NEXT:    [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
-; IS________NPM-NEXT:    ret i32 [[TMP2]]
+; CHECK-LABEL: define {{[^@]+}}@test10() {
+; CHECK-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree [[DOTH2S]])
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[DOTH2S]] to i32*
+; CHECK-NEXT:    store i32 10, i32* [[TMP1]], align 4
+; CHECK-NEXT:    [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    ret i32 [[TMP2]]
 ;
   %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-LABEL: define {{[^@]+}}@test_lifetime() {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; IS________OPM-NEXT:    call void @llvm.lifetime.start.p0i8(i64 noundef 4, i8* noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[TMP1]])
-; 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]])
-; IS________OPM-NEXT:    ret i32 [[TMP3]]
-;
-; IS________NPM-LABEL: define {{[^@]+}}@test_lifetime() {
-; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree [[DOTH2S]])
-; IS________NPM-NEXT:    call void @llvm.lifetime.start.p0i8(i64 noundef 4, i8* noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[DOTH2S]])
-; IS________NPM-NEXT:    [[TMP1:%.*]] = bitcast i8* [[DOTH2S]] to i32*
-; IS________NPM-NEXT:    store i32 10, i32* [[TMP1]], align 4
-; IS________NPM-NEXT:    [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
-; IS________NPM-NEXT:    ret i32 [[TMP2]]
+; CHECK-LABEL: define {{[^@]+}}@test_lifetime() {
+; CHECK-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree [[DOTH2S]])
+; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 noundef 4, i8* noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[DOTH2S]])
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[DOTH2S]] to i32*
+; CHECK-NEXT:    store i32 10, i32* [[TMP1]], align 4
+; CHECK-NEXT:    [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    ret i32 [[TMP2]]
 ;
   %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-LABEL: define {{[^@]+}}@test11() {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; IS________OPM-NEXT:    tail call void @sync_will_return(i8* [[TMP1]]) #[[ATTR9]]
-; IS________OPM-NEXT:    tail call void @free(i8* nocapture [[TMP1]])
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM-LABEL: define {{[^@]+}}@test11() {
-; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    tail call void @sync_will_return(i8* [[DOTH2S]]) #[[ATTR10]]
-; IS________NPM-NEXT:    ret void
+; CHECK-LABEL: define {{[^@]+}}@test11() {
+; CHECK-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    tail call void @sync_will_return(i8* [[DOTH2S]]) #[[ATTR10]]
+; 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-LABEL: define {{[^@]+}}@irreducible_cfg
-; IS________OPM-SAME: (i32 [[TMP0:%.*]]) {
-; IS________OPM-NEXT:    [[TMP2:%.*]] = call noalias 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 [[TMP16]])
-; IS________OPM-NEXT:    [[TMP17:%.*]] = load i32, i32* [[TMP3]], align 4
-; IS________OPM-NEXT:    ret i32 [[TMP17]]
-;
-; IS________NPM-LABEL: define {{[^@]+}}@irreducible_cfg
-; IS________NPM-SAME: (i32 [[TMP0:%.*]]) {
-; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    [[TMP2:%.*]] = bitcast i8* [[DOTH2S]] to i32*
-; IS________NPM-NEXT:    store i32 10, i32* [[TMP2]], align 4
-; IS________NPM-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 1
-; IS________NPM-NEXT:    br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP6:%.*]]
-; IS________NPM:       4:
-; IS________NPM-NEXT:    [[TMP5:%.*]] = add nsw i32 [[TMP0]], 5
-; IS________NPM-NEXT:    br label [[TMP12:%.*]]
-; IS________NPM:       6:
-; IS________NPM-NEXT:    br label [[TMP7:%.*]]
-; IS________NPM:       7:
-; IS________NPM-NEXT:    [[DOT0:%.*]] = phi i32 [ [[TMP13:%.*]], [[TMP12]] ], [ 1, [[TMP6]] ]
-; IS________NPM-NEXT:    [[TMP8:%.*]] = load i32, i32* [[TMP2]], align 4
-; IS________NPM-NEXT:    [[TMP9:%.*]] = add nsw i32 [[TMP8]], -1
-; IS________NPM-NEXT:    store i32 [[TMP9]], i32* [[TMP2]], align 4
-; IS________NPM-NEXT:    [[TMP10:%.*]] = icmp ne i32 [[TMP8]], 0
-; IS________NPM-NEXT:    br i1 [[TMP10]], label [[TMP11:%.*]], label [[TMP14:%.*]]
-; IS________NPM:       11:
-; IS________NPM-NEXT:    br label [[TMP12]]
-; IS________NPM:       12:
-; IS________NPM-NEXT:    [[DOT1:%.*]] = phi i32 [ [[TMP5]], [[TMP4]] ], [ [[DOT0]], [[TMP11]] ]
-; IS________NPM-NEXT:    [[TMP13]] = add nsw i32 [[DOT1]], 1
-; IS________NPM-NEXT:    br label [[TMP7]]
-; IS________NPM:       14:
-; IS________NPM-NEXT:    [[TMP15:%.*]] = bitcast i32* [[TMP2]] to i8*
-; IS________NPM-NEXT:    [[TMP16:%.*]] = load i32, i32* [[TMP2]], align 4
-; IS________NPM-NEXT:    ret i32 [[TMP16]]
+; CHECK-LABEL: define {{[^@]+}}@irreducible_cfg
+; CHECK-SAME: (i32 [[TMP0:%.*]]) {
+; CHECK-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i8* [[DOTH2S]] to i32*
+; CHECK-NEXT:    store i32 10, i32* [[TMP2]], align 4
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 1
+; CHECK-NEXT:    br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP6:%.*]]
+; CHECK:       4:
+; CHECK-NEXT:    [[TMP5:%.*]] = add nsw i32 [[TMP0]], 5
+; CHECK-NEXT:    br label [[TMP12:%.*]]
+; CHECK:       6:
+; CHECK-NEXT:    br label [[TMP7:%.*]]
+; CHECK:       7:
+; CHECK-NEXT:    [[DOT0:%.*]] = phi i32 [ [[TMP13:%.*]], [[TMP12]] ], [ 1, [[TMP6]] ]
+; CHECK-NEXT:    [[TMP8:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT:    [[TMP9:%.*]] = add nsw i32 [[TMP8]], -1
+; CHECK-NEXT:    store i32 [[TMP9]], i32* [[TMP2]], align 4
+; CHECK-NEXT:    [[TMP10:%.*]] = icmp ne i32 [[TMP8]], 0
+; CHECK-NEXT:    br i1 [[TMP10]], label [[TMP11:%.*]], label [[TMP14:%.*]]
+; CHECK:       11:
+; CHECK-NEXT:    br label [[TMP12]]
+; CHECK:       12:
+; CHECK-NEXT:    [[DOT1:%.*]] = phi i32 [ [[TMP5]], [[TMP4]] ], [ [[DOT0]], [[TMP11]] ]
+; CHECK-NEXT:    [[TMP13]] = add nsw i32 [[DOT1]], 1
+; CHECK-NEXT:    br label [[TMP7]]
+; CHECK:       14:
+; CHECK-NEXT:    [[TMP15:%.*]] = bitcast i32* [[TMP2]] to i8*
+; CHECK-NEXT:    [[TMP16:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT:    ret i32 [[TMP16]]
 ;
   %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-LABEL: define {{[^@]+}}@test16a
-; IS________OPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree readnone [[P:%.*]]) {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; 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]])
-; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture noundef nonnull dereferenceable(1) [[TMP1]])
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM-LABEL: define {{[^@]+}}@test16a
-; IS________NPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree readnone [[P:%.*]]) {
-; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    store i8 [[V]], i8* [[DOTH2S]], align 1
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[DOTH2S]])
-; IS________NPM-NEXT:    ret void
+; CHECK-LABEL: define {{[^@]+}}@test16a
+; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree readnone [[P:%.*]]) {
+; CHECK-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    store i8 [[V]], i8* [[DOTH2S]], align 1
+; CHECK-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[DOTH2S]])
+; 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-LABEL: define {{[^@]+}}@test16c
-; IS________OPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree writeonly [[P:%.*]]) {
-; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; IS________OPM-NEXT:    store i8* [[TMP1]], i8** [[P]], align 8
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree [[TMP1]]) #[[ATTR9]]
-; IS________OPM-NEXT:    tail call void @free(i8* nocapture [[TMP1]])
-; IS________OPM-NEXT:    ret void
-;
-; IS________NPM-LABEL: define {{[^@]+}}@test16c
-; IS________NPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree writeonly [[P:%.*]]) {
-; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    store i8* [[DOTH2S]], i8** [[P]], align 8
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree [[DOTH2S]]) #[[ATTR10]]
-; IS________NPM-NEXT:    ret void
+; CHECK-LABEL: define {{[^@]+}}@test16c
+; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree writeonly [[P:%.*]]) {
+; CHECK-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT:    store i8* [[DOTH2S]], i8** [[P]], align 8
+; CHECK-NEXT:    tail call void @no_sync_func(i8* nocapture nofree [[DOTH2S]]) #[[ATTR10]]
+; 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-LABEL: define {{[^@]+}}@test16d
 ; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree writeonly [[P:%.*]]) {
 ; CHECK-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
 ; 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]+]] = { allockind("alloc,uninitialized") allocsize(0) }
-; IS________OPM: attributes #[[ATTR1:[0-9]+]] = { nounwind willreturn }
-; IS________OPM: attributes #[[ATTR2:[0-9]+]] = { nofree nosync willreturn }
-; IS________OPM: attributes #[[ATTR3:[0-9]+]] = { nofree nounwind }
-; IS________OPM: attributes #[[ATTR4]] = { noreturn }
-; IS________OPM: attributes #[[ATTR5:[0-9]+]] = { allockind("free") }
-; IS________OPM: attributes #[[ATTR6:[0-9]+]] = { argmemonly nocallback nofree nosync nounwind willreturn }
-; IS________OPM: attributes #[[ATTR7:[0-9]+]] = { allockind("alloc,uninitialized,aligned") allocsize(1) }
-; IS________OPM: attributes #[[ATTR8:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) }
-; IS________OPM: attributes #[[ATTR9]] = { nounwind }
-;.
-; IS________NPM: attributes #[[ATTR0:[0-9]+]] = { allockind("alloc,uninitialized") allocsize(0) }
-; IS________NPM: attributes #[[ATTR1:[0-9]+]] = { nounwind willreturn }
-; IS________NPM: attributes #[[ATTR2:[0-9]+]] = { nofree nosync willreturn }
-; IS________NPM: attributes #[[ATTR3:[0-9]+]] = { nofree nounwind }
-; IS________NPM: attributes #[[ATTR4]] = { noreturn }
-; IS________NPM: attributes #[[ATTR5:[0-9]+]] = { allockind("free") }
-; IS________NPM: attributes #[[ATTR6:[0-9]+]] = { argmemonly nocallback nofree nosync nounwind willreturn }
-; IS________NPM: attributes #[[ATTR7:[0-9]+]] = { allockind("alloc,uninitialized,aligned") allocsize(1) }
-; IS________NPM: attributes #[[ATTR8:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) }
-; IS________NPM: attributes #[[ATTR9:[0-9]+]] = { argmemonly nofree nounwind willreturn writeonly }
-; IS________NPM: attributes #[[ATTR10]] = { nounwind }
+; CHECK: attributes #[[ATTR0:[0-9]+]] = { allockind("alloc,uninitialized") allocsize(0) }
+; CHECK: attributes #[[ATTR1:[0-9]+]] = { nounwind willreturn }
+; CHECK: attributes #[[ATTR2:[0-9]+]] = { nofree nosync willreturn }
+; CHECK: attributes #[[ATTR3:[0-9]+]] = { nofree nounwind }
+; CHECK: attributes #[[ATTR4]] = { noreturn }
+; CHECK: attributes #[[ATTR5:[0-9]+]] = { allockind("free") }
+; CHECK: attributes #[[ATTR6:[0-9]+]] = { argmemonly nocallback nofree nosync nounwind willreturn }
+; CHECK: attributes #[[ATTR7:[0-9]+]] = { allockind("alloc,uninitialized,aligned") allocsize(1) }
+; CHECK: attributes #[[ATTR8:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) }
+; CHECK: attributes #[[ATTR9:[0-9]+]] = { argmemonly nofree nounwind willreturn writeonly }
+; CHECK: attributes #[[ATTR10]] = { nounwind }
 ;.

llvm/test/Transforms/Attributor/lowerheap.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
 ; RUN: opt -max-heap-to-stack-size=-1 -attributor -enable-new-pm=0 -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
 ; RUN: opt -max-heap-to-stack-size=-1 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
 ; RUN: opt -max-heap-to-stack-size=-1 -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM
 ; RUN: opt -max-heap-to-stack-size=-1 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM
 
 declare i64 @subfn(i8*) #0
 
 declare noalias i8* @malloc(i64) allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc"
 declare noalias i8* @calloc(i64, i64) allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc"
 declare void @free(i8*) allockind("free") "alloc-family"="malloc"
 
 define i64 @f(i64 %len) {
-; IS________OPM-LABEL: define {{[^@]+}}@f
-; IS________OPM-SAME: (i64 [[LEN:%.*]]) {
-; IS________OPM-NEXT:  entry:
-; IS________OPM-NEXT:    [[MEM:%.*]] = call noalias i8* @malloc(i64 [[LEN]])
-; IS________OPM-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[MEM]]) #[[ATTR4:[0-9]+]]
-; IS________OPM-NEXT:    call void @free(i8* [[MEM]])
-; IS________OPM-NEXT:    ret i64 [[RES]]
-;
-; IS________NPM-LABEL: define {{[^@]+}}@f
-; IS________NPM-SAME: (i64 [[LEN:%.*]]) {
-; IS________NPM-NEXT:  entry:
-; IS________NPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 [[LEN]], align 1
-; IS________NPM-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[TMP0]]) #[[ATTR5:[0-9]+]]
-; IS________NPM-NEXT:    ret i64 [[RES]]
+; CHECK-LABEL: define {{[^@]+}}@f
+; CHECK-SAME: (i64 [[LEN:%.*]]) {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = alloca i8, i64 [[LEN]], align 1
+; CHECK-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[TMP0]]) #[[ATTR5:[0-9]+]]
+; CHECK-NEXT:    ret i64 [[RES]]
 ;
 entry:
   %mem = call i8* @malloc(i64 %len)
   %res = call i64 @subfn(i8* %mem)
   call void @free(i8* %mem)
   ret i64 %res
 }
 
 
 define i64 @g(i64 %len) {
-; IS________OPM-LABEL: define {{[^@]+}}@g
-; IS________OPM-SAME: (i64 [[LEN:%.*]]) {
-; IS________OPM-NEXT:  entry:
-; IS________OPM-NEXT:    [[MEM:%.*]] = call noalias i8* @calloc(i64 [[LEN]], i64 noundef 8)
-; IS________OPM-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[MEM]]) #[[ATTR4]]
-; IS________OPM-NEXT:    call void @free(i8* [[MEM]])
-; IS________OPM-NEXT:    ret i64 [[RES]]
-;
-; IS________NPM-LABEL: define {{[^@]+}}@g
-; IS________NPM-SAME: (i64 [[LEN:%.*]]) {
-; IS________NPM-NEXT:  entry:
-; IS________NPM-NEXT:    [[TMP0:%.*]] = mul i64 [[LEN]], 8
-; IS________NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 [[TMP0]], align 1
-; IS________NPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[TMP1]], i8 0, i64 [[TMP0]], i1 false)
-; IS________NPM-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[TMP1]]) #[[ATTR5]]
-; IS________NPM-NEXT:    ret i64 [[RES]]
+; CHECK-LABEL: define {{[^@]+}}@g
+; CHECK-SAME: (i64 [[LEN:%.*]]) {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = mul i64 [[LEN]], 8
+; CHECK-NEXT:    [[TMP1:%.*]] = alloca i8, i64 [[TMP0]], align 1
+; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[TMP1]], i8 0, i64 [[TMP0]], i1 false)
+; CHECK-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[TMP1]]) #[[ATTR5]]
+; CHECK-NEXT:    ret i64 [[RES]]
 ;
 entry:
   %mem = call i8* @calloc(i64 %len, i64 8)
   %res = call i64 @subfn(i8* %mem)
   call void @free(i8* %mem)
   ret i64 %res
 }
 
 attributes #0 = { nounwind willreturn }
 ;.
-; IS________OPM: attributes #[[ATTR0:[0-9]+]] = { nounwind willreturn }
-; IS________OPM: attributes #[[ATTR1:[0-9]+]] = { allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
-; IS________OPM: attributes #[[ATTR2:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" }
-; IS________OPM: attributes #[[ATTR3:[0-9]+]] = { allockind("free") "alloc-family"="malloc" }
-; IS________OPM: attributes #[[ATTR4]] = { nounwind }
-;.
-; IS________NPM: attributes #[[ATTR0:[0-9]+]] = { nounwind willreturn }
-; IS________NPM: attributes #[[ATTR1:[0-9]+]] = { allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
-; IS________NPM: attributes #[[ATTR2:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" }
-; IS________NPM: attributes #[[ATTR3:[0-9]+]] = { allockind("free") "alloc-family"="malloc" }
-; IS________NPM: attributes #[[ATTR4:[0-9]+]] = { argmemonly nofree nounwind willreturn writeonly }
-; IS________NPM: attributes #[[ATTR5]] = { nounwind }
+; CHECK: attributes #[[ATTR0:[0-9]+]] = { nounwind willreturn }
+; CHECK: attributes #[[ATTR1:[0-9]+]] = { allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; CHECK: attributes #[[ATTR2:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" }
+; CHECK: attributes #[[ATTR3:[0-9]+]] = { allockind("free") "alloc-family"="malloc" }
+; CHECK: attributes #[[ATTR4:[0-9]+]] = { argmemonly nofree nounwind willreturn writeonly }
+; CHECK: attributes #[[ATTR5]] = { nounwind }
 ;.

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:    [[CALL_H2S:%.*]] = alloca i8, i64 4, align 1
 ; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL_H2S]] to i32*
 ; IS__TUNIT_NPM-NEXT:    store i32 [[X]], i32* [[TMP0]], 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:    [[CALL_H2S:%.*]] = alloca i8, i64 4, align 1
 ; IS__CGSCC_NPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL_H2S]] to i32*
 ; IS__CGSCC_NPM-NEXT:    store i32 [[X]], i32* [[TMP0]], 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:    [[CALL_H2S:%.*]] = alloca i8, i64 4, align 1
 ; IS__TUNIT_NPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL_H2S]], i8 0, i64 4, i1 false)
 ; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL_H2S]] 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* [[TMP0]], align 4
 ; IS__TUNIT_NPM-NEXT:    br label [[IF_END]]
 ; IS__TUNIT_NPM:       if.end:
 ; IS__TUNIT_NPM-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 4
 ; IS__TUNIT_NPM-NEXT:    ret i32 [[TMP1]]
 ;
 ; 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:    [[CALL_H2S:%.*]] = alloca i8, i64 4, align 1
 ; IS__CGSCC_NPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL_H2S]], i8 0, i64 4, i1 false)
 ; IS__CGSCC_NPM-NEXT:    [[TMP0:%.*]] = bitcast i8* [[CALL_H2S]] 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:    [[CALL_H2S:%.*]] = alloca i8, i64 4, align 1
 ; IS__TUNIT_NPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL_H2S]], 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:    [[CALL_H2S:%.*]] = alloca i8, i64 4, align 1
 ; IS__CGSCC_NPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL_H2S]], 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 }