Skip to content

Commit 8eed36b

Browse files
dipeshs809dipeshs809
committed
use legalFor for static checks
1 parent 6f4add3 commit 8eed36b

File tree

1 file changed

+84
-154
lines changed

1 file changed

+84
-154
lines changed

‎llvm/lib/Target/X86/GISel/X86LegalizerInfo.cpp

Lines changed: 84 additions & 154 deletions
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,8 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
4343
bool HasDQI = Subtarget.hasAVX512() && Subtarget.hasDQI();
4444
bool HasBWI = Subtarget.hasAVX512() && Subtarget.hasBWI();
4545
bool UseX87 = !Subtarget.useSoftFloat() && Subtarget.hasX87();
46+
bool HasPOPCNT = Subtarget.hasPOPCNT();
47+
bool HasLZCNT = Subtarget.hasLZCNT();
4648

4749
const LLT p0 = LLT::pointer(0, TM.getPointerSizeInBits(0));
4850
const LLT s1 = LLT::scalar(1);
@@ -56,7 +58,6 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
5658
const LLT v2s32 = LLT::fixed_vector(2, 32);
5759
const LLT v4s8 = LLT::fixed_vector(4, 8);
5860

59-
6061
const LLT v16s8 = LLT::fixed_vector(16, 8);
6162
const LLT v8s16 = LLT::fixed_vector(8, 16);
6263
const LLT v4s32 = LLT::fixed_vector(4, 32);
@@ -83,19 +84,15 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
8384

8485
// implicit/constants
8586
getActionDefinitionsBuilder(G_IMPLICIT_DEF)
86-
.legalIf([=](const LegalityQuery &Query) -> bool {
87-
// 32/64-bits needs support for s64/s128 to handle cases:
88-
// s64 = EXTEND (G_IMPLICIT_DEF s32) -> s64 = G_IMPLICIT_DEF
89-
// s128 = EXTEND (G_IMPLICIT_DEF s32/s64) -> s128 = G_IMPLICIT_DEF
90-
return typeInSet(0, {p0, s1, s8, s16, s32, s64})(Query) ||
91-
(Is64Bit && typeInSet(0, {s128})(Query));
92-
});
87+
.legalFor({p0, s1, s8, s16, s32, s64})
88+
.legalFor(Is64Bit, {s128});
89+
// 32/64-bits needs support for s64/s128 to handle cases:
90+
// s64 = EXTEND (G_IMPLICIT_DEF s32) -> s64 = G_IMPLICIT_DEF
91+
// s128 = EXTEND (G_IMPLICIT_DEF s32/s64) -> s128 = G_IMPLICIT_DEF
9392

9493
getActionDefinitionsBuilder(G_CONSTANT)
95-
.legalIf([=](const LegalityQuery &Query) -> bool {
96-
return typeInSet(0, {p0, s8, s16, s32})(Query) ||
97-
(Is64Bit && typeInSet(0, {s64})(Query));
98-
})
94+
.legalFor({p0, s8, s16, s32})
95+
.legalFor(Is64Bit, {s64})
9996
.widenScalarToNextPow2(0, /*Min=*/8)
10097
.clampScalar(0, s8, sMaxScalar);
10198

@@ -147,21 +144,12 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
147144

148145
// integer addition/subtraction
149146
getActionDefinitionsBuilder({G_ADD, G_SUB})
150-
.legalIf([=](const LegalityQuery &Query) -> bool {
151-
if (typeInSet(0, {s8, s16, s32})(Query))
152-
return true;
153-
if (Is64Bit && typeInSet(0, {s64})(Query))
154-
return true;
155-
if (HasSSE2 && typeInSet(0, {v16s8, v8s16, v4s32, v2s64})(Query))
156-
return true;
157-
if (HasAVX2 && typeInSet(0, {v32s8, v16s16, v8s32, v4s64})(Query))
158-
return true;
159-
if (HasAVX512 && typeInSet(0, {v16s32, v8s64})(Query))
160-
return true;
161-
if (HasBWI && typeInSet(0, {v64s8, v32s16})(Query))
162-
return true;
163-
return false;
164-
})
147+
.legalFor({s8, s16, s32})
148+
.legalFor(Is64Bit, {s64})
149+
.legalFor(HasSSE2, {v16s8, v8s16, v4s32, v2s64})
150+
.legalFor(HasAVX2, {v32s8, v16s16, v8s32, v4s64})
151+
.legalFor(HasAVX512, {v16s32, v8s64})
152+
.legalFor(HasBWI, {v64s8, v32s16})
165153
.clampMinNumElements(0, s8, 16)
166154
.clampMinNumElements(0, s16, 8)
167155
.clampMinNumElements(0, s32, 4)
@@ -175,38 +163,24 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
175163
.scalarize(0);
176164

177165
getActionDefinitionsBuilder({G_UADDE, G_UADDO, G_USUBE, G_USUBO})
178-
.legalIf([=](const LegalityQuery &Query) -> bool {
179-
return typePairInSet(0, 1, {{s8, s1}, {s16, s1}, {s32, s1}})(Query) ||
180-
(Is64Bit && typePairInSet(0, 1, {{s64, s1}})(Query));
181-
})
166+
.legalFor({{s8, s1}, {s16, s1}, {s32, s1}})
167+
.legalFor(Is64Bit, {{s64, s1}})
182168
.widenScalarToNextPow2(0, /*Min=*/32)
183169
.clampScalar(0, s8, sMaxScalar)
184170
.clampScalar(1, s1, s1)
185171
.scalarize(0);
186172

187173
// integer multiply
188174
getActionDefinitionsBuilder(G_MUL)
189-
.legalIf([=](const LegalityQuery &Query) -> bool {
190-
if (typeInSet(0, {s8, s16, s32})(Query))
191-
return true;
192-
if (Is64Bit && typeInSet(0, {s64})(Query))
193-
return true;
194-
if (HasSSE2 && typeInSet(0, {v8s16})(Query))
195-
return true;
196-
if (HasSSE41 && typeInSet(0, {v4s32})(Query))
197-
return true;
198-
if (HasAVX2 && typeInSet(0, {v16s16, v8s32})(Query))
199-
return true;
200-
if (HasAVX512 && typeInSet(0, {v16s32})(Query))
201-
return true;
202-
if (HasDQI && typeInSet(0, {v8s64})(Query))
203-
return true;
204-
if (HasDQI && HasVLX && typeInSet(0, {v2s64, v4s64})(Query))
205-
return true;
206-
if (HasBWI && typeInSet(0, {v32s16})(Query))
207-
return true;
208-
return false;
209-
})
175+
.legalFor({s8, s16, s32})
176+
.legalFor(Is64Bit, {s64})
177+
.legalFor(HasSSE2, {v8s16})
178+
.legalFor(HasSSE41, {v4s32})
179+
.legalFor(HasAVX2, {v16s16, v8s32})
180+
.legalFor(HasAVX512, {v16s32})
181+
.legalFor(HasDQI, {v8s64})
182+
.legalFor(HasDQI && HasVLX, {v2s64, v4s64})
183+
.legalFor(HasBWI, {v32s16})
210184
.clampMinNumElements(0, s16, 8)
211185
.clampMinNumElements(0, s32, 4)
212186
.clampMinNumElements(0, s64, HasVLX ? 2 : 8)
@@ -218,47 +192,33 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
218192
.scalarize(0);
219193

220194
getActionDefinitionsBuilder({G_SMULH, G_UMULH})
221-
.legalIf([=](const LegalityQuery &Query) -> bool {
222-
return typeInSet(0, {s8, s16, s32})(Query) ||
223-
(Is64Bit && typeInSet(0, {s64})(Query));
224-
})
195+
.legalFor({s8, s16, s32})
196+
.legalFor(Is64Bit, {s64})
225197
.widenScalarToNextPow2(0, /*Min=*/32)
226198
.clampScalar(0, s8, sMaxScalar)
227199
.scalarize(0);
228200

229201
// integer divisions
230202
getActionDefinitionsBuilder({G_SDIV, G_SREM, G_UDIV, G_UREM})
231-
.legalIf([=](const LegalityQuery &Query) -> bool {
232-
return typeInSet(0, {s8, s16, s32})(Query) ||
233-
(Is64Bit && typeInSet(0, {s64})(Query));
234-
})
203+
.legalFor({s8, s16, s32})
204+
.legalFor(Is64Bit, {s64})
235205
.libcallFor({s64})
236206
.clampScalar(0, s8, sMaxScalar);
237207

238208
// integer shifts
239209
getActionDefinitionsBuilder({G_SHL, G_LSHR, G_ASHR})
240-
.legalIf([=](const LegalityQuery &Query) -> bool {
241-
return typePairInSet(0, 1, {{s8, s8}, {s16, s8}, {s32, s8}})(Query) ||
242-
(Is64Bit && typePairInSet(0, 1, {{s64, s8}})(Query));
243-
})
210+
.legalFor({{s8, s8}, {s16, s8}, {s32, s8}})
211+
.legalFor(Is64Bit, {{s64, s8}})
244212
.clampScalar(0, s8, sMaxScalar)
245213
.clampScalar(1, s8, s8);
246214

247215
// integer logic
248216
getActionDefinitionsBuilder({G_AND, G_OR, G_XOR})
249-
.legalIf([=](const LegalityQuery &Query) -> bool {
250-
if (typeInSet(0, {s8, s16, s32})(Query))
251-
return true;
252-
if (Is64Bit && typeInSet(0, {s64})(Query))
253-
return true;
254-
if (HasSSE2 && typeInSet(0, {v16s8, v8s16, v4s32, v2s64})(Query))
255-
return true;
256-
if (HasAVX && typeInSet(0, {v32s8, v16s16, v8s32, v4s64})(Query))
257-
return true;
258-
if (HasAVX512 && typeInSet(0, {v64s8, v32s16, v16s32, v8s64})(Query))
259-
return true;
260-
return false;
261-
})
217+
.legalFor({s8, s16, s32})
218+
.legalFor(Is64Bit, {s64})
219+
.legalFor(HasSSE2, {v16s8, v8s16, v4s32, v2s64})
220+
.legalFor(HasAVX, {v32s8, v16s16, v8s32, v4s64})
221+
.legalFor(HasAVX512, {v64s8, v32s16, v16s32, v8s64})
262222
.clampMinNumElements(0, s8, 16)
263223
.clampMinNumElements(0, s16, 8)
264224
.clampMinNumElements(0, s32, 4)
@@ -282,31 +242,23 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
282242

283243
// bswap
284244
getActionDefinitionsBuilder(G_BSWAP)
285-
.legalIf([=](const LegalityQuery &Query) {
286-
return Query.Types[0] == s32 ||
287-
(Subtarget.is64Bit() && Query.Types[0] == s64);
288-
})
245+
.legalFor({s32})
246+
.legalFor(Is64Bit, {s64})
289247
.widenScalarToNextPow2(0, /*Min=*/32)
290248
.clampScalar(0, s32, sMaxScalar);
291249

292250
// popcount
293251
getActionDefinitionsBuilder(G_CTPOP)
294-
.legalIf([=](const LegalityQuery &Query) -> bool {
295-
return Subtarget.hasPOPCNT() &&
296-
(typePairInSet(0, 1, {{s16, s16}, {s32, s32}})(Query) ||
297-
(Is64Bit && typePairInSet(0, 1, {{s64, s64}})(Query)));
298-
})
252+
.legalFor(HasPOPCNT, {{s16, s16}, {s32, s32}})
253+
.legalFor(Is64Bit, {{s64, s64}})
299254
.widenScalarToNextPow2(1, /*Min=*/16)
300255
.clampScalar(1, s16, sMaxScalar)
301256
.scalarSameSizeAs(0, 1);
302257

303258
// count leading zeros (LZCNT)
304259
getActionDefinitionsBuilder(G_CTLZ)
305-
.legalIf([=](const LegalityQuery &Query) -> bool {
306-
return Subtarget.hasLZCNT() &&
307-
(typePairInSet(0, 1, {{s16, s16}, {s32, s32}})(Query) ||
308-
(Is64Bit && typePairInSet(0, 1, {{s64, s64}})(Query)));
309-
})
260+
.legalFor(HasLZCNT, {{s16, s16}, {s32, s32}})
261+
.legalFor(Is64Bit, {{s64, s64}})
310262
.widenScalarToNextPow2(1, /*Min=*/16)
311263
.clampScalar(1, s16, sMaxScalar)
312264
.scalarSameSizeAs(0, 1);
@@ -324,15 +276,12 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
324276

325277
// control flow
326278
getActionDefinitionsBuilder(G_PHI)
327-
.legalIf([=](const LegalityQuery &Query) -> bool {
328-
return typeInSet(0, {s8, s16, s32, p0})(Query) ||
329-
(UseX87 && typeIs(0, s80)(Query)) ||
330-
(Is64Bit && typeIs(0, s64)(Query)) ||
331-
(HasSSE1 && typeInSet(0, {v16s8, v8s16, v4s32, v2s64})(Query)) ||
332-
(HasAVX && typeInSet(0, {v32s8, v16s16, v8s32, v4s64})(Query)) ||
333-
(HasAVX512 &&
334-
typeInSet(0, {v64s8, v32s16, v16s32, v8s64})(Query));
335-
})
279+
.legalFor({s8, s16, s32, p0})
280+
.legalFor(UseX87, {s80})
281+
.legalFor(Is64Bit, {s64})
282+
.legalFor(HasSSE1, {v16s8, v8s16, v4s32, v2s64})
283+
.legalFor(HasAVX, {v32s8, v16s16, v8s32, v4s64})
284+
.legalFor(HasAVX512, {v64s8, v32s16, v16s32, v8s64})
336285
.clampMinNumElements(0, s8, 16)
337286
.clampMinNumElements(0, s16, 8)
338287
.clampMinNumElements(0, s32, 4)
@@ -361,10 +310,8 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
361310
getActionDefinitionsBuilder(G_CONSTANT_POOL).legalFor({p0});
362311

363312
getActionDefinitionsBuilder(G_PTR_ADD)
364-
.legalIf([=](const LegalityQuery &Query) -> bool {
365-
return typePairInSet(0, 1, {{p0, s32}})(Query) ||
366-
(Is64Bit && typePairInSet(0, 1, {{p0, s64}})(Query));
367-
})
313+
.legalFor({{p0, s32}})
314+
.legalFor(Is64Bit, {{p0, s64}})
368315
.widenScalarToNextPow2(1, /*Min*/ 32)
369316
.clampScalar(1, s32, sMaxScalar);
370317

@@ -450,21 +397,18 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
450397

451398
// fp constants
452399
getActionDefinitionsBuilder(G_FCONSTANT)
453-
.legalIf([=](const LegalityQuery &Query) -> bool {
454-
return (typeInSet(0, {s32, s64})(Query)) ||
455-
(UseX87 && typeInSet(0, {s80})(Query));
456-
});
400+
.legalFor({s32, s64})
401+
.legalFor(UseX87, {s80});
457402

458403
// fp arithmetic
459404
getActionDefinitionsBuilder({G_FADD, G_FSUB, G_FMUL, G_FDIV})
460-
.legalIf([=](const LegalityQuery &Query) {
461-
return (typeInSet(0, {s32, s64})(Query)) ||
462-
(HasSSE1 && typeInSet(0, {v4s32})(Query)) ||
463-
(HasSSE2 && typeInSet(0, {v2s64})(Query)) ||
464-
(HasAVX && typeInSet(0, {v8s32, v4s64})(Query)) ||
465-
(HasAVX512 && typeInSet(0, {v16s32, v8s64})(Query)) ||
466-
(UseX87 && typeInSet(0, {s80})(Query));
467-
});
405+
.legalFor({s32, s64})
406+
.legalFor(HasSSE1, {v4s32})
407+
.legalFor(HasSSE2, {v2s64})
408+
.legalFor(HasAVX, {v8s32, v4s64})
409+
.legalFor(HasAVX512, {v16s32, v8s64})
410+
.legalFor(UseX87, {s80});
411+
468412

469413
// fp comparison
470414
getActionDefinitionsBuilder(G_FCMP)
@@ -476,18 +420,15 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
476420
.widenScalarToNextPow2(1);
477421

478422
// fp conversions
479-
getActionDefinitionsBuilder(G_FPEXT).legalIf([=](const LegalityQuery &Query) {
480-
return (HasSSE2 && typePairInSet(0, 1, {{s64, s32}})(Query)) ||
481-
(HasAVX && typePairInSet(0, 1, {{v4s64, v4s32}})(Query)) ||
482-
(HasAVX512 && typePairInSet(0, 1, {{v8s64, v8s32}})(Query));
483-
});
484-
485-
getActionDefinitionsBuilder(G_FPTRUNC).legalIf(
486-
[=](const LegalityQuery &Query) {
487-
return (HasSSE2 && typePairInSet(0, 1, {{s32, s64}})(Query)) ||
488-
(HasAVX && typePairInSet(0, 1, {{v4s32, v4s64}})(Query)) ||
489-
(HasAVX512 && typePairInSet(0, 1, {{v8s32, v8s64}})(Query));
490-
});
423+
getActionDefinitionsBuilder(G_FPEXT)
424+
.legalFor(HasSSE2, {{s64, s32}})
425+
.legalFor(HasAVX, {{v4s64, v4s32}})
426+
.legalFor(HasAVX512, {{v8s64, v8s32}});
427+
428+
getActionDefinitionsBuilder(G_FPTRUNC)
429+
.legalFor(HasSSE2, {{s32, s64}})
430+
.legalFor(HasAVX, {{v4s32, v4s64}})
431+
.legalFor(HasAVX512, {{v8s32, v8s64}});
491432

492433
getActionDefinitionsBuilder(G_SITOFP)
493434
.legalFor(HasSSE1, {{s32, s32}})
@@ -518,11 +459,8 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
518459
//
519460
// For AVX512 we simply widen types as there is direct mapping from opcodes
520461
// to asm instructions.
521-
getActionDefinitionsBuilder(G_UITOFP)
522-
.legalIf([=](const LegalityQuery &Query) {
523-
return HasAVX512 && typeInSet(0, {s32, s64})(Query) &&
524-
typeInSet(1, {s32, s64})(Query);
525-
})
462+
getActionDefinitionsBuilder(G_UITOFP)
463+
.legalFor(HasAVX512, {{s32, s32}, {s32, s64}, {s64, s32}, {s64, s64}})
526464
.customIf([=](const LegalityQuery &Query) {
527465
return !HasAVX512 &&
528466
((HasSSE1 && typeIs(0, s32)(Query)) ||
@@ -541,11 +479,8 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
541479
.clampScalar(1, s32, sMaxScalar)
542480
.widenScalarToNextPow2(1);
543481

544-
getActionDefinitionsBuilder(G_FPTOUI)
545-
.legalIf([=](const LegalityQuery &Query) {
546-
return HasAVX512 && typeInSet(0, {s32, s64})(Query) &&
547-
typeInSet(1, {s32, s64})(Query);
548-
})
482+
getActionDefinitionsBuilder(G_FPTOUI)
483+
.legalFor(HasAVX512, {{s32, s32}, {s32, s64}, {s64, s32}, {s64, s64}})
549484
.customIf([=](const LegalityQuery &Query) {
550485
return !HasAVX512 &&
551486
((HasSSE1 && typeIs(1, s32)(Query)) ||
@@ -603,22 +538,17 @@ X86LegalizerInfo::X86LegalizerInfo(const X86Subtarget &STI,
603538

604539
// todo: only permit dst types up to max legal vector register size?
605540
getActionDefinitionsBuilder(G_CONCAT_VECTORS)
606-
.legalIf([=](const LegalityQuery &Query) {
607-
return (HasSSE1 && typePairInSet(1, 0,
608-
{{v16s8, v32s8},
609-
{v8s16, v16s16},
610-
{v4s32, v8s32},
611-
{v2s64, v4s64}})(Query)) ||
612-
(HasAVX && typePairInSet(1, 0,
613-
{{v16s8, v64s8},
614-
{v32s8, v64s8},
615-
{v8s16, v32s16},
616-
{v16s16, v32s16},
617-
{v4s32, v16s32},
618-
{v8s32, v16s32},
619-
{v2s64, v8s64},
620-
{v4s64, v8s64}})(Query));
621-
});
541+
.legalFor(
542+
HasSSE1,
543+
{{v32s8, v16s8}, {v16s16, v8s16}, {v8s32, v4s32}, {v4s64, v2s64}})
544+
.legalFor(HasAVX, {{v64s8, v16s8},
545+
{v64s8, v32s8},
546+
{v32s16, v8s16},
547+
{v32s16, v16s16},
548+
{v16s32, v4s32},
549+
{v16s32, v8s32},
550+
{v8s64, v2s64},
551+
{v8s64, v4s64}});
622552

623553
// todo: vectors and address spaces
624554
getActionDefinitionsBuilder(G_SELECT)

0 commit comments

Comments
 (0)