Fix corruption of result number in LegalizeVectorOps.cpp

[uweigand]

Summary

When VectorLegalizer::LegalizeOp creates a new SDValue after iterating over its arguments, it will always select the result number 0 even if the SDValue originally referred to some other result of the node.

This apparently never caused any issues so far (maybe nodes involving vector types with multiple results are rare?), but now with strict floating-point nodes it appears much more frequently. I've noticed this in my own tests related to https://reviews.llvm.org/D45576, but it seems this is already visible with an in-tree test case that was recently checked in here: https://reviews.llvm.org/D48809

Looking at e.g. constrained_vector_fdiv_v4f64 in test/CodeGen/X86/vector-constrained-fp-intrinsics.ll, we get the following legalized DAG:

t0: ch = EntryToken
t19: v2f64 = BUILD_VECTOR ConstantFP:f64<1.000000e+01>, ConstantFP:f64<1.000000e+01>
  t21: v2f64 = BUILD_VECTOR ConstantFP:f64<3.000000e+00>, ConstantFP:f64<4.000000e+00>
t23: v2f64,ch = strict_fdiv t0, t21, t19
  t20: v2f64 = BUILD_VECTOR ConstantFP:f64<1.000000e+00>, ConstantFP:f64<2.000000e+00>
t22: v2f64,ch = strict_fdiv t0, t20, t19
  t24: ch = TokenFactor t22, t23

This is incorrect; note how the TokenFactor in t24 refers to arguments that aren't even chain values. With this patch, we get instead the correct:

t24: ch = TokenFactor t22:1, t23:1

[cameron.mcinally]

Oh, whoa. Good catch, Ulrich. I approve this change.

Vector loads/stores/gathers/scatters will definitely have multiple results. Perhaps the special handling of those (just below your change) avoided this issue.

llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp

SDValue VectorLegalizer::LegalizeOp(SDValue Op) {
 
   SDNode* Node = Op.getNode();
 
   // Legalize the operands
   SmallVector<SDValue, 8> Ops;
   for (const SDValue &Op : Node->op_values())
     Ops.push_back(LegalizeOp(Op));
 
-  SDValue Result = SDValue(DAG.UpdateNodeOperands(Op.getNode(), Ops), 0);
+  SDValue Result = SDValue(DAG.UpdateNodeOperands(Op.getNode(), Ops),
+                           Op.getResNo());
 
   bool HasVectorValue = false;
   if (Op.getOpcode() == ISD::LOAD) {
     LoadSDNode *LD = cast<LoadSDNode>(Op.getNode());
     ISD::LoadExtType ExtType = LD->getExtensionType();
     if (LD->getMemoryVT().isVector() && ExtType != ISD::NON_EXTLOAD) {
       LLVM_DEBUG(dbgs() << "\nLegalizing extending vector load: ";
                  Node->dump(&DAG));

llvm/trunk/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll

%div = call <2 x double> @llvm.experimental.constrained.fdiv.v2f64(
            metadata !"fpexcept.strict")
   ret <2 x double> %div
 }
 
 define <4 x double> @constrained_vector_fdiv_v4f64() {
 ; NO-FMA-LABEL: constrained_vector_fdiv_v4f64:
 ; NO-FMA:       # %bb.0:
 ; NO-FMA-NEXT:    movapd {{.*#+}} xmm2 = [1.000000e+01,1.000000e+01]
-; NO-FMA-NEXT:    movapd {{.*#+}} xmm1 = [3.000000e+00,4.000000e+00]
-; NO-FMA-NEXT:    divpd %xmm2, %xmm1
 ; NO-FMA-NEXT:    movapd {{.*#+}} xmm0 = [1.000000e+00,2.000000e+00]
 ; NO-FMA-NEXT:    divpd %xmm2, %xmm0
+; NO-FMA-NEXT:    movapd {{.*#+}} xmm1 = [3.000000e+00,4.000000e+00]
+; NO-FMA-NEXT:    divpd %xmm2, %xmm1
 ; NO-FMA-NEXT:    retq
 ;
 ; HAS-FMA-LABEL: constrained_vector_fdiv_v4f64:
 ; HAS-FMA:       # %bb.0:
 ; HAS-FMA-NEXT:    vmovapd {{.*#+}} ymm0 = [1.000000e+00,2.000000e+00,3.000000e+00,4.000000e+00]
 ; HAS-FMA-NEXT:    vdivpd {{.*}}(%rip), %ymm0, %ymm0
 ; HAS-FMA-NEXT:    retq
   %div = call <4 x double> @llvm.experimental.constrained.fdiv.v4f64(
%mul = call <2 x double> @llvm.experimental.constrained.fmul.v2f64(
            metadata !"round.dynamic",
            metadata !"fpexcept.strict")
   ret <2 x double> %mul
 }
 
 define <4 x double> @constrained_vector_fmul_v4f64() {
 ; NO-FMA-LABEL: constrained_vector_fmul_v4f64:
 ; NO-FMA:       # %bb.0: # %entry
-; NO-FMA-NEXT:    movapd {{.*#+}} xmm0 = [1.797693e+308,1.797693e+308]
-; NO-FMA-NEXT:    movapd {{.*#+}} xmm1 = [4.000000e+00,5.000000e+00]
-; NO-FMA-NEXT:    mulpd %xmm0, %xmm1
-; NO-FMA-NEXT:    mulpd {{.*}}(%rip), %xmm0
+; NO-FMA-NEXT:    movapd {{.*#+}} xmm1 = [1.797693e+308,1.797693e+308]
+; NO-FMA-NEXT:    movapd {{.*#+}} xmm0 = [2.000000e+00,3.000000e+00]
+; NO-FMA-NEXT:    mulpd %xmm1, %xmm0
+; NO-FMA-NEXT:    mulpd {{.*}}(%rip), %xmm1
 ; NO-FMA-NEXT:    retq
 ;
 ; HAS-FMA-LABEL: constrained_vector_fmul_v4f64:
 ; HAS-FMA:       # %bb.0: # %entry
 ; HAS-FMA-NEXT:    vmovapd {{.*#+}} ymm0 = [1.797693e+308,1.797693e+308,1.797693e+308,1.797693e+308]
 ; HAS-FMA-NEXT:    vmulpd {{.*}}(%rip), %ymm0, %ymm0
 ; HAS-FMA-NEXT:    retq
 entry:
%add = call <2 x double> @llvm.experimental.constrained.fadd.v2f64(
            metadata !"round.dynamic",
            metadata !"fpexcept.strict")
   ret <2 x double> %add
 }
 
 define <4 x double> @constrained_vector_fadd_v4f64() {
 ; NO-FMA-LABEL: constrained_vector_fadd_v4f64:
 ; NO-FMA:       # %bb.0: # %entry
-; NO-FMA-NEXT:    movapd {{.*#+}} xmm0 = [1.797693e+308,1.797693e+308]
-; NO-FMA-NEXT:    movapd {{.*#+}} xmm1 = [2.000000e+00,2.000000e-01]
-; NO-FMA-NEXT:    addpd %xmm0, %xmm1
-; NO-FMA-NEXT:    addpd {{.*}}(%rip), %xmm0
+; NO-FMA-NEXT:    movapd {{.*#+}} xmm1 = [1.797693e+308,1.797693e+308]
+; NO-FMA-NEXT:    movapd {{.*#+}} xmm0 = [1.000000e+00,1.000000e-01]
+; NO-FMA-NEXT:    addpd %xmm1, %xmm0
+; NO-FMA-NEXT:    addpd {{.*}}(%rip), %xmm1
 ; NO-FMA-NEXT:    retq
 ;
 ; HAS-FMA-LABEL: constrained_vector_fadd_v4f64:
 ; HAS-FMA:       # %bb.0: # %entry
 ; HAS-FMA-NEXT:    vmovapd {{.*#+}} ymm0 = [1.797693e+308,1.797693e+308,1.797693e+308,1.797693e+308]
 ; HAS-FMA-NEXT:    vaddpd {{.*}}(%rip), %ymm0, %ymm0
 ; HAS-FMA-NEXT:    retq
 entry:
%sub = call <2 x double> @llvm.experimental.constrained.fsub.v2f64(
            metadata !"round.dynamic",
            metadata !"fpexcept.strict")
   ret <2 x double> %sub
 }
 
 define <4 x double> @constrained_vector_fsub_v4f64() {
 ; NO-FMA-LABEL: constrained_vector_fsub_v4f64:
 ; NO-FMA:       # %bb.0: # %entry
-; NO-FMA-NEXT:    movapd {{.*#+}} xmm0 = [-1.797693e+308,-1.797693e+308]
-; NO-FMA-NEXT:    movapd %xmm0, %xmm1
-; NO-FMA-NEXT:    subpd {{.*}}(%rip), %xmm1
+; NO-FMA-NEXT:    movapd {{.*#+}} xmm1 = [-1.797693e+308,-1.797693e+308]
+; NO-FMA-NEXT:    movapd %xmm1, %xmm0
 ; NO-FMA-NEXT:    subpd {{.*}}(%rip), %xmm0
+; NO-FMA-NEXT:    subpd {{.*}}(%rip), %xmm1
 ; NO-FMA-NEXT:    retq
 ;
 ; HAS-FMA-LABEL: constrained_vector_fsub_v4f64:
 ; HAS-FMA:       # %bb.0: # %entry
 ; HAS-FMA-NEXT:    vmovapd {{.*#+}} ymm0 = [-1.797693e+308,-1.797693e+308,-1.797693e+308,-1.797693e+308]
 ; HAS-FMA-NEXT:    vsubpd {{.*}}(%rip), %ymm0, %ymm0
 ; HAS-FMA-NEXT:    retq
 entry:
%sqrt = call <2 x double> @llvm.experimental.constrained.sqrt.v2f64(
                               metadata !"round.dynamic",
                               metadata !"fpexcept.strict")
   ret <2 x double> %sqrt
 }
 
 define <4 x double> @constrained_vector_sqrt_v4f64() {
 ; NO-FMA-LABEL: constrained_vector_sqrt_v4f64:
 ; NO-FMA:       # %bb.0: # %entry
-; NO-FMA-NEXT:    sqrtpd {{.*}}(%rip), %xmm1
 ; NO-FMA-NEXT:    sqrtpd {{.*}}(%rip), %xmm0
+; NO-FMA-NEXT:    sqrtpd {{.*}}(%rip), %xmm1
 ; NO-FMA-NEXT:    retq
 ;
 ; HAS-FMA-LABEL: constrained_vector_sqrt_v4f64:
 ; HAS-FMA:       # %bb.0: # %entry
 ; HAS-FMA-NEXT:    vsqrtpd {{.*}}(%rip), %ymm0
 ; HAS-FMA-NEXT:    retq
 entry:
   %sqrt = call <4 x double> @llvm.experimental.constrained.sqrt.v4f64(