CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp

14 // computation in two identical registers of a smaller type.  The Lo/Hi part
30 // These routines assume that the Lo/Hi part is stored first in memory on
31 // little/big-endian machines, followed by the Hi/Lo part.  This means that
34                                               SDValue &Lo, SDValue &Hi) {
36   GetExpandedOp(Op, Lo, Hi);
39 void DAGTypeLegalizer::ExpandRes_BITCAST(SDNode *N, SDValue &Lo, SDValue &Hi) {
53       SplitInteger(GetSoftenedFloat(InOp), Lo, Hi);
55       Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
60       GetExpandedOp(InOp, Lo, Hi);
62       Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
65       GetSplitVector(InOp, Lo, Hi);
67         std::swap(Lo, Hi);
69       Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
73       SplitInteger(BitConvertToInteger(GetScalarizedVector(InOp)), Lo, Hi);
75       Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
84       Hi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, InNVT, InOp,
87         std::swap(Lo, Hi);
89       Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
120       // Build Lo, Hi pair by pairing extracted elements if needed.
124         // there are only two nodes left, i.e. Lo and Hi.
138       Hi = Vals[Slot++];
141         std::swap(Lo, Hi);
173   Hi = DAG.getLoad(NOutVT, dl, Store, StackPtr,
179     std::swap(Lo, Hi);
183                                             SDValue &Hi) {
186   Hi = N->getOperand(1);
190                                                  SDValue &Hi) {
191   GetExpandedOp(N->getOperand(0), Lo, Hi);
193                    Hi : Lo;
198   GetPairElements(Part, Lo, Hi);
202                                                     SDValue &Hi) {
239   Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx);
242     std::swap(Lo, Hi);
246                                             SDValue &Hi) {
268   Hi = DAG.getLoad(NVT, dl, Chain, Ptr,
276                       Hi.getValue(1));
280     std::swap(Lo, Hi);
287 void DAGTypeLegalizer::ExpandRes_VAARG(SDNode *N, SDValue &Lo, SDValue &Hi) {
296   Hi = DAG.getVAArg(NVT, dl, Lo.getValue(1), Ptr, N->getOperand(2), 0);
300     std::swap(Lo, Hi);
304   ReplaceValueWith(SDValue(N, 1), Hi.getValue(1));
358     SDValue Lo, Hi;
359     GetExpandedOp(N->getOperand(i), Lo, Hi);
361       std::swap(Lo, Hi);
363     NewElts.push_back(Hi);
376   SDValue Lo, Hi;
377   GetExpandedOp(N->getOperand(0), Lo, Hi);
378   return cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? Hi : Lo;
400   SDValue Lo, Hi;
401   GetExpandedOp(Val, Lo, Hi);
403     std::swap(Lo, Hi);
410   NewVec =  DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Hi, Idx);
447   SDValue Lo, Hi;
448   GetExpandedOp(St->getValue(), Lo, Hi);
451     std::swap(Lo, Hi);
459   Hi = DAG.getStore(Chain, dl, Hi, Ptr,
464   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
472 // Be careful to make no assumptions about which of Lo/Hi is stored first in
473 // memory (for vectors it is always Lo first followed by Hi in the following
478                                              SDValue &Lo, SDValue &Hi) {
480   GetSplitOp(Op, Lo, Hi);
484                                        SDValue &Hi) {
504   Hi = DAG.getNode(N->getOpcode(), dl, LH.getValueType(), CH, LH, RH);
508                                           SDValue &Hi) {
516   Hi = DAG.getNode(ISD::SELECT_CC, dl, LH.getValueType(), N->getOperand(0),
520 void DAGTypeLegalizer::SplitRes_UNDEF(SDNode *N, SDValue &Lo, SDValue &Hi) {
524   Hi = DAG.getUNDEF(HiVT);