NVPTX: Fix not preserving volatile when expanding memset

[arsenm]

r293851

lib/Target/NVPTX/NVPTXLowerAggrCopies.cpp

void convertMemMoveToLoop(Instruction *ConvertedInst, Value *SrcAddr,
   FwdCopyPhi->addIncoming(ConstantInt::get(TypeOfCopyLen, 0), CopyForwardBB);
 
   BranchInst::Create(ExitBB, FwdLoopBB, CompareN, ElseTerm);
   ElseTerm->eraseFromParent();
 }
 
 // Lower memset to loop.
 void convertMemSetToLoop(Instruction *ConvertedInst, Value *DstAddr,
-                         Value *CopyLen, Value *SetValue, LLVMContext &Context,
-                         Function &F) {
+                         Value *CopyLen, Value *SetValue,
+                         bool IsVolatile, LLVMContext &Context, Function &F) {
   BasicBlock *OrigBB = ConvertedInst->getParent();
   BasicBlock *NewBB =
       ConvertedInst->getParent()->splitBasicBlock(ConvertedInst, "split");
   BasicBlock *LoopBB = BasicBlock::Create(Context, "loadstoreloop", &F, NewBB);
 
   OrigBB->getTerminator()->setSuccessor(0, LoopBB);
   IRBuilder<> Builder(OrigBB->getTerminator());
 
   // Cast pointer to the type of value getting stored
   unsigned dstAS = cast<PointerType>(DstAddr->getType())->getAddressSpace();
   DstAddr = Builder.CreateBitCast(DstAddr,
                                   PointerType::get(SetValue->getType(), dstAS));
 
   IRBuilder<> LoopBuilder(LoopBB);
   PHINode *LoopIndex = LoopBuilder.CreatePHI(CopyLen->getType(), 0);
   LoopIndex->addIncoming(ConstantInt::get(CopyLen->getType(), 0), OrigBB);
 
   LoopBuilder.CreateStore(
       SetValue,
       LoopBuilder.CreateInBoundsGEP(SetValue->getType(), DstAddr, LoopIndex),
-      false);
+      IsVolatile);
 
   Value *NewIndex =
       LoopBuilder.CreateAdd(LoopIndex, ConstantInt::get(CopyLen->getType(), 1));
   LoopIndex->addIncoming(NewIndex, LoopBB);
 
   LoopBuilder.CreateCondBr(LoopBuilder.CreateICmpULT(NewIndex, CopyLen), LoopBB,
                            NewBB);
 }
if (MemCpyInst *Memcpy = dyn_cast<MemCpyInst>(MemCall)) {
                            /* Context */ Context,
                            /* Function F */ F);
 
     } else if (MemSetInst *Memset = dyn_cast<MemSetInst>(MemCall)) {
       convertMemSetToLoop(/* ConvertedInst */ Memset,
                           /* DstAddr */ Memset->getRawDest(),
                           /* CopyLen */ Memset->getLength(),
                           /* SetValue */ Memset->getValue(),
+                          /* IsVolatile */ Memset->isVolatile(),
                           /* Context */ Context,
                           /* Function F */ F);
     }
     MemCall->eraseFromParent();
   }
 
   return true;
 }

test/CodeGen/NVPTX/lower-aggr-copies.ll

 ; PTX:        ld.param.u8 %rs[[REG:[0-9]+]]
 ; PTX:        LBB[[LABEL:[_0-9]+]]:
 ; PTX:        st.u8 [%rd{{[0-9]+}}], %rs[[REG]]
 ; PTX:        add.s64 %rd[[COUNTER:[0-9]+]], %rd[[COUNTER]], 1
 ; PTX-NEXT:   setp.lt.u64 %p[[PRED:[0-9]+]], %rd[[COUNTER]], %rd
 ; PTX-NEXT:   @%p[[PRED]] bra LBB[[LABEL]]
 }
 
+define i8* @volatile_memset_caller(i8* %dst, i32 %c, i64 %n) #0 {
+entry:
+  %0 = trunc i32 %c to i8
+  tail call void @llvm.memset.p0i8.i64(i8* %dst, i8 %0, i64 %n, i32 1, i1 true)
+  ret i8* %dst
+
+; IR-LABEL:   @volatile_memset_caller
+; IR:         [[VAL:%[0-9]+]] = trunc i32 %c to i8
+; IR:         loadstoreloop:
+; IR:         [[STOREPTR:%[0-9]+]] = getelementptr inbounds i8, i8* %dst, i64
+; IR-NEXT:    store volatile i8 [[VAL]], i8* [[STOREPTR]]
+}
+
 define i8* @memmove_caller(i8* %dst, i8* %src, i64 %n) #0 {
 entry:
   tail call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %n, i32 1, i1 false)
   ret i8* %dst
 
 ; IR-LABEL:   @memmove_caller
 ; IR:         icmp ult i8* %src, %dst
 ; IR:         [[PHIVAL:%[0-9a-zA-Z_]+]] = phi i64