From 7b787408b2e59a9873a4f13ecedc38ff39ab0704 Mon Sep 17 00:00:00 2001 From: Han-Kuan Chen Date: Fri, 3 Jan 2025 22:41:17 -0800 Subject: [PATCH] [SLP] NFC. Make InstructionsState support default constructor. Previously, InstructionsState::invalid was used to create an InstructionsState. However, since all of the member functions of InstructionsState are const, we don't need to consider that the state will change after it is created. Using the default constructor to represent the state as invalid is much simpler. --- .../Transforms/Vectorize/SLPVectorizer.cpp | 33 +++++++++---------- 1 file changed, 16 insertions(+), 17 deletions(-) diff --git a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp index c4582df89213d..ddface5cef32b 100644 --- a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp +++ b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp @@ -812,8 +812,8 @@ namespace { /// Main data required for vectorization of instructions. class InstructionsState { /// The main/alternate instruction. MainOp is also VL0. - Instruction *MainOp = nullptr; - Instruction *AltOp = nullptr; + Instruction *MainOp; + Instruction *AltOp; public: Instruction *getMainOp() const { @@ -844,10 +844,9 @@ class InstructionsState { explicit operator bool() const { return valid(); } - InstructionsState() = delete; + InstructionsState() : InstructionsState(nullptr, nullptr) {} InstructionsState(Instruction *MainOp, Instruction *AltOp) : MainOp(MainOp), AltOp(AltOp) {} - static InstructionsState invalid() { return {nullptr, nullptr}; } }; } // end anonymous namespace @@ -909,17 +908,17 @@ static InstructionsState getSameOpcode(ArrayRef VL, const TargetLibraryInfo &TLI) { // Make sure these are all Instructions. if (!all_of(VL, IsaPred)) - return InstructionsState::invalid(); + return InstructionsState(); auto *It = find_if(VL, IsaPred); if (It == VL.end()) - return InstructionsState::invalid(); + return InstructionsState(); Value *V = *It; unsigned InstCnt = std::count_if(It, VL.end(), IsaPred); if ((VL.size() > 2 && !isa(V) && InstCnt < VL.size() / 2) || (VL.size() == 2 && InstCnt < 2)) - return InstructionsState::invalid(); + return InstructionsState(); bool IsCastOp = isa(V); bool IsBinOp = isa(V); @@ -962,7 +961,7 @@ static InstructionsState getSameOpcode(ArrayRef VL, BaseID = getVectorIntrinsicIDForCall(CallBase, &TLI); BaseMappings = VFDatabase(*CallBase).getMappings(*CallBase); if (!isTriviallyVectorizable(BaseID) && BaseMappings.empty()) - return InstructionsState::invalid(); + return InstructionsState(); } bool AnyPoison = InstCnt != VL.size(); for (int Cnt = 0, E = VL.size(); Cnt < E; Cnt++) { @@ -974,7 +973,7 @@ static InstructionsState getSameOpcode(ArrayRef VL, // TODO: do some smart analysis of the CallInsts to exclude divide-like // intrinsics/functions only. if (AnyPoison && (I->isIntDivRem() || I->isFPDivRem() || isa(I))) - return InstructionsState::invalid(); + return InstructionsState(); unsigned InstOpcode = I->getOpcode(); if (IsBinOp && isa(I)) { if (InstOpcode == Opcode || InstOpcode == AltOpcode) @@ -1046,28 +1045,28 @@ static InstructionsState getSameOpcode(ArrayRef VL, if (auto *Gep = dyn_cast(I)) { if (Gep->getNumOperands() != 2 || Gep->getOperand(0)->getType() != IBase->getOperand(0)->getType()) - return InstructionsState::invalid(); + return InstructionsState(); } else if (auto *EI = dyn_cast(I)) { if (!isVectorLikeInstWithConstOps(EI)) - return InstructionsState::invalid(); + return InstructionsState(); } else if (auto *LI = dyn_cast(I)) { auto *BaseLI = cast(IBase); if (!LI->isSimple() || !BaseLI->isSimple()) - return InstructionsState::invalid(); + return InstructionsState(); } else if (auto *Call = dyn_cast(I)) { auto *CallBase = cast(IBase); if (Call->getCalledFunction() != CallBase->getCalledFunction()) - return InstructionsState::invalid(); + return InstructionsState(); if (Call->hasOperandBundles() && (!CallBase->hasOperandBundles() || !std::equal(Call->op_begin() + Call->getBundleOperandsStartIndex(), Call->op_begin() + Call->getBundleOperandsEndIndex(), CallBase->op_begin() + CallBase->getBundleOperandsStartIndex()))) - return InstructionsState::invalid(); + return InstructionsState(); Intrinsic::ID ID = getVectorIntrinsicIDForCall(Call, &TLI); if (ID != BaseID) - return InstructionsState::invalid(); + return InstructionsState(); if (!ID) { SmallVector Mappings = VFDatabase(*Call).getMappings(*Call); if (Mappings.size() != BaseMappings.size() || @@ -1077,12 +1076,12 @@ static InstructionsState getSameOpcode(ArrayRef VL, Mappings.front().Shape.VF != BaseMappings.front().Shape.VF || Mappings.front().Shape.Parameters != BaseMappings.front().Shape.Parameters) - return InstructionsState::invalid(); + return InstructionsState(); } } continue; } - return InstructionsState::invalid(); + return InstructionsState(); } return InstructionsState(cast(V),