[llvm] r176407 - add getUnderlyingObjectSize()

[Arnold]

Nice, thanks.


Sent from my iPhone

On Mar 2, 2013, at 5:23 AM, Nuno Lopes <nunoplopes at sapo.pt> wrote:

> Author: nlopes
> Date: Sat Mar  2 05:23:34 2013
> New Revision: 176407
> 
> URL: http://llvm.org/viewvc/llvm-project?rev=176407&view=rev
> Log:
> add getUnderlyingObjectSize()
> this is similar to getObjectSize(), but doesnt subtract the offset
> tweak the BasicAA code accordingly (per PR14988)
> 
> Modified:
>    llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h
>    llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
>    llvm/trunk/lib/Analysis/MemoryBuiltins.cpp
> 
> Modified: llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h?rev=176407&r1=176406&r2=176407&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h (original)
> +++ llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h Sat Mar  2 05:23:34 2013
> @@ -144,6 +144,14 @@ static inline CallInst *isFreeCall(Value
> bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout *TD,
>                    const TargetLibraryInfo *TLI, bool RoundToAlign = false);
> 
> +/// \brief Compute the size of the underlying object pointed by Ptr. Returns
> +/// true and the object size in Size if successful, and false otherwise.
> +/// If RoundToAlign is true, then Size is rounded up to the aligment of allocas,
> +/// byval arguments, and global variables.
> +bool getUnderlyingObjectSize(const Value *Ptr, uint64_t &Size,
> +                             const DataLayout *TD, const TargetLibraryInfo *TLI,
> +                             bool RoundToAlign = false);
> +
> 
> 
> typedef std::pair<APInt, APInt> SizeOffsetType;
> 
> Modified: llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp?rev=176407&r1=176406&r2=176407&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp (original)
> +++ llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp Sat Mar  2 05:23:34 2013
> @@ -88,7 +88,7 @@ static uint64_t getObjectSize(const Valu
>                               const TargetLibraryInfo &TLI,
>                               bool RoundToAlign = false) {
>   uint64_t Size;
> -  if (getObjectSize(V, Size, &TD, &TLI, RoundToAlign))
> +  if (getUnderlyingObjectSize(V, Size, &TD, &TLI, RoundToAlign))
>     return Size;
>   return AliasAnalysis::UnknownSize;
> }
> @@ -98,35 +98,6 @@ static uint64_t getObjectSize(const Valu
> static bool isObjectSmallerThan(const Value *V, uint64_t Size,
>                                 const DataLayout &TD,
>                                 const TargetLibraryInfo &TLI) {
> -  // Note that the meanings of the "object" are slightly different in the
> -  // following contexts:
> -  //    c1: llvm::getObjectSize()
> -  //    c2: llvm.objectsize() intrinsic
> -  //    c3: isObjectSmallerThan()
> -  // c1 and c2 share the same meaning; however, the meaning of "object" in c3
> -  // refers to the "entire object".
> -  //
> -  //  Consider this example:
> -  //     char *p = (char*)malloc(100)
> -  //     char *q = p+80;
> -  //
> -  //  In the context of c1 and c2, the "object" pointed by q refers to the
> -  // stretch of memory of q[0:19]. So, getObjectSize(q) should return 20.
> -  //
> -  //  However, in the context of c3, the "object" refers to the chunk of memory
> -  // being allocated. So, the "object" has 100 bytes, and q points to the middle
> -  // the "object". In case q is passed to isObjectSmallerThan() as the 1st
> -  // parameter, before the llvm::getObjectSize() is called to get the size of
> -  // entire object, we should:
> -  //    - either rewind the pointer q to the base-address of the object in
> -  //      question (in this case rewind to p), or
> -  //    - just give up. It is up to caller to make sure the pointer is pointing
> -  //      to the base address the object.
> -  // 
> -  // We go for 2nd option for simplicity.
> -  if (!isIdentifiedObject(V))
> -    return false;
> -
>   // This function needs to use the aligned object size because we allow
>   // reads a bit past the end given sufficient alignment.
>   uint64_t ObjectSize = getObjectSize(V, TD, TLI, /*RoundToAlign*/true);
> 
> Modified: llvm/trunk/lib/Analysis/MemoryBuiltins.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryBuiltins.cpp?rev=176407&r1=176406&r2=176407&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/MemoryBuiltins.cpp (original)
> +++ llvm/trunk/lib/Analysis/MemoryBuiltins.cpp Sat Mar  2 05:23:34 2013
> @@ -360,6 +360,26 @@ bool llvm::getObjectSize(const Value *Pt
>   return true;
> }
> 
> +/// \brief Compute the size of the underlying object pointed by Ptr. Returns
> +/// true and the object size in Size if successful, and false otherwise.
> +/// If RoundToAlign is true, then Size is rounded up to the aligment of allocas,
> +/// byval arguments, and global variables.
> +bool llvm::getUnderlyingObjectSize(const Value *Ptr, uint64_t &Size,
> +                                   const DataLayout *TD,
> +                                   const TargetLibraryInfo *TLI,
> +                                   bool RoundToAlign) {
> +  if (!TD)
> +    return false;
> +
> +  ObjectSizeOffsetVisitor Visitor(TD, TLI, Ptr->getContext(), RoundToAlign);
> +  SizeOffsetType Data = Visitor.compute(const_cast<Value*>(Ptr));
> +  if (!Visitor.knownSize(Data))
> +    return false;
> +
> +  Size = Data.first.getZExtValue();
> +  return true;
> +}
> +
> 
> STATISTIC(ObjectVisitorArgument,
>           "Number of arguments with unsolved size and offset");
> 
> 
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits