Add a new builtin: __builtin_dynamic_object_size

[erik.pilkington]

Summary

This builtin has the same UI as __builtin_object_size, but has the potential to be evaluated dynamically. It is meant to be used as a drop-in replacement for libraries that use __builtin_object_size when a dynamic checking mode is enabled. For instance, __builtin_object_size fails to provide any extra checking in the following function:

void f(size_t alloc) {
  char* p = malloc(alloc);
  strcpy(p, "foobar"); // expands to __builtin___strcpy_chk(p, "foobar", __builtin_object_size(p, 0))
}

This is an overflow if alloc < 7, but because LLVM can't fold the object size intrinsic statically, it folds __builtin_object_size to -1. With __builtin_dynamic_object_size, alloc is passed through to __builtin___strcpy_chk.

rdar://problem/32212419 ER: evaluate builtin_objectsize (or a successor) at runtime, at least when alloc_size is available

Thanks for taking a look!
Erik

[rsmith]

Thanks, this seems like a useful feature to me.

Would it make sense to model this as an (optional) extra flag bit for __builtin_object_size rather than as a new builtin? It'd seem reasonable to me to ask on the gcc dev list if they'd be interested in such an extension to their builtin -- if not, then we should use a new name, and something like this seems fine to me.

[george.burgess.iv]

Thanks for this!

Would it make sense to model this as an (optional) extra flag bit for __builtin_object_size rather than as a new builtin?

+1. That way, we could avoid making a pass_dynamic_object_size (assuming we wouldn't want to have a different API between that and __builtin_object_size), as well. :)

[jfb]

I pointed out this review to Jonathan Wakely, who posted it to the GCC list. Jakub replied with:

The current modes (0-3) certainly must not be changed and must return a
constant, that is what huge amounts of code in the wild relies on.

The reason to choose constants only was the desire to make _FORTIFY_SOURCE
cheap at runtime. For the dynamically computed expressions, the question
is how far it should go, how complex expressions it wants to build and how
much code and runtime can be spent on computing that.

The rationale for __builtin_dynamic_object_size lists only very simple
cases, where the builtin is just called on result of malloc, so that is
indeed easy, the argument is already evaluated before the malloc call, so
you can just save it in a temporary and use later. Slightly more complex
is calloc, where you need to multiply two numbers (do you handle overflow
somehow, or not?). But in real world, it can be arbitrarily more complex,
there can be pointer arithmetics with constant or variable offsets,
there can be conditional adjustments of pointers or PHIs with multiple
"dynamic" expressions for the sizes (shall the dynamic expression evaluate
as max over expressions for different phi arguments (that is essentially
what is done for the constant __builtin_object_size, but for dynamic
expressions max needs to be computed at runtime, or shall it reconstruct
the conditional or remember it and compute whatever ? val1 : val2),
loops which adjust pointers, etc. and all that can be done many times in
between where the objects are allocated and where the builtin is used.

@rsmith, what do you think and how do you want to proceed? We think something like what Erik implemented will catch things _FORTIFY_SOURCE currently cannot. We agree there are valid code generation complexity concerns, yet it seems like having a different spelling for the builtin helps mitigate those concerns.

[erik.pilkington]

In D56760#1367915, @jfb wrote:

@rsmith, what do you think and how do you want to proceed? We think something like what Erik implemented will catch things _FORTIFY_SOURCE currently cannot. We agree there are valid code generation complexity concerns, yet it seems like having a different spelling for the builtin helps mitigate those concerns.

Yeah, I think the codegen explosion concerns are somewhat valid. It seems like for the most part its just a matter of keeping a value alive or doing a multiply or add here or there, which doesn't seem like the end of the world if its opt-in. The kind of pathological expressions that this is addressing seems like exactly the places where you would want the extra dynamic checks, like where you're indexing into an object with dynamically computed value with weird control flow or something. That being said, we could probably bail out of folding this in LLVM if the expression gets too complex.

So it seems like the GCC people want to keep __builtin_object_size static. In that case, I think that this current patch is the way to go. I'll post a patch to fix up pass_object_size too.

Thanks @jfb!

[rsmith]

In D56760#1368054, @erik.pilkington wrote:

So it seems like the GCC people want to keep __builtin_object_size static.

I don't see any evidence of that. Jakub said that modes 0-3 should stay static, but that's in line with what we suggested.

[jfb]

In D56760#1368216, @rsmith wrote:

In D56760#1368054, @erik.pilkington wrote:

So it seems like the GCC people want to keep __builtin_object_size static.

I don't see any evidence of that. Jakub said that modes 0-3 should stay static, but that's in line with what we suggested.

You'd originally asked:

Would it make sense to model this as an (optional) extra flag bit for __builtin_object_size rather than as a new builtin? It'd seem reasonable to me to ask on the gcc dev list if they'd be interested in such an extension to their builtin -- if not, then we should use a new name, and something like this seems fine to me.

I agree Jakub wants to keep 0-3 static, but I didn't see a preference expressed for an extra bit versus __builtin_dynamic_object_size. Given this, which direction do you want to take?

[erik.pilkington]

In D56760#1368216, @rsmith wrote:

I don't see any evidence of that. Jakub said that modes 0-3 should stay static, but that's in line with what we suggested.

I don't think Jakub really said anything about whether we should go with a new builtin or use the flag bit. I'm basing this on Jonathan Wakely's comment:

I know Jakub is concerned about arbitrarily complex expressions, when
__builtin_object_size is supposed to always be efficient and always
evaluate at compile time (which would imply the dynamic behaviour
should be a separate builtin, if it exists at all).

So your call. FWIW I'd prefer the __builtin_object_size spelling too, but it doesn't seem like the GCC folks are super crazy about it to me. So it seems likely to me that if we implement it it will just be a clang extension for at least the medium term (if not permanently). I guess that's fine, so long as the GCC people are aware that it would be bad to extend their builtin to use type&4.

[rsmith]

In D56760#1368279, @erik.pilkington wrote:

FWIW I'd prefer the __builtin_object_size spelling too, but it doesn't seem like the GCC folks are super crazy about it to me. So it seems likely to me that if we implement it it will just be a clang extension for at least the medium term (if not permanently). I guess that's fine, so long as the GCC people are aware that it would be bad to extend their builtin to use type&4.

In the absence of a commitment from the GCC folks, I think we should use the __builtin_dynamic_object_size approach for now. If they later change their mind we can deprecate that spelling in favor of a flag bit.

cfe/trunk/docs/LanguageExtensions.rst

* The decision about which section-kind applies to each global is taken in the back-end.
   ``#pragma clang section`` directive, is applied to that global.
 
 Specifying Linker Options on ELF Targets
 ========================================
 
 The ``#pragma comment(lib, ...)`` directive is supported on all ELF targets.
 The second parameter is the library name (without the traditional Unix prefix of
 ``lib``).  This allows you to provide an implicit link of dependent libraries.
+
+Evaluating Object Size Dynamically
+==================================
+
+Clang supports the builtin ``__builtin_dynamic_object_size``, the semantics are
+the same as GCC's ``__builtin_object_size`` (which Clang also supports), but
+``__builtin_dynamic_object_size`` can evaluate the object's size at runtime.
+``__builtin_dynamic_object_size`` is meant to be used as a drop-in replacement
+for ``__builtin_object_size`` in libraries that support it.
+
+For instance, here is a program that ``__builtin_dynamic_object_size`` will make
+safer:
+
+.. code-block:: c
+
+  void copy_into_buffer(size_t size) {
+    char* buffer = malloc(size);
+    strlcpy(buffer, "some string", strlen("some string"));
+    // Previous line preprocesses to:
+    // __builtin___strlcpy_chk(buffer, "some string", strlen("some string"), __builtin_object_size(buffer, 0))
+  }
+
+Since the size of ``buffer`` can't be known at compile time, Clang will fold
+``__builtin_object_size(buffer, 0)`` into ``-1``. However, if this was written
+as ``__builtin_dynamic_object_size(buffer, 0)``, Clang will fold it into
+``size``, providing some extra runtime safety.

cfe/trunk/include/clang/Basic/Builtins.def

 BUILTIN(__builtin_frob_return_addr, "v*v*", "n")
 BUILTIN(__builtin_dwarf_cfa, "v*", "n")
 BUILTIN(__builtin_init_dwarf_reg_size_table, "vv*", "n")
 BUILTIN(__builtin_dwarf_sp_column, "Ui", "n")
 BUILTIN(__builtin_extend_pointer, "ULLiv*", "n") // _Unwind_Word == uint64_t
 
 // GCC Object size checking builtins
 BUILTIN(__builtin_object_size, "zvC*i", "nu")
+BUILTIN(__builtin_dynamic_object_size, "zvC*i", "nu") // Clang only.
 BUILTIN(__builtin___memcpy_chk, "v*v*vC*zz", "nF")
 BUILTIN(__builtin___memccpy_chk, "v*v*vC*izz", "nF")
 BUILTIN(__builtin___memmove_chk, "v*v*vC*zz", "nF")
 BUILTIN(__builtin___mempcpy_chk, "v*v*vC*zz", "nF")
 BUILTIN(__builtin___memset_chk, "v*v*izz", "nF")
 BUILTIN(__builtin___stpcpy_chk, "c*c*cC*z", "nF")
 BUILTIN(__builtin___strcat_chk, "c*c*cC*z", "nF")
 BUILTIN(__builtin___strcpy_chk, "c*c*cC*z", "nF")

cfe/trunk/lib/AST/ExprConstant.cpp

 }
 
 bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
                                             unsigned BuiltinOp) {
   switch (unsigned BuiltinOp = E->getBuiltinCallee()) {
   default:
     return ExprEvaluatorBaseTy::VisitCallExpr(E);
 
+  case Builtin::BI__builtin_dynamic_object_size:
   case Builtin::BI__builtin_object_size: {
     // The type was checked when we built the expression.
     unsigned Type =
         E->getArg(1)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
     assert(Type <= 3 && "unexpected type");
 
     uint64_t Size;
     if (tryEvaluateBuiltinObjectSize(E->getArg(0), Type, Info, Size))

cfe/trunk/lib/Analysis/CFG.cpp

if (FunctionDecl *FD = C->getDirectCallee()) {
     // (see [expr.call]).
     if (!FD->isVariadic())
       findConstructionContextsForArguments(C);
 
     if (FD->isNoReturn() || C->isBuiltinAssumeFalse(*Context))
       NoReturn = true;
     if (FD->hasAttr<NoThrowAttr>())
       AddEHEdge = false;
-    if (FD->getBuiltinID() == Builtin::BI__builtin_object_size)
+    if (FD->getBuiltinID() == Builtin::BI__builtin_object_size ||
+        FD->getBuiltinID() == Builtin::BI__builtin_dynamic_object_size)
       OmitArguments = true;
   }
 
   if (!CanThrow(C->getCallee(), *Context))
     AddEHEdge = false;
 
   if (OmitArguments) {
     assert(!NoReturn && "noreturn calls with unevaluated args not implemented");

cfe/trunk/lib/CodeGen/CGBuiltin.cpp

 static llvm::Value *
 getDefaultBuiltinObjectSizeResult(unsigned Type, llvm::IntegerType *ResType) {
   return ConstantInt::get(ResType, (Type & 2) ? 0 : -1, /*isSigned=*/true);
 }
 
 llvm::Value *
 CodeGenFunction::evaluateOrEmitBuiltinObjectSize(const Expr *E, unsigned Type,
                                                  llvm::IntegerType *ResType,
-                                                 llvm::Value *EmittedE) {
+                                                 llvm::Value *EmittedE,
+                                                 bool IsDynamic) {
   uint64_t ObjectSize;
   if (!E->tryEvaluateObjectSize(ObjectSize, getContext(), Type))
-    return emitBuiltinObjectSize(E, Type, ResType, EmittedE);
+    return emitBuiltinObjectSize(E, Type, ResType, EmittedE, IsDynamic);
   return ConstantInt::get(ResType, ObjectSize, /*isSigned=*/true);
 }
 
 /// Returns a Value corresponding to the size of the given expression.
 /// This Value may be either of the following:
 ///   - A llvm::Argument (if E is a param with the pass_object_size attribute on
 ///     it)
 ///   - A call to the @llvm.objectsize intrinsic
 ///
 /// EmittedE is the result of emitting `E` as a scalar expr. If it's non-null
 /// and we wouldn't otherwise try to reference a pass_object_size parameter,
 /// we'll call @llvm.objectsize on EmittedE, rather than emitting E.
 llvm::Value *
 CodeGenFunction::emitBuiltinObjectSize(const Expr *E, unsigned Type,
                                        llvm::IntegerType *ResType,
-                                       llvm::Value *EmittedE) {
+                                       llvm::Value *EmittedE, bool IsDynamic) {
   // We need to reference an argument if the pointer is a parameter with the
   // pass_object_size attribute.
   if (auto *D = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts())) {
     auto *Param = dyn_cast<ParmVarDecl>(D->getDecl());
     auto *PS = D->getDecl()->getAttr<PassObjectSizeAttr>();
     if (Param != nullptr && PS != nullptr &&
         areBOSTypesCompatible(PS->getType(), Type)) {
       auto Iter = SizeArguments.find(Param);
assert(Ptr->getType()->isPointerTy() &&
          "Non-pointer passed to __builtin_object_size?");
 
   Value *F = CGM.getIntrinsic(Intrinsic::objectsize, {ResType, Ptr->getType()});
 
   // LLVM only supports 0 and 2, make sure that we pass along that as a boolean.
   Value *Min = Builder.getInt1((Type & 2) != 0);
   // For GCC compatibility, __builtin_object_size treat NULL as unknown size.
   Value *NullIsUnknown = Builder.getTrue();
-  Value *Dynamic = Builder.getFalse();
+  Value *Dynamic = Builder.getInt1(IsDynamic);
   return Builder.CreateCall(F, {Ptr, Min, NullIsUnknown, Dynamic});
 }
 
 namespace {
 /// A struct to generically describe a bit test intrinsic.
 struct BitTest {
   enum ActionKind : uint8_t { TestOnly, Complement, Reset, Set };
   enum InterlockingKind : uint8_t {
case Builtin::BI__builtin_constant_p: {
 
     Value *ArgValue = EmitScalarExpr(Arg);
     Value *F = CGM.getIntrinsic(Intrinsic::is_constant, ConvertType(ArgType));
     Value *Result = Builder.CreateCall(F, ArgValue);
     if (Result->getType() != ResultType)
       Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/false);
     return RValue::get(Result);
   }
+  case Builtin::BI__builtin_dynamic_object_size:
   case Builtin::BI__builtin_object_size: {
     unsigned Type =
         E->getArg(1)->EvaluateKnownConstInt(getContext()).getZExtValue();
     auto *ResType = cast<llvm::IntegerType>(ConvertType(E->getType()));
 
     // We pass this builtin onto the optimizer so that it can figure out the
     // object size in more complex cases.
+    bool IsDynamic = BuiltinID == Builtin::BI__builtin_dynamic_object_size;
     return RValue::get(emitBuiltinObjectSize(E->getArg(0), Type, ResType,
-                                             /*EmittedE=*/nullptr));
+                                             /*EmittedE=*/nullptr, IsDynamic));
   }
   case Builtin::BI__builtin_prefetch: {
     Value *Locality, *RW, *Address = EmitScalarExpr(E->getArg(0));
     // FIXME: Technically these constants should of type 'int', yes?
     RW = (E->getNumArgs() > 1) ? EmitScalarExpr(E->getArg(1)) :
       llvm::ConstantInt::get(Int32Ty, 0);
     Locality = (E->getNumArgs() > 2) ? EmitScalarExpr(E->getArg(2)) :
       llvm::ConstantInt::get(Int32Ty, 3);

cfe/trunk/lib/CodeGen/CGCall.cpp

auto MaybeEmitImplicitObjectSize = [&](unsigned I, const Expr *Arg,
     if (PS == nullptr)
       return;
 
     const auto &Context = getContext();
     auto SizeTy = Context.getSizeType();
     auto T = Builder.getIntNTy(Context.getTypeSize(SizeTy));
     assert(EmittedArg.getScalarVal() && "We emitted nothing for the arg?");
     llvm::Value *V = evaluateOrEmitBuiltinObjectSize(Arg, PS->getType(), T,
-                                                     EmittedArg.getScalarVal());
+                                                     EmittedArg.getScalarVal(),
+                                                     /*IsDynamic=*/false);
     Args.add(RValue::get(V), SizeTy);
     // If we're emitting args in reverse, be sure to do so with
     // pass_object_size, as well.
     if (!LeftToRight)
       std::swap(Args.back(), *(&Args.back() - 1));
   };
 
   // Insert a stack save if we're going to need any inalloca args.

cfe/trunk/lib/CodeGen/CodeGenFunction.h

private:
 
   /// Attempts to statically evaluate the object size of E. If that
   /// fails, emits code to figure the size of E out for us. This is
   /// pass_object_size aware.
   ///
   /// If EmittedExpr is non-null, this will use that instead of re-emitting E.
   llvm::Value *evaluateOrEmitBuiltinObjectSize(const Expr *E, unsigned Type,
                                                llvm::IntegerType *ResType,
-                                               llvm::Value *EmittedE);
+                                               llvm::Value *EmittedE,
+                                               bool IsDynamic);
 
   /// Emits the size of E, as required by __builtin_object_size. This
   /// function is aware of pass_object_size parameters, and will act accordingly
   /// if E is a parameter with the pass_object_size attribute.
   llvm::Value *emitBuiltinObjectSize(const Expr *E, unsigned Type,
                                      llvm::IntegerType *ResType,
-                                     llvm::Value *EmittedE);
+                                     llvm::Value *EmittedE,
+                                     bool IsDynamic);
 
 public:
 #ifndef NDEBUG
   // Determine whether the given argument is an Objective-C method
   // that may have type parameters in its signature.
   static bool isObjCMethodWithTypeParams(const ObjCMethodDecl *method) {
     const DeclContext *dc = method->getDeclContext();
     if (const ObjCInterfaceDecl *classDecl= dyn_cast<ObjCInterfaceDecl>(dc)) {

cfe/trunk/lib/Sema/SemaChecking.cpp

Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
   case Builtin::BI__builtin_assume:
     if (SemaBuiltinAssume(TheCall))
       return ExprError();
     break;
   case Builtin::BI__builtin_assume_aligned:
     if (SemaBuiltinAssumeAligned(TheCall))
       return ExprError();
     break;
+  case Builtin::BI__builtin_dynamic_object_size:
   case Builtin::BI__builtin_object_size:
     if (SemaBuiltinConstantArgRange(TheCall, 1, 0, 3))
       return ExprError();
     break;
   case Builtin::BI__builtin_longjmp:
     if (SemaBuiltinLongjmp(TheCall))
       return ExprError();
     break;

cfe/trunk/lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp

DefinedOrUnknownSVal extentMatchesSizeArg =
       svalBuilder.evalEQ(state, Extent, Size);
     state = state->assume(extentMatchesSizeArg, true);
     assert(state && "The region should not have any previous constraints");
 
     C.addTransition(state->BindExpr(CE, LCtx, loc::MemRegionVal(R)));
     return true;
   }
 
+  case Builtin::BI__builtin_dynamic_object_size:
   case Builtin::BI__builtin_object_size:
   case Builtin::BI__builtin_constant_p: {
     // This must be resolvable at compile time, so we defer to the constant
     // evaluator for a value.
     SVal V = UnknownVal();
     Expr::EvalResult EVResult;
     if (CE->EvaluateAsInt(EVResult, C.getASTContext(), Expr::SE_NoSideEffects)) {
       // Make sure the result has the correct type.

cfe/trunk/test/CodeGen/alloc-size.c

-// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm %s -o - 2>&1 | FileCheck %s
+// RUN: %clang_cc1           -triple x86_64-apple-darwin -emit-llvm %s -o - 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -DDYNAMIC -triple x86_64-apple-darwin -emit-llvm %s -o - 2>&1 | FileCheck %s
+
+#ifdef DYNAMIC
+#define OBJECT_SIZE_BUILTIN __builtin_dynamic_object_size
+#else
+#define OBJECT_SIZE_BUILTIN __builtin_object_size
+#endif
 
 #define NULL ((void *)0)
 
 int gi;
 
 typedef unsigned long size_t;
 
 // CHECK-DAG-RE: define void @my_malloc({{.*}}) #[[MALLOC_ATTR_NUMBER:[0-9]+]]
 // N.B. LLVM's allocsize arguments are base-0, whereas ours are base-1 (for
 // compat with GCC)
 // CHECK-DAG-RE: attributes #[[MALLOC_ATTR_NUMBER]] = {.*allocsize(0).*}
 void *my_malloc(size_t) __attribute__((alloc_size(1)));
 
 // CHECK-DAG-RE: define void @my_calloc({{.*}}) #[[CALLOC_ATTR_NUMBER:[0-9]+]]
 // CHECK-DAG-RE: attributes #[[CALLOC_ATTR_NUMBER]] = {.*allocsize(0, 1).*}
 void *my_calloc(size_t, size_t) __attribute__((alloc_size(1, 2)));
 
 // CHECK-LABEL: @test1
 void test1() {
   void *const vp = my_malloc(100);
   // CHECK: store i32 100
-  gi = __builtin_object_size(vp, 0);
+  gi = OBJECT_SIZE_BUILTIN(vp, 0);
   // CHECK: store i32 100
-  gi = __builtin_object_size(vp, 1);
+  gi = OBJECT_SIZE_BUILTIN(vp, 1);
   // CHECK: store i32 100
-  gi = __builtin_object_size(vp, 2);
+  gi = OBJECT_SIZE_BUILTIN(vp, 2);
   // CHECK: store i32 100
-  gi = __builtin_object_size(vp, 3);
+  gi = OBJECT_SIZE_BUILTIN(vp, 3);
 
   void *const arr = my_calloc(100, 5);
   // CHECK: store i32 500
-  gi = __builtin_object_size(arr, 0);
+  gi = OBJECT_SIZE_BUILTIN(arr, 0);
   // CHECK: store i32 500
-  gi = __builtin_object_size(arr, 1);
+  gi = OBJECT_SIZE_BUILTIN(arr, 1);
   // CHECK: store i32 500
-  gi = __builtin_object_size(arr, 2);
+  gi = OBJECT_SIZE_BUILTIN(arr, 2);
   // CHECK: store i32 500
-  gi = __builtin_object_size(arr, 3);
+  gi = OBJECT_SIZE_BUILTIN(arr, 3);
 
   // CHECK: store i32 100
-  gi = __builtin_object_size(my_malloc(100), 0);
+  gi = OBJECT_SIZE_BUILTIN(my_malloc(100), 0);
   // CHECK: store i32 100
-  gi = __builtin_object_size(my_malloc(100), 1);
+  gi = OBJECT_SIZE_BUILTIN(my_malloc(100), 1);
   // CHECK: store i32 100
-  gi = __builtin_object_size(my_malloc(100), 2);
+  gi = OBJECT_SIZE_BUILTIN(my_malloc(100), 2);
   // CHECK: store i32 100
-  gi = __builtin_object_size(my_malloc(100), 3);
+  gi = OBJECT_SIZE_BUILTIN(my_malloc(100), 3);
 
   // CHECK: store i32 500
-  gi = __builtin_object_size(my_calloc(100, 5), 0);
+  gi = OBJECT_SIZE_BUILTIN(my_calloc(100, 5), 0);
   // CHECK: store i32 500
-  gi = __builtin_object_size(my_calloc(100, 5), 1);
+  gi = OBJECT_SIZE_BUILTIN(my_calloc(100, 5), 1);
   // CHECK: store i32 500
-  gi = __builtin_object_size(my_calloc(100, 5), 2);
+  gi = OBJECT_SIZE_BUILTIN(my_calloc(100, 5), 2);
   // CHECK: store i32 500
-  gi = __builtin_object_size(my_calloc(100, 5), 3);
+  gi = OBJECT_SIZE_BUILTIN(my_calloc(100, 5), 3);
 
   void *const zeroPtr = my_malloc(0);
   // CHECK: store i32 0
-  gi = __builtin_object_size(zeroPtr, 0);
+  gi = OBJECT_SIZE_BUILTIN(zeroPtr, 0);
   // CHECK: store i32 0
-  gi = __builtin_object_size(my_malloc(0), 0);
+  gi = OBJECT_SIZE_BUILTIN(my_malloc(0), 0);
 
   void *const zeroArr1 = my_calloc(0, 1);
   void *const zeroArr2 = my_calloc(1, 0);
   // CHECK: store i32 0
-  gi = __builtin_object_size(zeroArr1, 0);
+  gi = OBJECT_SIZE_BUILTIN(zeroArr1, 0);
   // CHECK: store i32 0
-  gi = __builtin_object_size(zeroArr2, 0);
+  gi = OBJECT_SIZE_BUILTIN(zeroArr2, 0);
   // CHECK: store i32 0
-  gi = __builtin_object_size(my_calloc(1, 0), 0);
+  gi = OBJECT_SIZE_BUILTIN(my_calloc(1, 0), 0);
   // CHECK: store i32 0
-  gi = __builtin_object_size(my_calloc(0, 1), 0);
+  gi = OBJECT_SIZE_BUILTIN(my_calloc(0, 1), 0);
 }
 
 // CHECK-LABEL: @test2
 void test2() {
   void *const vp = my_malloc(gi);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(vp, 0);
+  gi = OBJECT_SIZE_BUILTIN(vp, 0);
 
   void *const arr1 = my_calloc(gi, 1);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(arr1, 0);
+  gi = OBJECT_SIZE_BUILTIN(arr1, 0);
 
   void *const arr2 = my_calloc(1, gi);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(arr2, 0);
+  gi = OBJECT_SIZE_BUILTIN(arr2, 0);
 }
 
 // CHECK-LABEL: @test3
 void test3() {
   char *const buf = (char *)my_calloc(100, 5);
   // CHECK: store i32 500
-  gi = __builtin_object_size(buf, 0);
+  gi = OBJECT_SIZE_BUILTIN(buf, 0);
   // CHECK: store i32 500
-  gi = __builtin_object_size(buf, 1);
+  gi = OBJECT_SIZE_BUILTIN(buf, 1);
   // CHECK: store i32 500
-  gi = __builtin_object_size(buf, 2);
+  gi = OBJECT_SIZE_BUILTIN(buf, 2);
   // CHECK: store i32 500
-  gi = __builtin_object_size(buf, 3);
+  gi = OBJECT_SIZE_BUILTIN(buf, 3);
 }
 
 struct Data {
   int a;
   int t[10];
   char pad[3];
   char end[1];
 };
 
 // CHECK-LABEL: @test5
 void test5() {
   struct Data *const data = my_malloc(sizeof(*data));
   // CHECK: store i32 48
-  gi = __builtin_object_size(data, 0);
+  gi = OBJECT_SIZE_BUILTIN(data, 0);
   // CHECK: store i32 48
-  gi = __builtin_object_size(data, 1);
+  gi = OBJECT_SIZE_BUILTIN(data, 1);
   // CHECK: store i32 48
-  gi = __builtin_object_size(data, 2);
+  gi = OBJECT_SIZE_BUILTIN(data, 2);
   // CHECK: store i32 48
-  gi = __builtin_object_size(data, 3);
+  gi = OBJECT_SIZE_BUILTIN(data, 3);
 
   // CHECK: store i32 40
-  gi = __builtin_object_size(&data->t[1], 0);
+  gi = OBJECT_SIZE_BUILTIN(&data->t[1], 0);
   // CHECK: store i32 36
-  gi = __builtin_object_size(&data->t[1], 1);
+  gi = OBJECT_SIZE_BUILTIN(&data->t[1], 1);
   // CHECK: store i32 40
-  gi = __builtin_object_size(&data->t[1], 2);
+  gi = OBJECT_SIZE_BUILTIN(&data->t[1], 2);
   // CHECK: store i32 36
-  gi = __builtin_object_size(&data->t[1], 3);
+  gi = OBJECT_SIZE_BUILTIN(&data->t[1], 3);
 
   struct Data *const arr = my_calloc(sizeof(*data), 2);
   // CHECK: store i32 96
-  gi = __builtin_object_size(arr, 0);
+  gi = OBJECT_SIZE_BUILTIN(arr, 0);
   // CHECK: store i32 96
-  gi = __builtin_object_size(arr, 1);
+  gi = OBJECT_SIZE_BUILTIN(arr, 1);
   // CHECK: store i32 96
-  gi = __builtin_object_size(arr, 2);
+  gi = OBJECT_SIZE_BUILTIN(arr, 2);
   // CHECK: store i32 96
-  gi = __builtin_object_size(arr, 3);
+  gi = OBJECT_SIZE_BUILTIN(arr, 3);
 
   // CHECK: store i32 88
-  gi = __builtin_object_size(&arr->t[1], 0);
+  gi = OBJECT_SIZE_BUILTIN(&arr->t[1], 0);
   // CHECK: store i32 36
-  gi = __builtin_object_size(&arr->t[1], 1);
+  gi = OBJECT_SIZE_BUILTIN(&arr->t[1], 1);
   // CHECK: store i32 88
-  gi = __builtin_object_size(&arr->t[1], 2);
+  gi = OBJECT_SIZE_BUILTIN(&arr->t[1], 2);
   // CHECK: store i32 36
-  gi = __builtin_object_size(&arr->t[1], 3);
+  gi = OBJECT_SIZE_BUILTIN(&arr->t[1], 3);
 }
 
 // CHECK-LABEL: @test6
 void test6() {
   // Things that would normally trigger conservative estimates don't need to do
   // so when we know the source of the allocation.
   struct Data *const data = my_malloc(sizeof(*data) + 10);
   // CHECK: store i32 11
-  gi = __builtin_object_size(data->end, 0);
+  gi = OBJECT_SIZE_BUILTIN(data->end, 0);
   // CHECK: store i32 11
-  gi = __builtin_object_size(data->end, 1);
+  gi = OBJECT_SIZE_BUILTIN(data->end, 1);
   // CHECK: store i32 11
-  gi = __builtin_object_size(data->end, 2);
+  gi = OBJECT_SIZE_BUILTIN(data->end, 2);
   // CHECK: store i32 11
-  gi = __builtin_object_size(data->end, 3);
+  gi = OBJECT_SIZE_BUILTIN(data->end, 3);
 
   struct Data *const arr = my_calloc(sizeof(*arr) + 5, 3);
   // AFAICT, GCC treats malloc and calloc identically. So, we should do the
   // same.
   //
   // Additionally, GCC ignores the initial array index when determining whether
   // we're writing off the end of an alloc_size base. e.g.
   //   arr[0].end
   //   arr[1].end
   //   arr[2].end
   // ...Are all considered "writing off the end", because there's no way to tell
   // with high accuracy if the user meant "allocate a single N-byte `Data`",
   // or "allocate M smaller `Data`s with extra padding".
 
   // CHECK: store i32 112
-  gi = __builtin_object_size(arr->end, 0);
+  gi = OBJECT_SIZE_BUILTIN(arr->end, 0);
   // CHECK: store i32 112
-  gi = __builtin_object_size(arr->end, 1);
+  gi = OBJECT_SIZE_BUILTIN(arr->end, 1);
   // CHECK: store i32 112
-  gi = __builtin_object_size(arr->end, 2);
+  gi = OBJECT_SIZE_BUILTIN(arr->end, 2);
   // CHECK: store i32 112
-  gi = __builtin_object_size(arr->end, 3);
+  gi = OBJECT_SIZE_BUILTIN(arr->end, 3);
 
   // CHECK: store i32 112
-  gi = __builtin_object_size(arr[0].end, 0);
+  gi = OBJECT_SIZE_BUILTIN(arr[0].end, 0);
   // CHECK: store i32 112
-  gi = __builtin_object_size(arr[0].end, 1);
+  gi = OBJECT_SIZE_BUILTIN(arr[0].end, 1);
   // CHECK: store i32 112
-  gi = __builtin_object_size(arr[0].end, 2);
+  gi = OBJECT_SIZE_BUILTIN(arr[0].end, 2);
   // CHECK: store i32 112
-  gi = __builtin_object_size(arr[0].end, 3);
+  gi = OBJECT_SIZE_BUILTIN(arr[0].end, 3);
 
   // CHECK: store i32 64
-  gi = __builtin_object_size(arr[1].end, 0);
+  gi = OBJECT_SIZE_BUILTIN(arr[1].end, 0);
   // CHECK: store i32 64
-  gi = __builtin_object_size(arr[1].end, 1);
+  gi = OBJECT_SIZE_BUILTIN(arr[1].end, 1);
   // CHECK: store i32 64
-  gi = __builtin_object_size(arr[1].end, 2);
+  gi = OBJECT_SIZE_BUILTIN(arr[1].end, 2);
   // CHECK: store i32 64
-  gi = __builtin_object_size(arr[1].end, 3);
+  gi = OBJECT_SIZE_BUILTIN(arr[1].end, 3);
 
   // CHECK: store i32 16
-  gi = __builtin_object_size(arr[2].end, 0);
+  gi = OBJECT_SIZE_BUILTIN(arr[2].end, 0);
   // CHECK: store i32 16
-  gi = __builtin_object_size(arr[2].end, 1);
+  gi = OBJECT_SIZE_BUILTIN(arr[2].end, 1);
   // CHECK: store i32 16
-  gi = __builtin_object_size(arr[2].end, 2);
+  gi = OBJECT_SIZE_BUILTIN(arr[2].end, 2);
   // CHECK: store i32 16
-  gi = __builtin_object_size(arr[2].end, 3);
+  gi = OBJECT_SIZE_BUILTIN(arr[2].end, 3);
 }
 
 // CHECK-LABEL: @test7
 void test7() {
   struct Data *const data = my_malloc(sizeof(*data) + 5);
   // CHECK: store i32 9
-  gi = __builtin_object_size(data->pad, 0);
+  gi = OBJECT_SIZE_BUILTIN(data->pad, 0);
   // CHECK: store i32 3
-  gi = __builtin_object_size(data->pad, 1);
+  gi = OBJECT_SIZE_BUILTIN(data->pad, 1);
   // CHECK: store i32 9
-  gi = __builtin_object_size(data->pad, 2);
+  gi = OBJECT_SIZE_BUILTIN(data->pad, 2);
   // CHECK: store i32 3
-  gi = __builtin_object_size(data->pad, 3);
+  gi = OBJECT_SIZE_BUILTIN(data->pad, 3);
 }
 
 // CHECK-LABEL: @test8
 void test8() {
   // Non-const pointers aren't currently supported.
   void *buf = my_calloc(100, 5);
-  // CHECK: @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1 false)
-  gi = __builtin_object_size(buf, 0);
+  // CHECK: @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
+  gi = OBJECT_SIZE_BUILTIN(buf, 0);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(buf, 1);
+  gi = OBJECT_SIZE_BUILTIN(buf, 1);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(buf, 2);
+  gi = OBJECT_SIZE_BUILTIN(buf, 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size(buf, 3);
+  gi = OBJECT_SIZE_BUILTIN(buf, 3);
 }
 
 // CHECK-LABEL: @test9
 void test9() {
   // Check to be sure that we unwrap things correctly.
   short *const buf0 = (my_malloc(100));
   short *const buf1 = (short*)(my_malloc(100));
   short *const buf2 = ((short*)(my_malloc(100)));
 
   // CHECK: store i32 100
-  gi = __builtin_object_size(buf0, 0);
+  gi = OBJECT_SIZE_BUILTIN(buf0, 0);
   // CHECK: store i32 100
-  gi = __builtin_object_size(buf1, 0);
+  gi = OBJECT_SIZE_BUILTIN(buf1, 0);
   // CHECK: store i32 100
-  gi = __builtin_object_size(buf2, 0);
+  gi = OBJECT_SIZE_BUILTIN(buf2, 0);
 }
 
 // CHECK-LABEL: @test10
 void test10() {
   // Yay overflow
   short *const arr = my_calloc((size_t)-1 / 2 + 1, 2);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(arr, 0);
+  gi = OBJECT_SIZE_BUILTIN(arr, 0);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(arr, 1);
+  gi = OBJECT_SIZE_BUILTIN(arr, 1);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(arr, 2);
+  gi = OBJECT_SIZE_BUILTIN(arr, 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size(arr, 3);
+  gi = OBJECT_SIZE_BUILTIN(arr, 3);
 
   // As an implementation detail, CharUnits can't handle numbers greater than or
   // equal to 2**63. Realistically, this shouldn't be a problem, but we should
   // be sure we don't emit crazy results for this case.
   short *const buf = my_malloc((size_t)-1);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(buf, 0);
+  gi = OBJECT_SIZE_BUILTIN(buf, 0);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(buf, 1);
+  gi = OBJECT_SIZE_BUILTIN(buf, 1);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(buf, 2);
+  gi = OBJECT_SIZE_BUILTIN(buf, 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size(buf, 3);
+  gi = OBJECT_SIZE_BUILTIN(buf, 3);
 
   short *const arr_big = my_calloc((size_t)-1 / 2 - 1, 2);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(arr_big, 0);
+  gi = OBJECT_SIZE_BUILTIN(arr_big, 0);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(arr_big, 1);
+  gi = OBJECT_SIZE_BUILTIN(arr_big, 1);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(arr_big, 2);
+  gi = OBJECT_SIZE_BUILTIN(arr_big, 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size(arr_big, 3);
+  gi = OBJECT_SIZE_BUILTIN(arr_big, 3);
 }
 
 void *my_tiny_malloc(char) __attribute__((alloc_size(1)));
 void *my_tiny_calloc(char, char) __attribute__((alloc_size(1, 2)));
 
 // CHECK-LABEL: @test11
 void test11() {
   void *const vp = my_tiny_malloc(100);
   // CHECK: store i32 100
-  gi = __builtin_object_size(vp, 0);
+  gi = OBJECT_SIZE_BUILTIN(vp, 0);
   // CHECK: store i32 100
-  gi = __builtin_object_size(vp, 1);
+  gi = OBJECT_SIZE_BUILTIN(vp, 1);
   // CHECK: store i32 100
-  gi = __builtin_object_size(vp, 2);
+  gi = OBJECT_SIZE_BUILTIN(vp, 2);
   // CHECK: store i32 100
-  gi = __builtin_object_size(vp, 3);
+  gi = OBJECT_SIZE_BUILTIN(vp, 3);
 
   // N.B. This causes char overflow, but not size_t overflow, so it should be
   // supported.
   void *const arr = my_tiny_calloc(100, 5);
   // CHECK: store i32 500
-  gi = __builtin_object_size(arr, 0);
+  gi = OBJECT_SIZE_BUILTIN(arr, 0);
   // CHECK: store i32 500
-  gi = __builtin_object_size(arr, 1);
+  gi = OBJECT_SIZE_BUILTIN(arr, 1);
   // CHECK: store i32 500
-  gi = __builtin_object_size(arr, 2);
+  gi = OBJECT_SIZE_BUILTIN(arr, 2);
   // CHECK: store i32 500
-  gi = __builtin_object_size(arr, 3);
+  gi = OBJECT_SIZE_BUILTIN(arr, 3);
 }
 
 void *my_signed_malloc(long) __attribute__((alloc_size(1)));
 void *my_signed_calloc(long, long) __attribute__((alloc_size(1, 2)));
 
 // CHECK-LABEL: @test12
 void test12() {
   // CHECK: store i32 100
-  gi = __builtin_object_size(my_signed_malloc(100), 0);
+  gi = OBJECT_SIZE_BUILTIN(my_signed_malloc(100), 0);
   // CHECK: store i32 500
-  gi = __builtin_object_size(my_signed_calloc(100, 5), 0);
+  gi = OBJECT_SIZE_BUILTIN(my_signed_calloc(100, 5), 0);
 
   void *const vp = my_signed_malloc(-2);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(vp, 0);
+  gi = OBJECT_SIZE_BUILTIN(vp, 0);
   // N.B. These get lowered to -1 because the function calls may have
   // side-effects, and we can't determine the objectsize.
   // CHECK: store i32 -1
-  gi = __builtin_object_size(my_signed_malloc(-2), 0);
+  gi = OBJECT_SIZE_BUILTIN(my_signed_malloc(-2), 0);
 
   void *const arr1 = my_signed_calloc(-2, 1);
   void *const arr2 = my_signed_calloc(1, -2);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(arr1, 0);
+  gi = OBJECT_SIZE_BUILTIN(arr1, 0);
   // CHECK: @llvm.objectsize
-  gi = __builtin_object_size(arr2, 0);
+  gi = OBJECT_SIZE_BUILTIN(arr2, 0);
   // CHECK: store i32 -1
-  gi = __builtin_object_size(my_signed_calloc(1, -2), 0);
+  gi = OBJECT_SIZE_BUILTIN(my_signed_calloc(1, -2), 0);
   // CHECK: store i32 -1
-  gi = __builtin_object_size(my_signed_calloc(-2, 1), 0);
+  gi = OBJECT_SIZE_BUILTIN(my_signed_calloc(-2, 1), 0);
 }

cfe/trunk/test/CodeGen/object-size.c

-// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm %s -o - 2>&1 | FileCheck %s
+// RUN: %clang_cc1           -triple x86_64-apple-darwin -emit-llvm %s -o - 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -DDYNAMIC -triple x86_64-apple-darwin -emit-llvm %s -o - 2>&1 | FileCheck %s
+
+#ifndef DYNAMIC
+#define OBJECT_SIZE_BUILTIN __builtin_object_size
+#else
+#define OBJECT_SIZE_BUILTIN __builtin_dynamic_object_size
+#endif
 
 #define strcpy(dest, src) \
-  ((__builtin_object_size(dest, 0) != -1ULL) \
-   ? __builtin___strcpy_chk (dest, src, __builtin_object_size(dest, 1)) \
+  ((OBJECT_SIZE_BUILTIN(dest, 0) != -1ULL) \
+   ? __builtin___strcpy_chk (dest, src, OBJECT_SIZE_BUILTIN(dest, 1)) \
    : __inline_strcpy_chk(dest, src))
 
 static char *__inline_strcpy_chk (char *dest, const char *src) {
-  return __builtin___strcpy_chk(dest, src, __builtin_object_size(dest, 1));
+  return __builtin___strcpy_chk(dest, src, OBJECT_SIZE_BUILTIN(dest, 1));
 }
 
 char gbuf[63];
 char *gp;
 int gi, gj;
 
 // CHECK-LABEL: define void @test1
 void test1() {

 void test4() {
   // CHECK:     = call i8* @__strcpy_chk(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @gbuf, i64 0, i64 -1), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 0)
   strcpy((char*)(void*)&gbuf[-1], "Hi there");
 }
 
 // CHECK-LABEL: define void @test5
 void test5() {
   // CHECK:     = load i8*, i8** @gp
-  // CHECK-NEXT:= call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1 false)
+  // CHECK-NEXT:= call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
   strcpy(gp, "Hi there");
 }
 
 // CHECK-LABEL: define void @test6
 void test6() {
   char buf[57];
 
   // CHECK:       = call i8* @__strcpy_chk(i8* %{{.*}}, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 53)
void test16() {
   // CHECK-NOT:   __strcpy_chk
   // CHECK:       = call i8* @__inline_strcpy_chk(i8* %{{.*}}, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0))
   strcpy(gp += 1, "Hi there");
 }
 
 // CHECK-LABEL: @test17
 void test17() {
   // CHECK: store i32 -1
-  gi = __builtin_object_size(gp++, 0);
+  gi = OBJECT_SIZE_BUILTIN(gp++, 0);
   // CHECK: store i32 -1
-  gi = __builtin_object_size(gp++, 1);
+  gi = OBJECT_SIZE_BUILTIN(gp++, 1);
   // CHECK: store i32 0
-  gi = __builtin_object_size(gp++, 2);
+  gi = OBJECT_SIZE_BUILTIN(gp++, 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size(gp++, 3);
+  gi = OBJECT_SIZE_BUILTIN(gp++, 3);
 }
 
 // CHECK-LABEL: @test18
 unsigned test18(int cond) {
   int a[4], b[4];
   // CHECK: phi i32*
   // CHECK: call i64 @llvm.objectsize.i64
-  return __builtin_object_size(cond ? a : b, 0);
+  return OBJECT_SIZE_BUILTIN(cond ? a : b, 0);
 }
 
 // CHECK-LABEL: @test19
 void test19() {
   struct {
     int a, b;
   } foo;
 
   // CHECK: store i32 8
-  gi = __builtin_object_size(&foo.a, 0);
+  gi = OBJECT_SIZE_BUILTIN(&foo.a, 0);
   // CHECK: store i32 4
-  gi = __builtin_object_size(&foo.a, 1);
+  gi = OBJECT_SIZE_BUILTIN(&foo.a, 1);
   // CHECK: store i32 8
-  gi = __builtin_object_size(&foo.a, 2);
+  gi = OBJECT_SIZE_BUILTIN(&foo.a, 2);
   // CHECK: store i32 4
-  gi = __builtin_object_size(&foo.a, 3);
+  gi = OBJECT_SIZE_BUILTIN(&foo.a, 3);
 
   // CHECK: store i32 4
-  gi = __builtin_object_size(&foo.b, 0);
+  gi = OBJECT_SIZE_BUILTIN(&foo.b, 0);
   // CHECK: store i32 4
-  gi = __builtin_object_size(&foo.b, 1);
+  gi = OBJECT_SIZE_BUILTIN(&foo.b, 1);
   // CHECK: store i32 4
-  gi = __builtin_object_size(&foo.b, 2);
+  gi = OBJECT_SIZE_BUILTIN(&foo.b, 2);
   // CHECK: store i32 4
-  gi = __builtin_object_size(&foo.b, 3);
+  gi = OBJECT_SIZE_BUILTIN(&foo.b, 3);
 }
 
 // CHECK-LABEL: @test20
 void test20() {
   struct { int t[10]; } t[10];
 
   // CHECK: store i32 380
-  gi = __builtin_object_size(&t[0].t[5], 0);
+  gi = OBJECT_SIZE_BUILTIN(&t[0].t[5], 0);
   // CHECK: store i32 20
-  gi = __builtin_object_size(&t[0].t[5], 1);
+  gi = OBJECT_SIZE_BUILTIN(&t[0].t[5], 1);
   // CHECK: store i32 380
-  gi = __builtin_object_size(&t[0].t[5], 2);
+  gi = OBJECT_SIZE_BUILTIN(&t[0].t[5], 2);
   // CHECK: store i32 20
-  gi = __builtin_object_size(&t[0].t[5], 3);
+  gi = OBJECT_SIZE_BUILTIN(&t[0].t[5], 3);
 }
 
 // CHECK-LABEL: @test21
 void test21() {
   struct { int t; } t;
 
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t + 1, 0);
+  gi = OBJECT_SIZE_BUILTIN(&t + 1, 0);
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t + 1, 1);
+  gi = OBJECT_SIZE_BUILTIN(&t + 1, 1);
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t + 1, 2);
+  gi = OBJECT_SIZE_BUILTIN(&t + 1, 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t + 1, 3);
+  gi = OBJECT_SIZE_BUILTIN(&t + 1, 3);
 
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t.t + 1, 0);
+  gi = OBJECT_SIZE_BUILTIN(&t.t + 1, 0);
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t.t + 1, 1);
+  gi = OBJECT_SIZE_BUILTIN(&t.t + 1, 1);
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t.t + 1, 2);
+  gi = OBJECT_SIZE_BUILTIN(&t.t + 1, 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t.t + 1, 3);
+  gi = OBJECT_SIZE_BUILTIN(&t.t + 1, 3);
 }
 
 // CHECK-LABEL: @test22
 void test22() {
   struct { int t[10]; } t[10];
 
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t[10], 0);
+  gi = OBJECT_SIZE_BUILTIN(&t[10], 0);
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t[10], 1);
+  gi = OBJECT_SIZE_BUILTIN(&t[10], 1);
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t[10], 2);
+  gi = OBJECT_SIZE_BUILTIN(&t[10], 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t[10], 3);
+  gi = OBJECT_SIZE_BUILTIN(&t[10], 3);
 
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t[9].t[10], 0);
+  gi = OBJECT_SIZE_BUILTIN(&t[9].t[10], 0);
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t[9].t[10], 1);
+  gi = OBJECT_SIZE_BUILTIN(&t[9].t[10], 1);
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t[9].t[10], 2);
+  gi = OBJECT_SIZE_BUILTIN(&t[9].t[10], 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t[9].t[10], 3);
+  gi = OBJECT_SIZE_BUILTIN(&t[9].t[10], 3);
 
   // CHECK: store i32 0
-  gi = __builtin_object_size((char*)&t[0] + sizeof(t), 0);
+  gi = OBJECT_SIZE_BUILTIN((char*)&t[0] + sizeof(t), 0);
   // CHECK: store i32 0
-  gi = __builtin_object_size((char*)&t[0] + sizeof(t), 1);
+  gi = OBJECT_SIZE_BUILTIN((char*)&t[0] + sizeof(t), 1);
   // CHECK: store i32 0
-  gi = __builtin_object_size((char*)&t[0] + sizeof(t), 2);
+  gi = OBJECT_SIZE_BUILTIN((char*)&t[0] + sizeof(t), 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size((char*)&t[0] + sizeof(t), 3);
+  gi = OBJECT_SIZE_BUILTIN((char*)&t[0] + sizeof(t), 3);
 
   // CHECK: store i32 0
-  gi = __builtin_object_size((char*)&t[9].t[0] + 10*sizeof(t[0].t), 0);
+  gi = OBJECT_SIZE_BUILTIN((char*)&t[9].t[0] + 10*sizeof(t[0].t), 0);
   // CHECK: store i32 0
-  gi = __builtin_object_size((char*)&t[9].t[0] + 10*sizeof(t[0].t), 1);
+  gi = OBJECT_SIZE_BUILTIN((char*)&t[9].t[0] + 10*sizeof(t[0].t), 1);
   // CHECK: store i32 0
-  gi = __builtin_object_size((char*)&t[9].t[0] + 10*sizeof(t[0].t), 2);
+  gi = OBJECT_SIZE_BUILTIN((char*)&t[9].t[0] + 10*sizeof(t[0].t), 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size((char*)&t[9].t[0] + 10*sizeof(t[0].t), 3);
+  gi = OBJECT_SIZE_BUILTIN((char*)&t[9].t[0] + 10*sizeof(t[0].t), 3);
 }
 
 struct Test23Ty { int a; int t[10]; };
 
 // CHECK-LABEL: @test23
 void test23(struct Test23Ty *p) {
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(p, 0);
+  gi = OBJECT_SIZE_BUILTIN(p, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(p, 1);
+  gi = OBJECT_SIZE_BUILTIN(p, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(p, 2);
+  gi = OBJECT_SIZE_BUILTIN(p, 2);
   // Note: this is currently fixed at 0 because LLVM doesn't have sufficient
   // data to correctly handle type=3
   // CHECK: store i32 0
-  gi = __builtin_object_size(p, 3);
+  gi = OBJECT_SIZE_BUILTIN(p, 3);
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(&p->a, 0);
+  gi = OBJECT_SIZE_BUILTIN(&p->a, 0);
   // CHECK: store i32 4
-  gi = __builtin_object_size(&p->a, 1);
+  gi = OBJECT_SIZE_BUILTIN(&p->a, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(&p->a, 2);
+  gi = OBJECT_SIZE_BUILTIN(&p->a, 2);
   // CHECK: store i32 4
-  gi = __builtin_object_size(&p->a, 3);
+  gi = OBJECT_SIZE_BUILTIN(&p->a, 3);
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(&p->t[5], 0);
+  gi = OBJECT_SIZE_BUILTIN(&p->t[5], 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(&p->t[5], 1);
+  gi = OBJECT_SIZE_BUILTIN(&p->t[5], 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(&p->t[5], 2);
+  gi = OBJECT_SIZE_BUILTIN(&p->t[5], 2);
   // CHECK: store i32 20
-  gi = __builtin_object_size(&p->t[5], 3);
+  gi = OBJECT_SIZE_BUILTIN(&p->t[5], 3);
 }
 
-// PR24493 -- ICE if __builtin_object_size called with NULL and (Type & 1) != 0
+// PR24493 -- ICE if OBJECT_SIZE_BUILTIN called with NULL and (Type & 1) != 0
 // CHECK-LABEL: @test24
 void test24() {
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size((void*)0, 0);
+  gi = OBJECT_SIZE_BUILTIN((void*)0, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size((void*)0, 1);
+  gi = OBJECT_SIZE_BUILTIN((void*)0, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size((void*)0, 2);
+  gi = OBJECT_SIZE_BUILTIN((void*)0, 2);
   // Note: Currently fixed at zero because LLVM can't handle type=3 correctly.
   // Hopefully will be lowered properly in the future.
   // CHECK: store i32 0
-  gi = __builtin_object_size((void*)0, 3);
+  gi = OBJECT_SIZE_BUILTIN((void*)0, 3);
 }
 
 // CHECK-LABEL: @test25
 void test25() {
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size((void*)0x1000, 0);
+  gi = OBJECT_SIZE_BUILTIN((void*)0x1000, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size((void*)0x1000, 1);
+  gi = OBJECT_SIZE_BUILTIN((void*)0x1000, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size((void*)0x1000, 2);
+  gi = OBJECT_SIZE_BUILTIN((void*)0x1000, 2);
   // Note: Currently fixed at zero because LLVM can't handle type=3 correctly.
   // Hopefully will be lowered properly in the future.
   // CHECK: store i32 0
-  gi = __builtin_object_size((void*)0x1000, 3);
+  gi = OBJECT_SIZE_BUILTIN((void*)0x1000, 3);
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size((void*)0 + 0x1000, 0);
+  gi = OBJECT_SIZE_BUILTIN((void*)0 + 0x1000, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size((void*)0 + 0x1000, 1);
+  gi = OBJECT_SIZE_BUILTIN((void*)0 + 0x1000, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size((void*)0 + 0x1000, 2);
+  gi = OBJECT_SIZE_BUILTIN((void*)0 + 0x1000, 2);
   // Note: Currently fixed at zero because LLVM can't handle type=3 correctly.
   // Hopefully will be lowered properly in the future.
   // CHECK: store i32 0
-  gi = __builtin_object_size((void*)0 + 0x1000, 3);
+  gi = OBJECT_SIZE_BUILTIN((void*)0 + 0x1000, 3);
 }
 
 // CHECK-LABEL: @test26
 void test26() {
   struct { int v[10]; } t[10];
 
   // CHECK: store i32 316
-  gi = __builtin_object_size(&t[1].v[11], 0);
+  gi = OBJECT_SIZE_BUILTIN(&t[1].v[11], 0);
   // CHECK: store i32 312
-  gi = __builtin_object_size(&t[1].v[12], 1);
+  gi = OBJECT_SIZE_BUILTIN(&t[1].v[12], 1);
   // CHECK: store i32 308
-  gi = __builtin_object_size(&t[1].v[13], 2);
+  gi = OBJECT_SIZE_BUILTIN(&t[1].v[13], 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size(&t[1].v[14], 3);
+  gi = OBJECT_SIZE_BUILTIN(&t[1].v[14], 3);
 }
 
 struct Test27IncompleteTy;
 
 // CHECK-LABEL: @test27
 void test27(struct Test27IncompleteTy *t) {
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(t, 0);
+  gi = OBJECT_SIZE_BUILTIN(t, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(t, 1);
+  gi = OBJECT_SIZE_BUILTIN(t, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(t, 2);
+  gi = OBJECT_SIZE_BUILTIN(t, 2);
   // Note: this is currently fixed at 0 because LLVM doesn't have sufficient
   // data to correctly handle type=3
   // CHECK: store i32 0
-  gi = __builtin_object_size(t, 3);
+  gi = OBJECT_SIZE_BUILTIN(t, 3);
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(&test27, 0);
+  gi = OBJECT_SIZE_BUILTIN(&test27, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(&test27, 1);
+  gi = OBJECT_SIZE_BUILTIN(&test27, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(&test27, 2);
+  gi = OBJECT_SIZE_BUILTIN(&test27, 2);
   // Note: this is currently fixed at 0 because LLVM doesn't have sufficient
   // data to correctly handle type=3
   // CHECK: store i32 0
-  gi = __builtin_object_size(&test27, 3);
+  gi = OBJECT_SIZE_BUILTIN(&test27, 3);
 }
 
-// The intent of this test is to ensure that __builtin_object_size treats `&foo`
+// The intent of this test is to ensure that OBJECT_SIZE_BUILTIN treats `&foo`
 // and `(T*)&foo` identically, when used as the pointer argument.
 // CHECK-LABEL: @test28
 void test28() {
   struct { int v[10]; } t[10];
 
 #define addCasts(s) ((char*)((short*)(s)))
   // CHECK: store i32 360
-  gi = __builtin_object_size(addCasts(&t[1]), 0);
+  gi = OBJECT_SIZE_BUILTIN(addCasts(&t[1]), 0);
   // CHECK: store i32 360
-  gi = __builtin_object_size(addCasts(&t[1]), 1);
+  gi = OBJECT_SIZE_BUILTIN(addCasts(&t[1]), 1);
   // CHECK: store i32 360
-  gi = __builtin_object_size(addCasts(&t[1]), 2);
+  gi = OBJECT_SIZE_BUILTIN(addCasts(&t[1]), 2);
   // CHECK: store i32 360
-  gi = __builtin_object_size(addCasts(&t[1]), 3);
+  gi = OBJECT_SIZE_BUILTIN(addCasts(&t[1]), 3);
 
   // CHECK: store i32 356
-  gi = __builtin_object_size(addCasts(&t[1].v[1]), 0);
+  gi = OBJECT_SIZE_BUILTIN(addCasts(&t[1].v[1]), 0);
   // CHECK: store i32 36
-  gi = __builtin_object_size(addCasts(&t[1].v[1]), 1);
+  gi = OBJECT_SIZE_BUILTIN(addCasts(&t[1].v[1]), 1);
   // CHECK: store i32 356
-  gi = __builtin_object_size(addCasts(&t[1].v[1]), 2);
+  gi = OBJECT_SIZE_BUILTIN(addCasts(&t[1].v[1]), 2);
   // CHECK: store i32 36
-  gi = __builtin_object_size(addCasts(&t[1].v[1]), 3);
+  gi = OBJECT_SIZE_BUILTIN(addCasts(&t[1].v[1]), 3);
 #undef addCasts
 }
 
 struct DynStructVar {
   char fst[16];
   char snd[];
 };
 
struct StaticStruct {
   char fst[16];
   char snd[2];
 };
 
 // CHECK-LABEL: @test29
 void test29(struct DynStructVar *dv, struct DynStruct0 *d0,
             struct DynStruct1 *d1, struct StaticStruct *ss) {
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(dv->snd, 0);
+  gi = OBJECT_SIZE_BUILTIN(dv->snd, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(dv->snd, 1);
+  gi = OBJECT_SIZE_BUILTIN(dv->snd, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(dv->snd, 2);
+  gi = OBJECT_SIZE_BUILTIN(dv->snd, 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size(dv->snd, 3);
+  gi = OBJECT_SIZE_BUILTIN(dv->snd, 3);
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(d0->snd, 0);
+  gi = OBJECT_SIZE_BUILTIN(d0->snd, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(d0->snd, 1);
+  gi = OBJECT_SIZE_BUILTIN(d0->snd, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(d0->snd, 2);
+  gi = OBJECT_SIZE_BUILTIN(d0->snd, 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size(d0->snd, 3);
+  gi = OBJECT_SIZE_BUILTIN(d0->snd, 3);
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(d1->snd, 0);
+  gi = OBJECT_SIZE_BUILTIN(d1->snd, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(d1->snd, 1);
+  gi = OBJECT_SIZE_BUILTIN(d1->snd, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(d1->snd, 2);
+  gi = OBJECT_SIZE_BUILTIN(d1->snd, 2);
   // CHECK: store i32 1
-  gi = __builtin_object_size(d1->snd, 3);
+  gi = OBJECT_SIZE_BUILTIN(d1->snd, 3);
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(ss->snd, 0);
+  gi = OBJECT_SIZE_BUILTIN(ss->snd, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(ss->snd, 1);
+  gi = OBJECT_SIZE_BUILTIN(ss->snd, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(ss->snd, 2);
+  gi = OBJECT_SIZE_BUILTIN(ss->snd, 2);
   // CHECK: store i32 2
-  gi = __builtin_object_size(ss->snd, 3);
+  gi = OBJECT_SIZE_BUILTIN(ss->snd, 3);
 }
 
 // CHECK-LABEL: @test30
 void test30() {
   struct { struct DynStruct1 fst, snd; } *nested;
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(nested->fst.snd, 0);
+  gi = OBJECT_SIZE_BUILTIN(nested->fst.snd, 0);
   // CHECK: store i32 1
-  gi = __builtin_object_size(nested->fst.snd, 1);
+  gi = OBJECT_SIZE_BUILTIN(nested->fst.snd, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(nested->fst.snd, 2);
+  gi = OBJECT_SIZE_BUILTIN(nested->fst.snd, 2);
   // CHECK: store i32 1
-  gi = __builtin_object_size(nested->fst.snd, 3);
+  gi = OBJECT_SIZE_BUILTIN(nested->fst.snd, 3);
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(nested->snd.snd, 0);
+  gi = OBJECT_SIZE_BUILTIN(nested->snd.snd, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(nested->snd.snd, 1);
+  gi = OBJECT_SIZE_BUILTIN(nested->snd.snd, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(nested->snd.snd, 2);
+  gi = OBJECT_SIZE_BUILTIN(nested->snd.snd, 2);
   // CHECK: store i32 1
-  gi = __builtin_object_size(nested->snd.snd, 3);
+  gi = OBJECT_SIZE_BUILTIN(nested->snd.snd, 3);
 
   union { struct DynStruct1 d1; char c[1]; } *u;
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(u->c, 0);
+  gi = OBJECT_SIZE_BUILTIN(u->c, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(u->c, 1);
+  gi = OBJECT_SIZE_BUILTIN(u->c, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(u->c, 2);
+  gi = OBJECT_SIZE_BUILTIN(u->c, 2);
   // CHECK: store i32 1
-  gi = __builtin_object_size(u->c, 3);
+  gi = OBJECT_SIZE_BUILTIN(u->c, 3);
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(u->d1.snd, 0);
+  gi = OBJECT_SIZE_BUILTIN(u->d1.snd, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(u->d1.snd, 1);
+  gi = OBJECT_SIZE_BUILTIN(u->d1.snd, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(u->d1.snd, 2);
+  gi = OBJECT_SIZE_BUILTIN(u->d1.snd, 2);
   // CHECK: store i32 1
-  gi = __builtin_object_size(u->d1.snd, 3);
+  gi = OBJECT_SIZE_BUILTIN(u->d1.snd, 3);
 }
 
 // CHECK-LABEL: @test31
 void test31() {
   // Miscellaneous 'writing off the end' detection tests
   struct DynStructVar *dsv;
   struct DynStruct0 *ds0;
   struct DynStruct1 *ds1;
   struct StaticStruct *ss;
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(ds1[9].snd, 1);
+  gi = OBJECT_SIZE_BUILTIN(ds1[9].snd, 1);
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(&ss[9].snd[0], 1);
+  gi = OBJECT_SIZE_BUILTIN(&ss[9].snd[0], 1);
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(&ds1[9].snd[0], 1);
+  gi = OBJECT_SIZE_BUILTIN(&ds1[9].snd[0], 1);
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(&ds0[9].snd[0], 1);
+  gi = OBJECT_SIZE_BUILTIN(&ds0[9].snd[0], 1);
 
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(&dsv[9].snd[0], 1);
+  gi = OBJECT_SIZE_BUILTIN(&dsv[9].snd[0], 1);
 }
 
 // CHECK-LABEL: @PR30346
 void PR30346() {
   struct sa_family_t {};
   struct sockaddr {
     struct sa_family_t sa_family;
     char sa_data[14];
   };
 
   struct sockaddr *sa;
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(sa->sa_data, 0);
+  gi = OBJECT_SIZE_BUILTIN(sa->sa_data, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
-  gi = __builtin_object_size(sa->sa_data, 1);
+  gi = OBJECT_SIZE_BUILTIN(sa->sa_data, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
-  gi = __builtin_object_size(sa->sa_data, 2);
+  gi = OBJECT_SIZE_BUILTIN(sa->sa_data, 2);
   // CHECK: store i32 14
-  gi = __builtin_object_size(sa->sa_data, 3);
+  gi = OBJECT_SIZE_BUILTIN(sa->sa_data, 3);
 }
 
 extern char incomplete_char_array[];
 // CHECK-LABEL: @incomplete_and_function_types
 int incomplete_and_function_types() {
   // CHECK: call i64 @llvm.objectsize.i64.p0i8
-  gi = __builtin_object_size(incomplete_char_array, 0);
+  gi = OBJECT_SIZE_BUILTIN(incomplete_char_array, 0);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8
-  gi = __builtin_object_size(incomplete_char_array, 1);
+  gi = OBJECT_SIZE_BUILTIN(incomplete_char_array, 1);
   // CHECK: call i64 @llvm.objectsize.i64.p0i8
-  gi = __builtin_object_size(incomplete_char_array, 2);
+  gi = OBJECT_SIZE_BUILTIN(incomplete_char_array, 2);
   // CHECK: store i32 0
-  gi = __builtin_object_size(incomplete_char_array, 3);
+  gi = OBJECT_SIZE_BUILTIN(incomplete_char_array, 3);
 }
 
 // Flips between the pointer and lvalue evaluator a lot.
 void deeply_nested() {
   struct {
     struct {
       struct {
         struct {
           int e[2];
           char f; // Inhibit our writing-off-the-end check
         } d[2];
       } c[2];
     } b[2];
   } *a;
 
   // CHECK: store i32 4
-  gi = __builtin_object_size(&a->b[1].c[1].d[1].e[1], 1);
+  gi = OBJECT_SIZE_BUILTIN(&a->b[1].c[1].d[1].e[1], 1);
   // CHECK: store i32 4
-  gi = __builtin_object_size(&a->b[1].c[1].d[1].e[1], 3);
+  gi = OBJECT_SIZE_BUILTIN(&a->b[1].c[1].d[1].e[1], 3);
 }

cfe/trunk/test/Sema/builtin-object-size.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-darwin9 -verify %s
+// RUN: %clang_cc1 -DDYNAMIC -fsyntax-only -triple x86_64-apple-darwin9 -verify %s
+
+#ifndef DYNAMIC
+#define OBJECT_SIZE_BUILTIN __builtin_object_size
+#else
+#define OBJECT_SIZE_BUILTIN __builtin_dynamic_object_size
+#endif
 
 int a[10];
 
 int f0() {
-  return __builtin_object_size(&a); // expected-error {{too few arguments to function}}
+  return OBJECT_SIZE_BUILTIN(&a); // expected-error {{too few arguments to function}}
 }
 int f1() {
-  return (__builtin_object_size(&a, 0) + 
-          __builtin_object_size(&a, 1) + 
-          __builtin_object_size(&a, 2) + 
-          __builtin_object_size(&a, 3));
+  return (OBJECT_SIZE_BUILTIN(&a, 0) + 
+          OBJECT_SIZE_BUILTIN(&a, 1) + 
+          OBJECT_SIZE_BUILTIN(&a, 2) + 
+          OBJECT_SIZE_BUILTIN(&a, 3));
 }
 int f2() {
-  return __builtin_object_size(&a, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
+  return OBJECT_SIZE_BUILTIN(&a, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
 }
 int f3() {
-  return __builtin_object_size(&a, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
+  return OBJECT_SIZE_BUILTIN(&a, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
 }
 
 
 // rdar://6252231 - cannot call vsnprintf with va_list on x86_64
 void f4(const char *fmt, ...) {
  __builtin_va_list args;
  __builtin___vsnprintf_chk (0, 42, 0, 11, fmt, args); // expected-warning {{'__builtin___vsnprintf_chk' will always overflow; destination buffer has size 11, but size argument is 42}}
 }
 
 // rdar://18334276
 typedef __typeof__(sizeof(int)) size_t;
 void * memcset(void *restrict dst, int src, size_t n);
 void * memcpy(void *restrict dst, const void *restrict src, size_t n);
 
-#define memset(dest, src, len) __builtin___memset_chk(dest, src, len, __builtin_object_size(dest, 0))
-#define memcpy(dest, src, len) __builtin___memcpy_chk(dest, src, len, __builtin_object_size(dest, 0))
-#define memcpy1(dest, src, len) __builtin___memcpy_chk(dest, src, len, __builtin_object_size(dest, 4))
+#define memset(dest, src, len) __builtin___memset_chk(dest, src, len, OBJECT_SIZE_BUILTIN(dest, 0))
+#define memcpy(dest, src, len) __builtin___memcpy_chk(dest, src, len, OBJECT_SIZE_BUILTIN(dest, 0))
+#define memcpy1(dest, src, len) __builtin___memcpy_chk(dest, src, len, OBJECT_SIZE_BUILTIN(dest, 4))
 #define NULL ((void *)0)
 
 void f5(void)
 {
   char buf[10];
   memset((void *)0x100000000ULL, 0, 0x1000);
   memcpy((char *)NULL + 0x10000, buf, 0x10);
   memcpy1((char *)NULL + 0x10000, buf, 0x10); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
 }
 
 // rdar://18431336
 void f6(void)
 {
   char b[5];
   char buf[10];
-  __builtin___memccpy_chk (buf, b, '\0', sizeof(b), __builtin_object_size (buf, 0));
-  __builtin___memccpy_chk (b, buf, '\0', sizeof(buf), __builtin_object_size (b, 0));  // expected-warning {{'__builtin___memccpy_chk' will always overflow; destination buffer has size 5, but size argument is 10}}
+  __builtin___memccpy_chk (buf, b, '\0', sizeof(b), OBJECT_SIZE_BUILTIN (buf, 0));
+  __builtin___memccpy_chk (b, buf, '\0', sizeof(buf), OBJECT_SIZE_BUILTIN (b, 0));  // expected-warning {{'__builtin___memccpy_chk' will always overflow; destination buffer has size 5, but size argument is 10}}
 }
 
 int pr28314(void) {
   struct {
     struct InvalidField a; // expected-error{{has incomplete type}} expected-note 3{{forward declaration of 'struct InvalidField'}}
     char b[0];
   } *p;
 
   struct {
     struct InvalidField a; // expected-error{{has incomplete type}}
     char b[1];
   } *p2;
 
   struct {
     struct InvalidField a; // expected-error{{has incomplete type}}
     char b[2];
   } *p3;
 
   int a = 0;
-  a += __builtin_object_size(&p->a, 0);
-  a += __builtin_object_size(p->b, 0);
-  a += __builtin_object_size(p2->b, 0);
-  a += __builtin_object_size(p3->b, 0);
+  a += OBJECT_SIZE_BUILTIN(&p->a, 0);
+  a += OBJECT_SIZE_BUILTIN(p->b, 0);
+  a += OBJECT_SIZE_BUILTIN(p2->b, 0);
+  a += OBJECT_SIZE_BUILTIN(p3->b, 0);
   return a;
 }
 
 int pr31843() {
   int n = 0;
 
   struct { int f; } a;
   int b;
-  n += __builtin_object_size(({&(b ? &a : &a)->f; pr31843;}), 0); // expected-warning{{expression result unused}}
+  n += OBJECT_SIZE_BUILTIN(({&(b ? &a : &a)->f; pr31843;}), 0); // expected-warning{{expression result unused}}
 
   struct statfs { char f_mntonname[1024];};
   struct statfs *outStatFSBuf;
-  n += __builtin_object_size(outStatFSBuf->f_mntonname ? "" : "", 1); // expected-warning{{address of array}}
-  n += __builtin_object_size(outStatFSBuf->f_mntonname ?: "", 1);
+  n += OBJECT_SIZE_BUILTIN(outStatFSBuf->f_mntonname ? "" : "", 1); // expected-warning{{address of array}}
+  n += OBJECT_SIZE_BUILTIN(outStatFSBuf->f_mntonname ?: "", 1);
 
   return n;
 }
 
 typedef struct {
   char string[512];
 } NestedArrayStruct;
 
 typedef struct {
   int x;
   NestedArrayStruct session[];
 } IncompleteArrayStruct;
 
 void rd36094951_IAS_builtin_object_size_assertion(IncompleteArrayStruct *p) {
 #define rd36094951_CHECK(mode)                                                 \
   __builtin___strlcpy_chk(p->session[0].string, "ab", 2,                       \
-                          __builtin_object_size(p->session[0].string, mode))
+                          OBJECT_SIZE_BUILTIN(p->session[0].string, mode))
   rd36094951_CHECK(0);
   rd36094951_CHECK(1);
   rd36094951_CHECK(2);
   rd36094951_CHECK(3);
 }