[SimplifyLibcalls] Fold malloc + memset to calloc even for llvm.memset

[dblaikie]

Test case?

[lebedev.ri]

@xbolva00 please always always upload all the patches with the full context (-U99999)

test/Transforms/InstCombine/memset-1.ll

30

There is no https://bugs.llvm.org/show_bug.cgi?id=45344
You mean D45344?
Then it may be better not to use such a specific name.

[xbolva00]

Better test

[lebedev.ri]

(The diff still seem to be lacking context)

[xbolva00]

Fixed previous test, now it passes

[xbolva00]

Added context

[xbolva00]

In D45344#1059408, @lebedev.ri wrote:

(The diff still seem to be lacking context)

Yes, fixed now :D I am sorry for too many updated revisions, it is my first contribution to llvm :D

[spatel]

IIUC, these are 2 independent changes, so they should be split into separate patches:

1. Handle the memset intrinsic identically to the way we handle the memset libcall. What about memset_chk()?
2. Remove the hasOneUse() limitation on the malloc. The reason that's there is discussed in D16337 - the transform must be made safe from intermediate stores. This patch as-is will miscompile that pattern.

I've added tests at rL329412 and regenerated the check lines. Please fix/limit this patch and rebase.

[xbolva00]

In D45344#1059906, @spatel wrote:

IIUC, these are 2 independent changes, so they should be split into separate patches:

1. Handle the memset intrinsic identically to the way we handle the memset libcall. What about memset_chk()?
2. Remove the hasOneUse() limitation on the malloc. The reason that's there is discussed in D16337 - the transform must be made safe from intermediate stores. This patch as-is will miscompile that pattern.

I've added tests at rL329412 and regenerated the check lines. Please fix/limit this patch and rebase.

1. memset_chk change was removed from this commit.
2. https://reviews.llvm.org/D45381

[spatel]

Tests?

[xbolva00]

In D45344#1060243, @spatel wrote:

Tests?

Without https://reviews.llvm.org/D45381 is llvm.memset not folded to calloc.

[xbolva00]

In D45344#1060243, @spatel wrote:

Tests?

Your patch https://reviews.llvm.org/rL329412 (@malloc_and_memset_intrinsic) needs to be updated after these two patches are applied.

[xbolva00]

Added test

[spatel]

I'm confused. This patch is supposed to show a calloc transform.

@malloc_and_memset_intrinsic has multiple uses of the malloc result, so the transform doesn't work there. Is there some other way to show the transform? If not, then sorry that I misunderstood, but we can't split the patches.

But D45381 just removes the one-use check and miscompiles @buffer_is_modified_then_memset. Why is that ok?

[xbolva00]

In D45344#1060345, @spatel wrote:

I'm confused. This patch is supposed to show a calloc transform.

@malloc_and_memset_intrinsic has multiple uses of the malloc result, so the transform doesn't work there. Is there some other way to show the transform? If not, then sorry that I misunderstood, but we can't split the patches.

But D45381 just removes the one-use check and miscompiles @buffer_is_modified_then_memset. Why is that ok?

I closed D45381 & reupdated this patch, added test case. Test @buffer_is_modified_then_memset is ok now too.

[spatel]

If I apply this patch, the test case fails.

Do you understand the problem with the intervening store? You can't solve that by simply removing the one-use check.

[xbolva00]

In D45344#1060689, @spatel wrote:

If I apply this patch, the test case fails.

Do you understand the problem with the intervening store? You can't solve that by simply removing the one-use check.

Oh, yes :( Any idea how to work around it?

[xbolva00]

I added solution.

Simply check any Instruction between malloc and memset if use value from malloc, if so, do not fold.

[xbolva00]

WIP

[xbolva00]

Removed old test and added new one. Works for me.

[xbolva00]

Anything to be done? Or is this ok? @efriedma , @spatel...

[xbolva00]

Patch reworked.

• Malloc + llvm.memset folding
• Store instructions eliminated between malloc and memset calls.

Can you look at it? @spatel @efriedma

[efriedma]

This transform really belongs in DeadStoreElimination, not here; it has the relevant logic and some similar transforms.

[xbolva00]

In D45344#1081661, @efriedma wrote:

This transform really belongs in DeadStoreElimination, not here; it has the relevant logic and some similar transforms.

But folding part for intrinsic memset can be here, no?

[efriedma]

I mean the whole foldMallocMemset transform should be in DSE. I mean, arguably the transform isn't actually eliminating a dead store, but the code you need is very similar to eliminateNoopStore.

[xbolva00]

In D45344#1081728, @efriedma wrote:

I mean the whole foldMallocMemset transform should be in DSE. I mean, arguably the transform isn't actually eliminating a dead store, but the code you need is very similar to eliminateNoopStore.

Right, so I will close this for now..

lib/Transforms/Utils/SimplifyLibCalls.cpp

if (const auto *F = dyn_cast<Function>(Calloc->stripPointerCasts()))
     CI->setCallingConv(F->getCallingConv());
 
   return CI;
 }
 
 /// Fold memset[_chk](malloc(n), 0, n) --> calloc(1, n).
 static Value *foldMallocMemset(CallInst *Memset, IRBuilder<> &B,
                                const TargetLibraryInfo &TLI) {
+  auto Src = Memset->getArgOperand(0);
   // This has to be a memset of zeros (bzero).
   auto *FillValue = dyn_cast<ConstantInt>(Memset->getArgOperand(1));
   if (!FillValue || FillValue->getZExtValue() != 0)
     return nullptr;
 
-  // TODO: We should handle the case where the malloc has more than one use.
-  // This is necessary to optimize common patterns such as when the result of
-  // the malloc is checked against null or when a memset intrinsic is used in
-  // place of a memset library call.
-  auto *Malloc = dyn_cast<CallInst>(Memset->getArgOperand(0));
-  if (!Malloc || !Malloc->hasOneUse())
+  auto *Malloc = dyn_cast<CallInst>(Src);
+  if (!Malloc)
     return nullptr;
 
+  if (!Malloc->hasOneUse()) {
+    Instruction *I = Malloc->getNextNode();
+    while (I) {
+      auto *Call = dyn_cast<CallInst>(I);
+      if (Call && Call == Memset)
+        break;
+
+      for (unsigned i = 0; i < I->getNumOperands(); ++i) {
+        if (Src == I->getOperand(i)) {
+          return nullptr;
+        }
+      }
+
+      I = I->getNextNode();
+
+      // If we cannot find memset in current basic block, dont fold
+      if (!I)
+        return nullptr;
+    }
+  }
+
   // Is the inner call really malloc()?
   Function *InnerCallee = Malloc->getCalledFunction();
   if (!InnerCallee)
     return nullptr;
 
   LibFunc Func;
   if (!TLI.getLibFunc(*InnerCallee, Func) || !TLI.has(Func) ||
       Func != LibFunc_malloc)
static Value *foldMallocMemset(CallInst *Memset, IRBuilder<> &B,
 
   return Calloc;
 }
 
 Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilder<> &B) {
   if (auto *Calloc = foldMallocMemset(CI, B, *TLI))
     return Calloc;
 
+  if (CI->getCalledFunction()->isIntrinsic()) {
+    return nullptr;
+  }
+
   // memset(p, v, n) -> llvm.memset(align 1 p, v, n)
   Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
   B.CreateMemSet(CI->getArgOperand(0), Val, CI->getArgOperand(2), 1);
   return CI->getArgOperand(0);
 }
 
 //===----------------------------------------------------------------------===//
 // Math Library Optimizations
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI)) {
     case Intrinsic::pow:
       return optimizePow(CI, Builder);
     case Intrinsic::exp2:
       return optimizeExp2(CI, Builder);
     case Intrinsic::log:
       return optimizeLog(CI, Builder);
     case Intrinsic::sqrt:
       return optimizeSqrt(CI, Builder);
-    // TODO: Use foldMallocMemset() with memset intrinsic.
+    case Intrinsic::memset:
+      return optimizeMemSet(CI, Builder);
     default:
       return nullptr;
     }
   }
 
   // Also try to simplify calls to fortified library functions.
   if (Value *SimplifiedFortifiedCI = FortifiedSimplifier.optimizeCall(CI)) {
     // Try to further simplify the result.

test/Transforms/InstCombine/memset-1.ll

 }
 
 define i8* @pr25892_lite(i32 %size) #0 {
 ; CHECK-LABEL: @pr25892_lite(
 ; CHECK-NEXT:    [[CALLOC:%.*]] = call i8* @calloc(i32 1, i32 [[SIZE:%.*]])
 ; CHECK-NEXT:    ret i8* [[CALLOC]]
 ;
   %call1 = call i8* @malloc(i32 %size) #1
   %call2 = call i8* @memset(i8* %call1, i32 0, i32 %size) #1
   ret i8* %call2
 }
 
-; FIXME: A memset intrinsic should be handled similarly to a memset() libcall.
-
-define i8* @malloc_and_memset_intrinsic(i32 %n) #0 {
-; CHECK-LABEL: @malloc_and_memset_intrinsic(
-; CHECK-NEXT:    [[CALL:%.*]] = call i8* @malloc(i32 [[N:%.*]])
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* align 1 [[CALL]], i8 0, i32 [[N]], i1 false)
-; CHECK-NEXT:    ret i8* [[CALL]]
+define i8* @memset_intristic_malloc(i32 %n) #0 {
+; CHECK-LABEL: @memset_intristic_malloc(
+; CHECK-NEXT:    [[CALLOC:%.*]] = call i8* @calloc(i32 1, i32 [[N:%.*]])
+; CHECK-NEXT:    ret i8* [[CALLOC]]
 ;
   %call = call i8* @malloc(i32 %n)
   call void @llvm.memset.p0i8.i32(i8* %call, i8 0, i32 %n, i32 1, i1 false)
-  ret i8* %call
+  ret i8*%call
 }
 
 ; This should not create a calloc and should not crash the compiler.
 
 define i8* @notmalloc_memset(i32 %size, i8*(i32)* %notmalloc) {
 ; CHECK-LABEL: @notmalloc_memset(
 ; CHECK-NEXT:    [[CALL1:%.*]] = call i8* [[NOTMALLOC:%.*]](i32 [[SIZE:%.*]]) #0
 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* align 1 [[CALL1]], i8 0, i32 [[SIZE]], i1 false)