[PATCH] MemCpyOptimizer: Use max legal int size instead of pointer size

[Eli Friedman]

LGTM.

-Eli

On Thu, Sep 12, 2013 at 9:15 PM, Matt Arsenault
<Matthew.Arsenault at amd.com>wrote:

> If there are no legal integers, assume 1 byte.
>
> This makes more sense than using the pointer size as
> a guess for the maximum GPR width.
>
> It is conceivable to want to use some 64-bit pointers
> on a target where 64-bit integers aren't legal.
>
> http://llvm-reviews.chandlerc.com/D1669
>
> Files:
>   include/llvm/IR/DataLayout.h
>   lib/IR/DataLayout.cpp
>   lib/Transforms/Scalar/MemCpyOptimizer.cpp
>
> Index: include/llvm/IR/DataLayout.h
> ===================================================================
> --- include/llvm/IR/DataLayout.h
> +++ include/llvm/IR/DataLayout.h
> @@ -381,6 +381,17 @@
>    /// least as big as Width bits.
>    Type *getSmallestLegalIntType(LLVMContext &C, unsigned Width = 0) const;
>
> +  /// getLargestLegalIntType - Return the largest legal integer type, or
> null if
> +  /// none are set.
> +  Type *getLargestLegalIntType(LLVMContext &C) const {
> +    unsigned LargestSize = getLargestLegalIntTypeSize();
> +    return (LargestSize == 0) ? 0 : Type::getIntNTy(C, LargestSize);
> +  }
> +
> +  /// getLargestLegalIntType - Return the size of largest legal integer
> type
> +  /// size, or 0 if none are set.
> +  unsigned getLargestLegalIntTypeSize() const;
> +
>    /// getIndexedOffset - return the offset from the beginning of the type
> for
>    /// the specified indices.  This is used to implement getelementptr.
>    uint64_t getIndexedOffset(Type *Ty, ArrayRef<Value *> Indices) const;
> Index: lib/IR/DataLayout.cpp
> ===================================================================
> --- lib/IR/DataLayout.cpp
> +++ lib/IR/DataLayout.cpp
> @@ -629,6 +629,13 @@
>    return 0;
>  }
>
> +unsigned DataLayout::getLargestLegalIntTypeSize() const {
> +  unsigned MaxWidth = 0;
> +  for (unsigned i = 0, e = (unsigned)LegalIntWidths.size(); i != e; ++i)
> +    MaxWidth = std::max<unsigned>(MaxWidth, LegalIntWidths[i]);
> +  return MaxWidth;
> +}
> +
>  uint64_t DataLayout::getIndexedOffset(Type *ptrTy,
>                                        ArrayRef<Value *> Indices) const {
>    Type *Ty = ptrTy;
> Index: lib/Transforms/Scalar/MemCpyOptimizer.cpp
> ===================================================================
> --- lib/Transforms/Scalar/MemCpyOptimizer.cpp
> +++ lib/Transforms/Scalar/MemCpyOptimizer.cpp
> @@ -170,14 +170,17 @@
>    // pessimize the llvm optimizer.
>    //
>    // Since we don't have perfect knowledge here, make some assumptions:
> assume
> -  // the maximum GPR width is the same size as the pointer size and
> assume that
> -  // this width can be stored.  If so, check to see whether we will end up
> -  // actually reducing the number of stores used.
> +  // the maximum GPR width is the same size as the largest legal integer
> +  // size. If so, check to see whether we will end up actually reducing
> the
> +  // number of stores used.
>    unsigned Bytes = unsigned(End-Start);
> -  unsigned NumPointerStores = Bytes/TD.getPointerSize();
> +  unsigned MaxIntSize = TD.getLargestLegalIntTypeSize();
> +  if (MaxIntSize == 0)
> +    MaxIntSize = 1;
> +  unsigned NumPointerStores = Bytes / MaxIntSize;
>
>    // Assume the remaining bytes if any are done a byte at a time.
> -  unsigned NumByteStores = Bytes - NumPointerStores*TD.getPointerSize();
> +  unsigned NumByteStores = Bytes - NumPointerStores * MaxIntSize;
>
>    // If we will reduce the # stores (according to this heuristic), do the
>    // transformation.  This encourages merging 4 x i8 -> i32 and 2 x i16
> -> i32
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20130916/8909b2ae/attachment.html>