[SystemZ] Avoid inserting same value after replication

[jonpa]

Summary

A minor improvement of buildVector() that skips creating an INSERT_VECTOR_ELT for a Value which has already been used for the REPLICATE.

Seems like just two files benefit from this on SPEC:

update.s
vlvgf          :                   27                   18       -9
l              :                  166                  163       -3
vrepf          :                   11                    8       -3
vlvgp          :                    9                    6       -3
vlrepf         :                    0                    3       +3
lgr            :                  186                  184       -2
Spill|Reload   :                  478                  478       +0

pullinit.s
vlvgf          :                   93                   63      -30
Spill|Reload   :                   83                   83       +0

[uweigand]

LGTM, thanks!

As a future enhancement, we might prefer to choose the initial value to replicate such that the number of VLVGx instruction is minimized. E.g. if we load two integers LA and LB from memory and construct the vector { LA, LB, LB, LB }, the current code, even with your change, would load and replicate LA, and then use three VLVGx to insert the LB copies. We could save two instructions by instead using load-and-replicate for LB.

[jonpa]

r346504

As a future enhancement, we might prefer to choose the initial value to replicate such that the number of VLVGx instruction is minimized. E.g. if we load two integers LA and LB from memory and construct the vector { LA, LB, LB, LB }, the current code, even with your change, would load and replicate LA, and then use three VLVGx to insert the LB copies. We could save two instructions by instead using load-and-replicate for LB.

I'll give it a try...

lib/Target/SystemZ/SystemZISelLowering.cpp

if (Elem.getOpcode() == ISD::Constant ||
       Constants[I] = Elem;
       Done[I] = true;
     }
   }
   // If there was at least one constant, fill in the other elements of
   // Constants with undefs to get a full vector constant and use that
   // as the starting point.
   SDValue Result;
+  SDValue ReplicatedVal;
   if (NumConstants > 0) {
     for (unsigned I = 0; I < NumElements; ++I)
       if (!Constants[I].getNode())
         Constants[I] = DAG.getUNDEF(Elems[I].getValueType());
     Result = DAG.getBuildVector(VT, DL, Constants);
   } else {
     // Otherwise try to use VLREP or VLVGP to start the sequence in order to
     // avoid a false dependency on any previous contents of the vector
     // register.
 
     // Use a VLREP if at least one element is a load.
     unsigned LoadElIdx = UINT_MAX;
     for (unsigned I = 0; I < NumElements; ++I)
       if (Elems[I].getOpcode() == ISD::LOAD &&
           cast<LoadSDNode>(Elems[I])->isUnindexed()) {
         LoadElIdx = I;
         break;
       }
     if (LoadElIdx != UINT_MAX) {
       Result = DAG.getNode(SystemZISD::REPLICATE, DL, VT, Elems[LoadElIdx]);
       Done[LoadElIdx] = true;
+      ReplicatedVal = Elems[LoadElIdx];
     } else {
       // Try to use VLVGP.
       unsigned I1 = NumElements / 2 - 1;
       unsigned I2 = NumElements - 1;
       bool Def1 = !Elems[I1].isUndef();
       bool Def2 = !Elems[I2].isUndef();
       if (Def1 || Def2) {
         SDValue Elem1 = Elems[Def1 ? I1 : I2];
         SDValue Elem2 = Elems[Def2 ? I2 : I1];
         Result = DAG.getNode(ISD::BITCAST, DL, VT,
                              joinDwords(DAG, DL, Elem1, Elem2));
         Done[I1] = true;
         Done[I2] = true;
       } else
         Result = DAG.getUNDEF(VT);
     }
   }
 
   // Use VLVGx to insert the other elements.
   for (unsigned I = 0; I < NumElements; ++I)
-    if (!Done[I] && !Elems[I].isUndef())
+    if (!Done[I] && !Elems[I].isUndef() && Elems[I] != ReplicatedVal)
       Result = DAG.getNode(ISD::INSERT_VECTOR_ELT, DL, VT, Result, Elems[I],
                            DAG.getConstant(I, DL, MVT::i32));
   return Result;
 }
 
 SDValue SystemZTargetLowering::lowerBUILD_VECTOR(SDValue Op,
                                                  SelectionDAG &DAG) const {
   const SystemZInstrInfo *TII =

test/CodeGen/SystemZ/vec-move-19.ll

+; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z13 | FileCheck %s
+
+; Test that a loaded value which is replicated is not inserted also in any
+; elements.
+
+; CHECK:      vlvgp   %v0, %r0, %r0
+; CHECK-NEXT: vrepf   %v24, %v0, 1
+; CHECK-NOT:  vlvgf   %v24, %r0, 1
+; CHECK-NOT:  vlvgf   %v24, %r0, 2
+
+define <4 x i32> @fun(i32 %arg, i32* %dst) {
+  %tmp = load i32, i32* undef
+  %tmp8 = insertelement <4 x i32> undef, i32 %tmp, i32 0
+  %tmp9 = insertelement <4 x i32> %tmp8, i32 %tmp, i32 1
+  %tmp10 = insertelement <4 x i32> %tmp9, i32 %tmp, i32 2
+  %tmp11 = insertelement <4 x i32> %tmp10, i32 %arg, i32 3
+  store i32 %tmp, i32* %dst
+  ret <4 x i32> %tmp11
+}
+