[SelectionDAG] memcpy expansion of const volatile struct ignores const zero

[simonwallis2]

Summary

In getMemcpyLoadsAndStores(), a memcpy where the source is a zero constant is expanded to a MemOp::Set instead of a MemOp::Copy, even when the memcpy is volatile.
This is incorrect.

The fix is to add a check for volatile, and expand to MemOp::Copy in the volatile case.

[chill]

LGTM.

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

static SDValue getMemcpyLoadsAndStores(SelectionDAG &DAG, const SDLoc &dl,
   FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Dst);
   if (FI && !MFI.isFixedObjectIndex(FI->getIndex()))
     DstAlignCanChange = true;
   MaybeAlign SrcAlign = DAG.InferPtrAlign(Src);
   if (!SrcAlign || Alignment > *SrcAlign)
     SrcAlign = Alignment;
   assert(SrcAlign && "SrcAlign must be set");
   ConstantDataArraySlice Slice;
-  bool CopyFromConstant = isMemSrcFromConstant(Src, Slice);
+  // If marked as volatile, perform a copy even when marked as constant.
+  bool CopyFromConstant = !isVol && isMemSrcFromConstant(Src, Slice);
   bool isZeroConstant = CopyFromConstant && Slice.Array == nullptr;
   unsigned Limit = AlwaysInline ? ~0U : TLI.getMaxStoresPerMemcpy(OptSize);
   const MemOp Op = isZeroConstant
                        ? MemOp::Set(Size, DstAlignCanChange, Alignment,
                                     /*IsZeroMemset*/ true, isVol)
                        : MemOp::Copy(Size, DstAlignCanChange, Alignment,
                                      *SrcAlign, isVol, CopyFromConstant);
   if (!TLI.findOptimalMemOpLowering(

llvm/test/CodeGen/ARM/memcpy-const-vol-struct.ll

+; RUN: llc -mtriple=armv7-arm-none-eabi -o - %s | FileCheck %s
+
+%struct.sMyType = type { i32 }
+
+@val = hidden constant %struct.sMyType zeroinitializer, align 4
+@v = internal global %struct.sMyType zeroinitializer, align 4
+
+define hidden void @InitVal() local_unnamed_addr {
+entry:
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 bitcast (%struct.sMyType* @v to i8*), i8* align 4 bitcast (%struct.sMyType* @val to i8*), i32 4, i1 true)
+; The last argument is the isvolatile argument. This is a volatile memcpy.
+; Test that the memcpy expansion does not optimize away the load.
+; CHECK: ldr
+; CHECK: str
+  ret void
+}
+
+declare void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i32, i1 immarg)