Lines Matching defs:Result
955 SDValue Result = DAG.getNode(ISD::TRUNCATE, dl, VT, NewLD);
960 Result.getNode()->dump(&DAG);
963 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Result);
967 AddToWorkList(Result.getNode());
1305 SDValue Result;
1311 Result = DAG.getEntryNode();
1314 Result = DAG.getNode(ISD::TokenFactor, N->getDebugLoc(),
1319 return CombineTo(N, Result, false);
1322 return Result;
1475 SDValue Result = combineShlAddConstant(N->getDebugLoc(), N0, N1, DAG);
1476 if (Result.getNode()) return Result;
1479 SDValue Result = combineShlAddConstant(N->getDebugLoc(), N1, N0, DAG);
1480 if (Result.getNode()) return Result;
1536 // If the flag result is dead, turn this into an ADD.
1670 // If either operand of a sub is undef, the result is undef
1701 // If the flag result is dead, turn this into an SUB.
1891 // negate the result.
2382 // the same length because the result vector type is the same.
2599 ISD::CondCode Result = ISD::getSetCCAndOperation(Op0, Op1, isInteger);
2600 if (Result != ISD::SETCC_INVALID &&
2601 (!LegalOperations || TLI.isCondCodeLegal(Result, LL.getValueType())))
2603 LL, LR, Result);
2992 // Result of the bswap should be rotated by 16. If it's not legal, than
3096 ISD::CondCode Result = ISD::getSetCCOrOperation(Op0, Op1, isInteger);
3097 if (Result != ISD::SETCC_INVALID &&
3098 (!LegalOperations || TLI.isCondCodeLegal(Result, LL.getValueType())))
3100 LL, LR, Result);
3221 // If there is an AND of either shifted operand, apply it to the result.
3695 // If truncate is free for the target sext(shl) is likely to result in better
3701 // Determine what the truncate's result bitsize and type would be.
3887 // zeros, thus the result of the srl will always be zero.
3891 // the result of the ctlz is "32" and the result of the shift is one.
4408 // On some architectures (such as SSE/NEON/etc) the SETCC result type is
4414 // # elements of the compare (and the # elements of the compare result
4416 // we know that the element size of the sext'd result matches the
4710 // # elements of the compare (and the # elements of the compare result
4712 // we know that the element size of the sext'd result matches the
4894 // # elements of the compare (and the # elements of the compare result
4896 // we know that the element size of the sext'd result matches the
4976 /// ReduceLoadWidth - If the result of a wider load is shifted to right of N
4979 /// from address + N / num of bits of new type. If the result is to be
5034 // then the result of the shift+trunc is zero/undef (handled elsewhere).
5035 // If the load was a sextload then the result is a splat of the sign bit
5042 // If the load is shifted left (and the result isn't shifted back right),
5102 // Shift the result left, if we've swallowed a left shift.
5103 SDValue Result = Load;
5105 EVT ShImmTy = getShiftAmountTy(Result.getValueType());
5108 Result = DAG.getNode(ISD::SHL, N0.getDebugLoc(), VT,
5109 Result, DAG.getConstant(ShLeftAmt, ShImmTy));
5113 return Result;
5471 // If X has a different width than the result/lhs, sext it or truncate it.
6590 // smart enough to convert the result into a TEST/JMP sequence.
6851 SDValue Result;
6853 Result = DAG.getIndexedLoad(SDValue(N,0), N->getDebugLoc(),
6856 Result = DAG.getIndexedStore(SDValue(N,0), N->getDebugLoc(),
6863 Result.getNode()->dump(&DAG);
6867 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Result.getValue(0));
6868 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), Result.getValue(2));
6870 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Result.getValue(1));
6877 DAG.ReplaceAllUsesOfValueWith(Ptr, Result.getValue(isLoad ? 1 : 0));
6977 SDValue Result = isLoad
6987 Result.getNode()->dump(&DAG);
6991 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Result.getValue(0));
6992 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), Result.getValue(2));
6994 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Result.getValue(1));
7002 Result.getValue(isLoad ? 1 : 0));
7124 // Replace uses with load result and token factor. Don't add users
7142 std::pair<unsigned, unsigned> Result(0, 0);
7148 return Result;
7152 if (LD->getBasePtr() != Ptr) return Result; // Not from same pointer.
7159 return Result; // Fail.
7167 if (!isOk) return Result;
7174 return Result;
7181 if (NotMaskLZ & 7) return Result; // Must be multiple of a byte.
7183 if (NotMaskTZ & 7) return Result; // Must be multiple of a byte.
7184 if (NotMaskLZ == 64) return Result; // All zero mask.
7188 return Result;
7199 default: return Result; // All one mask, or 5-byte mask.
7204 if (NotMaskTZ && NotMaskTZ/8 % MaskedBytes) return Result;
7206 Result.first = MaskedBytes;
7207 Result.second = NotMaskTZ/8;
7208 return Result;
7710 // Check if the result type doesn't match the inserted element type. A
7769 // If the result of load has to be truncated, then it's not necessarily
7877 // If the result type of vextract is wider than the load, then issue an
8295 // The incoming shuffle must be of the same type as the result of the
8424 // things. Simplifying them may result in a loss of legality.
8618 // Users of the select now use the result of the load.
8789 // Now arithmetic right shift it all the way over, so the result is either
8814 // cast from setcc result type to select result type
8835 // shl setcc result by log2 n2c
