[NVPTX] Lower v2f16 and v2bf16 stores as 32-bit scalars.

[tra]

Summary

This avoids unnecessary vector splitting that was needed for vectorized store
instruction.

llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp

SDValue NVPTXTargetLowering::LowerSTORE(SDValue Op, SelectionDAG &DAG) const {
 
   // v2f16 is legal, so we can't rely on legalizer to handle unaligned
   // stores and have to handle it here.
   if (VT == MVT::v2f16 &&
       !allowsMemoryAccessForAlignment(*DAG.getContext(), DAG.getDataLayout(),
                                       VT, *Store->getMemOperand()))
     return expandUnalignedStore(Store, DAG);
 
+  // v2f16 and v2bf16 don't need special handling.
+  if (VT == MVT::v2f16 || VT == MVT::v2bf16)
+    return SDValue();
+
   if (VT.isVector())
     return LowerSTOREVector(Op, DAG);
 
   return SDValue();
 }
 
 SDValue
 NVPTXTargetLowering::LowerSTOREVector(SDValue Op, SelectionDAG &DAG) const {

llvm/test/CodeGen/NVPTX/f16x2-instructions.ll

define <2 x half> @test_frem(<2 x half> %a, <2 x half> %b) #0 {
   %r = frem <2 x half> %a, %b
   ret <2 x half> %r
 }
 
 ; CHECK-LABEL: .func test_ldst_v2f16(
 ; CHECK-DAG:    ld.param.u64    %[[A:rd[0-9]+]], [test_ldst_v2f16_param_0];
 ; CHECK-DAG:    ld.param.u64    %[[B:rd[0-9]+]], [test_ldst_v2f16_param_1];
 ; CHECK-DAG:    ld.b32          [[E:%r[0-9]+]], [%[[A]]]
-; CHECK:        mov.b32         {[[E0:%rs[0-9]+]], [[E1:%rs[0-9]+]]}, [[E]];
-; CHECK-DAG:    st.v2.b16       [%[[B]]], {[[E0]], [[E1]]};
+; CHECK-DAG:    st.b32          [%[[B]]], [[E]];
 ; CHECK:        ret;
 define void @test_ldst_v2f16(ptr %a, ptr %b) {
   %t1 = load <2 x half>, ptr %a
   store <2 x half> %t1, ptr %b, align 16
   ret void
 }
 
 ; CHECK-LABEL: .func test_ldst_v3f16(