Merging r281403:

    // options. This is a trivially-generalized version of the code from

    // Hacker's Delight (itself derived from Knuth's Algorithm M from section

    // 4.3.1).

    SDValue Mask =

      DAG.getConstant(APInt::getLowBitsSet(NVT.getSizeInBits(),

                                           NVT.getSizeInBits() >> 1), dl, NVT);

    unsigned Bits = NVT.getSizeInBits();

    unsigned HalfBits = Bits >> 1;

    SDValue Mask = DAG.getConstant(APInt::getLowBitsSet(Bits, HalfBits), dl,

                                   NVT);

    SDValue LLL = DAG.getNode(ISD::AND, dl, NVT, LL, Mask);

    SDValue RLL = DAG.getNode(ISD::AND, dl, NVT, RL, Mask);

    SDValue T = DAG.getNode(ISD::MUL, dl, NVT, LLL, RLL);

    SDValue TL = DAG.getNode(ISD::AND, dl, NVT, T, Mask);

    SDValue Shift =

      DAG.getConstant(NVT.getSizeInBits() >> 1, dl,

                      TLI.getShiftAmountTy(NVT, DAG.getDataLayout()));

    EVT ShiftAmtTy = TLI.getShiftAmountTy(NVT, DAG.getDataLayout());

    if (APInt::getMaxValue(ShiftAmtTy.getSizeInBits()).ult(HalfBits)) {

      // The type from TLI is too small to fit the shift amount we want.

      // Override it with i32. The shift will have to be legalized.

      ShiftAmtTy = MVT::i32;

    }

    SDValue Shift = DAG.getConstant(HalfBits, dl, ShiftAmtTy);

    SDValue TH = DAG.getNode(ISD::SRL, dl, NVT, T, Shift);

    SDValue LLH = DAG.getNode(ISD::SRL, dl, NVT, LL, Shift);

    SDValue RLH = DAG.getNode(ISD::SRL, dl, NVT, RL, Shift);