Lines Matching refs:Parts
94 const SDValue *Parts, unsigned NumParts,
97 /// getCopyFromParts - Create a value that contains the specified legal parts
98 /// combined into the value they represent. If the parts combine to a type
103 const SDValue *Parts,
108 return getCopyFromPartsVector(DAG, DL, Parts, NumParts,
111 assert(NumParts > 0 && "No parts to assemble!");
113 SDValue Val = Parts[0];
116 // Assemble the value from multiple parts.
132 Lo = getCopyFromParts(DAG, DL, Parts, RoundParts / 2,
134 Hi = getCopyFromParts(DAG, DL, Parts + RoundParts / 2,
137 Lo = DAG.getNode(ISD::BITCAST, DL, HalfVT, Parts[0]);
138 Hi = DAG.getNode(ISD::BITCAST, DL, HalfVT, Parts[1]);
151 Parts + RoundParts, OddParts, PartVT, OddVT, V);
153 // Combine the round and odd parts.
166 // FP split into multiple FP parts (for ppcf128)
170 Lo = DAG.getNode(ISD::BITCAST, DL, EVT(MVT::f64), Parts[0]);
171 Hi = DAG.getNode(ISD::BITCAST, DL, EVT(MVT::f64), Parts[1]);
176 // FP split into integer parts (soft fp)
180 Val = getCopyFromParts(DAG, DL, Parts, NumParts, PartVT, IntVT, V);
233 /// parts combined into the value they represent. If the parts combine to a
238 const SDValue *Parts, unsigned NumParts,
241 assert(NumParts > 0 && "No parts to assemble!");
243 SDValue Val = Parts[0];
256 assert(RegisterVT == Parts[0].getSimpleValueType() &&
259 // Assemble the parts into intermediate operands.
265 Ops[i] = getCopyFromParts(DAG, DL, &Parts[i], 1,
269 // operands from the parts.
271 "Must expand into a divisible number of parts!");
274 Ops[i] = getCopyFromParts(DAG, DL, &Parts[i * Factor], Factor,
293 // parts vector has more elements than the value vector, then we have a
340 SDValue Val, SDValue *Parts, unsigned NumParts,
344 /// split into legal parts. If the parts contain more bits than Val, then, for
347 SDValue Val, SDValue *Parts, unsigned NumParts,
354 return getCopyToPartsVector(DAG, DL, Val, Parts, NumParts, PartVT, V);
367 assert(NumParts == 1 && "No-op copy with multiple parts!");
368 Parts[0] = Val;
373 // If the parts cover more bits than the value has, promote the value.
391 parts cover less bits than value has, truncate the value.
411 Parts[0] = Val;
415 // Expand the value into multiple parts.
417 // The number of parts is not a power of 2. Split off and copy the tail.
425 getCopyToParts(DAG, DL, OddVal, Parts + RoundParts, OddParts, PartVT, V);
428 // The odd parts were reversed by getCopyToParts - unreverse them.
429 std::reverse(Parts + RoundParts, Parts + NumParts);
436 // The number of parts is a power of 2. Repeatedly bisect the value using
438 Parts[0] = DAG.getNode(ISD::BITCAST, DL,
447 SDValue &Part0 = Parts[i];
448 SDValue &Part1 = Parts[i+StepSize/2];
463 std::reverse(Parts, Parts + OrigNumParts);
468 /// value split into legal parts.
470 SDValue Val, SDValue *Parts, unsigned NumParts,
526 Parts[0] = Val;
557 // Split the intermediate operands into legal parts.
562 getCopyToParts(DAG, DL, Ops[i], &Parts[i], 1, PartVT, V);
565 // legal parts.
567 "Must expand into a divisible number of parts!");
570 getCopyToParts(DAG, DL, Ops[i], &Parts[i*Factor], Factor, PartVT, V);
676 // Assemble the legal parts into the final values.
678 SmallVector<SDValue, 8> Parts;
680 // Copy the legal parts from the registers.
685 Parts.resize(NumRegs);
696 Parts[i] = P;
717 Parts[i] = DAG.getConstant(0, RegisterVT);
746 Parts[i] = DAG.getNode(isSExt ? ISD::AssertSext : ISD::AssertZext, dl,
750 Values[Value] = getCopyFromParts(DAG, dl, Parts.begin(),
753 Parts.clear();
768 // Get the list of the values's legal parts.
770 SmallVector<SDValue, 8> Parts(NumRegs);
779 &Parts[Part], NumParts, RegisterVT, V, ExtendKind);
783 // Copy the parts into the registers.
788 Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i]);
790 Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i], *Flag);
1249 SmallVector<SDValue, 4> Parts(NumParts);
1252 &Parts[0], NumParts, PartVT, &I, ExtendKind);
1267 Outs.push_back(ISD::OutputArg(Flags, Parts[i].getValueType(),
1269 OutVals.push_back(Parts[i]);
7191 SmallVector<SDValue, 4> Parts(NumParts);
7219 getCopyToParts(CLI.DAG, CLI.DL, Op, &Parts[0], NumParts, PartVT,
7224 ISD::OutputArg MyFlags(Flags, Parts[j].getValueType(), VT,
7226 i, j*Parts[j].getValueType().getStoreSize());
7237 CLI.OutVals.push_back(Parts[j]);
7297 // Collect the legal value parts into potentially illegal values
