Lines Matching refs:SetCC
711 // Return true if this node is a setcc, or is a select_cc
713 // equivalent to a setcc. Also, set the incoming LHS, RHS, and CC references to
718 if (N.getOpcode() == ISD::SETCC) {
740 /// Return true if this is a SetCC-equivalent operation with only one use.
1399 case ISD::SETCC: return visitSETCC(N);
2872 // fold (and (setcc x), (setcc y)) -> (setcc (and x, y))
2929 TLI.isOperationLegal(ISD::SETCC, LL.getValueType())))) {
3585 // fold (or (setcc x), (setcc y)) -> (setcc (or x, y))
3620 TLI.isOperationLegal(ISD::SETCC, LL.getValueType())))) {
4131 llvm_unreachable("Unhandled SetCC Equivalent!");
4132 case ISD::SETCC:
4141 // fold (not (zext (setcc x, y))) -> (zext (not (setcc x, y)))
4153 // fold (not (or x, y)) -> (and (not x), (not y)) iff x or y are setcc
4367 // If setcc produces all-one true value then:
4368 // (shl (and (setcc) N01CV) N1CV) -> (and (setcc) N01CV<<N1CV)
4375 if (N01CV && N01CV->isConstant() && N00.getOpcode() == ISD::SETCC &&
4894 // %c = setcc eq %b, 0
5037 // can find the SETCC that produced it and inspect its operands. This is
5038 // fairly easy if C is the SETCC node, but it can potentially be
5164 // fold selects based on a setcc into other things, such as min/max/abs
5165 if (N0.getOpcode() == ISD::SETCC) {
5282 // SETCC, then split both nodes and its operands before legalization. This
5283 // prevents the type legalizer from unrolling SETCC into scalar comparisons
5285 if (Mask.getOpcode() != ISD::SETCC)
5343 // SETCC, then split both nodes and its operands before legalization. This
5344 // prevents the type legalizer from unrolling SETCC into scalar comparisons
5346 if (Mask.getOpcode() == ISD::SETCC) {
5416 // SETCC, then split both nodes and its operands before legalization. This
5417 // prevents the type legalizer from unrolling SETCC into scalar comparisons
5420 if (Mask.getOpcode() != ISD::SETCC)
5493 // SETCC, then split both nodes and its operands before legalization. This
5494 // prevents the type legalizer from unrolling SETCC into scalar comparisons
5497 if (Mask.getOpcode() == ISD::SETCC) {
5580 if (N0.getOpcode() == ISD::SETCC) {
5610 // SETCC, then split both nodes and its operands before legalization. This
5611 // prevents the type legalizer from unrolling SETCC into scalar comparisons
5613 if (N0.getOpcode() == ISD::SETCC) {
5682 // coherent the DAG creation, no setcc node is created in this case
5684 } else if (SCC.getOpcode() == ISD::SETCC) {
5712 // If Carry is false, fold to a regular SETCC.
5714 return DAG.getNode(ISD::SETCC, SDLoc(N), N->getVTList(), LHS, RHS, Cond);
5796 // FIXME: Only extend SETCC N, N and SETCC N, c for now.
5797 if (ExtOpc != ISD::ANY_EXTEND && User->getOpcode() == ISD::SETCC) {
5845 // Extend SetCC uses if necessary.
5847 SDNode *SetCC = SetCCs[i];
5851 SDValue SOp = SetCC->getOperand(j);
5858 Ops.push_back(SetCC->getOperand(2));
5859 CombineTo(SetCC, DAG.getNode(ISD::SETCC, DL, SetCC->getValueType(0), Ops));
6115 if (N0.getOpcode() == ISD::SETCC) {
6117 // sext(setcc) -> sext_in_reg(vsetcc) for vectors.
6122 // On some architectures (such as SSE/NEON/etc) the SETCC result type is
6123 // of the same size as the compared operands. Only optimize sext(setcc())
6149 // sext(setcc x, y, cc) -> (select (setcc x, y, cc), -1, 0)
6163 TLI.isOperationLegal(ISD::SETCC, N0.getOperand(0).getValueType())) {
6166 SDValue SetCC = DAG.getSetCC(DL, SetCCVT,
6168 return DAG.getSelect(DL, VT, SetCC,
6195 if (N->getOpcode() != ISD::SETCC || N->getValueType(0) != MVT::i1 ||
6439 if (N0.getOpcode() == ISD::SETCC) {
6446 // zext(setcc) -> (and (vsetcc), (1, 1, ...) for vectors.
6483 // zext(setcc x,y,cc) -> select_cc x, y, 1, 0, cc
6632 if (N0.getOpcode() == ISD::SETCC) {
6634 // aext(setcc) -> vsetcc
6635 // aext(setcc) -> truncate(vsetcc)
6636 // aext(setcc) -> aext(vsetcc)
6662 // aext(setcc x,y,cc) -> select_cc x, y, 1, 0, cc
8883 // fold (sint_to_fp (setcc x, y, cc)) -> (select_cc x, y, -1.0, 0.0,, cc)
8884 if (N0.getOpcode() == ISD::SETCC && N0.getValueType() == MVT::i1 &&
8896 // fold (sint_to_fp (zext (setcc x, y, cc))) ->
8899 N0.getOperand(0).getOpcode() == ISD::SETCC &&!VT.isVector() &&
8937 // fold (uint_to_fp (setcc x, y, cc)) -> (select_cc x, y, -1.0, 0.0,, cc)
8939 if (N0.getOpcode() == ISD::SETCC && !VT.isVector() &&
9330 // fold a brcond with a setcc condition into a BR_CC node if BR_CC is legal
9332 if (N1.getOpcode() == ISD::SETCC &&
9362 // %c = setcc eq %b, 0
9381 SDValue SetCC =
9388 MVT::Other, Chain, SetCC, N2);
9395 // Replace the uses of SRL with SETCC
9397 DAG.ReplaceAllUsesOfValueWith(N1, SetCC);
9437 if (Op0.getOpcode() != ISD::SETCC && Op1.getOpcode() != ISD::SETCC) {
9448 SDValue SetCC = DAG.getSetCC(SDLoc(TheXor),
9452 // Replace the uses of XOR with SETCC
9454 DAG.ReplaceAllUsesOfValueWith(N1, SetCC);
9457 MVT::Other, Chain, SetCC, N2);
9476 // Use SimplifySetCC to simplify SETCC's.
9482 // fold to a simpler setcc
9483 if (Simp.getNode() && Simp.getOpcode() == ISD::SETCC)
13794 assert(N0.getOpcode() ==ISD::SETCC && "First argument must be a SetCC node!");
13800 // break it down into a new SETCC node, and a new SELECT node, and then return
13803 // Check to see if we got a select_cc back (to turn into setcc/select).
13806 SDValue SETCC = DAG.getNode(ISD::SETCC, SDLoc(N0),
13810 AddToWorklist(SETCC.getNode());
13811 return DAG.getSelect(SDLoc(SCC), SCC.getValueType(), SETCC,
13828 // fold (select (setcc x, -0.0, *lt), NaN, (fsqrt x))
13829 // The select + setcc is redundant, because fsqrt returns NaN for X < -0.
13832 // We have: (select (setcc ?, ?, ?), NaN, (fsqrt ?))
13845 if (Cmp.getOpcode() == ISD::SETCC) {
13854 // We have: (select (setcc x, -0.0, *lt), NaN, (fsqrt x))
14152 // Get a SetCC of the condition
14153 // NOTE: Don't create a SETCC if it's not legal on this target.
14155 TLI.isOperationLegal(ISD::SETCC, N0.getValueType())) {
14157 // cast from setcc result type to select result type
14179 // shl setcc result by log2 n2c
