Skip to content

Commit 56b99f0

Browse files
topperctopperc
authored
[RISCV][GISel] Rename XLenVT sXLen to be consistent with other LLTs. (#70288)
This also renames DoubleXLenLLT to sDoubleXLen.
1 parent b165650 commit 56b99f0

File tree

2 files changed

+65
-79
lines changed

2 files changed

+65
-79
lines changed

‎llvm/lib/Target/RISCV/GISel/RISCVInstructionSelector.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -384,8 +384,8 @@ bool RISCVInstructionSelector::replacePtrWithInt(MachineOperand &Op,
384384
Register PtrReg = Op.getReg();
385385
assert(MRI.getType(PtrReg).isPointer() && "Operand is not a pointer!");
386386

387-
const LLT XLenLLT = LLT::scalar(STI.getXLen());
388-
auto PtrToInt = MIB.buildPtrToInt(XLenLLT, PtrReg);
387+
const LLT sXLen = LLT::scalar(STI.getXLen());
388+
auto PtrToInt = MIB.buildPtrToInt(sXLen, PtrReg);
389389
MRI.setRegBank(PtrToInt.getReg(0), RBI.getRegBank(RISCV::GPRRegBankID));
390390
Op.setReg(PtrToInt.getReg(0));
391391
return select(*PtrToInt);
@@ -397,11 +397,11 @@ void RISCVInstructionSelector::preISelLower(MachineInstr &MI,
397397
switch (MI.getOpcode()) {
398398
case TargetOpcode::G_PTR_ADD: {
399399
Register DstReg = MI.getOperand(0).getReg();
400-
const LLT XLenLLT = LLT::scalar(STI.getXLen());
400+
const LLT sXLen = LLT::scalar(STI.getXLen());
401401

402402
replacePtrWithInt(MI.getOperand(1), MIB, MRI);
403403
MI.setDesc(TII.get(TargetOpcode::G_ADD));
404-
MRI.setType(DstReg, XLenLLT);
404+
MRI.setType(DstReg, sXLen);
405405
break;
406406
}
407407
}

‎llvm/lib/Target/RISCV/GISel/RISCVLegalizerInfo.cpp

Lines changed: 61 additions & 75 deletions
Original file line numberDiff line numberDiff line change
@@ -23,8 +23,8 @@ using namespace LegalityPredicates;
2323

2424
RISCVLegalizerInfo::RISCVLegalizerInfo(const RISCVSubtarget &ST) {
2525
const unsigned XLen = ST.getXLen();
26-
const LLT XLenLLT = LLT::scalar(XLen);
27-
const LLT DoubleXLenLLT = LLT::scalar(2 * XLen);
26+
const LLT sXLen = LLT::scalar(XLen);
27+
const LLT sDoubleXLen = LLT::scalar(2 * XLen);
2828
const LLT p0 = LLT::pointer(0, XLen);
2929
const LLT s8 = LLT::scalar(8);
3030
const LLT s16 = LLT::scalar(16);
@@ -34,38 +34,35 @@ RISCVLegalizerInfo::RISCVLegalizerInfo(const RISCVSubtarget &ST) {
3434
using namespace TargetOpcode;
3535

3636
getActionDefinitionsBuilder({G_ADD, G_SUB, G_AND, G_OR, G_XOR})
37-
.legalFor({s32, XLenLLT})
37+
.legalFor({s32, sXLen})
3838
.widenScalarToNextPow2(0)
39-
.clampScalar(0, s32, XLenLLT);
39+
.clampScalar(0, s32, sXLen);
4040

4141
getActionDefinitionsBuilder(
4242
{G_UADDE, G_UADDO, G_USUBE, G_USUBO}).lower();
4343

44-
getActionDefinitionsBuilder({G_SADDO, G_SSUBO}).minScalar(0, XLenLLT).lower();
44+
getActionDefinitionsBuilder({G_SADDO, G_SSUBO}).minScalar(0, sXLen).lower();
4545

4646
getActionDefinitionsBuilder({G_ASHR, G_LSHR, G_SHL})
47-
.legalFor({{s32, s32}, {XLenLLT, XLenLLT}})
47+
.legalFor({{s32, s32}, {sXLen, sXLen}})
4848
.widenScalarToNextPow2(0)
49-
.clampScalar(1, s32, XLenLLT)
50-
.clampScalar(0, s32, XLenLLT)
49+
.clampScalar(1, s32, sXLen)
50+
.clampScalar(0, s32, sXLen)
5151
.minScalarSameAs(1, 0);
5252

5353
if (ST.is64Bit()) {
5454
getActionDefinitionsBuilder({G_ZEXT, G_SEXT, G_ANYEXT})
55-
.legalFor({{XLenLLT, s32}})
56-
.maxScalar(0, XLenLLT);
55+
.legalFor({{sXLen, s32}})
56+
.maxScalar(0, sXLen);
5757

5858
getActionDefinitionsBuilder(G_SEXT_INREG)
59-
.customFor({XLenLLT})
60-
.maxScalar(0, XLenLLT)
59+
.customFor({sXLen})
60+
.maxScalar(0, sXLen)
6161
.lower();
6262
} else {
63-
getActionDefinitionsBuilder({G_ZEXT, G_SEXT, G_ANYEXT})
64-
.maxScalar(0, XLenLLT);
63+
getActionDefinitionsBuilder({G_ZEXT, G_SEXT, G_ANYEXT}).maxScalar(0, sXLen);
6564

66-
getActionDefinitionsBuilder(G_SEXT_INREG)
67-
.maxScalar(0, XLenLLT)
68-
.lower();
65+
getActionDefinitionsBuilder(G_SEXT_INREG).maxScalar(0, sXLen).lower();
6966
}
7067

7168
// Merge/Unmerge
@@ -75,123 +72,112 @@ RISCVLegalizerInfo::RISCVLegalizerInfo(const RISCVSubtarget &ST) {
7572
getActionDefinitionsBuilder(Op)
7673
.widenScalarToNextPow2(LitTyIdx, XLen)
7774
.widenScalarToNextPow2(BigTyIdx, XLen)
78-
.clampScalar(LitTyIdx, XLenLLT, XLenLLT)
79-
.clampScalar(BigTyIdx, XLenLLT, XLenLLT);
75+
.clampScalar(LitTyIdx, sXLen, sXLen)
76+
.clampScalar(BigTyIdx, sXLen, sXLen);
8077
}
8178

8279
getActionDefinitionsBuilder({G_CONSTANT, G_IMPLICIT_DEF})
83-
.legalFor({s32, XLenLLT, p0})
80+
.legalFor({s32, sXLen, p0})
8481
.widenScalarToNextPow2(0)
85-
.clampScalar(0, s32, XLenLLT);
82+
.clampScalar(0, s32, sXLen);
8683

8784
getActionDefinitionsBuilder(G_ICMP)
88-
.legalFor({{XLenLLT, XLenLLT}, {XLenLLT, p0}})
85+
.legalFor({{sXLen, sXLen}, {sXLen, p0}})
8986
.widenScalarToNextPow2(1)
90-
.clampScalar(1, XLenLLT, XLenLLT)
91-
.clampScalar(0, XLenLLT, XLenLLT);
87+
.clampScalar(1, sXLen, sXLen)
88+
.clampScalar(0, sXLen, sXLen);
9289

9390
getActionDefinitionsBuilder(G_SELECT)
94-
.legalFor({{XLenLLT, XLenLLT}, {p0, XLenLLT}})
91+
.legalFor({{sXLen, sXLen}, {p0, sXLen}})
9592
.widenScalarToNextPow2(0)
96-
.clampScalar(0, XLenLLT, XLenLLT)
97-
.clampScalar(1, XLenLLT, XLenLLT);
93+
.clampScalar(0, sXLen, sXLen)
94+
.clampScalar(1, sXLen, sXLen);
9895

9996
getActionDefinitionsBuilder({G_LOAD, G_STORE})
10097
.legalForTypesWithMemDesc({{s32, p0, s8, 8},
10198
{s32, p0, s16, 16},
10299
{s32, p0, s32, 32},
103-
{XLenLLT, p0, s8, 8},
104-
{XLenLLT, p0, s16, 16},
105-
{XLenLLT, p0, s32, 32},
106-
{XLenLLT, p0, XLenLLT, XLen},
107-
{p0, p0, XLenLLT, XLen}})
108-
.clampScalar(0, s32, XLenLLT)
100+
{sXLen, p0, s8, 8},
101+
{sXLen, p0, s16, 16},
102+
{sXLen, p0, s32, 32},
103+
{sXLen, p0, sXLen, XLen},
104+
{p0, p0, sXLen, XLen}})
105+
.clampScalar(0, s32, sXLen)
109106
.lower();
110107

111-
auto &ExtLoadActions =
112-
getActionDefinitionsBuilder({G_SEXTLOAD, G_ZEXTLOAD})
113-
.legalForTypesWithMemDesc({{s32, p0, s8, 8},
114-
{s32, p0, s16, 16},
115-
{XLenLLT, p0, s8, 8},
116-
{XLenLLT, p0, s16, 16}});
108+
auto &ExtLoadActions = getActionDefinitionsBuilder({G_SEXTLOAD, G_ZEXTLOAD})
109+
.legalForTypesWithMemDesc({{s32, p0, s8, 8},
110+
{s32, p0, s16, 16},
111+
{sXLen, p0, s8, 8},
112+
{sXLen, p0, s16, 16}});
117113
if (XLen == 64)
118-
ExtLoadActions.legalForTypesWithMemDesc({{XLenLLT, p0, s32, 32}});
119-
ExtLoadActions
120-
.widenScalarToNextPow2(0)
121-
.clampScalar(0, s32, XLenLLT)
122-
.lower();
114+
ExtLoadActions.legalForTypesWithMemDesc({{sXLen, p0, s32, 32}});
115+
ExtLoadActions.widenScalarToNextPow2(0).clampScalar(0, s32, sXLen).lower();
123116

124-
getActionDefinitionsBuilder(G_PTR_ADD)
125-
.legalFor({{p0, XLenLLT}});
117+
getActionDefinitionsBuilder(G_PTR_ADD).legalFor({{p0, sXLen}});
126118

127119
getActionDefinitionsBuilder(G_PTRTOINT)
128-
.legalFor({{XLenLLT, p0}})
129-
.clampScalar(0, XLenLLT, XLenLLT);
120+
.legalFor({{sXLen, p0}})
121+
.clampScalar(0, sXLen, sXLen);
130122

131123
getActionDefinitionsBuilder(G_INTTOPTR)
132-
.legalFor({{p0, XLenLLT}})
133-
.clampScalar(1, XLenLLT, XLenLLT);
124+
.legalFor({{p0, sXLen}})
125+
.clampScalar(1, sXLen, sXLen);
134126

135-
getActionDefinitionsBuilder(G_BRCOND)
136-
.legalFor({XLenLLT})
137-
.minScalar(0, XLenLLT);
127+
getActionDefinitionsBuilder(G_BRCOND).legalFor({sXLen}).minScalar(0, sXLen);
138128

139129
getActionDefinitionsBuilder(G_PHI)
140-
.legalFor({p0, XLenLLT})
130+
.legalFor({p0, sXLen})
141131
.widenScalarToNextPow2(0)
142-
.clampScalar(0, XLenLLT, XLenLLT);
132+
.clampScalar(0, sXLen, sXLen);
143133

144134
getActionDefinitionsBuilder(G_GLOBAL_VALUE)
145135
.legalFor({p0});
146136

147137
if (ST.hasStdExtM() || ST.hasStdExtZmmul()) {
148138
getActionDefinitionsBuilder(G_MUL)
149-
.legalFor({s32, XLenLLT})
139+
.legalFor({s32, sXLen})
150140
.widenScalarToNextPow2(0)
151-
.clampScalar(0, s32, XLenLLT);
141+
.clampScalar(0, s32, sXLen);
152142

153143
// clang-format off
154144
getActionDefinitionsBuilder({G_SMULH, G_UMULH})
155-
.legalFor({XLenLLT})
145+
.legalFor({sXLen})
156146
.lower();
157147
// clang-format on
158148

159-
getActionDefinitionsBuilder({G_SMULO, G_UMULO})
160-
.minScalar(0, XLenLLT)
161-
.lower();
149+
getActionDefinitionsBuilder({G_SMULO, G_UMULO}).minScalar(0, sXLen).lower();
162150
} else {
163151
getActionDefinitionsBuilder(G_MUL)
164-
.libcallFor({XLenLLT, DoubleXLenLLT})
152+
.libcallFor({sXLen, sDoubleXLen})
165153
.widenScalarToNextPow2(0)
166-
.clampScalar(0, XLenLLT, DoubleXLenLLT);
154+
.clampScalar(0, sXLen, sDoubleXLen);
167155

168-
getActionDefinitionsBuilder({G_SMULH, G_UMULH}).lowerFor({XLenLLT});
156+
getActionDefinitionsBuilder({G_SMULH, G_UMULH}).lowerFor({sXLen});
169157

170158
getActionDefinitionsBuilder({G_SMULO, G_UMULO})
171-
.minScalar(0, XLenLLT)
172-
// Widen XLenLLT to DoubleXLenLLT so we can use a single libcall to get
159+
.minScalar(0, sXLen)
160+
// Widen sXLen to sDoubleXLen so we can use a single libcall to get
173161
// the low bits for the mul result and high bits to do the overflow
174162
// check.
175163
.widenScalarIf(
164+
[=](const LegalityQuery &Query) { return Query.Types[0] == sXLen; },
176165
[=](const LegalityQuery &Query) {
177-
return Query.Types[0] == XLenLLT;
178-
},
179-
[=](const LegalityQuery &Query) {
180-
return std::make_pair(0, DoubleXLenLLT);
166+
return std::make_pair(0, sDoubleXLen);
181167
})
182168
.lower();
183169
}
184170

185171
if (ST.hasStdExtM()) {
186172
getActionDefinitionsBuilder({G_UDIV, G_SDIV, G_UREM, G_SREM})
187-
.legalFor({s32, XLenLLT})
188-
.libcallFor({DoubleXLenLLT})
189-
.clampScalar(0, s32, DoubleXLenLLT)
173+
.legalFor({s32, sXLen})
174+
.libcallFor({sDoubleXLen})
175+
.clampScalar(0, s32, sDoubleXLen)
190176
.widenScalarToNextPow2(0);
191177
} else {
192178
getActionDefinitionsBuilder({G_UDIV, G_SDIV, G_UREM, G_SREM})
193-
.libcallFor({XLenLLT, DoubleXLenLLT})
194-
.clampScalar(0, XLenLLT, DoubleXLenLLT)
179+
.libcallFor({sXLen, sDoubleXLen})
180+
.clampScalar(0, sXLen, sDoubleXLen)
195181
.widenScalarToNextPow2(0);
196182
}
197183

0 commit comments

Comments
 (0)