[SelectionDAG] Remove PromoteIntOp_EXTRACT_SUBVECTOR.

[sdesmalen]

Summary

This code seems untested and is likely obsolete, because this case
should already be handled by the code that legalizes the result type
of EXTRACT_SUBVECTOR.

[craig.topper]

I'm not sure we can write a test for RISCV either. This can only happen if the element type needs to be promoted on the larger vector type, but not the narrower vector type used for the result. I don't even know to exercise this code with fixed vectors. The llvm-cov bot says its untested http://lab.llvm.org:8080/coverage/coverage-reports/coverage/Users/buildslave/jenkins/workspace/coverage/llvm-project/llvm/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp.html#L5001. Looks like it was added to support some case with mask vectors on X86, but that case no longer happens. Maybe we can just delete it?

[craig.topper]

llvm/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp

5095–5096

The use of MVT instead of EVT here is also questionable. That's probably another vote for dropping it.

[sdesmalen]

Changed patch to remove PromoteIntOp_EXTRACT_SUBVECTOR.

[sdesmalen]

In D110061#3010295, @craig.topper wrote:

I'm not sure we can write a test for RISCV either. This can only happen if the element type needs to be promoted on the larger vector type, but not the narrower vector type used for the result. I don't even know to exercise this code with fixed vectors. The llvm-cov bot says its untested http://lab.llvm.org:8080/coverage/coverage-reports/coverage/Users/buildslave/jenkins/workspace/coverage/llvm-project/llvm/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp.html#L5001. Looks like it was added to support some case with mask vectors on X86, but that case no longer happens. Maybe we can just delete it?

Thanks, I wasn't aware of a code-coverage buildbot that actually showed this info, that's very useful. Is there a more friendly interface to get such a report? (Other than manually constructing the URL with a path to the file)

I've removed the function now and think it makes sense, because I can't think of any instance where the result type would be legal, and the (wider vector) input type requiring promotion.

[craig.topper]

In D110061#3011500, @sdesmalen wrote:

In D110061#3010295, @craig.topper wrote:

I'm not sure we can write a test for RISCV either. This can only happen if the element type needs to be promoted on the larger vector type, but not the narrower vector type used for the result. I don't even know to exercise this code with fixed vectors. The llvm-cov bot says its untested http://lab.llvm.org:8080/coverage/coverage-reports/coverage/Users/buildslave/jenkins/workspace/coverage/llvm-project/llvm/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp.html#L5001. Looks like it was added to support some case with mask vectors on X86, but that case no longer happens. Maybe we can just delete it?

Thanks, I wasn't aware of a code-coverage buildbot that actually showed this info, that's very useful. Is there a more friendly interface to get such a report? (Other than manually constructing the URL with a path to the file)

There's an "llvm-cov" link in the left hand column on llvm.org that should take you to a list of all files.

[craig.topper]

LGTM

[bsmith]

I have reverted this patch in 7c68d4b8ff906ee97aa14c6ec97e19aaa766c08a as this code is still required for extracting fixed types from illegal scalable types on SVE, which is used for ACLE predicate types. We are lacking tests for this case, which I shall add.

llvm/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp

case ISD::MGATHER:  Res = PromoteIntOp_MGATHER(cast<MaskedGatherSDNode>(N),
                                                  OpNo); break;
   case ISD::MSCATTER: Res = PromoteIntOp_MSCATTER(cast<MaskedScatterSDNode>(N),
                                                   OpNo); break;
   case ISD::TRUNCATE:     Res = PromoteIntOp_TRUNCATE(N); break;
   case ISD::FP16_TO_FP:
   case ISD::UINT_TO_FP:   Res = PromoteIntOp_UINT_TO_FP(N); break;
   case ISD::STRICT_UINT_TO_FP:  Res = PromoteIntOp_STRICT_UINT_TO_FP(N); break;
   case ISD::ZERO_EXTEND:  Res = PromoteIntOp_ZERO_EXTEND(N); break;
-  case ISD::EXTRACT_SUBVECTOR: Res = PromoteIntOp_EXTRACT_SUBVECTOR(N); break;
   case ISD::INSERT_SUBVECTOR: Res = PromoteIntOp_INSERT_SUBVECTOR(N); break;
 
   case ISD::SHL:
   case ISD::SRA:
   case ISD::SRL:
   case ISD::ROTL:
   case ISD::ROTR: Res = PromoteIntOp_Shift(N); break;
 
SDValue DAGTypeLegalizer::PromoteIntOp_INSERT_SUBVECTOR(SDNode *N) {
   SDValue Idx = N->getOperand(2);
   EVT PromVT = EVT::getVectorVT(*DAG.getContext(),
                                 V1.getValueType().getVectorElementType(),
                                 V0.getValueType().getVectorElementCount());
   V0 = DAG.getAnyExtOrTrunc(V0, dl, PromVT);
   SDValue Ext = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, PromVT, V0, V1, Idx);
   return DAG.getAnyExtOrTrunc(Ext, dl, N->getValueType(0));
 }
 
-SDValue DAGTypeLegalizer::PromoteIntOp_EXTRACT_SUBVECTOR(SDNode *N) {
-  SDLoc dl(N);
-  SDValue V0 = GetPromotedInteger(N->getOperand(0));
-  MVT InVT = V0.getValueType().getSimpleVT();
-  MVT OutVT = MVT::getVectorVT(InVT.getVectorElementType(),
-                               N->getValueType(0).getVectorNumElements());
-  SDValue Ext = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OutVT, V0, N->getOperand(1));
-  return DAG.getNode(ISD::TRUNCATE, dl, N->getValueType(0), Ext);
-}
-
 SDValue DAGTypeLegalizer::PromoteIntOp_CONCAT_VECTORS(SDNode *N) {
   SDLoc dl(N);
 
   EVT ResVT = N->getValueType(0);
   unsigned NumElems = N->getNumOperands();
 
   if (ResVT.isScalableVector()) {
     SDValue ResVec = DAG.getUNDEF(ResVT);
 

llvm/lib/CodeGen/SelectionDAG/LegalizeTypes.h

private:
   SDValue PromoteIntOp_ATOMIC_STORE(AtomicSDNode *N);
   SDValue PromoteIntOp_BITCAST(SDNode *N);
   SDValue PromoteIntOp_BUILD_PAIR(SDNode *N);
   SDValue PromoteIntOp_BR_CC(SDNode *N, unsigned OpNo);
   SDValue PromoteIntOp_BRCOND(SDNode *N, unsigned OpNo);
   SDValue PromoteIntOp_BUILD_VECTOR(SDNode *N);
   SDValue PromoteIntOp_INSERT_VECTOR_ELT(SDNode *N, unsigned OpNo);
   SDValue PromoteIntOp_EXTRACT_VECTOR_ELT(SDNode *N);
-  SDValue PromoteIntOp_EXTRACT_SUBVECTOR(SDNode *N);
   SDValue PromoteIntOp_INSERT_SUBVECTOR(SDNode *N);
   SDValue PromoteIntOp_CONCAT_VECTORS(SDNode *N);
   SDValue PromoteIntOp_SCALAR_TO_VECTOR(SDNode *N);
   SDValue PromoteIntOp_SPLAT_VECTOR(SDNode *N);
   SDValue PromoteIntOp_SELECT(SDNode *N, unsigned OpNo);
   SDValue PromoteIntOp_SELECT_CC(SDNode *N, unsigned OpNo);
   SDValue PromoteIntOp_SETCC(SDNode *N, unsigned OpNo);
   SDValue PromoteIntOp_Shift(SDNode *N);