Promote aggregate store to memset when possible

[deadalnix]

Summary

As per title. This will allow the optimizer to pick up on it.

[mehdi_amini]

lib/Transforms/Scalar/MemCpyOptimizer.cpp

537 ↗

(On Diff #44112)

Unrelated change? Please commit separately if you want it.

639 ↗

(On Diff #44112)

It is not intuitive (to me at least) that it is always a good thing, especially since tryMergingIntoMemset just above has a notion of profitability.
If I understand correctly, you're doing it unconditionally for aggregate because the rest of the optimizer is not dealing nicely with them, right?
If this is correct, please add a comment here explaining this.

[deadalnix]

lib/Transforms/Scalar/MemCpyOptimizer.cpp

639 ↗

(On Diff #44112)

Yes, also one element aggregate would have been unpacked away by instcombine at this stage, so only somewhat large aggregate will be memsetted here.

It is done after tryMergingIntoMemset because it is indeed less profitable so we want the most profitable optimization tried first.

[deadalnix]

Add a comment to explain why the transformation.

[mehdi_amini]

LGTM.

llvm/trunk/lib/Transforms/Scalar/MemCpyOptimizer.cpp

bool MemCpyOpt::processStore(StoreInst *SI, BasicBlock::iterator &BBI) {
   }
 
   // There are two cases that are interesting for this code to handle: memcpy
   // and memset.  Right now we only handle memset.
 
   // Ensure that the value being stored is something that can be memset'able a
   // byte at a time like "0" or "-1" or any width, as well as things like
   // 0xA0A0A0A0 and 0.0.
-  if (Value *ByteVal = isBytewiseValue(SI->getOperand(0)))
+  auto *V = SI->getOperand(0);
+  if (Value *ByteVal = isBytewiseValue(V)) {
     if (Instruction *I = tryMergingIntoMemset(SI, SI->getPointerOperand(),
                                               ByteVal)) {
       BBI = I->getIterator(); // Don't invalidate iterator.
       return true;
     }
 
+    // If we have an aggregate, we try to promote it to memset regardless
+    // of opportunity for merging as it can expose optimization opportunities
+    // in subsequent passes.
+    auto *T = V->getType();
+    if (T->isAggregateType()) {
+      uint64_t Size = DL.getTypeStoreSize(T);
+      unsigned Align = SI->getAlignment();
+      if (!Align)
+        Align = DL.getABITypeAlignment(T);
+      IRBuilder<> Builder(SI);
+      auto *M = Builder.CreateMemSet(SI->getPointerOperand(), ByteVal,
+                                     Size, Align, SI->isVolatile());
+
+      DEBUG(dbgs() << "Promoting " << *SI << " to " << *M << "\n");
+
+      MD->removeInstruction(SI);
+      SI->eraseFromParent();
+      NumMemSetInfer++;
+
+      // Make sure we do not invalidate the iterator.
+      BBI = M->getIterator();
+      return true;
+    }
+  }
+
   return false;
 }
 
 bool MemCpyOpt::processMemSet(MemSetInst *MSI, BasicBlock::iterator &BBI) {
   // See if there is another memset or store neighboring this memset which
   // allows us to widen out the memset to do a single larger store.
   if (isa<ConstantInt>(MSI->getLength()) && !MSI->isVolatile())
     if (Instruction *I = tryMergingIntoMemset(MSI, MSI->getDest(),

llvm/trunk/test/Transforms/MemCpyOpt/fca2memcpy.ll

 ; RUN: opt -memcpyopt -S < %s | FileCheck %s
 
 target datalayout = "e-i64:64-f80:128-n8:16:32:64"
 target triple = "x86_64-unknown-linux-gnu"
 
-%S = type { i8*, i32 }
+%S = type { i8*, i8, i32 }
 
 define void @copy(%S* %src, %S* %dst) {
 ; CHECK-LABEL: copy
 ; CHECK-NOT: load
 ; CHECK: call void @llvm.memmove.p0i8.p0i8.i64
 ; CHECK-NEXT: ret void
   %1 = load %S, %S* %src
   store %S %1, %S* %dst

 ; CHECK-NEXT: ret void
   %1 = load %S, %S* %src
   store %S %1, %S* %dst
   ret void
 }
 
 define void @destroysrc(%S* %src, %S* %dst) {
 ; CHECK-LABEL: destroysrc
-; CHECK-NOT: call
-; CHECK: ret void
+; CHECK: load %S, %S* %src
+; CHECK: call void @llvm.memset.p0i8.i64
+; CHECK-NEXT: store %S %1, %S* %dst
+; CHECK-NEXT: ret void
   %1 = load %S, %S* %src
   store %S zeroinitializer, %S* %src
   store %S %1, %S* %dst
   ret void
 }
 
 define void @destroynoaliassrc(%S* noalias %src, %S* %dst) {
 ; CHECK-LABEL: destroynoaliassrc
 ; CHECK-NOT: load
 ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64
-; CHECK-NEXT: store %S zeroinitializer, %S* %src
+; CHECK-NEXT: call void @llvm.memset.p0i8.i64
 ; CHECK-NEXT: ret void
   %1 = load %S, %S* %src
   store %S zeroinitializer, %S* %src
   store %S %1, %S* %dst
   ret void
 }
 
 define void @copyalias(%S* %src, %S* %dst) {