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, s8}, {s16, s8}, {s32, s8}})
 
  198      .legalFor(Is64Bit, {{s64, s8}})
 
  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({{s16, s32}, {s32, s32}, {p0, s32}})
 
  579      .legalFor(!HasCMOV, {{s8, s32}})
 
  580      .legalFor(Is64Bit, {{s64, s32}})
 
  581      .legalFor(UseX87, {{s80, s32}})
 
  582      .clampScalar(1, s32, s32)