Lines Matching refs:Lo
14 // computation in two identical registers of a smaller type. The Lo/Hi part
31 // These routines assume that the Lo/Hi part is stored first in memory on
32 // little/big-endian machines, followed by the Hi/Lo part. This means that
33 // they cannot be used as is on vectors, for which Lo is always stored first.
35 SDValue &Lo, SDValue &Hi) {
37 GetExpandedOp(Op, Lo, Hi);
40 void DAGTypeLegalizer::ExpandRes_BITCAST(SDNode *N, SDValue &Lo, SDValue &Hi) {
56 SplitInteger(GetSoftenedFloat(InOp), Lo, Hi);
57 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
63 GetExpandedOp(InOp, Lo, Hi);
64 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
68 GetSplitVector(InOp, Lo, Hi);
70 std::swap(Lo, Hi);
71 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
76 SplitInteger(BitConvertToInteger(GetScalarizedVector(InOp)), Lo, Hi);
77 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
85 Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, InNVT, InOp,
90 std::swap(Lo, Hi);
91 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
104 Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NOutVT, CastInOp,
110 std::swap(Lo, Hi);
133 Lo = DAG.getLoad(NOutVT, dl, Store, StackPtr, PtrInfo, false, false, 0);
147 std::swap(Lo, Hi);
150 void DAGTypeLegalizer::ExpandRes_BUILD_PAIR(SDNode *N, SDValue &Lo,
153 Lo = N->getOperand(0);
157 void DAGTypeLegalizer::ExpandRes_EXTRACT_ELEMENT(SDNode *N, SDValue &Lo,
159 GetExpandedOp(N->getOperand(0), Lo, Hi);
161 Hi : Lo;
166 GetPairElements(Part, Lo, Hi);
169 void DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo,
193 Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx);
200 std::swap(Lo, Hi);
203 void DAGTypeLegalizer::ExpandRes_NormalLoad(SDNode *N, SDValue &Lo,
218 Lo = DAG.getLoad(NVT, dl, Chain, Ptr, LD->getPointerInfo(),
232 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
237 std::swap(Lo, Hi);
244 void DAGTypeLegalizer::ExpandRes_VAARG(SDNode *N, SDValue &Lo, SDValue &Hi) {
252 Lo = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2), Align);
253 Hi = DAG.getVAArg(NVT, dl, Lo.getValue(1), Ptr, N->getOperand(2), 0);
257 std::swap(Lo, Hi);
315 SDValue Lo, Hi;
316 GetExpandedOp(N->getOperand(i), Lo, Hi);
318 std::swap(Lo, Hi);
319 NewElts.push_back(Lo);
333 SDValue Lo, Hi;
334 GetExpandedOp(N->getOperand(0), Lo, Hi);
335 return cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? Hi : Lo;
357 SDValue Lo, Hi;
358 GetExpandedOp(Val, Lo, Hi);
360 std::swap(Lo, Hi);
364 NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Lo, Idx);
404 SDValue Lo, Hi;
405 GetExpandedOp(St->getValue(), Lo, Hi);
408 std::swap(Lo, Hi);
410 Lo = DAG.getStore(Chain, dl, Lo, Ptr, St->getPointerInfo(),
421 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
429 // Be careful to make no assumptions about which of Lo/Hi is stored first in
430 // memory (for vectors it is always Lo first followed by Hi in the following
431 // bytes; for integers and floats it is Lo first if and only if the machine is
435 SDValue &Lo, SDValue &Hi) {
437 GetSplitOp(Op, Lo, Hi);
440 void DAGTypeLegalizer::SplitRes_SELECT(SDNode *N, SDValue &Lo,
460 Lo = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), CL, LL, RL);
464 void DAGTypeLegalizer::SplitRes_SELECT_CC(SDNode *N, SDValue &Lo,
471 Lo = DAG.getNode(ISD::SELECT_CC, dl, LL.getValueType(), N->getOperand(0),
477 void DAGTypeLegalizer::SplitRes_UNDEF(SDNode *N, SDValue &Lo, SDValue &Hi) {
480 Lo = DAG.getUNDEF(LoVT);