Lines Matching refs:Result
920 SDValue Result = DAG.getNode(ISD::TRUNCATE, dl, VT, NewLD);
925 Result.getNode()->dump(&DAG);
928 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Result, &DeadNodes);
932 AddToWorkList(Result.getNode());
1255 SDValue Result;
1261 Result = DAG.getEntryNode();
1264 Result = DAG.getNode(ISD::TokenFactor, N->getDebugLoc(),
1269 return CombineTo(N, Result, false);
1272 return Result;
1425 SDValue Result = combineShlAddConstant(N->getDebugLoc(), N0, N1, DAG);
1426 if (Result.getNode()) return Result;
1429 SDValue Result = combineShlAddConstant(N->getDebugLoc(), N1, N0, DAG);
1430 if (Result.getNode()) return Result;
1486 // If the flag result is dead, turn this into an ADD.
1628 // If either operand of a sub is undef, the result is undef
1806 // negate the result.
2355 ISD::CondCode Result = ISD::getSetCCAndOperation(Op0, Op1, isInteger);
2356 if (Result != ISD::SETCC_INVALID &&
2357 (!LegalOperations || TLI.isCondCodeLegal(Result, LL.getValueType())))
2359 LL, LR, Result);
2720 // Result of the bswap should be rotated by 16. If it's not legal, than
2824 ISD::CondCode Result = ISD::getSetCCOrOperation(Op0, Op1, isInteger);
2825 if (Result != ISD::SETCC_INVALID &&
2826 (!LegalOperations || TLI.isCondCodeLegal(Result, LL.getValueType())))
2828 LL, LR, Result);
2949 // If there is an AND of either shifted operand, apply it to the result.
3421 // If truncate is free for the target sext(shl) is likely to result in better
3427 // Determine what the truncate's result bitsize and type would be.
3614 // zeros, thus the result of the srl will always be zero.
3618 // the result of the ctlz is "32" and the result of the shift is one.
4116 // # elements of the compare (and the # elements of the compare result
4118 // we know that the element size of the sext'd result matches the
4346 // # elements of the compare (and the # elements of the compare result
4348 // we know that the element size of the sext'd result matches the
4530 // # elements of the compare (and the # elements of the compare result
4532 // we know that the element size of the sext'd result matches the
4602 /// ReduceLoadWidth - If the result of a wider load is shifted to right of N
4605 /// from address + N / num of bits of new type. If the result is to be
4660 // then the result of the shift+trunc is zero/undef (handled elsewhere).
4661 // If the load was a sextload then the result is a splat of the sign bit
4668 // If the load is shifted left (and the result isn't shifted back right),
4724 // Shift the result left, if we've swallowed a left shift.
4725 SDValue Result = Load;
4727 EVT ShImmTy = getShiftAmountTy(Result.getValueType());
4730 Result = DAG.getNode(ISD::SHL, N0.getDebugLoc(), VT,
4731 Result, DAG.getConstant(ShLeftAmt, ShImmTy));
4735 return Result;
5053 // If X has a different width than the result/lhs, sext it or truncate it.
5742 // smart enough to convert the result into a TEST/JMP sequence.
5963 SDValue Result;
5965 Result = DAG.getIndexedLoad(SDValue(N,0), N->getDebugLoc(),
5968 Result = DAG.getIndexedStore(SDValue(N,0), N->getDebugLoc(),
5975 Result.getNode()->dump(&DAG);
5979 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Result.getValue(0),
5981 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), Result.getValue(2),
5984 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Result.getValue(1),
5992 DAG.ReplaceAllUsesOfValueWith(Ptr, Result.getValue(isLoad ? 1 : 0),
6095 SDValue Result = isLoad
6105 Result.getNode()->dump(&DAG);
6109 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Result.getValue(0),
6111 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), Result.getValue(2),
6114 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Result.getValue(1),
6123 Result.getValue(isLoad ? 1 : 0),
6247 // Replace uses with load result and token factor. Don't add users
6265 std::pair<unsigned, unsigned> Result(0, 0);
6271 return Result;
6275 if (LD->getBasePtr() != Ptr) return Result; // Not from same pointer.
6282 return Result; // Fail.
6290 if (!isOk) return Result;
6297 return Result;
6304 if (NotMaskLZ & 7) return Result; // Must be multiple of a byte.
6306 if (NotMaskTZ & 7) return Result; // Must be multiple of a byte.
6307 if (NotMaskLZ == 64) return Result; // All zero mask.
6311 return Result;
6322 default: return Result; // All one mask, or 5-byte mask.
6327 if (NotMaskTZ && NotMaskTZ/8 % MaskedBytes) return Result;
6329 Result.first = MaskedBytes;
6330 Result.second = NotMaskTZ/8;
6331 return Result;
6823 // Check if the result type doesn't match the inserted element type. A
6955 // If the input vector type disagrees with the result of the build_vector,
7190 // things. Simplifying them may result in a loss of legality.
7373 // Users of the select now use the result of the load.
7543 // Now arithmetic right shift it all the way over, so the result is either
7567 // cast from setcc result type to select result type
7588 // shl setcc result by log2 n2c
