Lines Matching full:parts
92 const SDValue *Parts, unsigned NumParts,
95 /// getCopyFromParts - Create a value that contains the specified legal parts
96 /// combined into the value they represent. If the parts combine to a type
101 const SDValue *Parts,
106 return getCopyFromPartsVector(DAG, DL, Parts, NumParts,
109 assert(NumParts > 0 && "No parts to assemble!");
111 SDValue Val = Parts[0];
114 // Assemble the value from multiple parts.
130 Lo = getCopyFromParts(DAG, DL, Parts, RoundParts / 2,
132 Hi = getCopyFromParts(DAG, DL, Parts + RoundParts / 2,
135 Lo = DAG.getNode(ISD::BITCAST, DL, HalfVT, Parts[0]);
136 Hi = DAG.getNode(ISD::BITCAST, DL, HalfVT, Parts[1]);
149 Parts + RoundParts, OddParts, PartVT, OddVT, V);
151 // Combine the round and odd parts.
164 // FP split into multiple FP parts (for ppcf128)
168 Lo = DAG.getNode(ISD::BITCAST, DL, EVT(MVT::f64), Parts[0]);
169 Hi = DAG.getNode(ISD::BITCAST, DL, EVT(MVT::f64), Parts[1]);
174 // FP split into integer parts (soft fp)
178 Val = getCopyFromParts(DAG, DL, Parts, NumParts, PartVT, IntVT, V);
217 /// parts combined into the value they represent. If the parts combine to a
222 const SDValue *Parts, unsigned NumParts,
225 assert(NumParts > 0 && "No parts to assemble!");
227 SDValue Val = Parts[0];
240 assert(RegisterVT == Parts[0].getSimpleValueType() &&
243 // Assemble the parts into intermediate operands.
249 Ops[i] = getCopyFromParts(DAG, DL, &Parts[i], 1,
253 // operands from the parts.
255 "Must expand into a divisible number of parts!");
258 Ops[i] = getCopyFromParts(DAG, DL, &Parts[i * Factor], Factor,
277 // parts vector has more elements than the value vector, then we have a
332 SDValue Val, SDValue *Parts, unsigned NumParts,
336 /// split into legal parts. If the parts contain more bits than Val, then, for
339 SDValue Val, SDValue *Parts, unsigned NumParts,
346 return getCopyToPartsVector(DAG, DL, Val, Parts, NumParts, PartVT, V);
359 assert(NumParts == 1 && "No-op copy with multiple parts!");
360 Parts[0] = Val;
365 // If the parts cover more bits than the value has, promote the value.
383 // If the parts cover less bits than value has, truncate the value.
412 Parts[0] = Val;
416 // Expand the value into multiple parts.
418 // The number of parts is not a power of 2. Split off and copy the tail.
426 getCopyToParts(DAG, DL, OddVal, Parts + RoundParts, OddParts, PartVT, V);
429 // The odd parts were reversed by getCopyToParts - unreverse them.
430 std::reverse(Parts + RoundParts, Parts + NumParts);
437 // The number of parts is a power of 2. Repeatedly bisect the value using
439 Parts[0] = DAG.getNode(ISD::BITCAST, DL,
448 SDValue &Part0 = Parts[i];
449 SDValue &Part1 = Parts[i+StepSize/2];
464 std::reverse(Parts, Parts + OrigNumParts);
469 /// value split into legal parts.
471 SDValue Val, SDValue *Parts, unsigned NumParts,
527 Parts[0] = Val;
558 // Split the intermediate operands into legal parts.
563 getCopyToParts(DAG, DL, Ops[i], &Parts[i], 1, PartVT, V);
566 // legal parts.
568 "Must expand into a divisible number of parts!");
571 getCopyToParts(DAG, DL, Ops[i], &Parts[i*Factor], Factor, PartVT, V);
687 // Assemble the legal parts into the final values.
689 SmallVector<SDValue, 8> Parts;
691 // Copy the legal parts from the registers.
696 Parts.resize(NumRegs);
707 Parts[i] = P;
728 Parts[i] = DAG.getConstant(0, RegisterVT);
757 Parts[i] = DAG.getNode(isSExt ? ISD::AssertSext : ISD::AssertZext, dl,
761 Values[Value] = getCopyFromParts(DAG, dl, Parts.begin(),
764 Parts.clear();
781 // Get the list of the values's legal parts.
783 SmallVector<SDValue, 8> Parts(NumRegs);
792 &Parts[Part], NumParts, RegisterVT, V, ExtendKind);
796 // Copy the parts into the registers.
801 Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i]);
803 Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i], *Flag);
1252 SmallVector<SDValue, 4> Parts(NumParts);
1255 &Parts[0], NumParts, PartVT, &I, ExtendKind);
1270 Outs.push_back(ISD::OutputArg(Flags, Parts[i].getValueType(),
1272 OutVals.push_back(Parts[i]);
6497 SmallVector<SDValue, 4> Parts(NumParts);
6525 getCopyToParts(CLI.DAG, CLI.DL, Op, &Parts[0], NumParts,
6530 ISD::OutputArg MyFlags(Flags, Parts[j].getValueType(),
6532 i, j*Parts[j].getValueType().getStoreSize());
6539 CLI.OutVals.push_back(Parts[j]);
6571 // Collect the legal value parts into potentially illegal values
