36 bool Is64Bit = Subtarget.is64Bit();
37 bool HasCMOV = Subtarget.canUseCMOV();
38 bool HasSSE1 = Subtarget.hasSSE1();
39 bool HasSSE2 = Subtarget.hasSSE2();
40 bool HasSSE41 = Subtarget.hasSSE41();
41 bool HasAVX = Subtarget.hasAVX();
42 bool HasAVX2 = Subtarget.hasAVX2();
43 bool HasAVX512 = Subtarget.hasAVX512();
44 bool HasVLX = Subtarget.hasVLX();
45 bool HasDQI = Subtarget.hasAVX512() && Subtarget.hasDQI();
46 bool HasBWI = Subtarget.hasAVX512() && Subtarget.hasBWI();
47 bool UseX87 = !Subtarget.useSoftFloat() && Subtarget.hasX87();
48 bool HasPOPCNT = Subtarget.hasPOPCNT();
49 bool HasLZCNT = Subtarget.hasLZCNT();
50 bool HasBMI = Subtarget.hasBMI();
60 const LLT sMaxScalar = Subtarget.is64Bit() ? s64 : s32;
81 const LLT s8MaxVector = HasAVX512 ? v64s8 : HasAVX ? v32s8 : v16s8;
82 const LLT s16MaxVector = HasAVX512 ? v32s16 : HasAVX ? v16s16 : v8s16;
83 const LLT s32MaxVector = HasAVX512 ? v16s32 : HasAVX ? v8s32 : v4s32;
84 const LLT s64MaxVector = HasAVX512 ? v8s64 : HasAVX ? v4s64 : v2s64;
93 {G_IMPLICIT_DEF, G_PHI, G_FREEZE, G_CONSTANT_FOLD_BARRIER})
94 .legalFor({p0, s1, s8, s16, s32, s64})
95 .legalFor(UseX87, {s80})
96 .legalFor(Is64Bit, {s128})
97 .legalFor(HasSSE2, {v16s8, v8s16, v4s32, v2s64})
98 .legalFor(HasAVX, {v32s8, v16s16, v8s32, v4s64})
99 .legalFor(HasAVX512, {v64s8, v32s16, v16s32, v8s64})
100 .widenScalarOrEltToNextPow2(0, 8)
101 .clampScalarOrElt(0, s8, sMaxScalar)
102 .moreElementsToNextPow2(0)
103 .clampMinNumElements(0, s8, 16)
104 .clampMinNumElements(0, s16, 8)
105 .clampMinNumElements(0, s32, 4)
106 .clampMinNumElements(0, s64, 2)
107 .clampMaxNumElements(0, s8, HasAVX512 ? 64 : (HasAVX ? 32 : 16))
108 .clampMaxNumElements(0, s16, HasAVX512 ? 32 : (HasAVX ? 16 : 8))
109 .clampMaxNumElements(0, s32, HasAVX512 ? 16 : (HasAVX ? 8 : 4))
110 .clampMaxNumElements(0, s64, HasAVX512 ? 8 : (HasAVX ? 4 : 2))
111 .clampMaxNumElements(0, p0,
112 Is64Bit ? s64MaxVector.getNumElements()
113 : s32MaxVector.getNumElements())
118 .legalFor(Is64Bit, {s64})
119 .widenScalarToNextPow2(0, 8)
123 G_FSIN, G_FSINH, G_FASIN, G_FTAN, G_FTANH,
124 G_FATAN, G_FATAN2, G_FPOW, G_FEXP, G_FEXP2,
125 G_FEXP10, G_FLOG, G_FLOG2, G_FLOG10, G_FPOWI,
126 G_FSINCOS, G_FCEIL, G_FFLOOR})
131 .legalFor(HasSSE2 || UseX87, {s64})
132 .legalFor(UseX87, {s80});
138 for (
unsigned Op : {G_MERGE_VALUES, G_UNMERGE_VALUES}) {
139 unsigned BigTyIdx =
Op == G_MERGE_VALUES ? 0 : 1;
140 unsigned LitTyIdx =
Op == G_MERGE_VALUES ? 1 : 0;
147 switch (Q.
Types[BigTyIdx].getSizeInBits()) {
158 switch (Q.
Types[LitTyIdx].getSizeInBits()) {
173 .widenScalarToNextPow2(0, 32)
178 .legalFor({s8, s16, s32})
179 .legalFor(Is64Bit, {s64})
180 .legalFor(HasSSE2, {v16s8, v8s16, v4s32, v2s64})
181 .legalFor(HasAVX2, {v32s8, v16s16, v8s32, v4s64})
182 .legalFor(HasAVX512, {v16s32, v8s64})
183 .legalFor(HasBWI, {v64s8, v32s16})
184 .clampMinNumElements(0, s8, 16)
197 .legalFor({{s8, s1}, {s16, s1}, {s32, s1}})
198 .legalFor(Is64Bit, {{s64, s1}})
199 .widenScalarToNextPow2(0, 32)
207 .legalFor(Is64Bit, {s64})
208 .legalFor(HasSSE2, {v8s16})
209 .legalFor(HasSSE41, {v4s32})
210 .legalFor(HasAVX2, {v16s16, v8s32})
211 .legalFor(HasAVX512, {v16s32})
212 .legalFor(HasDQI, {v8s64})
213 .legalFor(HasDQI && HasVLX, {v2s64, v4s64})
214 .legalFor(HasBWI, {v32s16})
215 .clampMinNumElements(0, s16, 8)
226 .legalFor({s8, s16, s32})
227 .legalFor(Is64Bit, {s64})
228 .widenScalarToNextPow2(0, 32)
234 .legalFor({s8, s16, s32})
235 .legalFor(Is64Bit, {s64})
237 .clampScalar(0, s8, sMaxScalar);
241 .legalFor({{s8, s8}, {s16, s8}, {s32, s8}})
242 .legalFor(Is64Bit, {{s64, s8}})
243 .clampScalar(0, s8, sMaxScalar)
248 .legalFor({s8, s16, s32})
249 .legalFor(Is64Bit, {s64})
250 .legalFor(HasSSE2, {v16s8, v8s16, v4s32, v2s64})
251 .legalFor(HasAVX, {v32s8, v16s16, v8s32, v4s64})
252 .legalFor(HasAVX512, {v64s8, v32s16, v16s32, v8s64})
253 .clampMinNumElements(0, s8, 16)
266 const std::initializer_list<LLT> IntTypes32 = {s8, s16, s32, p0};
267 const std::initializer_list<LLT> IntTypes64 = {s8, s16, s32, s64, p0};
271 .clampScalar(0, s8, s8)
277 .legalFor(Is64Bit, {s64})
278 .widenScalarToNextPow2(0, 32)
283 .
legalFor(HasPOPCNT, {{s16, s16}, {s32, s32}})
284 .legalFor(HasPOPCNT && Is64Bit, {{s64, s64}})
285 .widenScalarToNextPow2(1, 16)
291 .
legalFor(HasLZCNT, {{s16, s16}, {s32, s32}})
292 .legalFor(HasLZCNT && Is64Bit, {{s64, s64}})
293 .widenScalarToNextPow2(1, 16)
300 .legalFor(Is64Bit, {{s64, s64}})
301 .widenScalarToNextPow2(1, 16)
306 .
legalFor(HasBMI, {{s16, s16}, {s32, s32}})
307 .legalFor(HasBMI && Is64Bit, {{s64, s64}})
308 .widenScalarToNextPow2(1, 16)
315 const std::initializer_list<LLT> PtrTypes32 = {s1, s8, s16, s32};
316 const std::initializer_list<LLT> PtrTypes64 = {s1, s8, s16, s32, s64};
320 .maxScalar(0, sMaxScalar)
329 .legalFor(Is64Bit, {{p0, s64}})
330 .widenScalarToNextPow2(1, 32)
336 for (
unsigned Op : {G_LOAD, G_STORE}) {
338 Action.legalForTypesWithMemDesc({{s8, p0, s8, 1},
343 {v4s8, p0, v4s8, 1}});
345 Action.legalForTypesWithMemDesc(
346 {{s64, p0, s64, 1}, {v2s32, p0, v2s32, 1}});
349 Action.legalForTypesWithMemDesc({{v4s32, p0, v4s32, 1}});
351 Action.legalForTypesWithMemDesc({{v16s8, p0, v16s8, 1},
352 {v8s16, p0, v8s16, 1},
353 {v2s64, p0, v2s64, 1},
354 {v2p0, p0, v2p0, 1}});
356 Action.legalForTypesWithMemDesc({{v32s8, p0, v32s8, 1},
357 {v16s16, p0, v16s16, 1},
358 {v8s32, p0, v8s32, 1},
359 {v4s64, p0, v4s64, 1},
360 {v4p0, p0, v4p0, 1}});
362 Action.legalForTypesWithMemDesc({{v64s8, p0, v64s8, 1},
363 {v32s16, p0, v32s16, 1},
364 {v16s32, p0, v16s32, 1},
365 {v8s64, p0, v8s64, 1}});
369 Action.legalForTypesWithMemDesc({{s8, p0, s1, 1},
374 Action.legalForTypesWithMemDesc(
375 {{s64, p0, s8, 1}, {s64, p0, s16, 1}, {s64, p0, s32, 1}});
381 Action.widenScalarToNextPow2(0, 8)
382 .clampScalar(0, s8, sMaxScalar)
386 for (
unsigned Op : {G_SEXTLOAD, G_ZEXTLOAD}) {
388 Action.legalForTypesWithMemDesc(
389 {{s16, p0, s8, 1}, {s32, p0, s8, 1}, {s32, p0, s16, 1}});
391 Action.legalForTypesWithMemDesc(
392 {{s64, p0, s8, 1}, {s64, p0, s16, 1}, {s64, p0, s32, 1}});
399 .legalFor(Is64Bit, {s64})
400 .widenScalarToNextPow2(0, 8)
407 .legalFor({s8, s16, s32})
408 .legalFor(Is64Bit, {s64})
409 .widenScalarToNextPow2(0, 8)
420 .legalFor(UseX87, {s80});
424 .legalFor({s32, s64})
425 .legalFor(HasSSE1, {v4s32})
426 .legalFor(HasSSE2, {v2s64})
427 .legalFor(HasAVX, {v8s32, v4s64})
428 .legalFor(HasAVX512, {v16s32, v8s64})
429 .legalFor(UseX87, {s80});
433 .legalFor(UseX87 && !Is64Bit, {s64})
438 .
legalFor(HasSSE1 || UseX87, {s8, s32})
439 .legalFor(HasSSE2 || UseX87, {s8, s64})
440 .legalFor(UseX87, {s8, s80})
441 .clampScalar(0, s8, s8)
448 .legalFor(HasAVX, {{v4s64, v4s32}})
449 .legalFor(HasAVX512, {{v8s64, v8s32}});
453 .legalFor(HasAVX, {{v4s32, v4s64}})
454 .legalFor(HasAVX512, {{v8s32, v8s64}});
458 .legalFor(HasSSE1 && Is64Bit, {{s32, s64}})
459 .legalFor(HasSSE2, {{s64, s32}})
460 .legalFor(HasSSE2 && Is64Bit, {{s64, s64}})
461 .clampScalar(1, (UseX87 && !HasSSE1) ? s16 : s32, sMaxScalar)
464 .clampScalar(0, s32, HasSSE2 ? s64 : s32)
469 .legalFor(HasSSE1 && Is64Bit, {{s64, s32}})
470 .legalFor(HasSSE2, {{s32, s64}})
471 .legalFor(HasSSE2 && Is64Bit, {{s64, s64}})
472 .clampScalar(0, (UseX87 && !HasSSE1) ? s16 : s32, sMaxScalar)
475 .clampScalar(1, s32, HasSSE2 ? s64 : s32)
486 .
legalFor(HasAVX512, {{s32, s32}, {s32, s64}, {s64, s32}, {s64, s64}})
489 ((HasSSE1 &&
typeIs(0, s32)(Query)) ||
490 (HasSSE2 &&
typeIs(0, s64)(Query))) &&
496 ((HasSSE1 &&
typeIs(0, s32)(Query)) ||
497 (HasSSE2 &&
typeIs(0, s64)(Query))) &&
498 (Is64Bit &&
typeIs(1, s64)(Query));
500 .clampScalar(0, s32, HasSSE2 ? s64 : s32)
506 .
legalFor(HasAVX512, {{s32, s32}, {s32, s64}, {s64, s32}, {s64, s64}})
509 ((HasSSE1 &&
typeIs(1, s32)(Query)) ||
510 (HasSSE2 &&
typeIs(1, s64)(Query))) &&
519 ((HasSSE1 &&
typeIs(1, s32)(Query)) ||
520 (HasSSE2 &&
typeIs(1, s64)(Query))) &&
521 (Is64Bit &&
typeIs(0, s64)(Query));
523 .clampScalar(0, s32, sMaxScalar)
531 return (HasSSE1 &&
typeInSet(0, {v4s32})(Query)) ||
532 (HasSSE2 &&
typeInSet(0, {v2s64, v8s16, v16s8})(Query)) ||
533 (HasAVX &&
typeInSet(0, {v4s64, v8s32, v16s16, v32s8})(Query)) ||
534 (HasAVX512 &&
typeInSet(0, {v8s64, v16s32, v32s16, v64s8}));
536 .clampNumElements(0, v16s8, s8MaxVector)
544 unsigned SubIdx = Query.
Opcode == G_EXTRACT ? 0 : 1;
545 unsigned FullIdx = Query.
Opcode == G_EXTRACT ? 1 : 0;
550 {v2s64, v4s64}})(Query)) ||
559 {v4s64, v8s64}})(Query));
566 {{v32s8, v16s8}, {v16s16, v8s16}, {v8s32, v4s32}, {v4s64, v2s64}})
567 .legalFor(HasAVX, {{v64s8, v16s8},
578 .
legalFor({{s8, s32}, {s16, s32}, {s32, s32}, {s64, s32}, {p0, s32}})
579 .widenScalarToNextPow2(0, 8)