[DSE] Handle inaccessiblememonly calloc

[nikic]

Summary

Implement calloc handling in a way that expects it to be LiveOnEntry rather than clobbering.

[reames]

LGTM.

Make sure to revert e20b32f when you land this to avoid practical regressions.

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

bool storeIsNoop(MemoryDef *Def, const Value *DefUO) {
 
     if (!isRemovable(DefI))
       return false;
 
     if (StoredConstant && isAllocationFn(DefUO, &TLI)) {
       auto *CB = cast<CallBase>(DefUO);
       auto *InitC = getInitialValueOfAllocation(CB, &TLI,
                                                 StoredConstant->getType());
-      if (InitC && InitC == StoredConstant) {
-        auto *UnderlyingDef = cast<MemoryDef>(MSSA.getMemoryAccess(CB));
-        // If UnderlyingDef is the clobbering access of Def, no instructions
-        // between them can modify the memory location.
-        auto *ClobberDef =
-          MSSA.getSkipSelfWalker()->getClobberingMemoryAccess(Def);
-        return UnderlyingDef == ClobberDef;
-      }
+      // If the clobbering access is LiveOnEntry, no instructions between them
+      // can modify the memory location.
+      if (InitC && InitC == StoredConstant)
+        return MSSA.isLiveOnEntryDef(
+            MSSA.getSkipSelfWalker()->getClobberingMemoryAccess(Def));
     }
 
     if (!Store)
       return false;
 
     if (auto *LoadI = dyn_cast<LoadInst>(Store->getOperand(0))) {
       if (LoadI->getPointerOperand() == Store->getOperand(1)) {
         // Get the defining access for the load.

llvm/test/Transforms/DeadStoreElimination/calloc-store.ll

 ; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
-declare noalias i8* @calloc(i64, i64)
+declare noalias i8* @calloc(i64, i64) inaccessiblememonly
 
 define i32* @test1() {
 ; CHECK-LABEL: test1
   %1 = tail call noalias i8* @calloc(i64 1, i64 4)
   %2 = bitcast i8* %1 to i32*
   ; This store is dead and should be removed
   store i32 0, i32* %2, align 4
 ; CHECK-NOT: store i32 0, i32* %2, align 4

llvm/test/Transforms/DeadStoreElimination/noop-stores.ll

 ; CHECK-NEXT:    ret i8* [[CALL1]]
 ;
   %call1 = call i8* %notmalloc(i64 %size)
   call void @llvm.memset.p0i8.i64(i8* %call1, i8 0, i64 %size, i1 false)
   ret i8* %call1
 }
 
 ; This should not create recursive call to calloc.
-define i8* @calloc(i64 %nmemb, i64 %size) {
+define i8* @calloc(i64 %nmemb, i64 %size) inaccessiblememonly {
 ; CHECK-LABEL: @calloc(
 ; CHECK:       entry:
 ; CHECK-NEXT:    [[MUL:%.*]] = mul i64 [[SIZE:%.*]], [[NMEMB:%.*]]
 ; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias align 16 i8* @malloc(i64 [[MUL]])
 ; CHECK-NEXT:    [[TOBOOL_NOT:%.*]] = icmp eq i8* [[CALL]], null
 ; CHECK-NEXT:    br i1 [[TOBOOL_NOT]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i64(i8* nonnull align 16 [[CALL]], i8 0, i64 [[MUL]], i1 false)

 cleanup:
   ret i8* %call
 }
 
 ; PR50143
 define i8* @store_zero_after_calloc_inaccessiblememonly() {
 ; CHECK-LABEL: @store_zero_after_calloc_inaccessiblememonly(
 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 1, i64 10) #[[ATTR6:[0-9]+]]
-; CHECK-NEXT:    store i8 0, i8* [[CALL]], align 1
 ; CHECK-NEXT:    ret i8* [[CALL]]
 ;
   %call = tail call i8* @calloc(i64 1, i64 10)  inaccessiblememonly
   store i8 0, i8* %call
   ret i8* %call
 }
 
 define i8* @zero_memset_after_calloc()  {
;
   store i8 %v, i8* %gep
   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 20, i1 false)
   ret i8* %call
 }
 
 define i8* @zero_memset_after_calloc_inaccessiblememonly()  {
 ; CHECK-LABEL: @zero_memset_after_calloc_inaccessiblememonly(
 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 10000, i64 4) #[[ATTR6]]
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL]], i8 0, i64 40000, i1 false)
 ; CHECK-NEXT:    ret i8* [[CALL]]
 ;
   %call = tail call i8* @calloc(i64 10000, i64 4) inaccessiblememonly
   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 40000, i1 false)
   ret i8* %call
 }
 
 define i8* @cst_nonzero_memset_after_calloc() {

llvm/test/Transforms/DeadStoreElimination/operand-bundles.ll

define void @test3() {
   ; since it could be observed from the deopt continuation.
   ; CHECK: store i64 1, i64* %s
   store i64 1, i64* %s
   call void @foo() [ "deopt"(i64* %s) ]
   store i64 0, i64* %s
   ret void
 }
 
-declare noalias i8* @calloc(i64, i64)
+declare noalias i8* @calloc(i64, i64) inaccessiblememonly
 
 define void @test4() {
 ; CHECK-LABEL: @test4
   %local_obj = call i8* @calloc(i64 1, i64 4)
   call void @foo() ["deopt" (i8* %local_obj)]
   store i8 0, i8* %local_obj, align 4
   ; CHECK-NOT: store i8 0, i8* %local_obj, align 4
   call void @bar(i8* nocapture %local_obj)
   ret void
 }