lib/Analysis/BasicAliasAnalysis.cpp
static bool isObjectSmallerThan(const Value *V, uint64_t Size,
                                const DataLayout &DL,
                                const TargetLibraryInfo &TLI,
                                bool NullIsValidLoc) {
  // 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, DL, TLI, NullIsValidLoc,
                                      /*RoundToAlign*/ true);

  return ObjectSize != MemoryLocation::UnknownSize && ObjectSize < Size;
}
/// Returns true if we can prove that the object specified by V is smaller than
/// Size.
Returns true if we can prove that the object specified by V is smaller than
Size.
Returns true if we can prove that the object specified by V is smaller than Size .
static bool isObjectSmallerThan(const Value *V, uint64_t Size,
                                const DataLayout &DL,
                                const TargetLibraryInfo &TLI,
                                bool NullIsValidLoc) {
    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, DL, TLI, NullIsValidLoc,
                                       true);
  return ObjectSize != MemoryLocation::UnknownSize && ObjectSize < Size;
}
static bool isObjectSmallerThan ( const Value * V , uint64_t Size , const DataLayout & DL , const TargetLibraryInfo & TLI , bool NullIsValidLoc ) { if ( ! isIdentifiedObject ( V ) ) return false ; uint64_t ObjectSize = getObjectSize ( V , DL , TLI , NullIsValidLoc , true ) ; return ObjectSize != MemoryLocation :: UnknownSize && ObjectSize < Size ; }
Returns true if we can prove that the object specified by V is smaller than
Size.
Returns true if we can prove that the object specified by V is smaller than Size .
// 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. // This function needs to use the aligned object size because we allow // reads a bit past the end given sufficient alignment. /*RoundToAlign*/