Skip to content

Commit 954a110

Browse files
wangpc-ppwangpc-pp
committed
[RISCV] Convert some predicates to TIIPredicate
These predicates can also be used in macro fusion and scheduling model.
1 parent 53a8b89 commit 954a110

File tree

8 files changed

+192
-158
lines changed

8 files changed

+192
-158
lines changed

‎llvm/lib/Target/RISCV/RISCV.td

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,12 @@ include "RISCVCallingConv.td"
3636
include "RISCVInstrInfo.td"
3737
include "GISel/RISCVRegisterBanks.td"
3838

39+
//===----------------------------------------------------------------------===//
40+
// Instruction predicates
41+
//===----------------------------------------------------------------------===//
42+
43+
include "RISCVInstrPredicates.td"
44+
3945
//===----------------------------------------------------------------------===//
4046
// RISC-V macro fusions.
4147
//===----------------------------------------------------------------------===//

‎llvm/lib/Target/RISCV/RISCVISelLowering.cpp

Lines changed: 2 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -20574,23 +20574,6 @@ static MachineBasicBlock *emitBuildPairF64Pseudo(MachineInstr &MI,
2057420574
return BB;
2057520575
}
2057620576

20577-
static bool isSelectPseudo(MachineInstr &MI) {
20578-
switch (MI.getOpcode()) {
20579-
default:
20580-
return false;
20581-
case RISCV::Select_GPR_Using_CC_GPR:
20582-
case RISCV::Select_GPR_Using_CC_Imm:
20583-
case RISCV::Select_FPR16_Using_CC_GPR:
20584-
case RISCV::Select_FPR16INX_Using_CC_GPR:
20585-
case RISCV::Select_FPR32_Using_CC_GPR:
20586-
case RISCV::Select_FPR32INX_Using_CC_GPR:
20587-
case RISCV::Select_FPR64_Using_CC_GPR:
20588-
case RISCV::Select_FPR64INX_Using_CC_GPR:
20589-
case RISCV::Select_FPR64IN32X_Using_CC_GPR:
20590-
return true;
20591-
}
20592-
}
20593-
2059420577
static MachineBasicBlock *emitQuietFCMP(MachineInstr &MI, MachineBasicBlock *BB,
2059520578
unsigned RelOpcode, unsigned EqOpcode,
2059620579
const RISCVSubtarget &Subtarget) {
@@ -20786,7 +20769,7 @@ static MachineBasicBlock *emitSelectPseudo(MachineInstr &MI,
2078620769
SequenceMBBI != E; ++SequenceMBBI) {
2078720770
if (SequenceMBBI->isDebugInstr())
2078820771
continue;
20789-
if (isSelectPseudo(*SequenceMBBI)) {
20772+
if (RISCVInstrInfo::isSelectPseudo(*SequenceMBBI)) {
2079020773
if (SequenceMBBI->getOperand(1).getReg() != LHS ||
2079120774
!SequenceMBBI->getOperand(2).isReg() ||
2079220775
SequenceMBBI->getOperand(2).getReg() != RHS ||
@@ -20863,7 +20846,7 @@ static MachineBasicBlock *emitSelectPseudo(MachineInstr &MI,
2086320846
auto InsertionPoint = TailMBB->begin();
2086420847
while (SelectMBBI != SelectEnd) {
2086520848
auto Next = std::next(SelectMBBI);
20866-
if (isSelectPseudo(*SelectMBBI)) {
20849+
if (RISCVInstrInfo::isSelectPseudo(*SelectMBBI)) {
2086720850
// %Result = phi [ %TrueValue, HeadMBB ], [ %FalseValue, IfFalseMBB ]
2086820851
BuildMI(*TailMBB, InsertionPoint, SelectMBBI->getDebugLoc(),
2086920852
TII.get(RISCV::PHI), SelectMBBI->getOperand(0).getReg())

‎llvm/lib/Target/RISCV/RISCVInsertVSETVLI.cpp

Lines changed: 26 additions & 100 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,7 @@
2525
//===----------------------------------------------------------------------===//
2626

2727
#include "RISCV.h"
28+
#include "RISCVInstrInfo.h"
2829
#include "RISCVSubtarget.h"
2930
#include "llvm/ADT/Statistic.h"
3031
#include "llvm/CodeGen/LiveDebugVariables.h"
@@ -69,78 +70,6 @@ static unsigned getSEWOpNum(const MachineInstr &MI) {
6970
return RISCVII::getSEWOpNum(MI.getDesc());
7071
}
7172

72-
static bool isVectorConfigInstr(const MachineInstr &MI) {
73-
return MI.getOpcode() == RISCV::PseudoVSETVLI ||
74-
MI.getOpcode() == RISCV::PseudoVSETVLIX0 ||
75-
MI.getOpcode() == RISCV::PseudoVSETIVLI;
76-
}
77-
78-
/// Return true if this is 'vsetvli x0, x0, vtype' which preserves
79-
/// VL and only sets VTYPE.
80-
static bool isVLPreservingConfig(const MachineInstr &MI) {
81-
if (MI.getOpcode() != RISCV::PseudoVSETVLIX0)
82-
return false;
83-
assert(RISCV::X0 == MI.getOperand(1).getReg());
84-
return RISCV::X0 == MI.getOperand(0).getReg();
85-
}
86-
87-
static bool isFloatScalarMoveOrScalarSplatInstr(const MachineInstr &MI) {
88-
switch (RISCV::getRVVMCOpcode(MI.getOpcode())) {
89-
default:
90-
return false;
91-
case RISCV::VFMV_S_F:
92-
case RISCV::VFMV_V_F:
93-
return true;
94-
}
95-
}
96-
97-
static bool isVExtractInstr(const MachineInstr &MI) {
98-
return RISCV::getRVVMCOpcode(MI.getOpcode()) == RISCV::RI_VEXTRACT;
99-
}
100-
101-
static bool isScalarExtractInstr(const MachineInstr &MI) {
102-
switch (RISCV::getRVVMCOpcode(MI.getOpcode())) {
103-
default:
104-
return false;
105-
case RISCV::VMV_X_S:
106-
case RISCV::VFMV_F_S:
107-
return true;
108-
}
109-
}
110-
111-
static bool isScalarInsertInstr(const MachineInstr &MI) {
112-
switch (RISCV::getRVVMCOpcode(MI.getOpcode())) {
113-
default:
114-
return false;
115-
case RISCV::VMV_S_X:
116-
case RISCV::VFMV_S_F:
117-
return true;
118-
}
119-
}
120-
121-
static bool isScalarSplatInstr(const MachineInstr &MI) {
122-
switch (RISCV::getRVVMCOpcode(MI.getOpcode())) {
123-
default:
124-
return false;
125-
case RISCV::VMV_V_I:
126-
case RISCV::VMV_V_X:
127-
case RISCV::VFMV_V_F:
128-
return true;
129-
}
130-
}
131-
132-
static bool isVSlideInstr(const MachineInstr &MI) {
133-
switch (RISCV::getRVVMCOpcode(MI.getOpcode())) {
134-
default:
135-
return false;
136-
case RISCV::VSLIDEDOWN_VX:
137-
case RISCV::VSLIDEDOWN_VI:
138-
case RISCV::VSLIDEUP_VX:
139-
case RISCV::VSLIDEUP_VI:
140-
return true;
141-
}
142-
}
143-
14473
/// Get the EEW for a load or store instruction. Return std::nullopt if MI is
14574
/// not a load or store which ignores SEW.
14675
static std::optional<unsigned> getEEWForLoadStore(const MachineInstr &MI) {
@@ -170,13 +99,6 @@ static std::optional<unsigned> getEEWForLoadStore(const MachineInstr &MI) {
17099
}
171100
}
172101

173-
static bool isNonZeroLoadImmediate(const MachineInstr &MI) {
174-
return MI.getOpcode() == RISCV::ADDI &&
175-
MI.getOperand(1).isReg() && MI.getOperand(2).isImm() &&
176-
MI.getOperand(1).getReg() == RISCV::X0 &&
177-
MI.getOperand(2).getImm() != 0;
178-
}
179-
180102
/// Return true if this is an operation on mask registers. Note that
181103
/// this includes both arithmetic/logical ops and load/store (vlm/vsm).
182104
static bool isMaskRegOp(const MachineInstr &MI) {
@@ -462,7 +384,7 @@ DemandedFields getDemanded(const MachineInstr &MI, const RISCVSubtarget *ST) {
462384
}
463385

464386
// For vmv.s.x and vfmv.s.f, there are only two behaviors, VL = 0 and VL > 0.
465-
if (isScalarInsertInstr(MI)) {
387+
if (RISCVInstrInfo::isScalarInsertInstr(MI)) {
466388
Res.LMUL = DemandedFields::LMULNone;
467389
Res.SEWLMULRatio = false;
468390
Res.VLAny = false;
@@ -473,7 +395,8 @@ DemandedFields getDemanded(const MachineInstr &MI, const RISCVSubtarget *ST) {
473395
// tail lanes to either be the original value or -1. We are writing
474396
// unknown bits to the lanes here.
475397
if (hasUndefinedPassthru(MI)) {
476-
if (isFloatScalarMoveOrScalarSplatInstr(MI) && !ST->hasVInstructionsF64())
398+
if (RISCVInstrInfo::isFloatScalarMoveOrScalarSplatInstr(MI) &&
399+
!ST->hasVInstructionsF64())
477400
Res.SEW = DemandedFields::SEWGreaterThanOrEqualAndLessThan64;
478401
else
479402
Res.SEW = DemandedFields::SEWGreaterThanOrEqual;
@@ -482,7 +405,7 @@ DemandedFields getDemanded(const MachineInstr &MI, const RISCVSubtarget *ST) {
482405
}
483406

484407
// vmv.x.s, and vfmv.f.s are unconditional and ignore everything except SEW.
485-
if (isScalarExtractInstr(MI)) {
408+
if (RISCVInstrInfo::isScalarExtractInstr(MI)) {
486409
assert(!RISCVII::hasVLOp(TSFlags));
487410
Res.LMUL = DemandedFields::LMULNone;
488411
Res.SEWLMULRatio = false;
@@ -500,8 +423,8 @@ DemandedFields getDemanded(const MachineInstr &MI, const RISCVSubtarget *ST) {
500423
// non-zero VL. We could generalize this if we had a VL > C predicate.
501424
// * The LMUL1 restriction is for machines whose latency may depend on VL.
502425
// * As above, this is only legal for tail "undefined" not "agnostic".
503-
if (isVSlideInstr(MI) && VLOp.isImm() && VLOp.getImm() == 1 &&
504-
hasUndefinedPassthru(MI)) {
426+
if (RISCVInstrInfo::isVSlideInstr(MI) && VLOp.isImm() &&
427+
VLOp.getImm() == 1 && hasUndefinedPassthru(MI)) {
505428
Res.VLAny = false;
506429
Res.VLZeroness = true;
507430
Res.LMUL = DemandedFields::LMULLessThanOrEqualToM1;
@@ -514,12 +437,13 @@ DemandedFields getDemanded(const MachineInstr &MI, const RISCVSubtarget *ST) {
514437
// it's place. Since a splat is non-constant time in LMUL, we do need to be
515438
// careful to not increase the number of active vector registers (unlike for
516439
// vmv.s.x.)
517-
if (isScalarSplatInstr(MI) && VLOp.isImm() && VLOp.getImm() == 1 &&
518-
hasUndefinedPassthru(MI)) {
440+
if (RISCVInstrInfo::isScalarSplatInstr(MI) && VLOp.isImm() &&
441+
VLOp.getImm() == 1 && hasUndefinedPassthru(MI)) {
519442
Res.LMUL = DemandedFields::LMULLessThanOrEqualToM1;
520443
Res.SEWLMULRatio = false;
521444
Res.VLAny = false;
522-
if (isFloatScalarMoveOrScalarSplatInstr(MI) && !ST->hasVInstructionsF64())
445+
if (RISCVInstrInfo::isFloatScalarMoveOrScalarSplatInstr(MI) &&
446+
!ST->hasVInstructionsF64())
523447
Res.SEW = DemandedFields::SEWGreaterThanOrEqualAndLessThan64;
524448
else
525449
Res.SEW = DemandedFields::SEWGreaterThanOrEqual;
@@ -542,7 +466,7 @@ DemandedFields getDemanded(const MachineInstr &MI, const RISCVSubtarget *ST) {
542466
Res.MaskPolicy = false;
543467
}
544468

545-
if (isVExtractInstr(MI)) {
469+
if (RISCVInstrInfo::isVExtractInstr(MI)) {
546470
assert(!RISCVII::hasVLOp(TSFlags));
547471
// TODO: LMUL can be any larger value (without cost)
548472
Res.TailPolicy = false;
@@ -661,7 +585,7 @@ class VSETVLIInfo {
661585
return getAVLImm() > 0;
662586
if (hasAVLReg()) {
663587
if (auto *DefMI = getAVLDefMI(LIS))
664-
return isNonZeroLoadImmediate(*DefMI);
588+
return RISCVInstrInfo::isNonZeroLoadImmediate(*DefMI);
665589
}
666590
if (hasAVLVLMAX())
667591
return true;
@@ -989,7 +913,7 @@ void RISCVInsertVSETVLI::forwardVSETVLIAVL(VSETVLIInfo &Info) const {
989913
if (!Info.hasAVLReg())
990914
return;
991915
const MachineInstr *DefMI = Info.getAVLDefMI(LIS);
992-
if (!DefMI || !isVectorConfigInstr(*DefMI))
916+
if (!DefMI || !RISCVInstrInfo::isVectorConfigInstr(*DefMI))
993917
return;
994918
VSETVLIInfo DefInstrInfo = getInfoForVSETVLI(*DefMI);
995919
if (!DefInstrInfo.hasSameVLMAX(Info))
@@ -1095,7 +1019,8 @@ RISCVInsertVSETVLI::computeInfoForInstr(const MachineInstr &MI) const {
10951019
InstrInfo.setAVLRegDef(VNI, VLOp.getReg());
10961020
}
10971021
} else {
1098-
assert(isScalarExtractInstr(MI) || isVExtractInstr(MI));
1022+
assert(RISCVInstrInfo::isScalarExtractInstr(MI) ||
1023+
RISCVInstrInfo::isVExtractInstr(MI));
10991024
// Pick a random value for state tracking purposes, will be ignored via
11001025
// the demanded fields mechanism
11011026
InstrInfo.setAVLImm(1);
@@ -1136,7 +1061,7 @@ void RISCVInsertVSETVLI::insertVSETVLI(MachineBasicBlock &MBB,
11361061
// same, we can use the X0, X0 form.
11371062
if (Info.hasSameVLMAX(PrevInfo) && Info.hasAVLReg()) {
11381063
if (const MachineInstr *DefMI = Info.getAVLDefMI(LIS);
1139-
DefMI && isVectorConfigInstr(*DefMI)) {
1064+
DefMI && RISCVInstrInfo::isVectorConfigInstr(*DefMI)) {
11401065
VSETVLIInfo DefInfo = getInfoForVSETVLI(*DefMI);
11411066
if (DefInfo.hasSameAVL(PrevInfo) && DefInfo.hasSameVLMAX(PrevInfo)) {
11421067
auto MI = BuildMI(MBB, InsertPt, DL, TII->get(RISCV::PseudoVSETVLIX0))
@@ -1314,7 +1239,7 @@ void RISCVInsertVSETVLI::transferBefore(VSETVLIInfo &Info,
13141239
// reflect the changes MI might make.
13151240
void RISCVInsertVSETVLI::transferAfter(VSETVLIInfo &Info,
13161241
const MachineInstr &MI) const {
1317-
if (isVectorConfigInstr(MI)) {
1242+
if (RISCVInstrInfo::isVectorConfigInstr(MI)) {
13181243
Info = getInfoForVSETVLI(MI);
13191244
return;
13201245
}
@@ -1349,7 +1274,8 @@ bool RISCVInsertVSETVLI::computeVLVTYPEChanges(const MachineBasicBlock &MBB,
13491274
for (const MachineInstr &MI : MBB) {
13501275
transferBefore(Info, MI);
13511276

1352-
if (isVectorConfigInstr(MI) || RISCVII::hasSEWOp(MI.getDesc().TSFlags) ||
1277+
if (RISCVInstrInfo::isVectorConfigInstr(MI) ||
1278+
RISCVII::hasSEWOp(MI.getDesc().TSFlags) ||
13531279
isVectorCopy(ST->getRegisterInfo(), MI))
13541280
HadVectorOp = true;
13551281

@@ -1439,7 +1365,7 @@ bool RISCVInsertVSETVLI::needVSETVLIPHI(const VSETVLIInfo &Require,
14391365
if (!Value)
14401366
return true;
14411367
MachineInstr *DefMI = LIS->getInstructionFromIndex(Value->def);
1442-
if (!DefMI || !isVectorConfigInstr(*DefMI))
1368+
if (!DefMI || !RISCVInstrInfo::isVectorConfigInstr(*DefMI))
14431369
return true;
14441370

14451371
// We found a VSET(I)VLI make sure it matches the output of the
@@ -1470,7 +1396,7 @@ void RISCVInsertVSETVLI::emitVSETVLIs(MachineBasicBlock &MBB) {
14701396
transferBefore(CurInfo, MI);
14711397

14721398
// If this is an explicit VSETVLI or VSETIVLI, update our state.
1473-
if (isVectorConfigInstr(MI)) {
1399+
if (RISCVInstrInfo::isVectorConfigInstr(MI)) {
14741400
// Conservatively, mark the VL and VTYPE as live.
14751401
assert(MI.getOperand(3).getReg() == RISCV::VL &&
14761402
MI.getOperand(4).getReg() == RISCV::VTYPE &&
@@ -1677,12 +1603,12 @@ bool RISCVInsertVSETVLI::canMutatePriorConfig(
16771603
// If the VL values aren't equal, return false if either a) the former is
16781604
// demanded, or b) we can't rewrite the former to be the later for
16791605
// implementation reasons.
1680-
if (!isVLPreservingConfig(MI)) {
1606+
if (!RISCVInstrInfo::isVLPreservingConfig(MI)) {
16811607
if (Used.VLAny)
16821608
return false;
16831609

16841610
if (Used.VLZeroness) {
1685-
if (isVLPreservingConfig(PrevMI))
1611+
if (RISCVInstrInfo::isVLPreservingConfig(PrevMI))
16861612
return false;
16871613
if (!getInfoForVSETVLI(PrevMI).hasEquallyZeroAVL(getInfoForVSETVLI(MI),
16881614
LIS))
@@ -1733,7 +1659,7 @@ void RISCVInsertVSETVLI::coalesceVSETVLIs(MachineBasicBlock &MBB) const {
17331659

17341660
for (MachineInstr &MI : make_early_inc_range(reverse(MBB))) {
17351661

1736-
if (!isVectorConfigInstr(MI)) {
1662+
if (!RISCVInstrInfo::isVectorConfigInstr(MI)) {
17371663
Used.doUnion(getDemanded(MI, ST));
17381664
if (MI.isCall() || MI.isInlineAsm() ||
17391665
MI.modifiesRegister(RISCV::VL, /*TRI=*/nullptr) ||
@@ -1757,7 +1683,7 @@ void RISCVInsertVSETVLI::coalesceVSETVLIs(MachineBasicBlock &MBB) const {
17571683
}
17581684

17591685
if (canMutatePriorConfig(MI, *NextMI, Used)) {
1760-
if (!isVLPreservingConfig(*NextMI)) {
1686+
if (!RISCVInstrInfo::isVLPreservingConfig(*NextMI)) {
17611687
Register DefReg = NextMI->getOperand(0).getReg();
17621688

17631689
MI.getOperand(0).setReg(DefReg);

‎llvm/lib/Target/RISCV/RISCVInsertWriteVXRM.cpp

Lines changed: 3 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,7 @@
2727

2828
#include "MCTargetDesc/RISCVBaseInfo.h"
2929
#include "RISCV.h"
30+
#include "RISCVInstrInfo.h"
3031
#include "RISCVSubtarget.h"
3132
#include "llvm/CodeGen/MachineFunctionPass.h"
3233
#include <queue>
@@ -227,23 +228,13 @@ char RISCVInsertWriteVXRM::ID = 0;
227228
INITIALIZE_PASS(RISCVInsertWriteVXRM, DEBUG_TYPE, RISCV_INSERT_WRITE_VXRM_NAME,
228229
false, false)
229230

230-
static bool ignoresVXRM(const MachineInstr &MI) {
231-
switch (RISCV::getRVVMCOpcode(MI.getOpcode())) {
232-
default:
233-
return false;
234-
case RISCV::VNCLIP_WI:
235-
case RISCV::VNCLIPU_WI:
236-
return MI.getOperand(3).getImm() == 0;
237-
}
238-
}
239-
240231
bool RISCVInsertWriteVXRM::computeVXRMChanges(const MachineBasicBlock &MBB) {
241232
BlockData &BBInfo = BlockInfo[MBB.getNumber()];
242233

243234
bool NeedVXRMWrite = false;
244235
for (const MachineInstr &MI : MBB) {
245236
int VXRMIdx = RISCVII::getVXRMOpNum(MI.getDesc());
246-
if (VXRMIdx >= 0 && !ignoresVXRM(MI)) {
237+
if (VXRMIdx >= 0 && !RISCVInstrInfo::ignoresVXRM(MI)) {
247238
unsigned NewVXRMImm = MI.getOperand(VXRMIdx).getImm();
248239

249240
if (!BBInfo.VXRMUse.isValid())
@@ -401,7 +392,7 @@ void RISCVInsertWriteVXRM::emitWriteVXRM(MachineBasicBlock &MBB) {
401392

402393
for (MachineInstr &MI : MBB) {
403394
int VXRMIdx = RISCVII::getVXRMOpNum(MI.getDesc());
404-
if (VXRMIdx >= 0 && !ignoresVXRM(MI)) {
395+
if (VXRMIdx >= 0 && !RISCVInstrInfo::ignoresVXRM(MI)) {
405396
unsigned NewVXRMImm = MI.getOperand(VXRMIdx).getImm();
406397

407398
if (PendingInsert || !Info.isStatic() ||

0 commit comments

Comments
 (0)