[LegalizeTypes][NFC] Use getConstantOperandVal instead of cast constant getvalue.

[Jimerlife]

Summary

Use getConstantOperandVal(Num) API instead of cast<ConstantSDNode>(N->getOperand(Num))->getZExtValue().

[craig.topper]

llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

2367 ↗

(On Diff #451712)

Not sure that I like that we repeated the "1" here when we already have Idx. It's potentially more code too since we need to dereference N again.

[RKSimon]

llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

2367 ↗

(On Diff #451712)

+1 We've tended to avoid using getConstantOperand helpers when we're also accessing the raw getOperand() variant - probably just do this in cases where we can then remove the getOperand call

[Jimerlife]

address comment

[Jimerlife]

Only use getConstantOperandVal(Num) API instead of cast<ConstantSDNode>(N->getOperand(Num))->getZExtValue(). If We already have Idx, still keeping origin cast form. Thanks your suggestions @craig.topper @RKSimon.

[craig.topper]

LGTM

llvm/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp

if (OutVT.isScalableVector()) {
     EVT InVT = InOp0.getValueType();
 
     // Try and extract from a smaller type so that it eventually falls
     // into the promotion code below.
     if (getTypeAction(InVT) == TargetLowering::TypeSplitVector ||
         getTypeAction(InVT) == TargetLowering::TypeLegal) {
       EVT NInVT = InVT.getHalfNumVectorElementsVT(*DAG.getContext());
       unsigned NElts = NInVT.getVectorMinNumElements();
-      uint64_t IdxVal = cast<ConstantSDNode>(BaseIdx)->getZExtValue();
+      uint64_t IdxVal = N->getConstantOperandVal(1);
 
       SDValue Step1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NInVT, InOp0,
                                   DAG.getConstant(alignDown(IdxVal, NElts), dl,
                                                   BaseIdx.getValueType()));
       SDValue Step2 = DAG.getNode(
           ISD::EXTRACT_SUBVECTOR, dl, OutVT, Step1,
           DAG.getConstant(IdxVal % NElts, dl, BaseIdx.getValueType()));
       return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT, Step2);

llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp

void DAGTypeLegalizer::SplitVecRes_EXTRACT_SUBVECTOR(SDNode *N, SDValue &Lo,
   SDValue Vec = N->getOperand(0);
   SDValue Idx = N->getOperand(1);
   SDLoc dl(N);
 
   EVT LoVT, HiVT;
   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
 
   Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, LoVT, Vec, Idx);
-  uint64_t IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
+  uint64_t IdxVal = N->getConstantOperandVal(1);
   Hi = DAG.getNode(
       ISD::EXTRACT_SUBVECTOR, dl, HiVT, Vec,
       DAG.getVectorIdxConstant(IdxVal + LoVT.getVectorMinNumElements(), dl));
 }
 
 void DAGTypeLegalizer::SplitVecRes_INSERT_SUBVECTOR(SDNode *N, SDValue &Lo,
                                                     SDValue &Hi) {
   SDValue Vec = N->getOperand(0);
   SDValue SubVec = N->getOperand(1);
   SDValue Idx = N->getOperand(2);
   SDLoc dl(N);
   GetSplitVector(Vec, Lo, Hi);
 
   EVT VecVT = Vec.getValueType();
   EVT LoVT = Lo.getValueType();
   EVT SubVecVT = SubVec.getValueType();
   unsigned VecElems = VecVT.getVectorMinNumElements();
   unsigned SubElems = SubVecVT.getVectorMinNumElements();
   unsigned LoElems = LoVT.getVectorMinNumElements();
 
   // If we know the index is in the first half, and we know the subvector
   // doesn't cross the boundary between the halves, we can avoid spilling the
   // vector, and insert into the lower half of the split vector directly.
-  unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
+  uint64_t IdxVal = N->getConstantOperandVal(2);
   if (IdxVal + SubElems <= LoElems) {
     Lo = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, LoVT, Lo, SubVec, Idx);
     return;
   }
   // Similarly if the subvector is fully in the high half, but mind that we
   // can't tell whether a fixed-length subvector is fully within the high half
   // of a scalable vector.
   if (VecVT.isScalableVector() == SubVecVT.isScalableVector() &&
SDValue DAGTypeLegalizer::SplitVecOp_INSERT_SUBVECTOR(SDNode *N,
   SDValue Vec = N->getOperand(0);
   SDValue SubVec = N->getOperand(1);
   SDValue Idx = N->getOperand(2);
   SDLoc dl(N);
 
   SDValue Lo, Hi;
   GetSplitVector(SubVec, Lo, Hi);
 
-  uint64_t IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
+  uint64_t IdxVal = N->getConstantOperandVal(2);
   uint64_t LoElts = Lo.getValueType().getVectorMinNumElements();
 
   SDValue FirstInsertion =
       DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResVT, Vec, Lo, Idx);
   SDValue SecondInsertion =
       DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResVT, FirstInsertion, Hi,
                   DAG.getVectorIdxConstant(IdxVal + LoElts, dl));
 
SDValue DAGTypeLegalizer::SplitVecOp_EXTRACT_SUBVECTOR(SDNode *N) {
   if (SubVT.isScalableVector() !=
       N->getOperand(0).getValueType().isScalableVector())
     report_fatal_error("Extracting a fixed-length vector from an illegal "
                        "scalable vector is not yet supported");
 
   GetSplitVector(N->getOperand(0), Lo, Hi);
 
   uint64_t LoElts = Lo.getValueType().getVectorMinNumElements();
-  uint64_t IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
+  uint64_t IdxVal = N->getConstantOperandVal(1);
 
   if (IdxVal < LoElts) {
     assert(IdxVal + SubVT.getVectorMinNumElements() <= LoElts &&
            "Extracted subvector crosses vector split!");
     return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT, Lo, Idx);
   } else {
     return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT, Hi,
                        DAG.getVectorIdxConstant(IdxVal - LoElts, dl));
SDValue DAGTypeLegalizer::WidenVecRes_EXTRACT_SUBVECTOR(SDNode *N) {
 
   auto InOpTypeAction = getTypeAction(InOp.getValueType());
   if (InOpTypeAction == TargetLowering::TypeWidenVector)
     InOp = GetWidenedVector(InOp);
 
   EVT InVT = InOp.getValueType();
 
   // Check if we can just return the input vector after widening.
-  uint64_t IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
+  uint64_t IdxVal = N->getConstantOperandVal(1);
   if (IdxVal == 0 && InVT == WidenVT)
     return InOp;
 
   // Check if we can extract from the vector.
   unsigned WidenNumElts = WidenVT.getVectorMinNumElements();
   unsigned InNumElts = InVT.getVectorMinNumElements();
   unsigned VTNumElts = VT.getVectorMinNumElements();
   assert(IdxVal % VTNumElts == 0 &&