llvm dev - Feb 2016 - Question about method SelectionDAG::FoldConstantArithmetic

I find method SelectionDAG::FoldConstantArithmetic contains following code
(path: lib/CodeGen/SelectionDAG/SelectionDAG.cpp)


SDValue SelectionDAG::FoldConstantArithmetic(unsigned Opcode, SDLoc DL, EVT VT,
                                             SDNode *Cst1, SDNode *Cst2) {
  // If the opcode is a target-specific ISD node, there's nothing we can
  // do here and the operand rules may not line up with the below, so
  // bail early.
  if (Opcode >= ISD::BUILTIN_OP_END)
    return SDValue();


  // Handle the case of two scalars.
  if (const ConstantSDNode *Scalar1 = dyn_cast<ConstantSDNode>(Cst1)) {
    if (const ConstantSDNode *Scalar2 = dyn_cast<ConstantSDNode>(Cst2)) {
      if (SDValue Folded           FoldConstantArithmetic(Opcode, DL, VT,
Scalar1, Scalar2)) {
        if (!VT.isVector())
          return Folded;
        SmallVector<SDValue, 4> Outputs;
        // We may have a vector type but a scalar result. Create a splat.
        Outputs.resize(VT.getVectorNumElements(), Outputs.back());
        // Build a big vector out of the scalar elements we generated.
        return getNode(ISD::BUILD_VECTOR, SDLoc(), VT, Outputs);
      } else {
        return SDValue();
      }
    }
  }


The IF block enclosing the code marked in red tries to do constant folding for
the two constant operands.
If it finds out that we get a scalar result, but the expected type is a vector,
the code marked in red will be
executed.
But it confuses me, for the Outputs is empty, first even get last element for an
empty SmallVector
will trigger assert, second we will use an array of empty SDValue instances as
the operands for the
BUILD_VECTOR operator. It may trigger crash when try to access the NULL SDNode
pointer inside these
SDValue instances (tons of points not checking the NULL pointer before access).


Should it be like this, make the scalar result just elements of the vector
result (I don't fully understand what should do in this situation):


        SmallVector<SDValue, 4> Outputs;
        EVT SVT = VT.getScalarType();
        Outputs.push_back(getConstant(Folded.first, DL, SVT));
        // We may have a vector type but a scalar result. Create a splat.
        Outputs.resize(VT.getVectorNumElements(), Outputs.back());
        // Build a big vector out of the scalar elements we generated.
        return getNode(ISD::BUILD_VECTOR, SDLoc(), VT, Outputs);


Or may it just the case will not actually happen and can be removed?


Regards
Hui Wu
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20160223/1804eeda/attachment.html>