Lines Matching refs:Partition
110 STATISTIC(NumAllocaPartitionUses, "Number of alloca partition uses rewritten");
111 STATISTIC(MaxUsesPerAllocaPartition, "Maximum number of uses of a partition");
354 /// A partition of the slices.
357 /// a partition of the alloca. This range represents a span of the alloca's
359 /// overlapping some part of the partition.
363 class llvm::sroa::Partition {
371 /// partition.
374 /// The start and end iterators of this partition.
377 /// A collection of split slice tails overlapping the partition.
380 /// Raw constructor builds an empty partition starting and ending at
382 Partition(iterator SI) : SI(SI), SJ(SI) {}
385 /// The start offset of this partition.
390 /// The end offset of this partition.
395 /// The size of the partition.
403 /// Test whether this partition contains no slices, and merely spans
407 /// \name Iterate slices that start within the partition.
409 /// partition begin offset.
413 // contiguous iterators of the partition. That would give a much nicer
422 /// These tails are of slices which start before this partition but are
423 /// split and overlap into the partition. We accumulate these while forming
439 Partition> {
444 Partition P;
453 /// Sets the partition to be empty at given iterator, and sets the
458 // partition.
463 /// Advance the iterator to the next partition.
477 // Remove the uses which have ended in the prior partition. This
479 // the prior partition ended prior to that max.
506 // If we had a non-empty partition previously, set up the state for
510 // partition into the split list.
518 // Start from the end of the previous partition.
529 // not splittable immediately form an empty partition for the split
541 // partition is the beginning offset of the next slice unless we have
548 // There are two strategies to form a partition based on whether the
549 // partition starts with an unsplittable slice or a splittable slice.
555 // Form a partition including all of the overlapping slices with this
563 // We have a partition across a set of overlapping unsplittable
569 // a synthetic partition spanning it and any other overlapping splittable
571 assert(P.SI->isSplittable() && "Forming a splittable partition!");
582 // a partition spanning only splittable slices.
592 "End iterators don't match between compared partition iterators!");
615 Partition &operator*() { return P; }
1133 // If the type is larger than the partition, skip it. We only encounter
1774 /// This function is called to test each entry in a partition which is slated
1776 static bool isVectorPromotionViableForSlice(Partition &P, const Slice &S,
1847 /// partition (and its newly formed alloca) into a vector alloca with only
1852 static VectorType *isVectorPromotionViable(Partition &P, const DataLayout &DL) {
2042 /// Test whether the given alloca partition's integer operations can be
2048 static bool isIntegerWideningViable(Partition &P, Type *AllocaTy,
2073 // partition here...
2220 /// Also implements the rewriting to vector-based accesses when the partition
2243 // If we are rewriting an alloca partition which can be written as pure
3400 /// Try to find a partition of the aggregate type passed in for a given
3408 /// Note that this routine is very strict and tries to find a partition of the
3410 /// when the size or offset cause either end of type-based partition to be off.
3431 // Bail if the partition ends in a different array element.
3467 // See if any partition must be contained by the element.
3540 // the order they first appear during the partition scan. These give stable
3585 "Empty or backwards partition!");
3643 "Cannot have an empty set of splits on the second partition!");
3648 // Record each split. The last partition's end isn't needed as the size
3794 // Setup the next partition.
3916 // And store this partition.
3942 // Setup the next partition.
4007 /// Rewrite an alloca partition's users.
4010 /// to rewrite uses of an alloca partition to be conducive for SSA value
4011 /// promotion. If the partition needs a new, more refined alloca, this will
4018 Partition &P) {
4019 // Try to compute a friendly type for this partition of the alloca. This
4079 LLVM_DEBUG(dbgs() << "Rewriting alloca partition "
4107 // Now that we've processed all the slices in the new partition, check if any
4144 // We couldn't promote and we didn't create a new partition, nothing
4176 // to be rewritten into a partition.
4237 // Rewrite each partition.
4265 // Create a fragment expression describing the new partition or reuse AI's
4266 // expression if there is only one partition.
