Changing @llvm.objectsize(i8*, i1) to @llvm.objectsize(i8*, i8)

[george.burgess.iv]

Summary

I'm not sure who to tag for review due to the breadth of this change, so I'm seeing if there are any kind souls out there. :)

In order to make __builtin_object_size do a better job, we need to enable @llvm.objectsize to give more accurate answers. Currently, @llvm.objectsize takes an i1 Min argument instead of a Type, so whether or not we want information about a subobject is lost. Currently, this preference is mostly[1] useless to LLVM, because we can't rely on LLVM's type information to determine the size of a subobject. However, as is alluded to in the diff, the current plan is to use metadata in order to pass this information along so LLVM can be more accurate.

Full proposal for the metadata is here: https://docs.google.com/document/d/1D5GibUI2RCCfa3g1zb5-3a7-l7nY1-tm3jrYciLP8dI/edit?usp=sharing

Accompanying patch for clang will be posted soon.

[1] - If Type = 3, this information is highly relevant, because LLVM can only return 0 in this case. Currently, Clang handles this for LLVM by substituting 0 where it would normally emit @llvm.objectsize(%ptr, 3).

[vsk]

I have a few nits and two questions (first question inline).

Second question: I notice that we're changing objectsize(p, 1) to objectsize(p, 2) in the tests. Are existing users of objectsize(p, typ) affected by this, and if so, can we warn them?

thanks

docs/LangRef.rst

4187

&b[0] ?

lib/CodeGen/CodeGenPrepare.cpp

1364

Could you use int for this? It's a nit, but the value isn't strictly binary.

test/CodeGen/Generic/object-size-type.ll

27

Sorry, I may be missing something basic but I don't understand this result. Type=3 should mean find a lower bound of the size from %i to the closest enclosing array. Shouldn't that also be 4?

In your doc, I see: "If it can’t find these tags on potential sources of Ptr, it answers conservatively". Is the problem here that we don't have metadata on the gep?

38

Is it possible to add CHECKs here for the GEP metadata you expect? It'd be good to have at least one check for the 4 different types.

[majnemer]

You need auto-upgrade logic to transition old users to the new intrinsic.

[george.burgess.iv]

Fixed nits + added auto upgrade logic.

In response to comments:

In D12351#233926, @vsk wrote:

I notice that we're changing objectsize(p, 1) to objectsize(p, 2) in the tests. Are existing users of objectsize(p, typ) affected by this, and if so, can we warn them?

First, thanks for the feedback!

Pre-patch objectsize(p, 1) operates differently than post-patch objectsize(p, 1), yes. I'm happy to warn users of the change -- is there an official method for doing so, or will a post to llvm-dev suffice? (FWIW, there's a patch to update Clang to use the new intrinsic @D12352 as well)

In D12351#233940, @majnemer wrote:

You need auto-upgrade logic to transition old users to the new intrinsic.

That's a thing? That's kind of awesome. Thanks for the heads up! :) Is there a preferred way to test new auto-upgrade code, or does "I ran opt on a pre-patch file and the output LGTM for post-patch code" suffice?

test/CodeGen/Generic/object-size-type.ll

27

Type=3 should mean find a lower bound of the size from %i to the closest enclosing array

Not exactly. Type=3 finds the lower bound of the size of the closest source-level subobject. If this subobject is part of an array, then it will get the # of bytes remaining in the array. This exception does not apply for containers of the subobject.

Is the problem here that we don't have metadata on the gep?

Yup! The issue is a combination of two things:

• We're asking for a lower-bound, so higher-than-optimal answers are not allowed (the opposite is true with Type=1)
• We have no clue what the source-level types are, and are being asked for the size of a subobject. Consider:

struct Foo { char c; };
struct { struct Foo[8] fs; } b;
__builtin_object_size(&b.fs[4].c, 3); // Pretend this slipped through from clang -- currently clang can answer this correctly.

In this case, the optimal result of BOS is 1, because sizeof(b.fs[4].c) == 1. To your point, 4 would be correct if we changed the BOS call to:

__builtin_object_size(&b.fs[4], 3);

38

I can add checks and make the test an XFAIL if that would be preferable. This patch just brings us to using an i8 for Type. Patch for handling the metadata appropriately is in the works. :)

[davidxl]

I left some comments in the design doc.

David

[george.burgess.iv]

Patch is no longer necessary -- clang can handle __builtin_object_size well enough on its own for type={1,3}.

docs/LangRef.rst

.. code-block:: llvm
       %d = invoke i8 @bar() to label %cont
              unwind label %lpad, !range !3 ; Can only be -2, -1, 3, 4 or 5
     ...
     !0 = !{ i8 0, i8 2 }
     !1 = !{ i8 255, i8 2 }
     !2 = !{ i8 0, i8 2, i8 3, i8 6 }
     !3 = !{ i8 -2, i8 0, i8 3, i8 6 }
 
+'``llvm.objectsize``' Metadata
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+*Experimental/In progress* For reasons similar to ``tbaa``, ``llvm.objectsize``
+needs additional type information if it's asked to determine the size of a
+member of a struct or array. However, full type information isn't necessary for
+this task. In fact, all we need is an integer telling us how many bytes are
+in the field being accessed by a `getelementptr` instruction. If this pointer is
+based off of a previous pointer (e.g. in ``(char*)p + 1``), the integer is -1.
+
+An example of this metadata in action on a C object:
+
+.. code-block:: c
+  struct A { int8_t data[16]; };
+  struct B {
+    int32_t foo;
+    struct A a;
+    int8_t bar;
+  } b[2];
+
+  int main() {
+    void \*p = &b[0].a.data[10];
+    void \*v = (char*)p + 1;
+    printf("%ld %ld\n", __builtin_object_size(p, 1),
+           __builtin_object_size(v, 1));
+  }
+  // clang/LLVM produces (assuming some optimizations are run):
+  // %b = alloca i8, i32 21, align 4
+  // %p = getelementptr inbounds %i8, i8* %b, i32 14, !metadata !1
+  // %v = getelementptr inbounds %i8, i8* %p, i32 1, !metadata !2
+  // ; Insert call printf instruction here
+  // !1 = !{i32 16}
+  // !2 = !{i32 -1}
+
+
 '``llvm.loop``'
 ^^^^^^^^^^^^^^^
 
 It is sometimes useful to attach information to loop constructs. Currently,
 loop metadata is implemented as metadata attached to the branch instruction
 in the loop latch block. This type of metadata refer to a metadata node that is
 guaranteed to be separate for each loop. The loop identifier metadata is
 specified with the name ``llvm.loop``.

 '``llvm.objectsize``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i32 @llvm.objectsize.i32(i8* <object>, i1 <min>)
-      declare i64 @llvm.objectsize.i64(i8* <object>, i1 <min>)
+      declare i32 @llvm.objectsize.i32(i8* <object>, i8 <type>)
+      declare i64 @llvm.objectsize.i64(i8* <object>, i8 <type>)
 
 Overview:
 """""""""
 
 The ``llvm.objectsize`` intrinsic is designed to provide information to
 the optimizers to determine at compile time whether a) an operation
 (like memcpy) will overflow a buffer that corresponds to an object, or
 b) that a runtime check for overflow isn't necessary. An object in this
 context means an allocation of a specific class, structure, array, or
 other object.
 
 Arguments:
 """"""""""
 
 The ``llvm.objectsize`` intrinsic takes two arguments. The first
-argument is a pointer to or into the ``object``. The second argument is
-a boolean and determines whether ``llvm.objectsize`` returns 0 (if true)
-or -1 (if false) when the object size is unknown. The second argument
-only accepts constants.
+argument is a pointer to or into the ``object``. The second argument is an
+integer in the range [0,3]. It is comprised of two flags:
+
+- If the low bit is set, the result will be the number of bytes remaining in the
+  pointed to subobject, as defined by the accompanying type metadata. See the
+  ``llvm.objectsize Metadata`` section for more. If insufficient metadata is
+  available, it returns conservatively (0) for ``type=3``, and as though
+  ``type=0`` for ``type=1``.
+- If the high bit is set, the result will be a lower bound on the size of the
+  object. Otherwise, it will be an upper bound. If the object size is unknown,
+  ``llvm.objectsize`` will return ``0`` or ``-1`` if this bit is set or unset,
+  respectively.
+
+The second argument only accepts constants.
 
 Semantics:
 """"""""""
 
 The ``llvm.objectsize`` intrinsic is lowered to a constant representing
 the size of the object concerned. If the size cannot be determined at
 compile time, ``llvm.objectsize`` returns ``i32/i64 -1 or 0`` (depending
-on the ``min`` argument).
+on the ``type`` argument).
 
 '``llvm.expect``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 This is an overloaded intrinsic. You can use ``llvm.expect`` on any

include/llvm/IR/Intrinsics.td

 
 // NOTE: these are internal interfaces.
 def int_setjmp     : Intrinsic<[llvm_i32_ty],  [llvm_ptr_ty]>;
 def int_longjmp    : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty], [IntrNoReturn]>;
 def int_sigsetjmp  : Intrinsic<[llvm_i32_ty] , [llvm_ptr_ty, llvm_i32_ty]>;
 def int_siglongjmp : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty], [IntrNoReturn]>;
 
 // Internal interface for object size checking
-def int_objectsize : Intrinsic<[llvm_anyint_ty], [llvm_anyptr_ty, llvm_i1_ty],
+def int_objectsize : Intrinsic<[llvm_anyint_ty], [llvm_anyptr_ty, llvm_i8_ty],
                                [IntrNoMem]>,
                                GCCBuiltin<"__builtin_object_size">;
 
 //===------------------------- Expect Intrinsics --------------------------===//
 //
 def int_expect : Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>,
                                               LLVMMatchType<0>], [IntrNoMem]>;
 

lib/CodeGen/CodeGenPrepare.cpp

bool CodeGenPrepare::OptimizeCallInst(CallInst *CI, bool& ModifiedDT) {
   }
 
   IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI);
   if (II) {
     switch (II->getIntrinsicID()) {
     default: break;
     case Intrinsic::objectsize: {
       // Lower all uses of llvm.objectsize.*
-      bool Min = (cast<ConstantInt>(II->getArgOperand(1))->getZExtValue() == 1);
+      int Min = cast<ConstantInt>(II->getArgOperand(1))->getZExtValue() & 2;
       Type *ReturnTy = CI->getType();
       Constant *RetVal = ConstantInt::get(ReturnTy, Min ? 0 : -1ULL);
 
       // Substituting this can cause recursive simplifications, which can
       // invalidate our iterator.  Use a WeakVH to hold onto it in case this
       // happens.
       WeakVH IterHandle(CurInstIterator);
 

lib/CodeGen/SelectionDAG/FastISel.cpp

if (!V) {
       // We can't yet handle anything else here because it would require
       // generating code, thus altering codegen because of debug info.
       DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n");
     }
     return true;
   }
   case Intrinsic::objectsize: {
     ConstantInt *CI = cast<ConstantInt>(II->getArgOperand(1));
-    unsigned long long Res = CI->isZero() ? -1ULL : 0;
+    bool Min = CI->getZExtValue() & 2;
+    unsigned long long Res = Min ? 0 : -1ULL;
     Constant *ResCI = ConstantInt::get(II->getType(), Res);
     unsigned ResultReg = getRegForValue(ResCI);
     if (!ResultReg)
       return false;
     updateValueMap(II, ResultReg);
     return true;
   }
   case Intrinsic::expect: {

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

case Intrinsic::objectsize: {
     // If we don't know by now, we're never going to know.
     ConstantInt *CI = dyn_cast<ConstantInt>(I.getArgOperand(1));
 
     assert(CI && "Non-constant type in __builtin_object_size?");
 
     SDValue Arg = getValue(I.getCalledValue());
     EVT Ty = Arg.getValueType();
 
-    if (CI->isZero())
-      Res = DAG.getConstant(-1ULL, sdl, Ty);
-    else
+    if (CI->getZExtValue() & 2)
       Res = DAG.getConstant(0, sdl, Ty);
+    else
+      Res = DAG.getConstant(-1ULL, sdl, Ty);
 
     setValue(&I, Res);
     return nullptr;
   }
   case Intrinsic::annotation:
   case Intrinsic::ptr_annotation:
     // Drop the intrinsic, but forward the value
     setValue(&I, getValue(I.getOperand(0)));

lib/IR/AutoUpgrade.cpp

if (Name.startswith("cttz.") && F->arg_size() == 1) {
       NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::cttz,
                                         F->arg_begin()->getType());
       return true;
     }
     break;
   }
 
   case 'o':
-    // We only need to change the name to match the mangling including the
-    // address space.
+    // We need to change the name to match the mangling including the
+    // address space, and update the old bool arg to an i8.
     if (F->arg_size() == 2 && Name.startswith("objectsize.")) {
-      Type *Tys[2] = { F->getReturnType(), F->arg_begin()->getType() };
-      if (F->getName() != Intrinsic::getName(Intrinsic::objectsize, Tys)) {
+      const auto &Args = F->getArgumentList();
+      Type *PtrType = Args.front().getType();
+      Type *IntType = Args.back().getType();
+      Type *Tys[2] = { F->getReturnType(), PtrType};
+      if (IntType == Type::getInt1Ty(F->getContext()) ||
+          F->getName() != Intrinsic::getName(Intrinsic::objectsize, Tys)) {
         F->setName(Name + ".old");
         NewFn = Intrinsic::getDeclaration(F->getParent(),
                                           Intrinsic::objectsize, Tys);
         return true;
       }
     }
     break;
 
void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
 
   if (!NewFn) {
     // Get the Function's name.
     StringRef Name = F->getName();
 
     Value *Rep;
     // Upgrade packed integer vector compares intrinsics to compare instructions
     if (Name.startswith("llvm.x86.sse2.pcmpeq.") ||
                Name.startswith("llvm.x86.avx2.pcmpeq.")) {
       Rep = Builder.CreateICmpEQ(CI->getArgOperand(0), CI->getArgOperand(1),
                                  "pcmpeq");
       // need to sign extend since icmp returns vector of i1
       Rep = Builder.CreateSExt(Rep, CI->getType(), "");
     } else if (Name.startswith("llvm.x86.sse2.pcmpgt.") ||
                Name.startswith("llvm.x86.avx2.pcmpgt.")) {
       Rep = Builder.CreateICmpSGT(CI->getArgOperand(0), CI->getArgOperand(1),
                                   "pcmpgt");
void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
   case Intrinsic::cttz:
     assert(CI->getNumArgOperands() == 1 &&
            "Mismatch between function args and call args");
     CI->replaceAllUsesWith(Builder.CreateCall(
         NewFn, {CI->getArgOperand(0), Builder.getFalse()}, Name));
     CI->eraseFromParent();
     return;
 
-  case Intrinsic::objectsize:
-    CI->replaceAllUsesWith(Builder.CreateCall(
-        NewFn, {CI->getArgOperand(0), CI->getArgOperand(1)}, Name));
+  case Intrinsic::objectsize: {
+    Value *Args[] = {CI->getArgOperand(0), CI->getArgOperand(1)};
+    if (Args[1]->getType() == Type::getInt1Ty(C)) {
+      int NewValue = cast<ConstantInt>(Args[1])->isZero() ? 0 : 2;
+      Type *NewType = Type::getInt8Ty(C);
+      Args[1] = ConstantInt::get(NewType, NewValue, false);
+    }
+    CI->replaceAllUsesWith(Builder.CreateCall(NewFn, Args, Name));
     CI->eraseFromParent();
     return;
+  }
 
   case Intrinsic::ctpop: {
     CI->replaceAllUsesWith(Builder.CreateCall(NewFn, {CI->getArgOperand(0)}));
     CI->eraseFromParent();
     return;
   }
 
   case Intrinsic::x86_xop_vfrcz_ss:

lib/Transforms/InstCombine/InstCombineCalls.cpp

if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(II)) {
 
     if (Changed) return II;
   }
 
   switch (II->getIntrinsicID()) {
   default: break;
   case Intrinsic::objectsize: {
     uint64_t Size;
+    auto Arg = cast<ConstantInt>(II->getArgOperand(1))->getZExtValue();
+    // TODO(gbiv): Add better support for type == 1 and type == 3
+    // At the moment, just returning 0 is the best we can do for the lower bound
+    // of an inner member, because overestimation is incorrect.
+    if (Arg == 3)
+      return ReplaceInstUsesWith(CI, ConstantInt::get(CI.getType(), 0));
     if (getObjectSize(II->getArgOperand(0), Size, DL, TLI))
       return ReplaceInstUsesWith(CI, ConstantInt::get(CI.getType(), Size));
     return nullptr;
   }
   case Intrinsic::bswap: {
     Value *IIOperand = II->getArgOperand(0);
     Value *X = nullptr;
 

lib/Transforms/InstCombine/InstructionCombining.cpp

for (unsigned i = 0, e = Users.size(); i != e; ++i) {
         ReplaceInstUsesWith(*C,
                             ConstantInt::get(Type::getInt1Ty(C->getContext()),
                                              C->isFalseWhenEqual()));
       } else if (isa<BitCastInst>(I) || isa<GetElementPtrInst>(I)) {
         ReplaceInstUsesWith(*I, UndefValue::get(I->getType()));
       } else if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
         if (II->getIntrinsicID() == Intrinsic::objectsize) {
           ConstantInt *CI = cast<ConstantInt>(II->getArgOperand(1));
-          uint64_t DontKnow = CI->isZero() ? -1ULL : 0;
+          bool Min = CI->getZExtValue() & 2;
+          uint64_t DontKnow = Min ? 0 : -1ULL;
           ReplaceInstUsesWith(*I, ConstantInt::get(I->getType(), DontKnow));
         }
       }
       EraseInstFromFunction(*I);
     }
 
     if (InvokeInst *II = dyn_cast<InvokeInst>(&MI)) {
       // Replace invoke with a NOP intrinsic to maintain the original CFG

test/Assembler/auto_upgrade_intrinsics.ll

 ; Test to make sure intrinsics are automatically upgraded.
 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
 ; RUN: verify-uselistorder %s
 
 declare i8 @llvm.ctlz.i8(i8)
 declare i16 @llvm.ctlz.i16(i16)
 declare i32 @llvm.ctlz.i32(i32)
 declare i42 @llvm.ctlz.i42(i42)  ; Not a power-of-2
 
 
-declare i32 @llvm.objectsize.i32(i8*, i1) nounwind readonly
+declare i32 @llvm.objectsize.i32(i8*, i8) nounwind readonly
 
 
 define void @test.ctlz(i8 %a, i16 %b, i32 %c, i42 %d) {
 ; CHECK: @test.ctlz
 
 entry:
   ; CHECK: call i8 @llvm.ctlz.i8(i8 %a, i1 false)
   call i8 @llvm.ctlz.i8(i8 %a)

 
 
 @a = private global [60 x i8] zeroinitializer, align 1
 
 define i32 @test.objectsize() {
 ; CHECK-LABEL: @test.objectsize(
 ; CHECK: @llvm.objectsize.i32.p0i8
 ; CHECK-DAG: declare i32 @llvm.objectsize.i32.p0i8
-  %s = call i32 @llvm.objectsize.i32(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false)
+  %s = call i32 @llvm.objectsize.i32(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8 0)
   ret i32 %s
 }

test/CodeGen/AArch64/arm64-2012-07-11-InstrEmitterBug.ll

 ; RUN: llc < %s -mtriple=arm64-apple-ios
 ; rdar://11849816
 
 @shlib_path_substitutions = external hidden unnamed_addr global i8**, align 8
 
-declare i64 @llvm.objectsize.i64(i8*, i1) nounwind readnone
+declare i64 @llvm.objectsize.i64(i8*, i8) nounwind readnone
 
 declare noalias i8* @xmalloc(i64) optsize
 
 declare i64 @strlen(i8* nocapture) nounwind readonly optsize
 
 declare i8* @__strcpy_chk(i8*, i8*, i64) nounwind optsize
 
 declare i8* @__strcat_chk(i8*, i8*, i64) nounwind optsize

test/CodeGen/AArch64/arm64-indexed-vector-ldst-2.ll

entry:
   %3 = insertelement <2 x double> %2, double %1, i32 1
   %4 = fsub <2 x double> zeroinitializer, %3
   %5 = fmul <2 x double> undef, %4
   %6 = extractelement <2 x double> %5, i32 0
   %cmp168 = fcmp olt double %6, undef
   br i1 %cmp168, label %if.then172, label %return
 
 if.then172:                                       ; preds = %cond.end90
-  %7 = tail call i64 @llvm.objectsize.i64.p0i8(i8* undef, i1 false)
+  %7 = tail call i64 @llvm.objectsize.i64.p0i8(i8* undef, i8 0)
   br label %return
 
 return:                                           ; preds = %if.then172, %cond.end90, %entry
   ret void
 }
 
 ; Function Attrs: nounwind readnone
-declare i64 @llvm.objectsize.i64.p0i8(i8*, i1) #1
+declare i64 @llvm.objectsize.i64.p0i8(i8*, i8) #1
 
 attributes #0 = { nounwind ssp "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #1 = { nounwind readnone }
 
 !1 = !{!2, !2, i64 0}
 !2 = !{!"double", !3, i64 0}
 !3 = !{!"omnipotent char", !4, i64 0}
 !4 = !{!"Simple C/C++ TBAA"}

test/CodeGen/AArch64/arm64-memset-to-bzero.ll

entry:
   ret void
 }
 
 ; CHECK: @fct4
 ; Size <= 256, no change.
 ; CHECK: memset
 define void @fct4(i8* %ptr) {
 entry:
-  %tmp = tail call i64 @llvm.objectsize.i64(i8* %ptr, i1 false)
+  %tmp = tail call i64 @llvm.objectsize.i64(i8* %ptr, i8 0)
   %call = tail call i8* @__memset_chk(i8* %ptr, i32 0, i64 256, i64 %tmp)
   ret void
 }
 
 declare i8* @__memset_chk(i8*, i32, i64, i64)
 
-declare i64 @llvm.objectsize.i64(i8*, i1)
+declare i64 @llvm.objectsize.i64(i8*, i8)
 
 ; CHECK: @fct5
 ; Size > 256, change.
 ; CHECK-DARWIN: bzero
 ; CHECK-LINUX: memset
 define void @fct5(i8* %ptr) {
 entry:
-  %tmp = tail call i64 @llvm.objectsize.i64(i8* %ptr, i1 false)
+  %tmp = tail call i64 @llvm.objectsize.i64(i8* %ptr, i8 0)
   %call = tail call i8* @__memset_chk(i8* %ptr, i32 0, i64 257, i64 %tmp)
   ret void
 }
 
 ; CHECK: @fct6
 ; Size = unknown, change.
 ; CHECK-DARWIN: bzero
 ; CHECK-LINUX: memset
 define void @fct6(i8* %ptr, i32 %unknown) {
 entry:
   %conv = sext i32 %unknown to i64
-  %tmp = tail call i64 @llvm.objectsize.i64(i8* %ptr, i1 false)
+  %tmp = tail call i64 @llvm.objectsize.i64(i8* %ptr, i8 0)
   %call = tail call i8* @__memset_chk(i8* %ptr, i32 0, i64 %conv, i64 %tmp)
   ret void
 }
 
 ; Next functions check that memset is not turned into bzero
 ; when the set constant is non-zero, whatever the given size.
 
 ; CHECK: @fct7
 ; memset with something that is not a zero, no change.
 ; CHECK: memset
 define void @fct7(i8* %ptr) {
 entry:
-  %tmp = tail call i64 @llvm.objectsize.i64(i8* %ptr, i1 false)
+  %tmp = tail call i64 @llvm.objectsize.i64(i8* %ptr, i8 0)
   %call = tail call i8* @__memset_chk(i8* %ptr, i32 1, i64 256, i64 %tmp)
   ret void
 }
 
 ; CHECK: @fct8
 ; memset with something that is not a zero, no change.
 ; CHECK: memset
 define void @fct8(i8* %ptr) {
 entry:
-  %tmp = tail call i64 @llvm.objectsize.i64(i8* %ptr, i1 false)
+  %tmp = tail call i64 @llvm.objectsize.i64(i8* %ptr, i8 0)
   %call = tail call i8* @__memset_chk(i8* %ptr, i32 1, i64 257, i64 %tmp)
   ret void
 }
 
 ; CHECK: @fct9
 ; memset with something that is not a zero, no change.
 ; CHECK: memset
 define void @fct9(i8* %ptr, i32 %unknown) {
 entry:
   %conv = sext i32 %unknown to i64
-  %tmp = tail call i64 @llvm.objectsize.i64(i8* %ptr, i1 false)
+  %tmp = tail call i64 @llvm.objectsize.i64(i8* %ptr, i8 0)
   %call = tail call i8* @__memset_chk(i8* %ptr, i32 1, i64 %conv, i64 %tmp)
   ret void
 }

test/CodeGen/ARM/divmod.ll

 bb:
 ; A8: bl ___divmodsi4
 ; SWIFT: sdiv
 ; SWIFT: mls
 ; SWIFT-NOT: bl __divmodsi4
   %3 = load i32, i32* @tabsize, align 4
   %4 = srem i32 %cols, %3
   %5 = sdiv i32 %cols, %3
-  %6 = tail call i32 @llvm.objectsize.i32.p0i8(i8* null, i1 false)
+  %6 = tail call i32 @llvm.objectsize.i32.p0i8(i8* null, i8 0)
   %7 = tail call i8* @__memset_chk(i8* null, i32 9, i32 %5, i32 %6) nounwind
   br label %bb1
 
 bb1:
   %line_indent_len.0 = phi i32 [ %4, %bb ], [ 0, %entry ]
   %8 = getelementptr inbounds i8, i8* null, i32 %line_indent_len.0
   store i8 0, i8* %8, align 1
   ret void
 }
 
-declare i32 @llvm.objectsize.i32.p0i8(i8*, i1) nounwind readnone
+declare i32 @llvm.objectsize.i32.p0i8(i8*, i8) nounwind readnone
 declare i8* @__memset_chk(i8*, i32, i32, i32) nounwind
 
 ; rdar://11714607
 define i32 @howmany(i32 %x, i32 %y) nounwind {
 entry:
 ; A8-LABEL: howmany:
 ; A8: bl ___udivmodsi4
 ; A8-NOT: ___udivsi3

test/CodeGen/Generic/crash.ll

 %1 = getelementptr inbounds %struct.CAMERA, %struct.CAMERA* %.pre, i32 0, i32 1, i32 2
 br label %bb32
 
 bb32:                                             ; preds = %bb6
 %2 = load double, double* %0, align 4
 %3 = load double, double* %1, align 4
 %4 = load double, double* %0, align 4
 call void @Parse_Vector(double* %0) nounwind
-%5 = call i32 @llvm.objectsize.i32.p0i8(i8* undef, i1 false)
+%5 = call i32 @llvm.objectsize.i32.p0i8(i8* undef, i8 0)
 %6 = icmp eq i32 %5, -1
 br i1 %6, label %bb34, label %bb33
 
 bb33:                                             ; preds = %bb32
 unreachable
 
 bb34:                                             ; preds = %bb32
 unreachable
 
 }
 
 declare void @Parse_Vector(double*)
-declare i32 @llvm.objectsize.i32.p0i8(i8*, i1)
+declare i32 @llvm.objectsize.i32.p0i8(i8*, i8)
 
 
 ; PR9578
 %struct.S0 = type { i32, i8, i32 }
 
 define void @func_82() nounwind optsize {
 entry:
   br label %for.body.i

test/CodeGen/Generic/object-size-type.ll

+; A test to verify that we support objectsize with type == 0, 1, 2, 3
+; for simple cases with no metadata (for types 1, 3)
+
+; RUN: opt -instcombine < %s -S 2>&1 | FileCheck %s
+
+define void @verify_objectsize_supports_4_types() {
+  ; CHECK: @verify_objectsize_supports_4_types
+
+  %p = alloca i8, i32 8, align 8
+  %i = getelementptr i8, i8* %p, i32 4
+
+  ; CHECK: void @consume(i8 0, i32 4)
+  %1 = call i32 @llvm.objectsize.i32(i8* %i, i8 0)
+  call void @consume(i8 0, i32 %1)
+
+  ; CHECK: void @consume(i8 1, i32 4)
+  %2 = call i32 @llvm.objectsize.i32(i8* %i, i8 1)
+  call void @consume(i8 1, i32 %2)
+
+  ; CHECK: void @consume(i8 2, i32 4)
+  %3 = call i32 @llvm.objectsize.i32(i8* %i, i8 2)
+  call void @consume(i8 2, i32 %3)
+
+  ; CHECK: void @consume(i8 3, i32 0)
+  %4 = call i32 @llvm.objectsize.i32(i8* %i, i8 3)
+  call void @consume(i8 3, i32 %4)
+
+  ; At the time of writing, we need to keep %p alive. Otherwise, instcombine
+  ; will see the alloca is unused and RAUW(undef) it before objectsize can look
+  ; at it. @llvm.objectsize(undef) == conservative answer.
+  call void @keep_alive(i8* %p)
+  ret void
+}
+
+declare void @consume(i8, i32)
+declare void @keep_alive(i8*)
+declare i32 @llvm.objectsize.i32(i8*, i8)

test/CodeGen/X86/2011-05-26-UnreachableBlockElim.ll

 ; RUN: llc < %s -verify-coalescing
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-macosx10.6.0"
 
 %struct.attrib = type { i32, i32 }
 %struct.dfa = type { [80 x i8], i32, %struct.state*, i32, i32, %struct.attrib*, i32, i32 }
 %struct.state = type { i32, [4 x i32] }
 
 @aux_temp = external global %struct.dfa, align 8
 
-declare i64 @llvm.objectsize.i64.p0i8(i8*, i1) nounwind readnone
+declare i64 @llvm.objectsize.i64.p0i8(i8*, i8) nounwind readnone
 
 declare void @__memset_chk() nounwind
 
 define void @dfa_add_string() nounwind uwtable ssp {
 entry:
   br label %if.end.i
 
 if.end.i:                                         ; preds = %entry
   %idxprom.i = add i64 0, 1
   br i1 undef, label %land.end.thread.i, label %land.end.i
 
 land.end.thread.i:                                ; preds = %if.end.i
-  %0 = call i64 @llvm.objectsize.i64.p0i8(i8* undef, i1 false) nounwind
+  %0 = call i64 @llvm.objectsize.i64.p0i8(i8* undef, i8 0) nounwind
   %cmp1710.i = icmp eq i64 %0, -1
   br i1 %cmp1710.i, label %cond.false156.i, label %cond.true138.i
 
 land.end.i:                                       ; preds = %if.end.i
-  %1 = call i64 @llvm.objectsize.i64.p0i8(i8* undef, i1 false) nounwind
+  %1 = call i64 @llvm.objectsize.i64.p0i8(i8* undef, i8 0) nounwind
   %cmp17.i = icmp eq i64 %1, -1
   br i1 %cmp17.i, label %cond.false156.i, label %cond.true138.i
 
 cond.true138.i:                                   ; preds = %for.end.i, %land.end.thread.i
   call void @__memset_chk() nounwind
   br label %cond.end166.i
 
 cond.false156.i:                                  ; preds = %for.end.i, %land.end.thread.i

test/CodeGen/X86/crash.ll

entry:
   %4 = or i576 %3, %2
   store i576 %4, i576* undef, align 8
   ret void
 }
 
 ; <rdar://problem/9187792>
 define fastcc void @func_61() nounwind sspreq {
 entry:
-  %t1 = tail call i64 @llvm.objectsize.i64.p0i8(i8* undef, i1 false)
+  %t1 = tail call i64 @llvm.objectsize.i64.p0i8(i8* undef, i8 0)
   %t2 = icmp eq i64 %t1, -1
   br i1 %t2, label %bb2, label %bb1
 
 bb1:
   ret void
 
 bb2:
   ret void
 }
 
-declare i64 @llvm.objectsize.i64.p0i8(i8*, i1) nounwind readnone
+declare i64 @llvm.objectsize.i64.p0i8(i8*, i8) nounwind readnone
 
 ; PR10277
 ; This test has dead code elimination caused by remat during spilling.
 ; DCE causes a live interval to break into connected components.
 ; One of the components is spilled.
 
 %t2 = type { i8 }
 %t9 = type { %t10 }

test/CodeGen/X86/object-size.ll

 ; RUN: llc -O0 < %s -march=x86-64 | FileCheck %s
 
 ; ModuleID = 'ts.c'
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-darwin10.0"
 
 @p = common global i8* null, align 8              ; <i8**> [#uses=4]
 @.str = private constant [3 x i8] c"Hi\00"        ; <[3 x i8]*> [#uses=1]
 
 define void @bar() nounwind ssp {
 entry:
   %tmp = load i8*, i8** @p                             ; <i8*> [#uses=1]
-  %0 = call i64 @llvm.objectsize.i64.p0i8(i8* %tmp, i1 0) ; <i64> [#uses=1]
+  %0 = call i64 @llvm.objectsize.i64.p0i8(i8* %tmp, i8 0) ; <i64> [#uses=1]
   %cmp = icmp ne i64 %0, -1                       ; <i1> [#uses=1]
 ; CHECK: movq $-1, [[RAX:%r..]]
 ; CHECK: cmpq $-1, [[RAX]]
   br i1 %cmp, label %cond.true, label %cond.false
 
 cond.true:                                        ; preds = %entry
   %tmp1 = load i8*, i8** @p                            ; <i8*> [#uses=1]
   %tmp2 = load i8*, i8** @p                            ; <i8*> [#uses=1]
-  %1 = call i64 @llvm.objectsize.i64.p0i8(i8* %tmp2, i1 1) ; <i64> [#uses=1]
+  %1 = call i64 @llvm.objectsize.i64.p0i8(i8* %tmp2, i8 2) ; <i64> [#uses=1]
   %call = call i8* @__strcpy_chk(i8* %tmp1, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 %1) ssp ; <i8*> [#uses=1]
   br label %cond.end
 
 cond.false:                                       ; preds = %entry
   %tmp3 = load i8*, i8** @p                            ; <i8*> [#uses=1]
   %call4 = call i8* @__inline_strcpy_chk(i8* %tmp3, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0)) ssp ; <i8*> [#uses=1]
   br label %cond.end
 
 cond.end:                                         ; preds = %cond.false, %cond.true
   %cond = phi i8* [ %call, %cond.true ], [ %call4, %cond.false ] ; <i8*> [#uses=0]
   ret void
 }
 
-declare i64 @llvm.objectsize.i64.p0i8(i8*, i1) nounwind readonly
+declare i64 @llvm.objectsize.i64.p0i8(i8*, i8) nounwind readonly
 
 declare i8* @__strcpy_chk(i8*, i8*, i64) ssp
 
 define internal i8* @__inline_strcpy_chk(i8* %__dest, i8* %__src) nounwind ssp {
 entry:
   %retval = alloca i8*                            ; <i8**> [#uses=2]
   %__dest.addr = alloca i8*                       ; <i8**> [#uses=3]
   %__src.addr = alloca i8*                        ; <i8**> [#uses=2]
   store i8* %__dest, i8** %__dest.addr
   store i8* %__src, i8** %__src.addr
   %tmp = load i8*, i8** %__dest.addr                   ; <i8*> [#uses=1]
   %tmp1 = load i8*, i8** %__src.addr                   ; <i8*> [#uses=1]
   %tmp2 = load i8*, i8** %__dest.addr                  ; <i8*> [#uses=1]
-  %0 = call i64 @llvm.objectsize.i64.p0i8(i8* %tmp2, i1 1) ; <i64> [#uses=1]
+  %0 = call i64 @llvm.objectsize.i64.p0i8(i8* %tmp2, i8 2) ; <i64> [#uses=1]
   %call = call i8* @__strcpy_chk(i8* %tmp, i8* %tmp1, i64 %0) ssp ; <i8*> [#uses=1]
   store i8* %call, i8** %retval
   %1 = load i8*, i8** %retval                          ; <i8*> [#uses=1]
   ret i8* %1
 }

test/Transforms/CodeGenPrepare/basic.ll

 ; RUN: opt -codegenprepare -S < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-darwin10.0.0"
 
 ; CHECK-LABEL: @test1(
 ; objectsize should fold to a constant, which causes the branch to fold to an
 ; uncond branch. Next, we fold the control flow alltogether.
 ; rdar://8785296
 define i32 @test1(i8* %ptr) nounwind ssp noredzone align 2 {
 entry:
-  %0 = tail call i64 @llvm.objectsize.i64(i8* %ptr, i1 false)
+  %0 = tail call i64 @llvm.objectsize.i64(i8* %ptr, i8 0)
   %1 = icmp ugt i64 %0, 3
   br i1 %1, label %T, label %trap
 
 ; CHECK: T:
 ; CHECK-NOT: br label %
 
 trap:                                             ; preds = %0, %entry
   tail call void @llvm.trap() noreturn nounwind
   unreachable
 
 T:
 ; CHECK: ret i32 4
   ret i32 4
 }
 
-declare i64 @llvm.objectsize.i64(i8*, i1) nounwind readonly
+declare i64 @llvm.objectsize.i64(i8*, i8) nounwind readonly
 
 declare void @llvm.trap() nounwind

test/Transforms/InstCombine/debuginfo.ll

 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata) nounwind readnone
 
-declare i64 @llvm.objectsize.i64.p0i8(i8*, i1) nounwind readnone
+declare i64 @llvm.objectsize.i64.p0i8(i8*, i8) nounwind readnone
 
 declare i8* @foo(i8*, i32, i64, i64) nounwind
 
 define hidden i8* @foobar(i8* %__dest, i32 %__val, i64 %__len) nounwind inlinehint ssp {
 entry:
   %__dest.addr = alloca i8*, align 8
   %__val.addr = alloca i32, align 4
   %__len.addr = alloca i64, align 8
   store i8* %__dest, i8** %__dest.addr, align 8
 ; CHECK-NOT: call void @llvm.dbg.declare
 ; CHECK: call void @llvm.dbg.value
   call void @llvm.dbg.declare(metadata i8** %__dest.addr, metadata !0, metadata !DIExpression()), !dbg !16
   store i32 %__val, i32* %__val.addr, align 4
   call void @llvm.dbg.declare(metadata i32* %__val.addr, metadata !7, metadata !DIExpression()), !dbg !18
   store i64 %__len, i64* %__len.addr, align 8
   call void @llvm.dbg.declare(metadata i64* %__len.addr, metadata !9, metadata !DIExpression()), !dbg !20
   %tmp = load i8*, i8** %__dest.addr, align 8, !dbg !21
   %tmp1 = load i32, i32* %__val.addr, align 4, !dbg !21
   %tmp2 = load i64, i64* %__len.addr, align 8, !dbg !21
   %tmp3 = load i8*, i8** %__dest.addr, align 8, !dbg !21
-  %0 = call i64 @llvm.objectsize.i64.p0i8(i8* %tmp3, i1 false), !dbg !21
+  %0 = call i64 @llvm.objectsize.i64.p0i8(i8* %tmp3, i8 0), !dbg !21
   %call = call i8* @foo(i8* %tmp, i32 %tmp1, i64 %tmp2, i64 %0), !dbg !21
   ret i8* %call, !dbg !21
 }
 
 !llvm.dbg.cu = !{!3}
 !llvm.module.flags = !{!30}
 
 !0 = !DILocalVariable(name: "__dest", line: 78, arg: 1, scope: !1, file: !2, type: !6)

test/Transforms/InstCombine/invoke.ll

 ; RUN: opt < %s -instcombine -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_call_unexpected(i8*)
-declare i64 @llvm.objectsize.i64(i8*, i1) nounwind readonly
+declare i64 @llvm.objectsize.i64(i8*, i8) nounwind readonly
 declare i8* @_Znwm(i64)
 
 
 ; CHECK-LABEL: @f1(
 define i64 @f1() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; CHECK: nvoke noalias i8* undef()
   %call = invoke noalias i8* undef()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
 ; CHECK: ret i64 0
-  %0 = tail call i64 @llvm.objectsize.i64(i8* %call, i1 false)
+  %0 = tail call i64 @llvm.objectsize.i64(i8* %call, i8 0)
   ret i64 %0
 
 lpad:
   %1 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   %2 = extractvalue { i8*, i32 } %1, 0
   tail call void @__cxa_call_unexpected(i8* %2) noreturn nounwind
   unreachable
 }
 
 ; CHECK-LABEL: @f2(
 define i64 @f2() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; CHECK: nvoke noalias i8* null()
   %call = invoke noalias i8* null()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
 ; CHECK: ret i64 0
-  %0 = tail call i64 @llvm.objectsize.i64(i8* %call, i1 false)
+  %0 = tail call i64 @llvm.objectsize.i64(i8* %call, i8 0)
   ret i64 %0
 
 lpad:
   %1 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   %2 = extractvalue { i8*, i32 } %1, 0
   tail call void @__cxa_call_unexpected(i8* %2) noreturn nounwind
   unreachable

test/Transforms/InstCombine/malloc-free-delete.ll

; CHECK-NEXT: ret i1 false
   %m = call i8* @malloc(i32 1)
   %z = icmp eq i8* %m, null
   call void @free(i8* %m)
   ret i1 %z
 }
 
 declare void @llvm.lifetime.start(i64, i8*)
 declare void @llvm.lifetime.end(i64, i8*)
-declare i64 @llvm.objectsize.i64(i8*, i1)
+declare i64 @llvm.objectsize.i64(i8*, i8)
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
 declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
 declare void @llvm.memset.p0i8.i32(i8*, i8, i32, i32, i1) nounwind
 
 define void @test3(i8* %src) {
 ; CHECK-LABEL: @test3(
 ; CHECK-NEXT: ret void
   %a = call noalias i8* @malloc(i32 10)
   call void @llvm.lifetime.start(i64 10, i8* %a)
   call void @llvm.lifetime.end(i64 10, i8* %a)
-  %size = call i64 @llvm.objectsize.i64(i8* %a, i1 true)
+  %size = call i64 @llvm.objectsize.i64(i8* %a, i8 2)
   store i8 42, i8* %a
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a, i8* %src, i32 32, i32 1, i1 false)
   call void @llvm.memmove.p0i8.p0i8.i32(i8* %a, i8* %src, i32 32, i32 1, i1 false)
   call void @llvm.memset.p0i8.i32(i8* %a, i8 5, i32 32, i32 1, i1 false)
   %alloc2 = call noalias i8* @calloc(i32 5, i32 7) nounwind
   %z = icmp ne i8* %alloc2, null
   ret void
 }

test/Transforms/InstCombine/objsize-64.ll

 ; RUN: opt < %s -instcombine -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 declare noalias i8* @malloc(i32) nounwind
 declare noalias i8* @_Znwm(i64)  ; new(unsigned long)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_call_unexpected(i8*)
-declare i64 @llvm.objectsize.i64(i8*, i1) nounwind readonly
+declare i64 @llvm.objectsize.i64(i8*, i8) nounwind readonly
 
 ; CHECK-LABEL: @f1(
 define i64 @f1(i8 **%esc) {
   %call = call i8* @malloc(i32 4)
   store i8* %call, i8** %esc
-  %size = call i64 @llvm.objectsize.i64(i8* %call, i1 false)
+  %size = call i64 @llvm.objectsize.i64(i8* %call, i8 0)
 ; CHECK: ret i64 4
   ret i64 %size
 }
 
 
 ; CHECK-LABEL: @f2(
 define i64 @f2(i8** %esc) nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; CHECK: invoke noalias i8* @_Znwm(i64 13)
   %call = invoke noalias i8* @_Znwm(i64 13)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
 ; CHECK: ret i64 13
   store i8* %call, i8** %esc
-  %0 = tail call i64 @llvm.objectsize.i64(i8* %call, i1 false)
+  %0 = tail call i64 @llvm.objectsize.i64(i8* %call, i8 0)
   ret i64 %0
 
 lpad:
   %1 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   %2 = extractvalue { i8*, i32 } %1, 0
   tail call void @__cxa_call_unexpected(i8* %2) noreturn nounwind
   unreachable
 }

test/Transforms/InstCombine/objsize-address-space.ll

 ; RUN: opt -S -instcombine -o - %s | FileCheck %s
 target datalayout = "e-p:32:32:32-p1:64:64:64-p2:8:8:8-p3:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:32"
 
-declare i32 @llvm.objectsize.i32.p0i8(i8*, i1) nounwind readonly
-declare i32 @llvm.objectsize.i32.p1i8(i8 addrspace(1)*, i1) nounwind readonly
-declare i32 @llvm.objectsize.i32.p2i8(i8 addrspace(2)*, i1) nounwind readonly
-declare i32 @llvm.objectsize.i32.p3i8(i8 addrspace(3)*, i1) nounwind readonly
-declare i16 @llvm.objectsize.i16.p3i8(i8 addrspace(3)*, i1) nounwind readonly
+declare i32 @llvm.objectsize.i32.p0i8(i8*, i8) nounwind readonly
+declare i32 @llvm.objectsize.i32.p1i8(i8 addrspace(1)*, i8) nounwind readonly
+declare i32 @llvm.objectsize.i32.p2i8(i8 addrspace(2)*, i8) nounwind readonly
+declare i32 @llvm.objectsize.i32.p3i8(i8 addrspace(3)*, i8) nounwind readonly
+declare i16 @llvm.objectsize.i16.p3i8(i8 addrspace(3)*, i8) nounwind readonly
 
 @array_as2 = private addrspace(2) global [60 x i8] zeroinitializer, align 4
 
 @array_as1_pointers = private global [10 x i32 addrspace(1)*] zeroinitializer, align 4
 @array_as2_pointers = private global [24 x i32 addrspace(2)*] zeroinitializer, align 4
 @array_as3_pointers = private global [42 x i32 addrspace(3)*] zeroinitializer, align 4
 
 @array_as2_as1_pointer_pointers = private global [16 x i32 addrspace(2)* addrspace(1)*] zeroinitializer, align 4
 
 
 @a_as3 = private addrspace(3) global [60 x i8] zeroinitializer, align 1
 
 define i32 @foo_as3() nounwind {
 ; CHECK-LABEL: @foo_as3(
 ; CHECK-NEXT: ret i32 60
-  %1 = call i32 @llvm.objectsize.i32.p3i8(i8 addrspace(3)* getelementptr inbounds ([60 x i8], [60 x i8] addrspace(3)* @a_as3, i32 0, i32 0), i1 false)
+  %1 = call i32 @llvm.objectsize.i32.p3i8(i8 addrspace(3)* getelementptr inbounds ([60 x i8], [60 x i8] addrspace(3)* @a_as3, i32 0, i32 0), i8 0)
   ret i32 %1
 }
 
 define i16 @foo_as3_i16() nounwind {
 ; CHECK-LABEL: @foo_as3_i16(
 ; CHECK-NEXT: ret i16 60
-  %1 = call i16 @llvm.objectsize.i16.p3i8(i8 addrspace(3)* getelementptr inbounds ([60 x i8], [60 x i8] addrspace(3)* @a_as3, i32 0, i32 0), i1 false)
+  %1 = call i16 @llvm.objectsize.i16.p3i8(i8 addrspace(3)* getelementptr inbounds ([60 x i8], [60 x i8] addrspace(3)* @a_as3, i32 0, i32 0), i8 0)
   ret i16 %1
 }
 
 @a_alias = weak alias [60 x i8] addrspace(3)* @a_as3
 define i32 @foo_alias() nounwind {
-  %1 = call i32 @llvm.objectsize.i32.p3i8(i8 addrspace(3)* getelementptr inbounds ([60 x i8], [60 x i8] addrspace(3)* @a_alias, i32 0, i32 0), i1 false)
+  %1 = call i32 @llvm.objectsize.i32.p3i8(i8 addrspace(3)* getelementptr inbounds ([60 x i8], [60 x i8] addrspace(3)* @a_alias, i32 0, i32 0), i8 0)
   ret i32 %1
 }
 
 define i32 @array_as2_size() {
 ; CHECK-LABEL: @array_as2_size(
 ; CHECK-NEXT: ret i32 60
   %bc = bitcast [60 x i8] addrspace(2)* @array_as2 to i8 addrspace(2)*
-  %1 = call i32 @llvm.objectsize.i32.p2i8(i8 addrspace(2)* %bc, i1 false)
+  %1 = call i32 @llvm.objectsize.i32.p2i8(i8 addrspace(2)* %bc, i8 0)
   ret i32 %1
 }
 
 define i32 @pointer_array_as1() {
 ; CHECK-LABEL: @pointer_array_as1(
 ; CHECK-NEXT: ret i32 80
   %bc = addrspacecast [10 x i32 addrspace(1)*]* @array_as1_pointers to i8 addrspace(1)*
-  %1 = call i32 @llvm.objectsize.i32.p1i8(i8 addrspace(1)* %bc, i1 false)
+  %1 = call i32 @llvm.objectsize.i32.p1i8(i8 addrspace(1)* %bc, i8 0)
   ret i32 %1
 }
 
 define i32 @pointer_array_as2() {
 ; CHECK-LABEL: @pointer_array_as2(
 ; CHECK-NEXT: ret i32 24
   %bc = bitcast [24 x i32 addrspace(2)*]* @array_as2_pointers to i8*
-  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* %bc, i1 false)
+  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* %bc, i8 0)
   ret i32 %1
 }
 
 define i32 @pointer_array_as3() {
 ; CHECK-LABEL: @pointer_array_as3(
 ; CHECK-NEXT: ret i32 84
   %bc = bitcast [42 x i32 addrspace(3)*]* @array_as3_pointers to i8*
-  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* %bc, i1 false)
+  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* %bc, i8 0)
   ret i32 %1
 }
 
 define i32 @pointer_pointer_array_as2_as1() {
 ; CHECK-LABEL: @pointer_pointer_array_as2_as1(
 ; CHECK-NEXT: ret i32 128
   %bc = bitcast [16 x i32 addrspace(2)* addrspace(1)*]* @array_as2_as1_pointer_pointers to i8*
-  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* %bc, i1 false)
+  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* %bc, i8 0)
   ret i32 %1
 }
 

test/Transforms/InstCombine/objsize-noverify.ll

 ; Test objectsize bounds checking that won't verify until after -instcombine.
 ; RUN: opt < %s -disable-verify -instcombine -S | opt -S | FileCheck %s
 ; We need target data to get the sizes of the arrays and structures.
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
 
-declare i32 @llvm.objectsize.i32.p0i8(i8*, i1) nounwind readonly
+declare i32 @llvm.objectsize.i32.p0i8(i8*, i8) nounwind readonly
 
 ; CHECK-LABEL: @PR13390(
 define i32 @PR13390(i1 %bool, i8* %a) {
 entry:
   %cond = or i1 %bool, true
   br i1 %cond, label %return, label %xpto
 
 xpto:
   %select = select i1 %bool, i8* %select, i8* %a
   %select2 = select i1 %bool, i8* %a, i8* %select2
-  %0 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %select, i1 true)
-  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %select2, i1 true)
+  %0 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %select, i8 2)
+  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %select2, i8 2)
   %2 = add i32 %0, %1
 ; CHECK: ret i32 undef
   ret i32 %2
 
 return:
   ret i32 42
 }
 
 ; CHECK-LABEL: @PR13621(
 define i32 @PR13621(i1 %bool) nounwind {
 entry:
   %cond = or i1 %bool, true
   br i1 %cond, label %return, label %xpto
 
 ; technically reachable, but this malformed IR may appear as a result of constant propagation
 xpto:
   %gep2 = getelementptr i8, i8* %gep, i32 1
   %gep = getelementptr i8, i8* %gep2, i32 1
-  %o = call i32 @llvm.objectsize.i32.p0i8(i8* %gep, i1 true)
+  %o = call i32 @llvm.objectsize.i32.p0i8(i8* %gep, i8 2)
 ; CHECK: ret i32 undef
   ret i32 %o
 
 return:
   ret i32 7
 }

test/Transforms/InstCombine/objsize.ll

 ; Test a pile of objectsize bounds checking.
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 ; We need target data to get the sizes of the arrays and structures.
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
 
 @a = private global [60 x i8] zeroinitializer, align 1 ; <[60 x i8]*>
 @.str = private constant [8 x i8] c"abcdefg\00"   ; <[8 x i8]*>
 define i32 @foo() nounwind {
 ; CHECK-LABEL: @foo(
 ; CHECK-NEXT: ret i32 60
-  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false)
+  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8 0)
   ret i32 %1
 }
 
 define i8* @bar() nounwind {
 ; CHECK-LABEL: @bar(
 entry:
   %retval = alloca i8*
-  %0 = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false)
+  %0 = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8 0)
   %cmp = icmp ne i32 %0, -1
 ; CHECK: br i1 true
   br i1 %cmp, label %cond.true, label %cond.false
 
 cond.true:
   %1 = load i8*, i8** %retval
   ret i8* %1
 
 cond.false:
   %2 = load i8*, i8** %retval
   ret i8* %2
 }
 
 define i32 @f() nounwind {
 ; CHECK-LABEL: @f(
 ; CHECK-NEXT: ret i32 0
-  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr ([60 x i8], [60 x i8]* @a, i32 1, i32 0), i1 false)
+  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr ([60 x i8], [60 x i8]* @a, i32 1, i32 0), i8 0)
   ret i32 %1
 }
 
 @window = external global [0 x i8]
 
 define i1 @baz() nounwind {
 ; CHECK-LABEL: @baz(
 ; CHECK-NEXT: objectsize
-  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @window, i32 0, i32 0), i1 false)
+  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @window, i32 0, i32 0), i8 0)
   %2 = icmp eq i32 %1, -1
   ret i1 %2
 }
 
 define void @test1(i8* %q, i32 %x) nounwind noinline {
 ; CHECK-LABEL: @test1(
 ; CHECK: objectsize.i32.p0i8
 entry:
-  %0 = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @window, i32 0, i32 10), i1 false) ; <i64> [#uses=1]
+  %0 = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @window, i32 0, i32 10), i8 0) ; <i64> [#uses=1]
   %1 = icmp eq i32 %0, -1                         ; <i1> [#uses=1]
   br i1 %1, label %"47", label %"46"
 
 "46":                                             ; preds = %entry
   unreachable
 
 "47":                                             ; preds = %entry
   unreachable
 }
 
 @.str5 = private constant [9 x i32] [i32 97, i32 98, i32 99, i32 100, i32 0, i32
  101, i32 102, i32 103, i32 0], align 4
 define i32 @test2() nounwind {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT: ret i32 34
-  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr (i8, i8* bitcast ([9 x i32]* @.str5 to i8*), i32 2), i1 false)
+  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr (i8, i8* bitcast ([9 x i32]* @.str5 to i8*), i32 2), i8 0)
   ret i32 %1
 }
 
 ; rdar://7674946
 @array = internal global [480 x float] zeroinitializer ; <[480 x float]*> [#uses=1]
 
 declare i8* @__memcpy_chk(i8*, i8*, i32, i32) nounwind
 
-declare i32 @llvm.objectsize.i32.p0i8(i8*, i1) nounwind readonly
+declare i32 @llvm.objectsize.i32.p0i8(i8*, i8) nounwind readonly
 
 declare i8* @__inline_memcpy_chk(i8*, i8*, i32) nounwind inlinehint
 
 define void @test3() nounwind {
 ; CHECK-LABEL: @test3(
 entry:
   br i1 undef, label %bb11, label %bb12
 
 bb11:
   %0 = getelementptr inbounds float, float* getelementptr inbounds ([480 x float], [480 x float]* @array, i32 0, i32 128), i32 -127 ; <float*> [#uses=1]
   %1 = bitcast float* %0 to i8*                   ; <i8*> [#uses=1]
-  %2 = call i32 @llvm.objectsize.i32.p0i8(i8* %1, i1 false) ; <i32> [#uses=1]
+  %2 = call i32 @llvm.objectsize.i32.p0i8(i8* %1, i8 0) ; <i32> [#uses=1]
   %3 = call i8* @__memcpy_chk(i8* undef, i8* undef, i32 512, i32 %2) nounwind ; <i8*> [#uses=0]
 ; CHECK: unreachable
   unreachable
 
 bb12:
   %4 = getelementptr inbounds float, float* getelementptr inbounds ([480 x float], [480 x float]* @array, i32 0, i32 128), i32 -127 ; <float*> [#uses=1]
   %5 = bitcast float* %4 to i8*                   ; <i8*> [#uses=1]
   %6 = call i8* @__inline_memcpy_chk(i8* %5, i8* undef, i32 512) nounwind inlinehint ; <i8*> [#uses=0]
 ; CHECK: @__inline_memcpy_chk
   unreachable
 }
 
 ; rdar://7718857
 
 %struct.data = type { [100 x i32], [100 x i32], [1024 x i8] }
 
 define i32 @test4(i8** %esc) nounwind ssp {
 ; CHECK-LABEL: @test4(
 entry:
   %0 = alloca %struct.data, align 8
   %1 = bitcast %struct.data* %0 to i8*
-  %2 = call i32 @llvm.objectsize.i32.p0i8(i8* %1, i1 false) nounwind
+  %2 = call i32 @llvm.objectsize.i32.p0i8(i8* %1, i8 0) nounwind
 ; CHECK-NOT: @llvm.objectsize
 ; CHECK: @llvm.memset.p0i8.i32(i8* %1, i8 0, i32 1824, i32 8, i1 false)
   %3 = call i8* @__memset_chk(i8* %1, i32 0, i32 1824, i32 %2) nounwind
   store i8* %1, i8** %esc
   ret i32 0
 }
 
 ; rdar://7782496
 @s = external global i8*
 
 define i8* @test5(i32 %n) nounwind ssp {
 ; CHECK-LABEL: @test5(
 entry:
   %0 = tail call noalias i8* @malloc(i32 20) nounwind
-  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %0, i1 false)
+  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %0, i8 0)
   %2 = load i8*, i8** @s, align 8
 ; CHECK-NOT: @llvm.objectsize
 ; CHECK: @llvm.memcpy.p0i8.p0i8.i32(i8* %0, i8* %1, i32 10, i32 1, i1 false)
   %3 = tail call i8* @__memcpy_chk(i8* %0, i8* %2, i32 10, i32 %1) nounwind
   ret i8* %0
 }
 
 define void @test6(i32 %n) nounwind ssp {
 ; CHECK-LABEL: @test6(
 entry:
   %0 = tail call noalias i8* @malloc(i32 20) nounwind
-  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %0, i1 false)
+  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %0, i8 0)
   %2 = load i8*, i8** @s, align 8
 ; CHECK-NOT: @llvm.objectsize
 ; CHECK: @__memcpy_chk(i8* %0, i8* %1, i32 30, i32 20)
   %3 = tail call i8* @__memcpy_chk(i8* %0, i8* %2, i32 30, i32 %1) nounwind
   ret void
 }
 
 declare i8* @__memset_chk(i8*, i32, i32, i32) nounwind
 
 declare noalias i8* @malloc(i32) nounwind
 
 define i32 @test7(i8** %esc) {
 ; CHECK-LABEL: @test7(
   %alloc = call noalias i8* @malloc(i32 48) nounwind
   store i8* %alloc, i8** %esc
   %gep = getelementptr inbounds i8, i8* %alloc, i32 16
-  %objsize = call i32 @llvm.objectsize.i32.p0i8(i8* %gep, i1 false) nounwind readonly
+  %objsize = call i32 @llvm.objectsize.i32.p0i8(i8* %gep, i8 0) nounwind readonly
 ; CHECK: ret i32 32
   ret i32 %objsize
 }
 
 declare noalias i8* @calloc(i32, i32) nounwind
 
 define i32 @test8(i8** %esc) {
 ; CHECK-LABEL: @test8(
   %alloc = call noalias i8* @calloc(i32 5, i32 7) nounwind
   store i8* %alloc, i8** %esc
   %gep = getelementptr inbounds i8, i8* %alloc, i32 5
-  %objsize = call i32 @llvm.objectsize.i32.p0i8(i8* %gep, i1 false) nounwind readonly
+  %objsize = call i32 @llvm.objectsize.i32.p0i8(i8* %gep, i8 0) nounwind readonly
 ; CHECK: ret i32 30
   ret i32 %objsize
 }
 
 declare noalias i8* @strdup(i8* nocapture) nounwind
 declare noalias i8* @strndup(i8* nocapture, i32) nounwind
 
 ; CHECK-LABEL: @test9(
 define i32 @test9(i8** %esc) {
   %call = tail call i8* @strdup(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0)) nounwind
   store i8* %call, i8** %esc, align 8
-  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %call, i1 true)
+  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %call, i8 2)
 ; CHECK: ret i32 8
   ret i32 %1
 }
 
 ; CHECK-LABEL: @test10(
 define i32 @test10(i8** %esc) {
   %call = tail call i8* @strndup(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i32 3) nounwind
   store i8* %call, i8** %esc, align 8
-  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %call, i1 true)
+  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %call, i8 2)
 ; CHECK: ret i32 4
   ret i32 %1
 }
 
 ; CHECK-LABEL: @test11(
 define i32 @test11(i8** %esc) {
   %call = tail call i8* @strndup(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i32 7) nounwind
   store i8* %call, i8** %esc, align 8
-  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %call, i1 true)
+  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %call, i8 2)
 ; CHECK: ret i32 8
   ret i32 %1
 }
 
 ; CHECK-LABEL: @test12(
 define i32 @test12(i8** %esc) {
   %call = tail call i8* @strndup(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i32 8) nounwind
   store i8* %call, i8** %esc, align 8
-  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %call, i1 true)
+  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %call, i8 2)
 ; CHECK: ret i32 8
   ret i32 %1
 }
 
 ; CHECK-LABEL: @test13(
 define i32 @test13(i8** %esc) {
   %call = tail call i8* @strndup(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i32 57) nounwind
   store i8* %call, i8** %esc, align 8
-  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %call, i1 true)
+  %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %call, i8 2)
 ; CHECK: ret i32 8
   ret i32 %1
 }
 
 @globalalias = internal alias [60 x i8]* @a
 
 ; CHECK-LABEL: @test18(
 ; CHECK-NEXT: ret i32 60
 define i32 @test18() {
   %bc = bitcast [60 x i8]* @globalalias to i8*
-  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* %bc, i1 false)
+  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* %bc, i8 0)
   ret i32 %1
 }
 
 @globalalias2 = weak alias [60 x i8]* @a
 
 ; CHECK-LABEL: @test19(
 ; CHECK: llvm.objectsize
 define i32 @test19() {
   %bc = bitcast [60 x i8]* @globalalias2 to i8*
-  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* %bc, i1 false)
+  %1 = call i32 @llvm.objectsize.i32.p0i8(i8* %bc, i8 0)
   ret i32 %1
 }
 

test/Transforms/InstCombine/stpcpy_chk-1.ll

 
 ; Check case where the string length is not constant.
 
 define i8* @test_simplify5() {
 ; CHECK-LABEL: @test_simplify5(
   %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
   %src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0
 
-; CHECK-NEXT: %len = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false)
+; CHECK-NEXT: %len = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8 0)
 ; CHECK-NEXT: %1 = call i8* @__memcpy_chk(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i32 %len)
 ; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 11)
-  %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i1 false)
+  %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i8 0)
   %ret = call i8* @__stpcpy_chk(i8* %dst, i8* %src, i32 %len)
   ret i8* %ret
 }
 
 ; Check case where the source and destination are the same.
 
 define i8* @test_simplify6() {
 ; CHECK-LABEL: @test_simplify6(
   %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
 
 ; CHECK-NEXT: %strlen = call i32 @strlen(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0))
 ; CHECK-NEXT: %1 = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 %strlen
 ; CHECK-NEXT: ret i8* %1
-  %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i1 false)
+  %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i8 0)
   %ret = call i8* @__stpcpy_chk(i8* %dst, i8* %dst, i32 %len)
   ret i8* %ret
 }
 
 ; Check case where slen < strlen (src).
 
 define i8* @test_no_simplify1() {
 ; CHECK-LABEL: @test_no_simplify1(
   %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
   %src = getelementptr inbounds [60 x i8], [60 x i8]* @b, i32 0, i32 0
 
 ; CHECK-NEXT: %ret = call i8* @__stpcpy_chk(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* getelementptr inbounds ([60 x i8], [60 x i8]* @b, i32 0, i32 0), i32 8)
 ; CHECK-NEXT: ret i8* %ret
   %ret = call i8* @__stpcpy_chk(i8* %dst, i8* %src, i32 8)
   ret i8* %ret
 }
 
 declare i8* @__stpcpy_chk(i8*, i8*, i32) nounwind
-declare i32 @llvm.objectsize.i32.p0i8(i8*, i1) nounwind readonly
+declare i32 @llvm.objectsize.i32.p0i8(i8*, i8) nounwind readonly

test/Transforms/InstCombine/strcpy_chk-1.ll

 
 ; Check case where the string length is not constant.
 
 define i8* @test_simplify5() {
 ; CHECK-LABEL: @test_simplify5(
   %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
   %src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0
 
-; CHECK-NEXT: %len = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false)
+; CHECK-NEXT: %len = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8 0)
 ; CHECK-NEXT: %1 = call i8* @__memcpy_chk(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i32 %len)
 ; CHECK-NEXT: ret i8* %1
-  %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i1 false)
+  %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i8 0)
   %ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 %len)
   ret i8* %ret
 }
 
 ; Check case where the source and destination are the same.
 
 define i8* @test_simplify6() {
 ; CHECK-LABEL: @test_simplify6(
   %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
 
-; CHECK-NEXT: %len = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false)
+; CHECK-NEXT: %len = call i32 @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8 0)
 ; CHECK-NEXT: %ret = call i8* @__strcpy_chk(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i32 %len)
 ; CHECK-NEXT: ret i8* %ret
-  %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i1 false)
+  %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i8 0)
   %ret = call i8* @__strcpy_chk(i8* %dst, i8* %dst, i32 %len)
   ret i8* %ret
 }
 
 ; Check case where slen < strlen (src).
 
 define i8* @test_no_simplify1() {
 ; CHECK-LABEL: @test_no_simplify1(
   %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
   %src = getelementptr inbounds [60 x i8], [60 x i8]* @b, i32 0, i32 0
 
 ; CHECK-NEXT: %ret = call i8* @__strcpy_chk(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* getelementptr inbounds ([60 x i8], [60 x i8]* @b, i32 0, i32 0), i32 8)
 ; CHECK-NEXT: ret i8* %ret
   %ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 8)
   ret i8* %ret
 }
 
 declare i8* @__strcpy_chk(i8*, i8*, i32) nounwind
-declare i32 @llvm.objectsize.i32.p0i8(i8*, i1) nounwind readonly
+declare i32 @llvm.objectsize.i32.p0i8(i8*, i8) nounwind readonly