Lines Matching refs:Uses
13 /// convert uses of an element (or set of elements) of an alloca into a vector
116 /// formed by examining the uses of the alloca. During formation, they may
150 /// This structure is used to associate uses of a partition with it. They
153 /// The bounds of these uses are determined by intersecting the bounds of the
155 /// intentionally overlap between various uses of the same partition.
189 /// information about the nature of uses of each slice of the alloca. The goal
220 /// partition's uses.
222 /// The iteration support provided for uses is more limited, but also
223 /// includes some manipulation routines to support rewriting the uses of
227 use_iterator use_begin(unsigned Idx) { return Uses[Idx].begin(); }
228 use_iterator use_begin(const_iterator I) { return Uses[I - begin()].begin(); }
229 use_iterator use_end(unsigned Idx) { return Uses[Idx].end(); }
230 use_iterator use_end(const_iterator I) { return Uses[I - begin()].end(); }
233 const_use_iterator use_begin(unsigned Idx) const { return Uses[Idx].begin(); }
235 return Uses[I - begin()].begin();
237 const_use_iterator use_end(unsigned Idx) const { return Uses[Idx].end(); }
239 return Uses[I - begin()].end();
242 unsigned use_size(unsigned Idx) const { return Uses[Idx].size(); }
243 unsigned use_size(const_iterator I) const { return Uses[I - begin()].size(); }
245 return Uses[PIdx][UIdx];
248 return Uses[I - begin()][UIdx];
252 Uses[Idx].push_back(PU);
255 Uses[I - begin()].push_back(PU);
328 return Uses[MapIt->second.first].begin() + MapIt->second.second;
331 /// \brief Compute a common type among the uses of a particular partition.
333 /// This routines walks all of the uses of a particular partition and tries
376 /// \brief The uses of the partitions.
378 /// This is essentially a mapping from each partition to a list of uses of
379 /// that partition. The mapping is done with a Uses vector that has the exact
381 /// a vector of the uses.
382 SmallVector<SmallVector<PartitionUse, 2>, 8> Uses;
405 /// \brief A side datastructure used when building up the partitions and uses.
438 /// This class builds an alloca partitioning by recursively visiting the uses
461 // Completely skip uses which have a zero size or start either before or
478 // but that is not so! There may be widened loads or PHI-node uses where
664 // the same offset to be a viable use for partitioning purposes. These uses
668 SmallVector<std::pair<Instruction *, Instruction *>, 4> Uses;
670 Uses.push_back(std::make_pair(cast<Instruction>(*U), Root));
676 llvm::tie(UsedI, I) = Uses.pop_back_val();
701 Uses.push_back(std::make_pair(I, cast<Instruction>(*UI)));
702 } while (!Uses.empty());
765 /// This class adds the uses of an alloca to all of the partitions which they
774 /// of unsplittable uses and M are the number of splittable. This visitor does
831 = std::make_pair(I - P.begin(), P.Uses[I - P.begin()].size() - 1);
1072 // Sort the uses. This arranges for the offsets to be in ascending order,
1102 Uses.resize(Partitions.size());
1114 continue; // Skip dead uses.
1126 return 0; // Bail if we have weird uses.
1156 << (Uses[I - begin()].empty() ? " (zero uses)" : "")
1164 continue; // Skip dead uses.
1395 // Note that we need to use an index here as the underlying vector of uses
1397 // new uses, and so we can use the initial size bound.
1424 /// We can do this to a select if its only uses are loads and if the operands
1533 // No uses to rewrite.
1536 // Try to lookup and rewrite any partition uses corresponding to this phi
1564 /// We can do this to a select if its only uses are loads and if the operand
1609 // its uses. We'll add in the new loads below.
2090 // Check the uses to ensure the uses are (likely) promotable integer uses.
2372 continue; // Skip dead uses.
2523 // basis for the new value. This allows us to replace the uses of LI with
3038 /// Queue of pointer uses to analyze and potentially rewrite.
3066 /// This uses a set to de-duplicate users.
3382 /// to rewrite uses of an alloca partition to be conducive for SSA value
3385 /// rewrite the uses of the old alloca to point at the new one and have the
3400 return false; // No live uses left of this partition.
3490 /// \brief Walks the partitioning of an alloca rewriting uses of each partition.
