[VPlan] Add initial anlysis to infer scalar type of VPValues. #69013
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,232 @@ | ||
| //===- VPlanAnalysis.cpp - Various Analyses working on VPlan ----*- C++ -*-===// | ||
| // | ||
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | ||
| // See https://llvm.org/LICENSE.txt for license information. | ||
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
|
|
||
| #include "VPlanAnalysis.h" | ||
| #include "VPlan.h" | ||
| #include "llvm/ADT/TypeSwitch.h" | ||
|
|
||
| using namespace llvm; | ||
|
|
||
| #define DEBUG_TYPE "vplan" | ||
|
|
||
| Type *VPTypeAnalysis::inferScalarTypeForRecipe(const VPBlendRecipe *R) { | ||
| Type *ResTy = inferScalarType(R->getIncomingValue(0)); | ||
| for (unsigned I = 1, E = R->getNumIncomingValues(); I != E; ++I) { | ||
| VPValue *Inc = R->getIncomingValue(I); | ||
| assert(inferScalarType(Inc) == ResTy && | ||
| "different types inferred for different incoming values"); | ||
| CachedTypes[Inc] = ResTy; | ||
| } | ||
| return ResTy; | ||
| } | ||
|
|
||
| Type *VPTypeAnalysis::inferScalarTypeForRecipe(const VPInstruction *R) { | ||
| switch (R->getOpcode()) { | ||
| case Instruction::Select: { | ||
| Type *ResTy = inferScalarType(R->getOperand(1)); | ||
| VPValue *OtherV = R->getOperand(2); | ||
| assert(inferScalarType(OtherV) == ResTy && | ||
| "different types inferred for different operands"); | ||
| CachedTypes[OtherV] = ResTy; | ||
| return ResTy; | ||
| } | ||
| case VPInstruction::FirstOrderRecurrenceSplice: { | ||
| Type *ResTy = inferScalarType(R->getOperand(0)); | ||
| VPValue *OtherV = R->getOperand(1); | ||
| assert(inferScalarType(OtherV) == ResTy && | ||
| "different types inferred for different operands"); | ||
| CachedTypes[OtherV] = ResTy; | ||
| return ResTy; | ||
| } | ||
| default: | ||
| break; | ||
| } | ||
|
There was a problem hiding this comment. Ah, this works w/o return nor unreachable at the end? Very well. Perhaps worth a comment. Switch below should be consistent, i.e., with an unreachable default but no return at the unreachable end. There was a problem hiding this comment. I updated it to move the unreachable out of the switch here as well |
||
| // Type inference not implemented for opcode. | ||
| LLVM_DEBUG({ | ||
| dbgs() << "LV: Found unhandled opcode for: "; | ||
| R->getVPSingleValue()->dump(); | ||
| }); | ||
| llvm_unreachable("Unhandled opcode!"); | ||
| } | ||
|
|
||
| Type *VPTypeAnalysis::inferScalarTypeForRecipe(const VPWidenRecipe *R) { | ||
| unsigned Opcode = R->getOpcode(); | ||
| switch (Opcode) { | ||
| case Instruction::ICmp: | ||
| case Instruction::FCmp: | ||
| return IntegerType::get(Ctx, 1); | ||
| case Instruction::UDiv: | ||
| case Instruction::SDiv: | ||
| case Instruction::SRem: | ||
| case Instruction::URem: | ||
| case Instruction::Add: | ||
| case Instruction::FAdd: | ||
| case Instruction::Sub: | ||
| case Instruction::FSub: | ||
| case Instruction::Mul: | ||
| case Instruction::FMul: | ||
| case Instruction::FDiv: | ||
| case Instruction::FRem: | ||
| case Instruction::Shl: | ||
| case Instruction::LShr: | ||
| case Instruction::AShr: | ||
| case Instruction::And: | ||
| case Instruction::Or: | ||
| case Instruction::Xor: { | ||
| Type *ResTy = inferScalarType(R->getOperand(0)); | ||
| assert(ResTy == inferScalarType(R->getOperand(1)) && | ||
| "types for both operands must match for binary op"); | ||
| CachedTypes[R->getOperand(1)] = ResTy; | ||
| return ResTy; | ||
| } | ||
| case Instruction::FNeg: | ||
| case Instruction::Freeze: | ||
| return inferScalarType(R->getOperand(0)); | ||
| default: | ||
| break; | ||
| } | ||
|
|
||
| // Type inference not implemented for opcode. | ||
| LLVM_DEBUG({ | ||
| dbgs() << "LV: Found unhandled opcode for: "; | ||
| R->getVPSingleValue()->dump(); | ||
| }); | ||
| llvm_unreachable("Unhandled opcode!"); | ||
| } | ||
|
|
||
| Type *VPTypeAnalysis::inferScalarTypeForRecipe(const VPWidenCallRecipe *R) { | ||
| auto &CI = *cast<CallInst>(R->getUnderlyingInstr()); | ||
| return CI.getType(); | ||
| } | ||
|
|
||
| Type *VPTypeAnalysis::inferScalarTypeForRecipe( | ||
| const VPWidenMemoryInstructionRecipe *R) { | ||
| assert(!R->isStore() && "Store recipes should not define any values"); | ||
| return cast<LoadInst>(&R->getIngredient())->getType(); | ||
| } | ||
|
|
||
| Type *VPTypeAnalysis::inferScalarTypeForRecipe(const VPWidenSelectRecipe *R) { | ||
| Type *ResTy = inferScalarType(R->getOperand(1)); | ||
| VPValue *OtherV = R->getOperand(2); | ||
| assert(inferScalarType(OtherV) == ResTy && | ||
| "different types inferred for different operands"); | ||
| CachedTypes[OtherV] = ResTy; | ||
| return ResTy; | ||
| } | ||
|
|
||
| Type *VPTypeAnalysis::inferScalarTypeForRecipe(const VPReplicateRecipe *R) { | ||
| switch (R->getUnderlyingInstr()->getOpcode()) { | ||
| case Instruction::Call: { | ||
| unsigned CallIdx = R->getNumOperands() - (R->isPredicated() ? 2 : 1); | ||
| return cast<Function>(R->getOperand(CallIdx)->getLiveInIRValue()) | ||
| ->getReturnType(); | ||
| } | ||
| case Instruction::UDiv: | ||
| case Instruction::SDiv: | ||
| case Instruction::SRem: | ||
| case Instruction::URem: | ||
| case Instruction::Add: | ||
| case Instruction::FAdd: | ||
| case Instruction::Sub: | ||
| case Instruction::FSub: | ||
| case Instruction::Mul: | ||
| case Instruction::FMul: | ||
| case Instruction::FDiv: | ||
| case Instruction::FRem: | ||
| case Instruction::Shl: | ||
| case Instruction::LShr: | ||
| case Instruction::AShr: | ||
| case Instruction::And: | ||
| case Instruction::Or: | ||
| case Instruction::Xor: { | ||
| Type *ResTy = inferScalarType(R->getOperand(0)); | ||
| assert(ResTy == inferScalarType(R->getOperand(1)) && | ||
| "inferred types for operands of binary op don't match"); | ||
| CachedTypes[R->getOperand(1)] = ResTy; | ||
| return ResTy; | ||
| } | ||
| case Instruction::Select: { | ||
| Type *ResTy = inferScalarType(R->getOperand(1)); | ||
| assert(ResTy == inferScalarType(R->getOperand(2)) && | ||
| "inferred types for operands of select op don't match"); | ||
| CachedTypes[R->getOperand(2)] = ResTy; | ||
| return ResTy; | ||
| } | ||
| case Instruction::ICmp: | ||
| case Instruction::FCmp: | ||
| return IntegerType::get(Ctx, 1); | ||
| case Instruction::Alloca: | ||
| case Instruction::BitCast: | ||
| case Instruction::Trunc: | ||
| case Instruction::SExt: | ||
| case Instruction::ZExt: | ||
| case Instruction::FPExt: | ||
| case Instruction::FPTrunc: | ||
| case Instruction::ExtractValue: | ||
| case Instruction::SIToFP: | ||
| case Instruction::UIToFP: | ||
| case Instruction::FPToSI: | ||
| case Instruction::FPToUI: | ||
| case Instruction::PtrToInt: | ||
| case Instruction::IntToPtr: | ||
| return R->getUnderlyingInstr()->getType(); | ||
|
|
||
| case Instruction::Freeze: | ||
| case Instruction::FNeg: | ||
| case Instruction::GetElementPtr: | ||
| return inferScalarType(R->getOperand(0)); | ||
| case Instruction::Load: | ||
| return cast<LoadInst>(R->getUnderlyingInstr())->getType(); | ||
|
There was a problem hiding this comment. Does it matter that the underlying value is a LoadInst? Also supply the type of values being stored? There was a problem hiding this comment.
It's an extra consistency check.
There was a problem hiding this comment.
LoadInst deserves an extra consistency check that truncation and extends do not?
Stores cannot be reached indirectly, but one can query their type directly, and one did provide support for querying the type of a widened stores above and interleaved stored below. Treatment should be consistent regardless of how stores are handled (replicated, widened, interleaved). If querying the type of stores is forbidden, it should be documented. There was a problem hiding this comment. The interface returns the type of the defined value of the inputs (the public interface computes the type for a VPValue). As stores won't define a result, no type can be queried for them. Does that make sense? |
||
| default: | ||
| break; | ||
|
There was a problem hiding this comment. switches with return/unreachable cases/default should be handled consistently. There was a problem hiding this comment. Should be handled consistently now, by sinking |
||
| } | ||
| // Type inference not implemented for opcode. | ||
| LLVM_DEBUG({ | ||
| dbgs() << "LV: Found unhandled opcode for: "; | ||
| R->getVPSingleValue()->dump(); | ||
| }); | ||
| llvm_unreachable("Unhandled opcode"); | ||
| } | ||
|
|
||
| Type *VPTypeAnalysis::inferScalarType(const VPValue *V) { | ||
| if (Type *CachedTy = CachedTypes.lookup(V)) | ||
| return CachedTy; | ||
|
|
||
| if (V->isLiveIn()) | ||
| return V->getLiveInIRValue()->getType(); | ||
|
|
||
| Type *ResultTy = | ||
| TypeSwitch<const VPRecipeBase *, Type *>(V->getDefiningRecipe()) | ||
| .Case<VPCanonicalIVPHIRecipe, VPFirstOrderRecurrencePHIRecipe, | ||
| VPReductionPHIRecipe, VPWidenPointerInductionRecipe>( | ||
| [this](const auto *R) { | ||
| // Handle header phi recipes, except VPWienIntOrFpInduction | ||
| // which needs special handling due it being possibly truncated. | ||
|
There was a problem hiding this comment. nit/TODO: consider inferring/caching type of siblings, e.g., backedge value, here and in cases below. |
||
| // TODO: consider inferring/caching type of siblings, e.g., | ||
| // backedge value, here and in cases below. | ||
| return inferScalarType(R->getStartValue()); | ||
| }) | ||
| .Case<VPWidenIntOrFpInductionRecipe, VPDerivedIVRecipe>( | ||
| [](const auto *R) { return R->getScalarType(); }) | ||
| .Case<VPPredInstPHIRecipe, VPWidenPHIRecipe, VPScalarIVStepsRecipe, | ||
| VPWidenGEPRecipe>([this](const VPRecipeBase *R) { | ||
| return inferScalarType(R->getOperand(0)); | ||
| }) | ||
| .Case<VPBlendRecipe, VPInstruction, VPWidenRecipe, VPReplicateRecipe, | ||
| VPWidenCallRecipe, VPWidenMemoryInstructionRecipe, | ||
| VPWidenSelectRecipe>( | ||
| [this](const auto *R) { return inferScalarTypeForRecipe(R); }) | ||
| .Case<VPInterleaveRecipe>([V](const VPInterleaveRecipe *R) { | ||
| // TODO: Use info from interleave group. | ||
| return V->getUnderlyingValue()->getType(); | ||
| }) | ||
| .Case<VPWidenCastRecipe>( | ||
| [](const VPWidenCastRecipe *R) { return R->getResultType(); }); | ||
| assert(ResultTy && "could not infer type for the given VPValue"); | ||
| CachedTypes[V] = ResultTy; | ||
| return ResultTy; | ||
| } | ||
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Check should appear in execute, of every recipe (fine to add others later), but easier for replicate recipe to have it here, once?
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Yep it is simpler here, as the current structure of VPReplicateRecipe::execute uses earlier exits for different cases