|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
lib/CodeGen/SelectionDAG/DAGCombiner.cpp 225 TLI.isTypeLegal(EVT(VT)) &&
679 return TLI.isOperationLegal(Opcode, VT);
680 return TLI.isOperationLegalOrCustom(Opcode, VT);
693 return TLI.getShiftAmountTy(LHSTy, DAG.getDataLayout(), LegalTypes);
700 return TLI.isTypeLegal(VT);
705 return TLI.getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT);
817 !TLI.isConstTrueVal(N.getOperand(2).getNode()) ||
818 !TLI.isConstFalseVal(N.getOperand(3).getNode()))
821 if (TLI.getBooleanContents(N.getValueType()) ==
923 if (!TLI.isLegalAddressingMode(DAG.getDataLayout(), AM, AccessTy, AS))
928 if (!TLI.isLegalAddressingMode(DAG.getDataLayout(), AM, AccessTy, AS))
971 assert(TLI.isCommutativeBinOp(Opc) && "Operation not commutative.");
1045 if (!TLI.SimplifyDemandedBits(Op, DemandedBits, DemandedElts, Known, TLO))
1069 if (!TLI.SimplifyDemandedVectorElts(Op, DemandedElts, KnownUndef, KnownZero,
1132 if (!TLI.isOperationLegal(ISD::ANY_EXTEND, PVT))
1138 if (!TLI.isOperationLegal(ISD::SIGN_EXTEND_INREG, PVT))
1182 if (TLI.isTypeDesirableForOp(Opc, VT))
1188 if (TLI.IsDesirableToPromoteOp(Op, PVT)) {
1247 if (TLI.isTypeDesirableForOp(Opc, VT))
1253 if (TLI.IsDesirableToPromoteOp(Op, PVT)) {
1296 if (TLI.isTypeDesirableForOp(Opc, VT))
1302 if (TLI.IsDesirableToPromoteOp(Op, PVT)) {
1327 if (TLI.isTypeDesirableForOp(Opc, VT))
1333 if (TLI.IsDesirableToPromoteOp(Op, PVT)) {
1631 TLI.hasTargetDAGCombine((ISD::NodeType)N->getOpcode())) {
1637 RV = TLI.PerformDAGCombine(N, DagCombineInfo);
1672 if (!RV.getNode() && TLI.isCommutativeBinOp(N->getOpcode()) &&
1917 assert(TLI.isBinOp(BO->getOpcode()) && BO->getNumValues() == 1 &&
2139 (TLI.isOperationLegal(ISD::XOR, X.getValueType()) &&
2140 TLI.isOperationLegal(ISD::ZERO_EXTEND, VT))) &&
2268 if (!TLI.preferIncOfAddToSubOfNot(VT) && N0.hasOneUse() &&
2308 if ((!LegalOperations || TLI.isOperationLegal(ISD::OR, VT)) &&
2438 if (!TLI.preferIncOfAddToSubOfNot(VT) && N0.hasOneUse() &&
2466 TLI.getBooleanContents(VT) == TargetLowering::ZeroOrOneBooleanContent) {
2488 if (TLI.isOperationLegalOrCustom(ISD::ADDCARRY, VT))
2489 if (SDValue Carry = getAsCarry(TLI, N1))
2621 flipBoolean(Sub.getValue(1), DL, DAG, TLI));
2650 if (TLI.isOperationLegalOrCustom(ISD::ADDCARRY, VT))
2651 if (SDValue Carry = getAsCarry(TLI, N1))
2692 TLI.isOperationLegalOrCustom(ISD::UADDO, N->getValueType(0)))
2807 if (SDValue NotC = extractBooleanFlip(CarryIn, DAG, TLI, true)) {
2812 flipBoolean(Sub.getValue(1), DL, DAG, TLI));
2831 if (auto Y = getAsCarry(TLI, N1)) {
2872 return tryFoldToZero(DL, TLI, VT, DAG, LegalOperations);
2901 if (!LegalOperations || TLI.isOperationLegal(NewSh, VT))
3053 if (TLI.preferIncOfAddToSubOfNot(VT) && N1.hasOneUse() && isBitwiseNot(N1)) {
3090 TLI.getBooleanContents(VT) ==
3097 if (TLI.isOperationLegalOrCustom(ISD::ABS, VT)) {
3112 if (!LegalOperations && TLI.isOffsetFoldingLegal(GA)) {
3147 if (TLI.isOperationLegalOrCustom(ISD::ADDCARRY, VT)) {
3149 if (SDValue Carry = getAsCarry(TLI, N0)) {
3286 TLI.isOperationLegalOrCustom(ISD::USUBO, N->getValueType(0)))
3412 if (N1IsConst && TLI.decomposeMulByConstant(*DAG.getContext(), VT, N1)) {
3520 if (!TLI.isTypeLegal(VT) && !TLI.isOperationCustom(DivRemOpc, VT))
3520 if (!TLI.isTypeLegal(VT) && !TLI.isOperationCustom(DivRemOpc, VT))
3525 if (!TLI.isOperationLegalOrCustom(DivRemOpc, VT) &&
3526 !isDivRemLibcallAvailable(Node, isSigned, TLI))
3533 if (TLI.isOperationLegalOrCustom(Opcode, VT))
3537 if (TLI.isOperationLegalOrCustom(OtherOpcode, VT))
3679 if (!N1C || TLI.isIntDivCheap(N->getValueType(0), Attr))
3760 !TLI.isIntDivCheap(N->getValueType(0), Attr))
3817 if (!N1C || TLI.isIntDivCheap(N->getValueType(0), Attr))
3860 !TLI.isIntDivCheap(N->getValueType(0), Attr))
3926 if (DAG.isKnownNeverZero(N1) && !TLI.isIntDivCheap(VT, Attr)) {
3983 if (TLI.isOperationLegal(ISD::MUL, NewVT)) {
4039 if (TLI.isOperationLegal(ISD::MUL, NewVT)) {
4061 TLI.isOperationLegalOrCustom(LoOp, N->getValueType(0)))) {
4069 TLI.isOperationLegalOrCustom(HiOp, N->getValueType(1)))) {
4085 TLI.isOperationLegalOrCustom(LoOpt.getOpcode(), LoOpt.getValueType())))
4095 TLI.isOperationLegalOrCustom(HiOpt.getOpcode(), HiOpt.getValueType())))
4115 if (TLI.isOperationLegal(ISD::MUL, NewVT)) {
4158 if (TLI.isOperationLegal(ISD::MUL, NewVT)) {
4282 !TLI.isOperationLegalOrCustom(LogicOpcode, XVT))
4287 !TLI.isTypeDesirableForOp(LogicOpcode, XVT))
4304 if (LegalOperations && !TLI.isOperationLegal(LogicOpcode, XVT))
4308 if (TLI.isZExtFree(VT, XVT) && TLI.isTruncateFree(XVT, VT))
4308 if (TLI.isZExtFree(VT, XVT) && TLI.isTruncateFree(XVT, VT))
4310 if (!TLI.isTypeLegal(XVT))
4348 !(VT.isVector() && TLI.isTypeLegal(VT) &&
4349 !XVT.isVector() && !TLI.isTypeLegal(XVT))) {
4385 ShOp = tryFoldToZero(DL, TLI, VT, DAG, LegalOperations);
4398 ShOp = tryFoldToZero(DL, TLI, VT, DAG, LegalOperations);
4497 if (IsInteger && TLI.convertSetCCLogicToBitwiseLogic(OpVT) && CC0 == CC1 &&
4550 (TLI.isCondCodeLegal(NewCC, LL.getSimpleValueType()) &&
4551 TLI.isOperationLegal(ISD::SETCC, OpVT))))
4585 !TLI.isLegalAddImmediate(ADDC.getSExtValue())) {
4590 if (TLI.isLegalAddImmediate(ADDC.getSExtValue())) {
4626 TLI.isNarrowingProfitable(VT, HalfVT) &&
4627 TLI.isTypeDesirableForOp(ISD::AND, HalfVT) &&
4628 TLI.isTypeDesirableForOp(ISD::SRL, HalfVT) &&
4629 TLI.isTruncateFree(VT, HalfVT) &&
4630 TLI.isZExtFree(HalfVT, VT)) {
4640 EVT ShiftVT = TLI.getShiftAmountTy(HalfVT, DAG.getDataLayout());
4669 TLI.isLoadExtLegal(ISD::ZEXTLOAD, LoadResultTy, ExtVT))) {
4685 !TLI.isLoadExtLegal(ISD::ZEXTLOAD, LoadResultTy, ExtVT))
4688 if (!TLI.shouldReduceLoadWidth(LoadN, ISD::ZEXTLOAD, ExtVT))
4718 !TLI.allowsMemoryAccess(*DAG.getContext(), DAG.getDataLayout(), MemVT,
4736 !TLI.isLoadExtLegal(ExtType, Load->getValueType(0), MemVT))
4754 if (!TLI.shouldReduceLoadWidth(Load, ExtType, MemVT))
4764 !TLI.isTruncStoreLegal(Store->getValue().getValueType(), MemVT))
4939 if (!TLI.shouldFoldMaskToVariableShiftPair(N0))
5180 bool CanZextLoadProfitably = TLI.isLoadExtLegal(ISD::ZEXTLOAD,
5297 TLI.isLoadExtLegal(ISD::ZEXTLOAD, VT, MemVT))) {
5317 if (TLI.hasBitTest(N0, N1))
5333 if (!TLI.isOperationLegalOrCustom(ISD::BSWAP, VT))
5557 if (!TLI.isOperationLegalOrCustom(ISD::BSWAP, VT))
5593 if (TLI.isOperationLegalOrCustom(ISD::ROTL, VT))
5595 if (TLI.isOperationLegalOrCustom(ISD::ROTR, VT))
5705 TLI.isTypeLegal(VT)) {
5755 TLI.buildLegalVectorShuffle(VT, SDLoc(N), NewLHS, NewRHS,
5837 if ((!LegalOperations || TLI.isOperationLegal(ISD::ADD, VT)) &&
6125 bool HasPos = TLI.isOperationLegalOrCustom(PosOpcode, VT);
6139 if (!TLI.isTypeLegal(VT))
6833 if (!TLI.hasAndNot(M))
6839 if (!TLI.hasAndNot(Y)) {
6840 assert(TLI.hasAndNot(X) && "Only mask is a variable? Unreachable.");
6905 if (TLI.isConstTrueVal(N1.getNode()) && isSetCCEquivalent(N0, LHS, RHS, CC)) {
6909 TLI.isCondCodeLegal(NotCC, LHS.getSimpleValueType())) {
6998 if (TLI.isOperationLegalOrCustom(ISD::ABS, VT)) {
7015 return tryFoldToZero(DL, TLI, VT, DAG, LegalOperations);
7035 if (TLI.isOperationLegalOrCustom(ISD::ROTL, VT) && N0Opcode == ISD::SHL &&
7138 if (!LHS.hasOneUse() || !TLI.isDesirableToCommuteWithShift(N, Level))
7207 TLI.isTypeDesirableForOp(ISD::AND, TruncVT)) {
7306 TLI.getBooleanContents(N00.getOperand(0).getValueType()) ==
7465 TLI.shouldFoldConstantShiftPairToMask(N, Level)) {
7507 TLI.isDesirableToCommuteWithShift(N, Level)) {
7571 TLI.isOperationLegal(ISD::SIGN_EXTEND_INREG, ExtVT)))
7628 TLI.isOperationLegalOrCustom(ISD::SIGN_EXTEND, TruncVT) &&
7629 TLI.isOperationLegalOrCustom(ISD::TRUNCATE, VT) &&
7630 TLI.isTruncateFree(VT, TruncVT)) {
7664 if (TruncVT.isSimple() && TLI.isTruncateFree(VT, TruncVT)) {
7823 if (!LegalTypes || TLI.isTypeDesirableForOp(ISD::SRL, SmallVT)) {
8062 if (!LegalOperations || TLI.isOperationLegal(ISD::CTLZ_ZERO_UNDEF, VT)) {
8089 if (!LegalOperations || TLI.isOperationLegal(ISD::CTTZ_ZERO_UNDEF, VT)) {
8265 if (TLI.convertSelectOfConstantsToMath(VT)) {
8308 TLI.getBooleanContents(/*isVec*/false, /*isFloat*/true) ==
8310 TLI.getBooleanContents(/*isVec*/false, /*isFloat*/false) ==
8374 TLI.shouldNormalizeToSelectSequence(*DAG.getContext(), VT);
8443 if (SDValue F = extractBooleanFlip(N0, DAG, TLI, false)) {
8458 if (N0.hasOneUse() && isLegalToCombineMinNumMaxNum(DAG, N1, N2, TLI))
8460 CC, TLI, DAG))
8468 if (!LegalOperations && TLI.isOperationLegalOrCustom(ISD::UADDO, VT) &&
8492 if (TLI.isOperationLegal(ISD::SELECT_CC, VT) ||
8494 TLI.isOperationLegalOrCustom(ISD::SELECT_CC, VT))) {
8623 !TLI.convertSelectOfConstantsToMath(VT) ||
8689 if (SDValue F = extractBooleanFlip(N0, DAG, TLI, false))
8712 if (TLI.isOperationLegalOrCustom(ISD::ABS, VT))
8730 if (N0.hasOneUse() && isLegalToCombineMinNumMaxNum(DAG, LHS, RHS, TLI)) {
8732 combineMinNumMaxNum(DL, VT, LHS, RHS, N1, N2, CC, TLI, DAG))
8751 TLI.isLoadExtLegalOrCustom(LoadExtOpcode, WideVT, NarrowVT) &&
8752 TLI.isOperationLegalOrCustom(ISD::SETCC, WideVT)) {
9089 !TLI.isVectorLoadExtDesirable(SDValue(N, 0)))
9093 if (!ExtendUsesToFormExtLoad(DstVT, N, N0, N->getOpcode(), SetCCs, TLI))
9102 while (!TLI.isLoadExtLegalOrCustom(ExtType, SplitDstVT, SplitSrcVT) &&
9108 if (!TLI.isLoadExtLegalOrCustom(ExtType, SplitDstVT, SplitSrcVT))
9160 if (TLI.isZExtFree(OrigVT, VT))
9168 (LegalOperations && !TLI.isOperationLegal(N0.getOpcode(), VT)))
9175 (LegalOperations && !TLI.isOperationLegal(N1.getOpcode(), VT)))
9183 if (!TLI.isLoadExtLegal(ISD::ZEXTLOAD, VT, MemVT) ||
9198 ISD::ZERO_EXTEND, SetCCs, TLI))
9247 if (LegalOperations || !TLI.isOperationLegalOrCustom(ISD::VSELECT, VT))
9415 if (SDValue Res = tryToFoldExtendOfConstant(N, TLI, DAG, LegalTypes))
9462 if (!LegalOperations || TLI.isOperationLegal(ISD::SIGN_EXTEND_INREG,
9475 tryToFoldExtOfLoad(DAG, *this, TLI, VT, LegalOperations, N, N0,
9480 tryToFoldExtOfMaskedLoad(DAG, TLI, VT, N, N0, ISD::SEXTLOAD,
9491 DAG, *this, TLI, VT, LegalOperations, N, N0, ISD::SEXTLOAD))
9500 (!LegalOperations && TLI.isOperationLegal(N0.getOpcode(), VT))) {
9503 if (TLI.isLoadExtLegal(ISD::SEXTLOAD, VT, MemVT) &&
9507 ISD::SIGN_EXTEND, SetCCs, TLI);
9551 TLI.getBooleanContents(N00VT) ==
9599 if (!VT.isVector() && !TLI.convertSelectOfConstantsToMath(VT)) {
9606 (!LegalOperations || TLI.isOperationLegal(ISD::SETCC, N00VT))) {
9614 if ((!LegalOperations || TLI.isOperationLegal(ISD::ZERO_EXTEND, VT)) &&
9626 TLI.isOperationLegalOrCustom(ISD::SUB, VT)) {
9635 TLI.isOperationLegalOrCustom(ISD::ADD, VT)) {
9703 if (SDValue Res = tryToFoldExtendOfConstant(N, TLI, DAG, LegalTypes))
9749 if (!LegalOperations || (TLI.isOperationLegal(ISD::AND, SrcVT) &&
9750 TLI.isOperationLegal(ISD::ZERO_EXTEND, VT))) {
9761 if (!LegalOperations || TLI.isOperationLegal(ISD::AND, VT)) {
9777 (!TLI.isTruncateFree(N0.getOperand(0).getOperand(0).getValueType(),
9779 !TLI.isZExtFree(N0.getValueType(), VT))) {
9791 tryToFoldExtOfLoad(DAG, *this, TLI, VT, LegalOperations, N, N0,
9796 tryToFoldExtOfMaskedLoad(DAG, TLI, VT, N, N0, ISD::ZEXTLOAD,
9813 (!LegalOperations && TLI.isOperationLegal(N0.getOpcode(), VT))) {
9816 if (TLI.isLoadExtLegal(ISD::ZEXTLOAD, VT, MemVT) &&
9831 ISD::ZERO_EXTEND, SetCCs, TLI);
9871 DAG, *this, TLI, VT, LegalOperations, N, N0, ISD::ZEXTLOAD))
9959 if (SDValue Res = tryToFoldExtendOfConstant(N, TLI, DAG, LegalTypes))
9993 !TLI.isTruncateFree(N0.getOperand(0).getOperand(0).getValueType(),
10010 TLI.isLoadExtLegal(ISD::EXTLOAD, VT, N0.getValueType())) {
10015 TLI);
10046 if (!LegalOperations || TLI.isLoadExtLegal(ExtType, VT, MemVT)) {
10267 TLI.isLoadExtLegal(ExtType, N0.getValueType(), MaskedVT))
10278 ExtVT == VT && TLI.isNarrowingProfitable(N0.getValueType(), VT)) {
10405 (!LegalOperations || TLI.isOperationLegal(ISD::SIGN_EXTEND, VT)))
10415 TLI.isOperationLegal(ISD::SIGN_EXTEND_VECTOR_INREG, VT))
10425 (!LegalOperations || TLI.isOperationLegal(ISD::SIGN_EXTEND, VT)))
10467 TLI.isLoadExtLegal(ISD::SEXTLOAD, VT, EVT))) {
10483 TLI.isLoadExtLegal(ISD::SEXTLOAD, VT, EVT))) {
10512 if (SDValue Res = tryToFoldExtendOfConstant(N, TLI, DAG, LegalTypes))
10528 if (SDValue Res = tryToFoldExtendOfConstant(N, TLI, DAG, LegalTypes))
10602 EVT IndexTy = TLI.getVectorIdxTy(DAG.getDataLayout());
10614 if ((!LegalOperations || TLI.isOperationLegal(ISD::SELECT, SrcVT)) &&
10615 TLI.isTruncateFree(SrcVT, VT)) {
10626 (!LegalOperations || TLI.isOperationLegal(ISD::SHL, VT)) &&
10627 TLI.isTypeDesirableForOp(ISD::SHL, VT)) {
10633 EVT AmtVT = TLI.getShiftAmountTy(VT, DAG.getDataLayout());
10646 TLI.isTruncateFree(SrcVT.getScalarType(), VT.getScalarType())) {
10701 if (!LegalTypes || TLI.isTypeDesirableForOp(N0.getOpcode(), VT)) {
10772 TLI.isOperationLegal(ISD::EXTRACT_VECTOR_ELT, VecSrcVT))) {
10775 EVT IdxVT = TLI.getVectorIdxTy(DAG.getDataLayout());
10794 TLI.isOperationLegal(N0.getOpcode(), VT))) {
10838 if (VT.isScalarInteger() || TLI.isOperationLegal(N0.getOpcode(), VT)) {
10883 (!LegalOperations || TLI.isOperationLegal(ISD::LOAD, VT)))
10966 TLI.isTypeLegal(VT.getVectorElementType()))) &&
10979 TLI.isOperationLegal(ISD::ConstantFP, VT)) ||
10981 TLI.isOperationLegal(ISD::Constant, VT))) {
10996 TLI.hasBigEndianPartOrdering(N0.getValueType(), DAG.getDataLayout()) ==
10997 TLI.hasBigEndianPartOrdering(VT, DAG.getDataLayout()) &&
11004 TLI.isOperationLegal(ISD::LOAD, VT))) {
11007 if (TLI.isLoadBitCastBeneficial(N0.getValueType(), VT, DAG,
11018 if (SDValue V = foldBitcastedFPLogic(N, DAG, TLI))
11033 if (((N0.getOpcode() == ISD::FNEG && !TLI.isFNegFree(N0.getValueType())) ||
11034 (N0.getOpcode() == ISD::FABS && !TLI.isFAbsFree(N0.getValueType()))) &&
11156 if (Level < AfterLegalizeDAG && TLI.isTypeLegal(VT) && VT.isVector() &&
11190 TLI.buildLegalVectorShuffle(VT, SDLoc(N), SV0, SV1, NewMask, DAG);
11333 bool HasFMAD = (LegalOperations && TLI.isOperationLegal(ISD::FMAD, VT));
11337 TLI.isFMAFasterThanFMulAndFAdd(VT) &&
11338 (!LegalOperations || TLI.isOperationLegalOrCustom(ISD::FMA, VT));
11358 bool Aggressive = TLI.enableAggressiveFMAFusion(VT);
11393 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, N00.getValueType())) {
11407 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, N10.getValueType())) {
11461 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, N020.getValueType())) {
11490 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, N00.getValueType())) {
11505 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, N120.getValueType())) {
11523 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, N10.getValueType())) {
11544 bool HasFMAD = (LegalOperations && TLI.isOperationLegal(ISD::FMAD, VT));
11548 TLI.isFMAFasterThanFMulAndFAdd(VT) &&
11549 (!LegalOperations || TLI.isOperationLegalOrCustom(ISD::FMA, VT));
11570 bool Aggressive = TLI.enableAggressiveFMAFusion(VT);
11613 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, N00.getValueType())) {
11629 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, N10.getValueType())) {
11651 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, N00.getValueType())) {
11674 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, N000.getValueType())) {
11725 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, N020.getValueType())) {
11750 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, N00.getValueType())) {
11773 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, N120.getValueType())) {
11802 TLI.isFPExtFoldable(PreferredFusedOpcode, VT, CvtSrc.getValueType())) {
11846 TLI.isFMAFasterThanFMulAndFAdd(VT) &&
11847 (!LegalOperations || TLI.isOperationLegalOrCustom(ISD::FMA, VT));
11852 (LegalOperations && TLI.isOperationLegal(ISD::FMAD, VT));
11860 bool Aggressive = TLI.enableAggressiveFMAFusion(VT);
11952 if ((!LegalOperations || TLI.isOperationLegalOrCustom(ISD::FSUB, VT)) &&
11953 TLI.isNegatibleForFree(N1, DAG, LegalOperations, ForCodeSize) == 2)
11956 TLI.getNegatedExpression(N1, DAG, LegalOperations, ForCodeSize), Flags);
11959 if ((!LegalOperations || TLI.isOperationLegalOrCustom(ISD::FSUB, VT)) &&
11960 TLI.isNegatibleForFree(N0, DAG, LegalOperations, ForCodeSize) == 2)
11963 TLI.getNegatedExpression(N0, DAG, LegalOperations, ForCodeSize), Flags);
12016 if (TLI.isOperationLegalOrCustom(ISD::FMUL, VT) && !N0CFP && !N1CFP) {
12142 if (TLI.isNegatibleForFree(N1, DAG, LegalOperations, ForCodeSize))
12143 return TLI.getNegatedExpression(N1, DAG, LegalOperations, ForCodeSize);
12144 if (!LegalOperations || TLI.isOperationLegal(ISD::FNEG, VT))
12161 if (TLI.isNegatibleForFree(N1, DAG, LegalOperations, ForCodeSize))
12164 TLI.getNegatedExpression(N1, DAG, LegalOperations, ForCodeSize), Flags);
12179 TLI.isNegatibleForFree(X, DAG, LegalOperations, ForCodeSize))
12181 TLI.isNegatibleForFree(Y, DAG, LegalOperations, ForCodeSize))
12257 if (!LegalOperations || TLI.isOperationLegal(ISD::FNEG, VT))
12263 TLI.getNegatedExpression(N0, DAG, LegalOperations, ForCodeSize);
12265 TLI.getNegatedExpression(N1, DAG, LegalOperations, ForCodeSize);
12273 TLI.isOperationLegal(ISD::FABS, VT)) {
12304 TLI.isOperationLegal(ISD::FNEG, VT))
12348 TLI.getNegatedExpression(N0, DAG, LegalOperations, ForCodeSize);
12350 TLI.getNegatedExpression(N1, DAG, LegalOperations, ForCodeSize);
12401 (!LegalOperations || TLI.isOperationLegal(ISD::FNEG, VT))) {
12410 (TLI.isOperationLegal(ISD::ConstantFP, VT) ||
12411 (N1.hasOneUse() && !TLI.isFPImmLegal(N1CFP->getValueAPF(), VT,
12464 unsigned MinUses = TLI.combineRepeatedFPDivisors();
12552 TLI.isOperationLegal(ISD::ConstantFP, VT) ||
12553 TLI.isFPImmLegal(Recip, VT, ForCodeSize)))
12611 TLI.getNegatedExpression(N0, DAG, LegalOperations, ForCodeSize),
12612 TLI.getNegatedExpression(N1, DAG, LegalOperations, ForCodeSize), Flags);
12641 if (TLI.isFsqrtCheap(N0, DAG))
12680 if (!LegalOperations || TLI.isOperationLegal(ISD::FABS, VT))
12683 if (!LegalOperations || TLI.isOperationLegal(ISD::FNEG, VT))
12836 TLI.isOperationLegalOrCustom(ISD::ConstantFP, VT)))
12849 if (TLI.isOperationLegalOrCustom(ISD::SELECT_CC, VT) || !LegalOperations) {
12854 TLI.isOperationLegalOrCustom(ISD::ConstantFP, VT))) {
12868 TLI.isOperationLegalOrCustom(ISD::ConstantFP, VT))) {
12878 if (SDValue FTrunc = foldFPToIntToFP(N, DAG, TLI))
12897 TLI.isOperationLegalOrCustom(ISD::ConstantFP, VT)))
12910 if (TLI.isOperationLegalOrCustom(ISD::SELECT_CC, VT) || !LegalOperations) {
12914 TLI.isOperationLegalOrCustom(ISD::ConstantFP, VT))) {
12924 if (SDValue FTrunc = foldFPToIntToFP(N, DAG, TLI))
13073 TLI.getOperationAction(ISD::FP16_TO_FP, VT) == TargetLowering::Legal)
13090 TLI.isLoadExtLegal(ISD::EXTLOAD, VT, N0.getValueType())) {
13166 if (TLI.isNegatibleForFree(N0, DAG, LegalOperations, ForCodeSize))
13167 return TLI.getNegatedExpression(N0, DAG, LegalOperations, ForCodeSize);
13171 if (!TLI.isFNegFree(VT) &&
13197 (N0.getNode()->hasOneUse() || !TLI.isFNegFree(VT))) {
13203 (TLI.isFPImmLegal(CVal, VT, ForCodeSize) ||
13204 TLI.isOperationLegal(ISD::ConstantFP, VT)))
13271 if (!TLI.isFAbsFree(VT) && N0.getOpcode() == ISD::BITCAST && N0.hasOneUse()) {
13310 TLI.isOperationLegalOrCustom(ISD::BR_CC,
13512 if (!TLI.isIndexedLoadLegal(ISD::PRE_INC, VT) &&
13513 !TLI.isIndexedLoadLegal(ISD::PRE_DEC, VT))
13520 if (!TLI.isIndexedStoreLegal(ISD::PRE_INC, VT) &&
13521 !TLI.isIndexedStoreLegal(ISD::PRE_DEC, VT))
13539 if (!TLI.getPreIndexedAddressParts(N, BasePtr, Offset, AM, DAG))
13638 if (!canFoldInAddressingMode(Ptr.getNode(), Use, DAG, TLI))
13743 if (!TLI.isIndexedLoadLegal(ISD::POST_INC, VT) &&
13744 !TLI.isIndexedLoadLegal(ISD::POST_DEC, VT))
13751 if (!TLI.isIndexedStoreLegal(ISD::POST_INC, VT) &&
13752 !TLI.isIndexedStoreLegal(ISD::POST_DEC, VT))
13771 if (TLI.getPostIndexedAddressParts(N, Op, BasePtr, Offset, AM, DAG)) {
13797 if (!canFoldInAddressingMode(Use, UseUse, DAG, TLI))
13890 TLI.isOperationLegal(ISD::FTRUNC, STMemType)) {
14903 !TLI.isOperationLegalOrCustom(Opc, NewVT) ||
14904 !TLI.isNarrowingProfitable(VT, NewVT))) {
14979 if (!TLI.isOperationLegal(ISD::LOAD, IntVT) ||
14980 !TLI.isOperationLegal(ISD::STORE, IntVT) ||
14981 !TLI.isDesirableToTransformToIntegerOp(ISD::LOAD, VT) ||
14982 !TLI.isDesirableToTransformToIntegerOp(ISD::STORE, VT))
15241 TLI.getTypeToTransformTo(*DAG.getContext(), StoredVal.getValueType());
15616 if (TLI.isTypeLegal(StoreTy) &&
15617 TLI.canMergeStoresTo(FirstStoreAS, StoreTy, DAG) &&
15618 TLI.allowsMemoryAccess(Context, DL, StoreTy,
15624 } else if (TLI.getTypeAction(Context, StoreTy) ==
15627 TLI.getTypeToTransformTo(Context, StoredVal.getValueType());
15628 if (TLI.isTruncStoreLegal(LegalizedStoredValTy, StoreTy) &&
15629 TLI.canMergeStoresTo(FirstStoreAS, LegalizedStoredValTy, DAG) &&
15630 TLI.allowsMemoryAccess(Context, DL, StoreTy,
15643 TLI.storeOfVectorConstantIsCheap(MemVT, i + 1, FirstStoreAS)) &&
15648 if (TLI.isTypeLegal(Ty) && TLI.isTypeLegal(MemVT) &&
15648 if (TLI.isTypeLegal(Ty) && TLI.isTypeLegal(MemVT) &&
15649 TLI.canMergeStoresTo(FirstStoreAS, Ty, DAG) &&
15650 TLI.allowsMemoryAccess(
15720 if (TLI.isTypeLegal(Ty) &&
15721 TLI.canMergeStoresTo(FirstStoreAS, Ty, DAG) &&
15722 TLI.allowsMemoryAccess(Context, DL, Ty,
15804 TLI.hasPairedLoad(MemVT, RequiredAlignment) &&
15851 if (TLI.isTypeLegal(StoreTy) &&
15852 TLI.canMergeStoresTo(FirstStoreAS, StoreTy, DAG) &&
15853 TLI.allowsMemoryAccess(Context, DL, StoreTy,
15856 TLI.allowsMemoryAccess(Context, DL, StoreTy,
15865 if (TLI.isTypeLegal(StoreTy) &&
15866 TLI.canMergeStoresTo(FirstStoreAS, StoreTy, DAG) &&
15867 TLI.allowsMemoryAccess(Context, DL, StoreTy,
15870 TLI.allowsMemoryAccess(Context, DL, StoreTy,
15876 } else if (TLI.getTypeAction(Context, StoreTy) ==
15878 EVT LegalizedStoredValTy = TLI.getTypeToTransformTo(Context, StoreTy);
15879 if (TLI.isTruncStoreLegal(LegalizedStoredValTy, StoreTy) &&
15880 TLI.canMergeStoresTo(FirstStoreAS, LegalizedStoredValTy, DAG) &&
15881 TLI.isLoadExtLegal(ISD::ZEXTLOAD, LegalizedStoredValTy,
15883 TLI.isLoadExtLegal(ISD::SEXTLOAD, LegalizedStoredValTy,
15885 TLI.isLoadExtLegal(ISD::EXTLOAD, LegalizedStoredValTy, StoreTy) &&
15886 TLI.allowsMemoryAccess(Context, DL, StoreTy,
15890 TLI.allowsMemoryAccess(Context, DL, StoreTy,
15982 TLI.getTypeToTransformTo(*DAG.getContext(), JointMemOpVT);
16072 TLI.isOperationLegalOrCustom(ISD::STORE, MVT::i32)) {
16082 if ((TLI.isTypeLegal(MVT::i64) && !LegalOperations &&
16084 TLI.isOperationLegalOrCustom(ISD::STORE, MVT::i64)) {
16093 TLI.isOperationLegalOrCustom(ISD::STORE, MVT::i32)) {
16141 TLI.isOperationLegal(ISD::STORE, SVT)) &&
16142 TLI.isStoreBitCastBeneficial(Value.getValueType(), SVT,
16293 TLI.isTruncStoreLegal(Value.getOperand(0).getValueType(),
16302 if (!LegalTypes || (TLI.mergeStoresAfterLegalization(ST->getMemoryVT()))) {
16467 if (!TLI.isMultiStoresCheaperThanBitsMerge(LowTy, HighTy))
16532 TLI.buildLegalVectorShuffle(Vec.getValueType(), SDLoc(N), X,
16571 if (!TLI.isShuffleMaskLegal(Mask, ShufVT))
16609 if (InVec.isUndef() && TLI.shouldSplatInsEltVarIndex(VT)) {
16642 if (LegalOperations && !TLI.isOperationLegal(ISD::BUILD_VECTOR, VT))
16684 if (NewAlign > Align || !TLI.isOperationLegalOrCustom(ISD::LOAD, VecEltVT))
16689 if (!TLI.shouldReduceLoadWidth(OriginalLoad, ExtTy, VecEltVT))
16726 ISD::LoadExtType ExtType = TLI.isLoadExtLegal(ISD::ZEXTLOAD, ResultVT,
16834 TLI.isTypeLegal(VecVT) &&
16835 (VecOp.hasOneUse() || TLI.aggressivelyPreferBuildVectorSources(VecVT))) {
16926 TLI.isOperationLegal(ISD::EXTRACT_VECTOR_ELT, VecVT) ||
16927 TLI.isOperationExpand(ISD::VECTOR_SHUFFLE, VecVT)) {
16928 EVT IndexTy = TLI.getVectorIdxTy(DAG.getDataLayout());
16962 if (ScalarVT.bitsLT(LVT) && !TLI.isTruncateFree(LVT, ScalarVT))
17153 (!TLI.isOperationLegal(ISD::BUILD_VECTOR, VecVT) &&
17154 TLI.isOperationLegal(ISD::BUILD_VECTOR, VT)))
17170 MVT IdxTy = TLI.getVectorIdxTy(DAG.getDataLayout());
17198 if (!TLI.isExtractSubvectorCheap(VT, InVT1, NumElems))
17216 !TLI.isOperationLegal(ISD::VECTOR_SHUFFLE, InVT1))
17223 if (!TLI.isTypeLegal(InVT2))
17374 if (LegalOperations && !TLI.isOperationLegal(ISD::VECTOR_SHUFFLE, VT))
17446 MVT IdxTy = TLI.getVectorIdxTy(DAG.getDataLayout());
17463 if (TLI.isTypeLegal(SplitVT)) {
17608 if (LegalTypes && !TLI.isTypeLegal(InVT))
17647 if (!LegalTypes || TLI.isTypeLegal(NewVT)) {
17658 if (TLI.getOperationAction(ISD::SPLAT_VECTOR, VT) != TargetLowering::Expand)
17885 !TLI.isTypeLegal(Scalar.getValueType()) &&
17886 TLI.isTypeLegal(Scalar->getOperand(0).getValueType()))
17903 if (!TLI.isTypeLegal(NVT) || !TLI.isTypeLegal(Scalar.getValueType()))
17903 if (!TLI.isTypeLegal(NVT) || !TLI.isTypeLegal(Scalar.getValueType()))
17965 if (Level < AfterLegalizeVectorOps && TLI.isTypeLegal(VT))
18230 if (TLI.isOperationLegalOrCustomOrPromote(ISD::LOAD, NVT))
18239 if (TLI.isExtractSubvectorCheap(NVT, V.getOperand(0).getValueType(),
18241 TLI.isOperationLegalOrCustom(ISD::EXTRACT_SUBVECTOR, NVT)) {
18260 if (TLI.isOperationLegalOrCustom(ISD::EXTRACT_SUBVECTOR, NewExtVT)) {
18304 TLI.isOperationLegal(ISD::BUILD_VECTOR, ExtractVT))) &&
18305 (!LegalTypes || TLI.isTypeLegal(ExtractVT))) {
18901 if (N0.hasOneUse() && TLI.isExtractVecEltCheap(VT, SplatIndex) &&
18902 TLI.isBinOp(N0.getOpcode()) && N0.getNode()->getNumValues() == 1) {
18976 if (SDValue V = combineShuffleToVectorExtend(SVN, DAG, TLI, LegalOperations))
18994 if (Level < AfterLegalizeDAG && TLI.isTypeLegal(VT))
18995 if (SDValue Res = combineShuffleOfScalars(SVN, DAG, TLI))
19003 TLI.isTypeLegal(VT)) {
19025 if (TLI.isTypeLegal(ScaleVT) &&
19046 bool LegalMask = TLI.isShuffleMaskLegal(NewMask, ScaleVT);
19050 LegalMask = TLI.isShuffleMaskLegal(NewMask, ScaleVT);
19069 TLI.isTypeLegal(VT)) {
19092 Level < AfterLegalizeDAG && TLI.isTypeLegal(VT)) {
19182 return TLI.buildLegalVectorShuffle(VT, SDLoc(N), SV0, SV1, Mask, DAG);
19217 TLI.buildLegalVectorShuffle(InVecT, SDLoc(N), InVec,
19226 MVT IdxTy = TLI.getVectorIdxTy(DAG.getDataLayout());
19326 MVT IdxVT = TLI.getVectorIdxTy(DAG.getDataLayout());
19421 DAG.getConstant(0, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
19432 if (!TLI.isOperationLegalOrCustom(Opcode, VT) &&
19433 TLI.isOperationLegalOrCustom(NewOpcode, VT) &&
19510 if (!TLI.isVectorClearMaskLegal(Indices, ClearVT))
19631 TLI.isOperationLegalOrCustomOrPromote(Opcode, NarrowVT)) {
19660 TLI.isOperationLegalOrCustomOrPromote(Opcode, NarrowVT)) {
19794 !TLI.isOperationLegalOrCustom(TheSelect->getOpcode(),
19920 if (CC == ISD::SETGT && TLI.hasAndNot(N2)) {
19977 if (!TLI.reduceSelectOfFPConstantLoads(N0.getValueType()))
19985 if (!TV || !FV || !TLI.isTypeLegal(VT))
19989 if (TLI.getOperationAction(ISD::ConstantFP, VT) == TargetLowering::Legal ||
19990 TLI.isFPImmLegal(TV->getValueAPF(), TV->getValueType(0), ForCodeSize) ||
19991 TLI.isFPImmLegal(FV->getValueAPF(), FV->getValueType(0), ForCodeSize))
20006 SDValue CPIdx = DAG.getConstantPool(CA, TLI.getPointerTy(DAG.getDataLayout()),
20070 TLI.isOperationLegal(ISD::SHL, VT) &&
20071 TLI.isOperationLegal(ISD::SRA, VT)) {
20098 TLI.getBooleanContents(CmpOpVT) ==
20100 (!LegalOperations || TLI.isOperationLegal(ISD::SETCC, CmpOpVT))) {
20160 (!LegalOperations || TLI.isOperationLegal(ISD::CTTZ, VT)))
20167 (!LegalOperations || TLI.isOperationLegal(ISD::CTLZ, VT)))
20182 return TLI.SimplifySetCC(VT, N0, N1, Cond, foldBooleans, DagCombineInfo, DL);
20196 if (SDValue S = TLI.BuildSDIV(N, DAG, LegalOperations, Built)) {
20217 if (SDValue S = TLI.BuildSDIVPow2(N, C->getAPIntValue(), DAG, Built)) {
20237 if (SDValue S = TLI.BuildUDIV(N, DAG, LegalOperations, Built)) {
20277 int Enabled = TLI.getRecipEstimateDivEnabled(VT, MF);
20278 if (Enabled == TLI.ReciprocalEstimate::Disabled)
20283 int Iterations = TLI.getDivRefinementSteps(VT, MF);
20284 if (SDValue Est = TLI.getRecipEstimate(Op, DAG, Enabled, Iterations)) {
20416 int Enabled = TLI.getRecipEstimateSqrtEnabled(VT, MF);
20417 if (Enabled == TLI.ReciprocalEstimate::Disabled)
20422 int Iterations = TLI.getSqrtRefinementSteps(VT, MF);
20426 TLI.getSqrtEstimate(Op, DAG, Enabled, Iterations, UseOneConstNR,
20676 if (Depth > TLI.getGatherAllAliasesMaxDepth()) {