200     Legal,      // The target natively supports this operation.  enumerator
207   /// This enum indicates whether a types are legal for a target, and if not,
277     OnlyLegalOrCustom, // Only expand when the resulting instructions are legal
399   /// type. Targets should return a legal type if the input type is legal.
424   /// ISD::VP_ADD, ISD::VP_SUB, etc. It must be a legal scalar integer type,
529   // the constraint that all of the necessary shuffles are legal (as determined
761   /// integer values of the given size. Assume that any legal integer type can
1044   /// The 'representative' register class is the largest legal super-reg
1111   /// legal (return 'Legal') or we need to promote it to a larger type (return
1124   /// legal (return 'Legal') or we need to promote it to a larger type (return
1147   /// the largest legal type it will be expanded to.
1158         llvm_unreachable("Type is not legal nor is it to be expanded!");  in getTypeToExpandTo()
1163   /// Vector types are broken down into some number of legal first class types.
1178   /// vector type is legal.
1227   /// legal.
1234   /// VT must be a legal type. By default, we optimistically assume most
1248     return Legal;  in getCustomOperationAction()
1251   /// Return how this operation should be treated: either it is legal, needs to
1279     if (Action != Legal)  in getFixedPointOperationAction()
1319   /// Return true if the specified operation is legal on this target or can be
1320   /// made legal with custom lowering. This is used to help guide high-level
1329       (getOperationAction(Op, VT) == Legal ||
1333   /// Return true if the specified operation is legal on this target or can be
1334   /// made legal using promotion. This is used to help guide high-level lowering
1343       (getOperationAction(Op, VT) == Legal ||
1347   /// Return true if the specified operation is legal on this target or can be
1348   /// made legal with custom lowering or using promotion. This is used to help
1357       (getOperationAction(Op, VT) == Legal ||
1363   /// the type is legal or not.
1424   /// unlikely to be made legal with custom lowering. This is used to help guide
1430   /// Return true if the specified operation is legal on this target.
1433            getOperationAction(Op, VT) == Legal;  in isOperationLegal()
1436   /// Return how this load with extension should be treated: either it is legal,
1450   /// Return true if the specified load with extension is legal on this target.
1452     return getLoadExtAction(ExtType, ValVT, MemVT) == Legal;  in isLoadExtLegal()
1455   /// Return true if the specified load with extension is legal or custom
1458     return getLoadExtAction(ExtType, ValVT, MemVT) == Legal ||  in isLoadExtLegalOrCustom()
1473     assert((Action == Legal || Action == Expand) &&  in getAtomicLoadExtAction()
1478   /// Return true if the specified atomic load with extension is legal on
1481     return getAtomicLoadExtAction(ExtType, ValVT, MemVT) == Legal;  in isAtomicLoadExtLegal()
1485   /// legal, needs to be promoted to a larger size, needs to be expanded to some
1496   /// Return true if the specified store with truncation is legal on this
1499     return isTypeLegal(ValVT) && getTruncStoreAction(ValVT, MemVT) == Legal;  in isTruncStoreLegal()
1506       (getTruncStoreAction(ValVT, MemVT) == Legal ||  in isTruncStoreLegalOrCustom()
1518   /// Return how the indexed load should be treated: either it is legal, needs
1525   /// Return true if the specified indexed load is legal on this target.
1528       (getIndexedLoadAction(IdxMode, VT.getSimpleVT()) == Legal ||  in isIndexedLoadLegal()
1532   /// Return how the indexed store should be treated: either it is legal, needs
1539   /// Return true if the specified indexed load is legal on this target.
1542       (getIndexedStoreAction(IdxMode, VT.getSimpleVT()) == Legal ||  in isIndexedStoreLegal()
1546   /// Return how the indexed load should be treated: either it is legal, needs
1553   /// Return true if the specified indexed load is legal on this target.
1556            (getIndexedMaskedLoadAction(IdxMode, VT.getSimpleVT()) == Legal ||  in isIndexedMaskedLoadLegal()
1560   /// Return how the indexed store should be treated: either it is legal, needs
1567   /// Return true if the specified indexed load is legal on this target.
1570            (getIndexedMaskedStoreAction(IdxMode, VT.getSimpleVT()) == Legal ||  in isIndexedMaskedStoreLegal()
1596   /// Return how the condition code should be treated: either it is legal, needs
1612   /// Return true if the specified condition code is legal on this target.
1614     return getCondCodeAction(CC, VT) == Legal;  in isCondCodeLegal()
1617   /// Return true if the specified condition code is legal or custom on this
1620     return getCondCodeAction(CC, VT) == Legal ||  in isCondCodeLegalOrCustom()
1768   /// are legal for some operations and not for other operations.
1981   /// have to be legal as the hook is used before type legalization.
2524   /// Return the largest legal super-reg register class of the register class
2574   /// is legal.
2799   /// Return true if the addressing mode represented by AM is legal for this
2803   /// mode is legal for a load/store of any legal type.  TODO: Handle
2825   /// Return true if the specified immediate is legal icmp immediate, that is
2832   /// Return true if the specified immediate is legal add immediate, that is the
2839   /// Return true if adding the specified scalable immediate is legal, that is
2845   /// Return true if the specified immediate is legal for the value input of a
3224   /// not legal, but should return true if those types will eventually legalize
3226   /// types that support FMAs (via Legal or Custom actions)
3237   /// not legal, but should return true if those types will eventually legalize
3239   /// types that support FMAs (via Legal or Custom actions)
3340   /// the operation is legal/custom for the given type because it may obscure
3562   /// register class is the largest legal super-reg register class of the
3581   /// operations are Legal (aka, supported natively by the target), but
3583   /// non-legal value types are not described here.
3592   /// Similar to LoadExtActions, but for atomic loads. Only Legal or Expand
3597   /// truncating store of a specific value type and truncating type is legal.
3751   /// register class are all legal.
3763 /// This class defines information used to lower LLVM code to legal SelectionDAG
3833   /// Returns true if the specified base+offset is a legal indexed addressing
3863   /// legal.  It is frequently not legal in PIC relocation models.
4178   /// Tries to build a legal vector shuffle using the provided parameters
4344   /// i16 is legal, but undesirable since i16 instruction encodings are longer
4347     // By default, assume all legal types are desirable.  in isTypeDesirableForOp()
4451   /// storing a legal type
4486   /// should fill in the InVals array with legal-type argument values, and
4745   /// array. The implementation should fill in the InVals array with legal-type
4860   /// illegal operand type but legal result types.  It replaces the
4878   /// values are all legal.  If the target has no operations that require custom
5302   /// vector nodes can only succeed if all operations are legal/custom.
5312   /// vector nodes can only succeed if all operations are legal/custom.
5329   /// vector nodes can only succeed if all operations are legal/custom.
5345   /// vector nodes can only succeed if all operations are legal/custom.
5499   /// Expand an SREM or UREM using SDIV/UDIV or SDIVREM/UDIVREM, if legal.