[PowerPC] Fix i64 to vector lowering on big endian

[qiucf]

Summary

Lowering for scalar to vector would skip if current subtarget is big endian and the scalar is larger or equal than 64 bits. However there's some issue in implementation that SToVRHS may refer to SToVLHS's scalar size if SToVLHS is present, which leads to some crash.

[qiucf]

Use a simpler test case and add comments.

[shchenz]

LGTM. Thanks.

Please wait for several days to see if @nemanjai is ok with this fix.

[nemanjai]

LGTM. Thanks for fixing this.

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

   // form (to prevent the need for a swap).
   SmallVector<int, 16> ShuffV(Mask.begin(), Mask.end());
   SDValue SToVLHS = isScalarToVec(LHS);
   SDValue SToVRHS = isScalarToVec(RHS);
   if (SToVLHS || SToVRHS) {
     int NumEltsIn = SToVLHS ? SToVLHS.getValueType().getVectorNumElements()
                             : SToVRHS.getValueType().getVectorNumElements();
     int NumEltsOut = ShuffV.size();
-    unsigned InElemSizeInBits =
-        SToVLHS ? SToVLHS.getValueType().getScalarSizeInBits()
-                : SToVRHS.getValueType().getScalarSizeInBits();
-    unsigned OutElemSizeInBits = SToVLHS
-                                     ? LHS.getValueType().getScalarSizeInBits()
-                                     : RHS.getValueType().getScalarSizeInBits();
-
     // The width of the "valid lane" (i.e. the lane that contains the value that
     // is vectorized) needs to be expressed in terms of the number of elements
     // of the shuffle. It is thereby the ratio of the values before and after
     // any bitcast.
-    unsigned ValidLaneWidth = InElemSizeInBits / OutElemSizeInBits;
+    unsigned ValidLaneWidth =
+        SToVLHS ? SToVLHS.getValueType().getScalarSizeInBits() /
+                      LHS.getValueType().getScalarSizeInBits()
+                : SToVRHS.getValueType().getVectorNumElements() /
+                      RHS.getValueType().getScalarSizeInBits();
 
     // Initially assume that neither input is permuted. These will be adjusted
     // accordingly if either input is.
     int LHSMaxIdx = -1;
     int RHSMinIdx = -1;
     int RHSMaxIdx = -1;
     int HalfVec = LHS.getValueType().getVectorNumElements() / 2;
 
     // Get the permuted scalar to vector nodes for the source(s) that come from
     // ISD::SCALAR_TO_VECTOR.
     // On big endian systems, this only makes sense for element sizes smaller
     // than 64 bits since for 64-bit elements, all instructions already put
     // the value into element zero.
     if (SToVLHS) {
-      if (!IsLittleEndian && InElemSizeInBits >= 64)
+      if (!IsLittleEndian && SToVLHS.getValueType().getScalarSizeInBits() >= 64)
         return Res;
       // Set up the values for the shuffle vector fixup.
       LHSMaxIdx = NumEltsOut / NumEltsIn;
       SToVLHS = getSToVPermuted(SToVLHS, DAG, Subtarget);
       if (SToVLHS.getValueType() != LHS.getValueType())
         SToVLHS = DAG.getBitcast(LHS.getValueType(), SToVLHS);
       LHS = SToVLHS;
     }
     if (SToVRHS) {
-      if (!IsLittleEndian && InElemSizeInBits >= 64)
+      if (!IsLittleEndian && SToVRHS.getValueType().getScalarSizeInBits() >= 64)
         return Res;
       RHSMinIdx = NumEltsOut;
       RHSMaxIdx = NumEltsOut / NumEltsIn + RHSMinIdx;
       SToVRHS = getSToVPermuted(SToVRHS, DAG, Subtarget);
       if (SToVRHS.getValueType() != RHS.getValueType())
         SToVRHS = DAG.getBitcast(RHS.getValueType(), SToVRHS);
       RHS = SToVRHS;
     }

llvm/test/CodeGen/PowerPC/p8-scalar_vector_conversions.ll

 ; CHECK-AIX-NEXT:    xxlor 1, 34, 34
 ; CHECK-AIX-NEXT:    # kill: def $f1 killed $f1 killed $vsl1
 ; CHECK-AIX-NEXT:    blr
 entry:
   %vecext = extractelement <2 x double> %vd, i32 %i
   ret double %vecext
 ; FIXME: add check patterns when variable element extraction is implemented
 }
+
+define <4 x i32> @buildi2(i32 %rk25, i32 %rk26) {
+; CHECK-LABEL: buildi2:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    mtfprwz f1, r3
+; CHECK-NEXT:    lfdx f0, 0, r3
+; CHECK-NEXT:    mtvsrwz v3, r4
+; CHECK-NEXT:    xxspltw vs2, vs1, 1
+; CHECK-NEXT:    xxsldwi vs1, vs1, vs2, 1
+; CHECK-NEXT:    xxsldwi v2, vs1, vs0, 3
+; CHECK-NEXT:    vmrglw v3, v2, v3
+; CHECK-NEXT:    xxswapd vs0, v2
+; CHECK-NEXT:    xxsldwi v2, vs0, v3, 2
+; CHECK-NEXT:    blr
+;
+; CHECK-LE-LABEL: buildi2:
+; CHECK-LE:       # %bb.0: # %entry
+; CHECK-LE-NEXT:    addis r5, r2, .LCPI82_0@toc@ha
+; CHECK-LE-NEXT:    lxsdx v3, 0, r3
+; CHECK-LE-NEXT:    mtvsrwz v4, r3
+; CHECK-LE-NEXT:    addis r3, r2, .LCPI82_1@toc@ha
+; CHECK-LE-NEXT:    addi r5, r5, .LCPI82_0@toc@l
+; CHECK-LE-NEXT:    addi r3, r3, .LCPI82_1@toc@l
+; CHECK-LE-NEXT:    lvx v2, 0, r5
+; CHECK-LE-NEXT:    vperm v2, v3, v4, v2
+; CHECK-LE-NEXT:    lvx v3, 0, r3
+; CHECK-LE-NEXT:    mtvsrwz v4, r4
+; CHECK-LE-NEXT:    vperm v2, v4, v2, v3
+; CHECK-LE-NEXT:    blr
+;
+; CHECK-AIX-LABEL: buildi2:
+; CHECK-AIX:       # %bb.0: # %entry
+; CHECK-AIX-NEXT:    mtfprwz 1, 3
+; CHECK-AIX-NEXT:    lfdx 0, 0, 3
+; CHECK-AIX-NEXT:    mtvsrwz 35, 4
+; CHECK-AIX-NEXT:    xxspltw 2, 1, 1
+; CHECK-AIX-NEXT:    xxsldwi 1, 1, 2, 1
+; CHECK-AIX-NEXT:    xxsldwi 34, 1, 0, 3
+; CHECK-AIX-NEXT:    vmrglw 3, 2, 3
+; CHECK-AIX-NEXT:    xxswapd 0, 34
+; CHECK-AIX-NEXT:    xxsldwi 34, 0, 35, 2
+; CHECK-AIX-NEXT:    blr
+entry:
+  %rk29 = load <2 x i32>, <2 x i32>* undef, align 4
+  %rk39 = insertelement <4 x i32> poison, i32 %rk25, i32 0
+  %rk40 = shufflevector <2 x i32> %rk29, <2 x i32> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
+  %rk41 = shufflevector <4 x i32> %rk39, <4 x i32> %rk40, <4 x i32> <i32 0, i32 4, i32 5, i32 undef>
+  %rk42 = insertelement <4 x i32> %rk41, i32 %rk26, i32 3
+  ret <4 x i32> %rk42
+}