Lines Matching refs:Parts
89 const SDValue *Parts, unsigned NumParts,
92 /// getCopyFromParts - Create a value that contains the specified legal parts
93 /// combined into the value they represent. If the parts combine to a type
98 const SDValue *Parts,
102 return getCopyFromPartsVector(DAG, DL, Parts, NumParts, PartVT, ValueVT);
104 assert(NumParts > 0 && "No parts to assemble!");
106 SDValue Val = Parts[0];
109 // Assemble the value from multiple parts.
125 Lo = getCopyFromParts(DAG, DL, Parts, RoundParts / 2,
127 Hi = getCopyFromParts(DAG, DL, Parts + RoundParts / 2,
130 Lo = DAG.getNode(ISD::BITCAST, DL, HalfVT, Parts[0]);
131 Hi = DAG.getNode(ISD::BITCAST, DL, HalfVT, Parts[1]);
144 Parts + RoundParts, OddParts, PartVT, OddVT);
146 // Combine the round and odd parts.
159 // FP split into multiple FP parts (for ppcf128)
163 Lo = DAG.getNode(ISD::BITCAST, DL, EVT(MVT::f64), Parts[0]);
164 Hi = DAG.getNode(ISD::BITCAST, DL, EVT(MVT::f64), Parts[1]);
169 // FP split into integer parts (soft fp)
173 Val = getCopyFromParts(DAG, DL, Parts, NumParts, PartVT, IntVT);
212 /// getCopyFromParts - Create a value that contains the specified legal parts
213 /// combined into the value they represent. If the parts combine to a type
218 const SDValue *Parts, unsigned NumParts,
221 assert(NumParts > 0 && "No parts to assemble!");
223 SDValue Val = Parts[0];
235 assert(RegisterVT == Parts[0].getValueType() &&
238 // Assemble the parts into intermediate operands.
244 Ops[i] = getCopyFromParts(DAG, DL, &Parts[i], 1,
248 // operands from the parts.
250 "Must expand into a divisible number of parts!");
253 Ops[i] = getCopyFromParts(DAG, DL, &Parts[i * Factor], Factor,
272 // parts vector has more elements than the value vector, then we have a
319 SDValue Val, SDValue *Parts, unsigned NumParts,
323 /// split into legal parts. If the parts contain more bits than Val, then, for
326 SDValue Val, SDValue *Parts, unsigned NumParts,
333 return getCopyToPartsVector(DAG, DL, Val, Parts, NumParts, PartVT);
345 assert(NumParts == 1 && "No-op copy with multiple parts!");
346 Parts[0] = Val;
351 // If the parts cover more bits than the value has, promote the value.
366 // If the parts cover less bits than value has, truncate the value.
380 Parts[0] = Val;
384 // Expand the value into multiple parts.
386 // The number of parts is not a power of 2. Split off and copy the tail.
394 getCopyToParts(DAG, DL, OddVal, Parts
397 // The odd parts were reversed by getCopyToParts - unreverse them.
398 std::reverse(Parts + RoundParts, Parts + NumParts);
405 // The number of parts is a power of 2. Repeatedly bisect the value using
407 Parts[0] = DAG.getNode(ISD::BITCAST, DL,
416 SDValue &Part0 = Parts[i];
417 SDValue &Part1 = Parts[i+StepSize/2];
432 std::reverse(Parts, Parts + OrigNumParts);
437 /// value split into legal parts.
439 SDValue Val, SDValue *Parts, unsigned NumParts,
493 Parts[0] = Val;
521 // Split the intermediate operands into legal parts.
526 getCopyToParts(DAG, DL, Ops[i], &Parts[i], 1, PartVT);
529 // legal parts.
531 "Must expand into a divisible number of parts!");
534 getCopyToParts(DAG, DL, Ops[i], &Parts[i*Factor], Factor, PartVT);
651 // Assemble the legal parts into the final values.
653 SmallVector<SDValue, 8> Parts;
655 // Copy the legal parts from the registers.
660 Parts.resize(NumRegs);
671 Parts[i] = P;
713 Parts[i] = DAG.getNode(isSExt ? ISD::AssertSext : ISD::AssertZext, dl,
717 Values[Value] = getCopyFromParts(DAG, dl, Parts.begin(),
720 Parts.clear();
736 // Get the list of the values's legal parts.
738 SmallVector<SDValue, 8> Parts(NumRegs);
745 &Parts[Part], NumParts, RegisterVT);
749 // Copy the parts into the registers.
754 Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i]);
756 Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i], *Flag);
1192 SmallVector<SDValue, 4> Parts(NumParts);
1195 &Parts[0], NumParts, PartVT, ExtendKind);
1209 Outs.push_back(ISD::OutputArg(Flags, Parts[i].getValueType(),
1211 OutVals.push_back(Parts[i]);
5273 // Collect the legal value parts into potentially illegal values
6375 SmallVector<SDValue, 4> Parts(NumParts);
6383 getCopyToParts(DAG, dl, Op, &Parts[0], NumParts,
6388 ISD::OutputArg MyFlags(Flags, Parts[j].getValueType(),
6396 OutVals.push_back(Parts[j]);
6451 // Collect the legal value parts into potentially illegal values
