Skip to content

Commit 4371c2f

Browse files
fhahnfhahn
committed
[LV] Add support for cmp reductions with decreasing IVs.
Similar to FindLastIV, add FindFirstIV to support select (icmp(), x, y) reductions where one of x or y is a decreasing induction. This is done via a new recurrence kind FindFirstIV, which selects the first value from the reduction vector using umax instead of the last value (FindLastIV). It uses unsigned max as sentinel value. Alternatively we could consolidate FindFirstIV/FindLastIV in a single FindIV kind, and add a field indicating if whether we want to select the first or last value.
1 parent 4504e77 commit 4371c2f

File tree

12 files changed

+477
-110
lines changed

12 files changed

+477
-110
lines changed

‎llvm/include/llvm/Analysis/IVDescriptors.h

Lines changed: 29 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -57,11 +57,14 @@ enum class RecurKind {
5757
IFindLastIV, ///< FindLast reduction with select(icmp(),x,y) where one of
5858
///< (x,y) is increasing loop induction, and both x and y are
5959
///< integer type.
60-
FFindLastIV ///< FindLast reduction with select(fcmp(),x,y) where one of (x,y)
61-
///< is increasing loop induction, and both x and y are integer
62-
///< type.
63-
// TODO: Any_of and FindLast reduction need not be restricted to integer type
64-
// only.
60+
FFindLastIV, ///< FindLast reduction with select(fcmp(),x,y) where one of (x,y)
61+
///< is increasing loop induction, and both x and y are integer
62+
///< type.
63+
FindFirstIV /// FindLast reduction with select(icmp(),x,y) where one of
64+
///< (x,y) is a decreasing loop induction, and both x and y are
65+
///< integer type.
66+
// TODO: Any_of, FindLast and FindFirst reduction need not be restricted to
67+
// integer type only.
6568
};
6669

6770
/// The RecurrenceDescriptor is used to identify recurrences variables in a
@@ -163,12 +166,13 @@ class RecurrenceDescriptor {
163166
/// Returns a struct describing whether the instruction is either a
164167
/// Select(ICmp(A, B), X, Y), or
165168
/// Select(FCmp(A, B), X, Y)
166-
/// where one of (X, Y) is an increasing loop induction variable, and the
167-
/// other is a PHI value.
169+
/// where one of (X, Y) is an increasing (FindLast) or decreasing (FindFirst)
170+
/// loop induction variable, and the other is a PHI value.
168171
// TODO: Support non-monotonic variable. FindLast does not need be restricted
169172
// to increasing loop induction variables.
170-
static InstDesc isFindLastIVPattern(Loop *TheLoop, PHINode *OrigPhi,
171-
Instruction *I, ScalarEvolution &SE);
173+
static InstDesc isFindIVPattern(RecurKind Kind, Loop *TheLoop,
174+
PHINode *OrigPhi, Instruction *I,
175+
ScalarEvolution &SE);
172176

173177
/// Returns a struct describing if the instruction is a
174178
/// Select(FCmp(X, Y), (Z = X op PHINode), PHINode) instruction pattern.
@@ -262,17 +266,29 @@ class RecurrenceDescriptor {
262266
return Kind == RecurKind::IFindLastIV || Kind == RecurKind::FFindLastIV;
263267
}
264268

269+
/// Returns true if the recurrence kind is of the form
270+
/// select(cmp(),x,y) where one of (x,y) is an increasing or decreasing loop
271+
/// induction.
272+
static bool isFindIVRecurrenceKind(RecurKind Kind) {
273+
return Kind == RecurKind::IFindLastIV || Kind == RecurKind::FFindLastIV ||
274+
Kind == RecurKind::FindFirstIV;
275+
}
276+
265277
/// Returns the type of the recurrence. This type can be narrower than the
266278
/// actual type of the Phi if the recurrence has been type-promoted.
267279
Type *getRecurrenceType() const { return RecurrenceType; }
268280

269-
/// Returns the sentinel value for FindLastIV recurrences to replace the start
281+
/// Returns the sentinel value for FindFirstIV &FindLastIV recurrences to replace the start
270282
/// value.
271283
Value *getSentinelValue() const {
272-
assert(isFindLastIVRecurrenceKind(Kind) && "Unexpected recurrence kind");
273284
Type *Ty = StartValue->getType();
274-
return ConstantInt::get(Ty,
275-
APInt::getSignedMinValue(Ty->getIntegerBitWidth()));
285+
if (isFindLastIVRecurrenceKind(Kind))
286+
return ConstantInt::get(
287+
Ty, APInt::getSignedMinValue(Ty->getIntegerBitWidth()));
288+
else {
289+
assert(Kind == RecurKind::FindFirstIV);
290+
return ConstantInt::get(Ty, APInt::getMaxValue(Ty->getIntegerBitWidth()));
291+
}
276292
}
277293

278294
/// Returns a reference to the instructions used for type-promoting the

‎llvm/lib/Analysis/IVDescriptors.cpp

Lines changed: 30 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -53,6 +53,7 @@ bool RecurrenceDescriptor::isIntegerRecurrenceKind(RecurKind Kind) {
5353
case RecurKind::FAnyOf:
5454
case RecurKind::IFindLastIV:
5555
case RecurKind::FFindLastIV:
56+
case RecurKind::FindFirstIV:
5657
return true;
5758
}
5859
return false;
@@ -688,8 +689,9 @@ RecurrenceDescriptor::isAnyOfPattern(Loop *Loop, PHINode *OrigPhi,
688689
// value of the data type or a non-constant value by using mask and multiple
689690
// reduction operations.
690691
RecurrenceDescriptor::InstDesc
691-
RecurrenceDescriptor::isFindLastIVPattern(Loop *TheLoop, PHINode *OrigPhi,
692-
Instruction *I, ScalarEvolution &SE) {
692+
RecurrenceDescriptor::isFindIVPattern(RecurKind Kind, Loop *TheLoop,
693+
PHINode *OrigPhi, Instruction *I,
694+
ScalarEvolution &SE) {
693695
// TODO: Support the vectorization of FindLastIV when the reduction phi is
694696
// used by more than one select instruction. This vectorization is only
695697
// performed when the SCEV of each increasing induction variable used by the
@@ -705,7 +707,7 @@ RecurrenceDescriptor::isFindLastIVPattern(Loop *TheLoop, PHINode *OrigPhi,
705707
m_Value(NonRdxPhi)))))
706708
return InstDesc(false, I);
707709

708-
auto IsIncreasingLoopInduction = [&](Value *V) {
710+
auto IsSupportedLoopInduction = [&](Value *V) {
709711
Type *Ty = V->getType();
710712
if (!SE.isSCEVable(Ty))
711713
return false;
@@ -715,20 +717,26 @@ RecurrenceDescriptor::isFindLastIVPattern(Loop *TheLoop, PHINode *OrigPhi,
715717
return false;
716718

717719
const SCEV *Step = AR->getStepRecurrence(SE);
718-
if (!SE.isKnownPositive(Step))
720+
if (Kind == RecurKind::FindFirstIV) {
721+
if (!SE.isKnownNegative(Step))
722+
return false;
723+
} else if (!SE.isKnownPositive(Step))
719724
return false;
720725

721726
const ConstantRange IVRange = SE.getSignedRange(AR);
722727
unsigned NumBits = Ty->getIntegerBitWidth();
723-
// Keep the minimum value of the recurrence type as the sentinel value.
724-
// The maximum acceptable range for the increasing induction variable,
725-
// called the valid range, will be defined as
728+
// Keep the minimum (FindLast) or maximum (FindFirst) value of the
729+
// recurrence type as the sentinel value. The maximum acceptable range for
730+
// the induction variable, called the valid range, will be defined as
726731
// [<sentinel value> + 1, <sentinel value>)
727-
// where <sentinel value> is SignedMin(<recurrence type>)
732+
// where <sentinel value> is SignedMin(<recurrence type>) for FindLast or
733+
// UnsignedMax(<recurrence type>) for FindFirst.
728734
// TODO: This range restriction can be lifted by adding an additional
729735
// virtual OR reduction.
730-
const APInt Sentinel = APInt::getSignedMinValue(NumBits);
731-
const ConstantRange ValidRange =
736+
const APInt Sentinel = Kind == RecurKind::FindFirstIV
737+
? APInt::getMaxValue(NumBits)
738+
: APInt::getSignedMinValue(NumBits);
739+
ConstantRange ValidRange =
732740
ConstantRange::getNonEmpty(Sentinel + 1, Sentinel);
733741
LLVM_DEBUG(dbgs() << "LV: FindLastIV valid range is " << ValidRange
734742
<< ", and the signed range of " << *AR << " is "
@@ -741,10 +749,11 @@ RecurrenceDescriptor::isFindLastIVPattern(Loop *TheLoop, PHINode *OrigPhi,
741749
// We are looking for selects of the form:
742750
// select(cmp(), phi, increasing_loop_induction) or
743751
// select(cmp(), increasing_loop_induction, phi)
744-
// TODO: Support for monotonically decreasing induction variable
745-
if (!IsIncreasingLoopInduction(NonRdxPhi))
752+
if (!IsSupportedLoopInduction(NonRdxPhi))
746753
return InstDesc(false, I);
747754

755+
if (Kind == RecurKind::FindFirstIV)
756+
return InstDesc(I, Kind);
748757
return InstDesc(I, isa<ICmpInst>(I->getOperand(0)) ? RecurKind::IFindLastIV
749758
: RecurKind::FFindLastIV);
750759
}
@@ -883,8 +892,8 @@ RecurrenceDescriptor::InstDesc RecurrenceDescriptor::isRecurrenceInstr(
883892
if (Kind == RecurKind::FAdd || Kind == RecurKind::FMul ||
884893
Kind == RecurKind::Add || Kind == RecurKind::Mul)
885894
return isConditionalRdxPattern(Kind, I);
886-
if (isFindLastIVRecurrenceKind(Kind) && SE)
887-
return isFindLastIVPattern(L, OrigPhi, I, *SE);
895+
if (isFindIVRecurrenceKind(Kind) && SE)
896+
return isFindIVPattern(Kind, L, OrigPhi, I, *SE);
888897
[[fallthrough]];
889898
case Instruction::FCmp:
890899
case Instruction::ICmp:
@@ -1002,6 +1011,12 @@ bool RecurrenceDescriptor::isReductionPHI(PHINode *Phi, Loop *TheLoop,
10021011
<< "FindLastIV reduction PHI." << *Phi << "\n");
10031012
return true;
10041013
}
1014+
if (AddReductionVar(Phi, RecurKind::FindFirstIV, TheLoop, FMF, RedDes, DB, AC,
1015+
DT, SE)) {
1016+
LLVM_DEBUG(dbgs() << "Found a FindFirstV reduction PHI." << *Phi << "\n");
1017+
return true;
1018+
}
1019+
10051020
if (AddReductionVar(Phi, RecurKind::FMul, TheLoop, FMF, RedDes, DB, AC, DT,
10061021
SE)) {
10071022
LLVM_DEBUG(dbgs() << "Found an FMult reduction PHI." << *Phi << "\n");
@@ -1171,6 +1186,7 @@ unsigned RecurrenceDescriptor::getOpcode(RecurKind Kind) {
11711186
case RecurKind::UMin:
11721187
case RecurKind::IAnyOf:
11731188
case RecurKind::IFindLastIV:
1189+
case RecurKind::FindFirstIV:
11741190
return Instruction::ICmp;
11751191
case RecurKind::FMax:
11761192
case RecurKind::FMin:

‎llvm/lib/Transforms/Utils/LoopUtils.cpp

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1244,12 +1244,14 @@ Value *llvm::createAnyOfReduction(IRBuilderBase &Builder, Value *Src,
12441244
Value *llvm::createFindLastIVReduction(IRBuilderBase &Builder, Value *Src,
12451245
Value *Start,
12461246
const RecurrenceDescriptor &Desc) {
1247-
assert(RecurrenceDescriptor::isFindLastIVRecurrenceKind(
1248-
Desc.getRecurrenceKind()) &&
1249-
"Unexpected reduction kind");
1247+
assert(
1248+
RecurrenceDescriptor::isFindIVRecurrenceKind(Desc.getRecurrenceKind()) &&
1249+
"Unexpected reduction kind");
12501250
Value *Sentinel = Desc.getSentinelValue();
12511251
Value *MaxRdx = Src->getType()->isVectorTy()
1252-
? Builder.CreateIntMaxReduce(Src, true)
1252+
? (Desc.getRecurrenceKind() == RecurKind::FindFirstIV
1253+
? Builder.CreateIntMinReduce(Src, false)
1254+
: Builder.CreateIntMaxReduce(Src, true))
12531255
: Src;
12541256
// Correct the final reduction result back to the start value if the maximum
12551257
// reduction is sentinel value.
@@ -1345,8 +1347,8 @@ Value *llvm::createSimpleReduction(IRBuilderBase &Builder, Value *Src,
13451347
Value *llvm::createSimpleReduction(VectorBuilder &VBuilder, Value *Src,
13461348
RecurKind Kind) {
13471349
assert(!RecurrenceDescriptor::isAnyOfRecurrenceKind(Kind) &&
1348-
!RecurrenceDescriptor::isFindLastIVRecurrenceKind(Kind) &&
1349-
"AnyOf or FindLastIV reductions are not supported.");
1350+
!RecurrenceDescriptor::isFindIVRecurrenceKind(Kind) &&
1351+
"AnyOf, FindFirstIV and FindLastIV reductions are not supported.");
13501352
Intrinsic::ID Id = getReductionIntrinsicID(Kind);
13511353
auto *SrcTy = cast<VectorType>(Src->getType());
13521354
Type *SrcEltTy = SrcTy->getElementType();

‎llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -5173,7 +5173,7 @@ LoopVectorizationCostModel::selectInterleaveCount(VPlan &Plan, ElementCount VF,
51735173
const RecurrenceDescriptor &RdxDesc = Reduction.second;
51745174
RecurKind RK = RdxDesc.getRecurrenceKind();
51755175
return RecurrenceDescriptor::isAnyOfRecurrenceKind(RK) ||
5176-
RecurrenceDescriptor::isFindLastIVRecurrenceKind(RK);
5176+
RecurrenceDescriptor::isFindIVRecurrenceKind(RK);
51775177
});
51785178
if (HasSelectCmpReductions) {
51795179
LLVM_DEBUG(dbgs() << "LV: Not interleaving select-cmp reductions.\n");
@@ -7726,7 +7726,7 @@ static void fixReductionScalarResumeWhenVectorizingEpilog(
77267726
auto *EpiRedResult = dyn_cast<VPInstruction>(R);
77277727
if (!EpiRedResult ||
77287728
(EpiRedResult->getOpcode() != VPInstruction::ComputeReductionResult &&
7729-
EpiRedResult->getOpcode() != VPInstruction::ComputeFindLastIVResult))
7729+
EpiRedResult->getOpcode() != VPInstruction::ComputeFindIVResult))
77307730
return;
77317731

77327732
auto *EpiRedHeaderPhi =
@@ -7744,7 +7744,7 @@ static void fixReductionScalarResumeWhenVectorizingEpilog(
77447744
"AnyOf expected to start by comparing main resume value to original "
77457745
"start value");
77467746
MainResumeValue = Cmp->getOperand(0);
7747-
} else if (RecurrenceDescriptor::isFindLastIVRecurrenceKind(
7747+
} else if (RecurrenceDescriptor::isFindIVRecurrenceKind(
77487748
RdxDesc.getRecurrenceKind())) {
77497749
using namespace llvm::PatternMatch;
77507750
Value *Cmp, *OrigResumeV, *CmpOp;
@@ -9760,7 +9760,7 @@ void LoopVectorizationPlanner::adjustRecipesForReductions(
97609760
RecurKind Kind = RdxDesc.getRecurrenceKind();
97619761
assert(
97629762
!RecurrenceDescriptor::isAnyOfRecurrenceKind(Kind) &&
9763-
!RecurrenceDescriptor::isFindLastIVRecurrenceKind(Kind) &&
9763+
!RecurrenceDescriptor::isFindIVRecurrenceKind(Kind) &&
97649764
"AnyOf and FindLast reductions are not allowed for in-loop reductions");
97659765

97669766
// Collect the chain of "link" recipes for the reduction starting at PhiR.
@@ -9917,7 +9917,7 @@ void LoopVectorizationPlanner::adjustRecipesForReductions(
99179917
(cast<VPInstruction>(&U)->getOpcode() ==
99189918
VPInstruction::ComputeReductionResult ||
99199919
cast<VPInstruction>(&U)->getOpcode() ==
9920-
VPInstruction::ComputeFindLastIVResult);
9920+
VPInstruction::ComputeFindIVResult);
99219921
});
99229922
if (CM.usePredicatedReductionSelect())
99239923
PhiR->setOperand(1, NewExitingVPV);
@@ -9962,11 +9962,11 @@ void LoopVectorizationPlanner::adjustRecipesForReductions(
99629962
VPInstruction *FinalReductionResult;
99639963
VPBuilder::InsertPointGuard Guard(Builder);
99649964
Builder.setInsertPoint(MiddleVPBB, IP);
9965-
if (RecurrenceDescriptor::isFindLastIVRecurrenceKind(
9965+
if (RecurrenceDescriptor::isFindIVRecurrenceKind(
99669966
RdxDesc.getRecurrenceKind())) {
99679967
VPValue *Start = PhiR->getStartValue();
99689968
FinalReductionResult =
9969-
Builder.createNaryOp(VPInstruction::ComputeFindLastIVResult,
9969+
Builder.createNaryOp(VPInstruction::ComputeFindIVResult,
99709970
{PhiR, Start, NewExitingVPV}, ExitDL);
99719971
} else {
99729972
FinalReductionResult = Builder.createNaryOp(
@@ -10013,11 +10013,11 @@ void LoopVectorizationPlanner::adjustRecipesForReductions(
1001310013
continue;
1001410014
}
1001510015

10016-
if (RecurrenceDescriptor::isFindLastIVRecurrenceKind(
10016+
if (RecurrenceDescriptor::isFindIVRecurrenceKind(
1001710017
RdxDesc.getRecurrenceKind())) {
10018-
// Adjust the start value for FindLastIV recurrences to use the sentinel
10019-
// value after generating the ResumePhi recipe, which uses the original
10020-
// start value.
10018+
// Adjust the start value for FindFirstIV/FindLastIV recurrences to use
10019+
// the sentinel value after generating the ResumePhi recipe, which uses
10020+
// the original start value.
1002110021
PhiR->setOperand(0, Plan->getOrAddLiveIn(RdxDesc.getSentinelValue()));
1002210022
}
1002310023
}
@@ -10385,7 +10385,7 @@ static void preparePlanForMainVectorLoop(VPlan &MainPlan, VPlan &EpiPlan) {
1038510385
VPlanTransforms::runPass(VPlanTransforms::removeDeadRecipes, MainPlan);
1038610386

1038710387
using namespace VPlanPatternMatch;
10388-
// When vectorizing the epilogue, FindLastIV reductions can introduce multiple
10388+
// When vectorizing the epilogue, FindFirstIV & FindLastIV reductions can introduce multiple
1038910389
// uses of undef/poison. If the reduction start value may be undef or poison
1039010390
// it needs to be frozen and the frozen start has to be used when computing
1039110391
// the reduction result. We also need to use the frozen value in the resume
@@ -10396,7 +10396,7 @@ static void preparePlanForMainVectorLoop(VPlan &MainPlan, VPlan &EpiPlan) {
1039610396
VPBuilder Builder(Plan.getEntry());
1039710397
for (VPRecipeBase &R : *Plan.getMiddleBlock()) {
1039810398
auto *VPI = dyn_cast<VPInstruction>(&R);
10399-
if (!VPI || VPI->getOpcode() != VPInstruction::ComputeFindLastIVResult)
10399+
if (!VPI || VPI->getOpcode() != VPInstruction::ComputeFindIVResult)
1040010400
continue;
1040110401
VPValue *OrigStart = VPI->getOperand(1);
1040210402
if (isGuaranteedNotToBeUndefOrPoison(OrigStart->getLiveInIRValue()))
@@ -10507,17 +10507,17 @@ preparePlanForEpilogueVectorLoop(VPlan &Plan, Loop *L,
1050710507
IRBuilder<> Builder(PBB, PBB->getFirstNonPHIIt());
1050810508
ResumeV =
1050910509
Builder.CreateICmpNE(ResumeV, RdxDesc.getRecurrenceStartValue());
10510-
} else if (RecurrenceDescriptor::isFindLastIVRecurrenceKind(RK)) {
10510+
} else if (RecurrenceDescriptor::isFindIVRecurrenceKind(RK)) {
1051110511
ToFrozen[RdxDesc.getRecurrenceStartValue()] =
1051210512
cast<PHINode>(ResumeV)->getIncomingValueForBlock(
1051310513
EPI.MainLoopIterationCountCheck);
1051410514

10515-
// VPReductionPHIRecipe for FindLastIV reductions requires an adjustment
10516-
// to the resume value. The resume value is adjusted to the sentinel
10517-
// value when the final value from the main vector loop equals the start
10518-
// value. This ensures correctness when the start value might not be
10519-
// less than the minimum value of a monotonically increasing induction
10520-
// variable.
10515+
// VPReductionPHIRecipe for FindFirstIV/FindLastIV reductions requires
10516+
// an adjustment to the resume value. The resume value is adjusted to
10517+
// the sentinel value when the final value from the main vector loop
10518+
// equals the start value. This ensures correctness when the start value
10519+
// might not be less than the minimum value of a monotonically
10520+
// increasing induction variable.
1052110521
BasicBlock *ResumeBB = cast<Instruction>(ResumeV)->getParent();
1052210522
IRBuilder<> Builder(ResumeBB, ResumeBB->getFirstNonPHIIt());
1052310523
Value *Cmp = Builder.CreateICmpEQ(

‎llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -23250,6 +23250,7 @@ class HorizontalReduction {
2325023250
case RecurKind::FAnyOf:
2325123251
case RecurKind::IFindLastIV:
2325223252
case RecurKind::FFindLastIV:
23253+
case RecurKind::FindFirstIV:
2325323254
case RecurKind::FMaximumNum:
2325423255
case RecurKind::FMinimumNum:
2325523256
case RecurKind::None:
@@ -23386,6 +23387,7 @@ class HorizontalReduction {
2338623387
case RecurKind::FAnyOf:
2338723388
case RecurKind::IFindLastIV:
2338823389
case RecurKind::FFindLastIV:
23390+
case RecurKind::FindFirstIV:
2338923391
case RecurKind::FMaximumNum:
2339023392
case RecurKind::FMinimumNum:
2339123393
case RecurKind::None:
@@ -23487,6 +23489,7 @@ class HorizontalReduction {
2348723489
case RecurKind::FAnyOf:
2348823490
case RecurKind::IFindLastIV:
2348923491
case RecurKind::FFindLastIV:
23492+
case RecurKind::FindFirstIV:
2349023493
case RecurKind::FMaximumNum:
2349123494
case RecurKind::FMinimumNum:
2349223495
case RecurKind::None:

‎llvm/lib/Transforms/Vectorize/VPlan.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -898,7 +898,7 @@ class VPInstruction : public VPRecipeWithIRFlags,
898898
BranchOnCount,
899899
BranchOnCond,
900900
Broadcast,
901-
ComputeFindLastIVResult,
901+
ComputeFindIVResult,
902902
ComputeReductionResult,
903903
// Extracts the last lane from its operand if it is a vector, or the last
904904
// part if scalar. In the latter case, the recipe will be removed during

‎llvm/lib/Transforms/Vectorize/VPlanAnalysis.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -87,7 +87,7 @@ Type *VPTypeAnalysis::inferScalarTypeForRecipe(const VPInstruction *R) {
8787
inferScalarType(R->getOperand(1)) &&
8888
"different types inferred for different operands");
8989
return IntegerType::get(Ctx, 1);
90-
case VPInstruction::ComputeFindLastIVResult:
90+
case VPInstruction::ComputeFindIVResult:
9191
case VPInstruction::ComputeReductionResult: {
9292
auto *PhiR = cast<VPReductionPHIRecipe>(R->getOperand(0));
9393
auto *OrigPhi = cast<PHINode>(PhiR->getUnderlyingValue());

0 commit comments

Comments
 (0)