This is an archive of the discontinued LLVM Phabricator instance.

Differential D56761

Add a parameter to the objectsize intrinsic that controls whether to evaluate size dynamically
ClosedPublic

Authored by erik.pilkington on Jan 15 2019, 4:52 PM.

Details

Reviewers
george.burgess.iv
ahatanak
majnemer
jfb
Commits
rG600e9deacfa8: Add a 'dynamic' parameter to the objectsize intrinsic
rC352664: Add a 'dynamic' parameter to the objectsize intrinsic
rL352664: Add a 'dynamic' parameter to the objectsize intrinsic
Summary

This will be used by a new clang builtin __builtin_dynamic_object_size. This builtin is meant to be used as drop-in replacement for __builtin_object_size. When BDOS can't be folded statically, then it computes the object size at runtime. You can see the clang patch here: https://reviews.llvm.org/D56760

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

Diff Detail

Repository
rL LLVM

Event Timeline

erik.pilkington created this revision.Jan 15 2019, 4:52 PM
Herald added subscribers: dexonsmith, jkorous, hiraditya and 3 others. · View Herald TranscriptJan 15 2019, 4:52 PM
erik.pilkington added a child revision: D56760: Add a new builtin: __builtin_dynamic_object_size.Jan 15 2019, 4:53 PM
jfb added a subscriber: jfb.Jan 18 2019, 10:42 AM
jfb accepted this revision.Jan 29 2019, 1:26 PM

This seems fine regardless of the route we take for D56760 (assuming we commit *something*).

This revision is now accepted and ready to land.Jan 29 2019, 1:26 PM
Closed by commit rL352664: Add a 'dynamic' parameter to the objectsize intrinsic (authored by epilk). · Explain WhyJan 30 2019, 12:34 PM
This revision was automatically updated to reflect the committed changes.
vsk added a subscriber: vsk.Feb 8 2019, 1:19 PM

I think this breaks bitcode backwards compatibility:

Callsite was not defined with variable arguments!
i64 (i8*, i1, i1)* @llvm.objectsize.i64.p0i8
Herald added a project: Restricted Project. · View Herald TranscriptFeb 8 2019, 1:19 PM
erik.pilkington mentioned this in D58071: Fix auto-upgrade for the new parameter to llvm.objectsize.Feb 11 2019, 1:14 PM
erik.pilkington marked an inline comment as done.
In D56761#1391118, @vsk wrote:

I think this breaks bitcode backwards compatibility:

Callsite was not defined with variable arguments!
i64 (i8*, i1, i1)* @llvm.objectsize.i64.p0i8

Thanks for letting me know, should be fixed by D58071.

Revision Contents

PathSize
cfe/
trunk/
lib/
CodeGen/
3 lines
3 lines
test/
CodeGen/
2 lines
2 lines
110 lines
14 lines
llvm/
trunk/
docs/
38 lines
include/
llvm/
Analysis/
27 lines
IR/
3 lines
lib/
Analysis/
51 lines
CodeGen/
2 lines
IR/
4 lines
Target/
AMDGPU/
3 lines
Transforms/
InstCombine/
5 lines
4 lines
Instrumentation/
5 lines
test/
Assembler/
5 lines
CodeGen/
AMDGPU/
6 lines
X86/
4 lines
Other/
4 lines
Transforms/
CodeGenPrepare/
18 lines
4 lines
InferAddressSpaces/
AMDGPU/
12 lines
InstCombine/
83 lines
2 lines
8 lines
58 lines
8 lines
10 lines

Diff 184351

cfe/trunk/lib/CodeGen/CGBuiltin.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 543 Lines • ▼ Show 20 Lines assert(Ptr->getType()->isPointerTy() &&
"Non-pointer passed to __builtin_object_size?"); "Non-pointer passed to __builtin_object_size?");
Value *F = CGM.getIntrinsic(Intrinsic::objectsize, {ResType, Ptr->getType()}); 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. // LLVM only supports 0 and 2, make sure that we pass along that as a boolean.
Value *Min = Builder.getInt1((Type & 2) != 0); Value *Min = Builder.getInt1((Type & 2) != 0);
// For GCC compatibility, __builtin_object_size treat NULL as unknown size. // For GCC compatibility, __builtin_object_size treat NULL as unknown size.
Value *NullIsUnknown = Builder.getTrue(); Value *NullIsUnknown = Builder.getTrue();
return Builder.CreateCall(F, {Ptr, Min, NullIsUnknown}); Value *Dynamic = Builder.getFalse();
return Builder.CreateCall(F, {Ptr, Min, NullIsUnknown, Dynamic});
} }
namespace { namespace {
/// A struct to generically describe a bit test intrinsic. /// A struct to generically describe a bit test intrinsic.
struct BitTest { struct BitTest {
enum ActionKind : uint8_t { TestOnly, Complement, Reset, Set }; enum ActionKind : uint8_t { TestOnly, Complement, Reset, Set };
enum InterlockingKind : uint8_t { enum InterlockingKind : uint8_t {
Unlocked, Unlocked,
▲ Show 20 Lines • Show All 13,325 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CGExpr.cpp

Show First 20 Lines • Show All 721 Lines • ▼ Show 20 Lines if (!ConstantSize || !ConstantSize->isNullValue()) {
// The glvalue must refer to a large enough storage region. // The glvalue must refer to a large enough storage region.
// FIXME: If Address Sanitizer is enabled, insert dynamic instrumentation // FIXME: If Address Sanitizer is enabled, insert dynamic instrumentation
// to check this. // to check this.
// FIXME: Get object address space // FIXME: Get object address space
llvm::Type *Tys[2] = { IntPtrTy, Int8PtrTy }; llvm::Type *Tys[2] = { IntPtrTy, Int8PtrTy };
llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, Tys); llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, Tys);
llvm::Value *Min = Builder.getFalse(); llvm::Value *Min = Builder.getFalse();
llvm::Value *NullIsUnknown = Builder.getFalse(); llvm::Value *NullIsUnknown = Builder.getFalse();
llvm::Value *Dynamic = Builder.getFalse();
llvm::Value *CastAddr = Builder.CreateBitCast(Ptr, Int8PtrTy); llvm::Value *CastAddr = Builder.CreateBitCast(Ptr, Int8PtrTy);
llvm::Value *LargeEnough = Builder.CreateICmpUGE( llvm::Value *LargeEnough = Builder.CreateICmpUGE(
Builder.CreateCall(F, {CastAddr, Min, NullIsUnknown}), Size); Builder.CreateCall(F, {CastAddr, Min, NullIsUnknown, Dynamic}), Size);
Checks.push_back(std::make_pair(LargeEnough, SanitizerKind::ObjectSize)); Checks.push_back(std::make_pair(LargeEnough, SanitizerKind::ObjectSize));
} }
} }
uint64_t AlignVal = 0; uint64_t AlignVal = 0;
llvm::Value *PtrAsInt = nullptr; llvm::Value *PtrAsInt = nullptr;
if (SanOpts.has(SanitizerKind::Alignment) && if (SanOpts.has(SanitizerKind::Alignment) &&
▲ Show 20 Lines • Show All 4,199 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 225 Lines • ▼ Show 20 Linesvoid test7() {
// CHECK: store i32 3 // CHECK: store i32 3
gi = __builtin_object_size(data->pad, 3); gi = __builtin_object_size(data->pad, 3);
} }
// CHECK-LABEL: @test8 // CHECK-LABEL: @test8
void test8() { void test8() {
// Non-const pointers aren't currently supported. // Non-const pointers aren't currently supported.
void *buf = my_calloc(100, 5); void *buf = my_calloc(100, 5);
// CHECK: @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1 false)
gi = __builtin_object_size(buf, 0); gi = __builtin_object_size(buf, 0);
// CHECK: @llvm.objectsize // CHECK: @llvm.objectsize
gi = __builtin_object_size(buf, 1); gi = __builtin_object_size(buf, 1);
// CHECK: @llvm.objectsize // CHECK: @llvm.objectsize
gi = __builtin_object_size(buf, 2); gi = __builtin_object_size(buf, 2);
// CHECK: store i32 0 // CHECK: store i32 0
gi = __builtin_object_size(buf, 3); gi = __builtin_object_size(buf, 3);
} }
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

cfe/trunk/test/CodeGen/catch-undef-behavior.c

Show All 29 Lines
// CHECK-UBSAN: @[[LINE_1600:.*]] = {{.*}}, i32 1600, i32 10 {{.*}} @{{.*}} } // CHECK-UBSAN: @[[LINE_1600:.*]] = {{.*}}, i32 1600, i32 10 {{.*}} @{{.*}} }
// PR6805 // PR6805
// CHECK-COMMON-LABEL: @foo // CHECK-COMMON-LABEL: @foo
void foo() { void foo() {
union { int i; } u; union { int i; } u;
// CHECK-COMMON: %[[I8PTR:.*]] = bitcast i32* %[[PTR:.*]] to i8* // CHECK-COMMON: %[[I8PTR:.*]] = bitcast i32* %[[PTR:.*]] to i8*
// CHECK-COMMON-NEXT: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64.p0i8(i8* %[[I8PTR]], i1 false, i1 false) // CHECK-COMMON-NEXT: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64.p0i8(i8* %[[I8PTR]], i1 false, i1 false, i1 false)
// CHECK-COMMON-NEXT: %[[OK:.*]] = icmp uge i64 %[[SIZE]], 4 // CHECK-COMMON-NEXT: %[[OK:.*]] = icmp uge i64 %[[SIZE]], 4
// CHECK-UBSAN: br i1 %[[OK]], {{.*}} !prof ![[WEIGHT_MD:.*]], !nosanitize // CHECK-UBSAN: br i1 %[[OK]], {{.*}} !prof ![[WEIGHT_MD:.*]], !nosanitize
// CHECK-TRAP: br i1 %[[OK]], {{.*}} // CHECK-TRAP: br i1 %[[OK]], {{.*}}
// CHECK-UBSAN: %[[ARG:.*]] = ptrtoint {{.*}} %[[PTR]] to i64 // CHECK-UBSAN: %[[ARG:.*]] = ptrtoint {{.*}} %[[PTR]] to i64
// CHECK-UBSAN-NEXT: call void @__ubsan_handle_type_mismatch_v1(i8* bitcast ({{.*}} @[[LINE_100]] to i8*), i64 %[[ARG]]) // CHECK-UBSAN-NEXT: call void @__ubsan_handle_type_mismatch_v1(i8* bitcast ({{.*}} @[[LINE_100]] to i8*), i64 %[[ARG]])
▲ Show 20 Lines • Show All 370 Lines • Show Last 20 Lines

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

Show All 34 Lines
void test4() { 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) // 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"); strcpy((char*)(void*)&gbuf[-1], "Hi there");
} }
// CHECK-LABEL: define void @test5 // CHECK-LABEL: define void @test5
void test5() { void test5() {
// CHECK: = load i8*, i8** @gp // CHECK: = load i8*, i8** @gp
// CHECK-NEXT:= call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK-NEXT:= call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1 false)
strcpy(gp, "Hi there"); strcpy(gp, "Hi there");
} }
// CHECK-LABEL: define void @test6 // CHECK-LABEL: define void @test6
void test6() { void test6() {
char buf[57]; 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) // CHECK: = call i8* @__strcpy_chk(i8* %{{.*}}, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 53)
▲ Show 20 Lines • Show All 197 Lines • ▼ Show 20 Linesvoid test22() {
// CHECK: store i32 0 // CHECK: store i32 0
gi = __builtin_object_size((char*)&t[9].t[0] + 10*sizeof(t[0].t), 3); gi = __builtin_object_size((char*)&t[9].t[0] + 10*sizeof(t[0].t), 3);
} }
struct Test23Ty { int a; int t[10]; }; struct Test23Ty { int a; int t[10]; };
// CHECK-LABEL: @test23 // CHECK-LABEL: @test23
void test23(struct Test23Ty *p) { void test23(struct Test23Ty *p) {
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(p, 0); gi = __builtin_object_size(p, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(p, 1); gi = __builtin_object_size(p, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(p, 2); gi = __builtin_object_size(p, 2);
// Note: this is currently fixed at 0 because LLVM doesn't have sufficient // Note: this is currently fixed at 0 because LLVM doesn't have sufficient
// data to correctly handle type=3 // data to correctly handle type=3
// CHECK: store i32 0 // CHECK: store i32 0
gi = __builtin_object_size(p, 3); gi = __builtin_object_size(p, 3);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(&p->a, 0); gi = __builtin_object_size(&p->a, 0);
// CHECK: store i32 4 // CHECK: store i32 4
gi = __builtin_object_size(&p->a, 1); gi = __builtin_object_size(&p->a, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(&p->a, 2); gi = __builtin_object_size(&p->a, 2);
// CHECK: store i32 4 // CHECK: store i32 4
gi = __builtin_object_size(&p->a, 3); gi = __builtin_object_size(&p->a, 3);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(&p->t[5], 0); gi = __builtin_object_size(&p->t[5], 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(&p->t[5], 1); gi = __builtin_object_size(&p->t[5], 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(&p->t[5], 2); gi = __builtin_object_size(&p->t[5], 2);
// CHECK: store i32 20 // CHECK: store i32 20
gi = __builtin_object_size(&p->t[5], 3); gi = __builtin_object_size(&p->t[5], 3);
} }
// PR24493 -- ICE if __builtin_object_size called with NULL and (Type & 1) != 0 // PR24493 -- ICE if __builtin_object_size called with NULL and (Type & 1) != 0
// CHECK-LABEL: @test24 // CHECK-LABEL: @test24
void test24() { void test24() {
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size((void*)0, 0); gi = __builtin_object_size((void*)0, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size((void*)0, 1); gi = __builtin_object_size((void*)0, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size((void*)0, 2); gi = __builtin_object_size((void*)0, 2);
// Note: Currently fixed at zero because LLVM can't handle type=3 correctly. // Note: Currently fixed at zero because LLVM can't handle type=3 correctly.
// Hopefully will be lowered properly in the future. // Hopefully will be lowered properly in the future.
// CHECK: store i32 0 // CHECK: store i32 0
gi = __builtin_object_size((void*)0, 3); gi = __builtin_object_size((void*)0, 3);
} }
// CHECK-LABEL: @test25 // CHECK-LABEL: @test25
void test25() { void test25() {
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size((void*)0x1000, 0); gi = __builtin_object_size((void*)0x1000, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size((void*)0x1000, 1); gi = __builtin_object_size((void*)0x1000, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size((void*)0x1000, 2); gi = __builtin_object_size((void*)0x1000, 2);
// Note: Currently fixed at zero because LLVM can't handle type=3 correctly. // Note: Currently fixed at zero because LLVM can't handle type=3 correctly.
// Hopefully will be lowered properly in the future. // Hopefully will be lowered properly in the future.
// CHECK: store i32 0 // CHECK: store i32 0
gi = __builtin_object_size((void*)0x1000, 3); gi = __builtin_object_size((void*)0x1000, 3);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size((void*)0 + 0x1000, 0); gi = __builtin_object_size((void*)0 + 0x1000, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size((void*)0 + 0x1000, 1); gi = __builtin_object_size((void*)0 + 0x1000, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size((void*)0 + 0x1000, 2); gi = __builtin_object_size((void*)0 + 0x1000, 2);
// Note: Currently fixed at zero because LLVM can't handle type=3 correctly. // Note: Currently fixed at zero because LLVM can't handle type=3 correctly.
// Hopefully will be lowered properly in the future. // Hopefully will be lowered properly in the future.
// CHECK: store i32 0 // CHECK: store i32 0
gi = __builtin_object_size((void*)0 + 0x1000, 3); gi = __builtin_object_size((void*)0 + 0x1000, 3);
} }
// CHECK-LABEL: @test26 // CHECK-LABEL: @test26
Show All 9 Linesvoid test26() {
// CHECK: store i32 0 // CHECK: store i32 0
gi = __builtin_object_size(&t[1].v[14], 3); gi = __builtin_object_size(&t[1].v[14], 3);
} }
struct Test27IncompleteTy; struct Test27IncompleteTy;
// CHECK-LABEL: @test27 // CHECK-LABEL: @test27
void test27(struct Test27IncompleteTy *t) { void test27(struct Test27IncompleteTy *t) {
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(t, 0); gi = __builtin_object_size(t, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(t, 1); gi = __builtin_object_size(t, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(t, 2); gi = __builtin_object_size(t, 2);
// Note: this is currently fixed at 0 because LLVM doesn't have sufficient // Note: this is currently fixed at 0 because LLVM doesn't have sufficient
// data to correctly handle type=3 // data to correctly handle type=3
// CHECK: store i32 0 // CHECK: store i32 0
gi = __builtin_object_size(t, 3); gi = __builtin_object_size(t, 3);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(&test27, 0); gi = __builtin_object_size(&test27, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(&test27, 1); gi = __builtin_object_size(&test27, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(&test27, 2); gi = __builtin_object_size(&test27, 2);
// Note: this is currently fixed at 0 because LLVM doesn't have sufficient // Note: this is currently fixed at 0 because LLVM doesn't have sufficient
// data to correctly handle type=3 // data to correctly handle type=3
// CHECK: store i32 0 // CHECK: store i32 0
gi = __builtin_object_size(&test27, 3); gi = __builtin_object_size(&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 __builtin_object_size treats `&foo`
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
struct StaticStruct { struct StaticStruct {
char fst[16]; char fst[16];
char snd[2]; char snd[2];
}; };
// CHECK-LABEL: @test29 // CHECK-LABEL: @test29
void test29(struct DynStructVar *dv, struct DynStruct0 *d0, void test29(struct DynStructVar *dv, struct DynStruct0 *d0,
struct DynStruct1 *d1, struct StaticStruct *ss) { struct DynStruct1 *d1, struct StaticStruct *ss) {
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(dv->snd, 0); gi = __builtin_object_size(dv->snd, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(dv->snd, 1); gi = __builtin_object_size(dv->snd, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(dv->snd, 2); gi = __builtin_object_size(dv->snd, 2);
// CHECK: store i32 0 // CHECK: store i32 0
gi = __builtin_object_size(dv->snd, 3); gi = __builtin_object_size(dv->snd, 3);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(d0->snd, 0); gi = __builtin_object_size(d0->snd, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(d0->snd, 1); gi = __builtin_object_size(d0->snd, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(d0->snd, 2); gi = __builtin_object_size(d0->snd, 2);
// CHECK: store i32 0 // CHECK: store i32 0
gi = __builtin_object_size(d0->snd, 3); gi = __builtin_object_size(d0->snd, 3);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(d1->snd, 0); gi = __builtin_object_size(d1->snd, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(d1->snd, 1); gi = __builtin_object_size(d1->snd, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(d1->snd, 2); gi = __builtin_object_size(d1->snd, 2);
// CHECK: store i32 1 // CHECK: store i32 1
gi = __builtin_object_size(d1->snd, 3); gi = __builtin_object_size(d1->snd, 3);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(ss->snd, 0); gi = __builtin_object_size(ss->snd, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(ss->snd, 1); gi = __builtin_object_size(ss->snd, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(ss->snd, 2); gi = __builtin_object_size(ss->snd, 2);
// CHECK: store i32 2 // CHECK: store i32 2
gi = __builtin_object_size(ss->snd, 3); gi = __builtin_object_size(ss->snd, 3);
} }
// CHECK-LABEL: @test30 // CHECK-LABEL: @test30
void test30() { void test30() {
struct { struct DynStruct1 fst, snd; } *nested; struct { struct DynStruct1 fst, snd; } *nested;
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(nested->fst.snd, 0); gi = __builtin_object_size(nested->fst.snd, 0);
// CHECK: store i32 1 // CHECK: store i32 1
gi = __builtin_object_size(nested->fst.snd, 1); gi = __builtin_object_size(nested->fst.snd, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(nested->fst.snd, 2); gi = __builtin_object_size(nested->fst.snd, 2);
// CHECK: store i32 1 // CHECK: store i32 1
gi = __builtin_object_size(nested->fst.snd, 3); gi = __builtin_object_size(nested->fst.snd, 3);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(nested->snd.snd, 0); gi = __builtin_object_size(nested->snd.snd, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(nested->snd.snd, 1); gi = __builtin_object_size(nested->snd.snd, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(nested->snd.snd, 2); gi = __builtin_object_size(nested->snd.snd, 2);
// CHECK: store i32 1 // CHECK: store i32 1
gi = __builtin_object_size(nested->snd.snd, 3); gi = __builtin_object_size(nested->snd.snd, 3);
union { struct DynStruct1 d1; char c[1]; } *u; union { struct DynStruct1 d1; char c[1]; } *u;
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(u->c, 0); gi = __builtin_object_size(u->c, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(u->c, 1); gi = __builtin_object_size(u->c, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(u->c, 2); gi = __builtin_object_size(u->c, 2);
// CHECK: store i32 1 // CHECK: store i32 1
gi = __builtin_object_size(u->c, 3); gi = __builtin_object_size(u->c, 3);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(u->d1.snd, 0); gi = __builtin_object_size(u->d1.snd, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(u->d1.snd, 1); gi = __builtin_object_size(u->d1.snd, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(u->d1.snd, 2); gi = __builtin_object_size(u->d1.snd, 2);
// CHECK: store i32 1 // CHECK: store i32 1
gi = __builtin_object_size(u->d1.snd, 3); gi = __builtin_object_size(u->d1.snd, 3);
} }
// CHECK-LABEL: @test31 // CHECK-LABEL: @test31
void test31() { void test31() {
// Miscellaneous 'writing off the end' detection tests // Miscellaneous 'writing off the end' detection tests
struct DynStructVar *dsv; struct DynStructVar *dsv;
struct DynStruct0 *ds0; struct DynStruct0 *ds0;
struct DynStruct1 *ds1; struct DynStruct1 *ds1;
struct StaticStruct *ss; struct StaticStruct *ss;
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(ds1[9].snd, 1); gi = __builtin_object_size(ds1[9].snd, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(&ss[9].snd[0], 1); gi = __builtin_object_size(&ss[9].snd[0], 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(&ds1[9].snd[0], 1); gi = __builtin_object_size(&ds1[9].snd[0], 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(&ds0[9].snd[0], 1); gi = __builtin_object_size(&ds0[9].snd[0], 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(&dsv[9].snd[0], 1); gi = __builtin_object_size(&dsv[9].snd[0], 1);
} }
// CHECK-LABEL: @PR30346 // CHECK-LABEL: @PR30346
void PR30346() { void PR30346() {
struct sa_family_t {}; struct sa_family_t {};
struct sockaddr { struct sockaddr {
struct sa_family_t sa_family; struct sa_family_t sa_family;
char sa_data[14]; char sa_data[14];
}; };
struct sockaddr *sa; struct sockaddr *sa;
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(sa->sa_data, 0); gi = __builtin_object_size(sa->sa_data, 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = __builtin_object_size(sa->sa_data, 1); gi = __builtin_object_size(sa->sa_data, 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1
gi = __builtin_object_size(sa->sa_data, 2); gi = __builtin_object_size(sa->sa_data, 2);
// CHECK: store i32 14 // CHECK: store i32 14
gi = __builtin_object_size(sa->sa_data, 3); gi = __builtin_object_size(sa->sa_data, 3);
} }
extern char incomplete_char_array[]; extern char incomplete_char_array[];
// CHECK-LABEL: @incomplete_and_function_types // CHECK-LABEL: @incomplete_and_function_types
int incomplete_and_function_types() { int incomplete_and_function_types() {
Show All 28 Lines

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

Show All 29 Lines
} }
// CHECK-LABEL: define void @_Z5test2v() // CHECK-LABEL: define void @_Z5test2v()
void test2() { void test2() {
struct A { char buf[16]; }; struct A { char buf[16]; };
struct B : A {}; struct B : A {};
struct C { int i; B bs[1]; } *c; struct C { int i; B bs[1]; } *c;
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1 false)
gi = __builtin_object_size(&c->bs[0], 0); gi = __builtin_object_size(&c->bs[0], 0);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1 false)
gi = __builtin_object_size(&c->bs[0], 1); gi = __builtin_object_size(&c->bs[0], 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1 false)
gi = __builtin_object_size(&c->bs[0], 2); gi = __builtin_object_size(&c->bs[0], 2);
// CHECK: store i32 16 // CHECK: store i32 16
gi = __builtin_object_size(&c->bs[0], 3); gi = __builtin_object_size(&c->bs[0], 3);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1 false)
gi = __builtin_object_size((A*)&c->bs[0], 0); gi = __builtin_object_size((A*)&c->bs[0], 0);
// CHECK: store i32 16 // CHECK: store i32 16
gi = __builtin_object_size((A*)&c->bs[0], 1); gi = __builtin_object_size((A*)&c->bs[0], 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1 false)
gi = __builtin_object_size((A*)&c->bs[0], 2); gi = __builtin_object_size((A*)&c->bs[0], 2);
// CHECK: store i32 16 // CHECK: store i32 16
gi = __builtin_object_size((A*)&c->bs[0], 3); gi = __builtin_object_size((A*)&c->bs[0], 3);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1 false)
gi = __builtin_object_size(&c->bs[0].buf[0], 0); gi = __builtin_object_size(&c->bs[0].buf[0], 0);
// CHECK: store i32 16 // CHECK: store i32 16
gi = __builtin_object_size(&c->bs[0].buf[0], 1); gi = __builtin_object_size(&c->bs[0].buf[0], 1);
// CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true) // CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 true, i1 true, i1 false)
gi = __builtin_object_size(&c->bs[0].buf[0], 2); gi = __builtin_object_size(&c->bs[0].buf[0], 2);
// CHECK: store i32 16 // CHECK: store i32 16
gi = __builtin_object_size(&c->bs[0].buf[0], 3); gi = __builtin_object_size(&c->bs[0].buf[0], 3);
} }

llvm/trunk/docs/LangRef.rst

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 15,569 Lines • ▼ Show 20 Lines
'``llvm.objectsize``' Intrinsic '``llvm.objectsize``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Syntax: Syntax:
""""""" """""""
:: ::
declare i32 @llvm.objectsize.i32(i8* <object>, i1 <min>, i1 <nullunknown>) declare i32 @llvm.objectsize.i32(i8* <object>, i1 <min>, i1 <nullunknown>, i1 <dynamic>)
declare i64 @llvm.objectsize.i64(i8* <object>, i1 <min>, i1 <nullunknown>) declare i64 @llvm.objectsize.i64(i8* <object>, i1 <min>, i1 <nullunknown>, i1 <dynamic>)
Overview: Overview:
""""""""" """""""""
The ``llvm.objectsize`` intrinsic is designed to provide information to The ``llvm.objectsize`` intrinsic is designed to provide information to the
the optimizers to determine at compile time whether a) an operation optimizer to determine whether a) an operation (like memcpy) will overflow a
(like memcpy) will overflow a buffer that corresponds to an object, or buffer that corresponds to an object, or b) that a runtime check for overflow
b) that a runtime check for overflow isn't necessary. An object in this isn't necessary. An object in this context means an allocation of a specific
context means an allocation of a specific class, structure, array, or class, structure, array, or other object.
other object.
Arguments: Arguments:
"""""""""" """"""""""
The ``llvm.objectsize`` intrinsic takes three arguments. The first argument is The ``llvm.objectsize`` intrinsic takes four arguments. The first argument is a
a pointer to or into the ``object``. The second argument determines whether pointer to or into the ``object``. The second argument determines whether
``llvm.objectsize`` returns 0 (if true) or -1 (if false) when the object size ``llvm.objectsize`` returns 0 (if true) or -1 (if false) when the object size is
is unknown. The third argument controls how ``llvm.objectsize`` acts when unknown. The third argument controls how ``llvm.objectsize`` acts when ``null``
``null`` in address space 0 is used as its pointer argument. If it's ``false``, in address space 0 is used as its pointer argument. If it's ``false``,
``llvm.objectsize`` reports 0 bytes available when given ``null``. Otherwise, if ``llvm.objectsize`` reports 0 bytes available when given ``null``. Otherwise, if
the ``null`` is in a non-zero address space or if ``true`` is given for the the ``null`` is in a non-zero address space or if ``true`` is given for the
third argument of ``llvm.objectsize``, we assume its size is unknown. third argument of ``llvm.objectsize``, we assume its size is unknown. The fourth
argument to ``llvm.objectsize`` determines if the value should be evaluated at
runtime.
The second and third arguments only accept constants. The second, third, and fourth arguments only accept constants.
Semantics: Semantics:
"""""""""" """"""""""
The ``llvm.objectsize`` intrinsic is lowered to a constant representing The ``llvm.objectsize`` intrinsic is lowered to a value representing the size of
the size of the object concerned. If the size cannot be determined at the object concerned. If the size cannot be determined, ``llvm.objectsize``
compile time, ``llvm.objectsize`` returns ``i32/i64 -1 or 0`` (depending returns ``i32/i64 -1 or 0`` (depending on the ``min`` argument).
on the ``min`` argument).
'``llvm.expect``' Intrinsic '``llvm.expect``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
Syntax: Syntax:
""""""" """""""
This is an overloaded intrinsic. You can use ``llvm.expect`` on any This is an overloaded intrinsic. You can use ``llvm.expect`` on any
▲ Show 20 Lines • Show All 1,061 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h

Show First 20 Lines • Show All 171 Lines • ▼ Show 20 Lines
/// Compute the size of the object pointed by Ptr. Returns true and the /// Compute the size of the object pointed by Ptr. Returns true and the
/// object size in Size if successful, and false otherwise. In this context, by /// object size in Size if successful, and false otherwise. In this context, by
/// object we mean the region of memory starting at Ptr to the end of the /// object we mean the region of memory starting at Ptr to the end of the
/// underlying object pointed to by Ptr. /// underlying object pointed to by Ptr.
bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL, bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL,
const TargetLibraryInfo *TLI, ObjectSizeOpts Opts = {}); const TargetLibraryInfo *TLI, ObjectSizeOpts Opts = {});
/// Try to turn a call to \@llvm.objectsize into an integer value of the given /// Try to turn a call to \@llvm.objectsize into an integer value of the given
/// Type. Returns null on failure. /// Type. Returns null on failure. If MustSucceed is true, this function will
/// If MustSucceed is true, this function will not return null, and may return /// not return null, and may return conservative values governed by the second
/// conservative values governed by the second argument of the call to /// argument of the call to objectsize.
/// objectsize. Value *lowerObjectSizeCall(IntrinsicInst *ObjectSize, const DataLayout &DL,
ConstantInt *lowerObjectSizeCall(IntrinsicInst *ObjectSize, const TargetLibraryInfo *TLI, bool MustSucceed);
const DataLayout &DL,
const TargetLibraryInfo *TLI,
bool MustSucceed);
using SizeOffsetType = std::pair<APInt, APInt>; using SizeOffsetType = std::pair<APInt, APInt>;
/// Evaluate the size and offset of an object pointed to by a Value* /// Evaluate the size and offset of an object pointed to by a Value*
/// statically. Fails if size or offset are not known at compile time. /// statically. Fails if size or offset are not known at compile time.
class ObjectSizeOffsetVisitor class ObjectSizeOffsetVisitor
: public InstVisitor<ObjectSizeOffsetVisitor, SizeOffsetType> { : public InstVisitor<ObjectSizeOffsetVisitor, SizeOffsetType> {
const DataLayout &DL; const DataLayout &DL;
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Linesclass ObjectSizeOffsetEvaluator
const DataLayout &DL; const DataLayout &DL;
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
LLVMContext &Context; LLVMContext &Context;
BuilderTy Builder; BuilderTy Builder;
IntegerType *IntTy; IntegerType *IntTy;
Value *Zero; Value *Zero;
CacheMapTy CacheMap; CacheMapTy CacheMap;
PtrSetTy SeenVals; PtrSetTy SeenVals;
bool RoundToAlign; ObjectSizeOpts EvalOpts;
SizeOffsetEvalType unknown() {
return std::make_pair(nullptr, nullptr);
}
SizeOffsetEvalType compute_(Value *V); SizeOffsetEvalType compute_(Value *V);
public: public:
static SizeOffsetEvalType unknown() {
return std::make_pair(nullptr, nullptr);
}
ObjectSizeOffsetEvaluator(const DataLayout &DL, const TargetLibraryInfo *TLI, ObjectSizeOffsetEvaluator(const DataLayout &DL, const TargetLibraryInfo *TLI,
LLVMContext &Context, bool RoundToAlign = false); LLVMContext &Context, ObjectSizeOpts EvalOpts = {});
SizeOffsetEvalType compute(Value *V); SizeOffsetEvalType compute(Value *V);
bool knownSize(SizeOffsetEvalType SizeOffset) { bool knownSize(SizeOffsetEvalType SizeOffset) {
return SizeOffset.first; return SizeOffset.first;
} }
bool knownOffset(SizeOffsetEvalType SizeOffset) { bool knownOffset(SizeOffsetEvalType SizeOffset) {
Show All 27 Lines

llvm/trunk/include/llvm/IR/Intrinsics.td

Show First 20 Lines • Show All 552 Lines • ▼ Show 20 Lines
// NOTE: these are internal interfaces. // NOTE: these are internal interfaces.
def int_setjmp : Intrinsic<[llvm_i32_ty], [llvm_ptr_ty]>; def int_setjmp : Intrinsic<[llvm_i32_ty], [llvm_ptr_ty]>;
def int_longjmp : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty], [IntrNoReturn]>; 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_sigsetjmp : Intrinsic<[llvm_i32_ty] , [llvm_ptr_ty, llvm_i32_ty]>;
def int_siglongjmp : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty], [IntrNoReturn]>; def int_siglongjmp : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty], [IntrNoReturn]>;
// Internal interface for object size checking // Internal interface for object size checking
def int_objectsize : Intrinsic<[llvm_anyint_ty], def int_objectsize : Intrinsic<[llvm_anyint_ty],
[llvm_anyptr_ty, llvm_i1_ty, llvm_i1_ty], [llvm_anyptr_ty, llvm_i1_ty,
llvm_i1_ty, llvm_i1_ty],
[IntrNoMem, IntrSpeculatable]>, [IntrNoMem, IntrSpeculatable]>,
GCCBuiltin<"__builtin_object_size">; GCCBuiltin<"__builtin_object_size">;
//===--------------- Constrained Floating Point Intrinsics ----------------===// //===--------------- Constrained Floating Point Intrinsics ----------------===//
// //
let IntrProperties = [IntrInaccessibleMemOnly] in { let IntrProperties = [IntrInaccessibleMemOnly] in {
def int_experimental_constrained_fadd : Intrinsic<[ llvm_anyfloat_ty ], def int_experimental_constrained_fadd : Intrinsic<[ llvm_anyfloat_ty ],
▲ Show 20 Lines • Show All 602 Lines • Show Last 20 Lines

llvm/trunk/lib/Analysis/MemoryBuiltins.cpp

Show First 20 Lines • Show All 435 Lines • ▼ Show 20 Linesbool llvm::getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL,
SizeOffsetType Data = Visitor.compute(const_cast<Value*>(Ptr)); SizeOffsetType Data = Visitor.compute(const_cast<Value*>(Ptr));
if (!Visitor.bothKnown(Data)) if (!Visitor.bothKnown(Data))
return false; return false;
Size = getSizeWithOverflow(Data).getZExtValue(); Size = getSizeWithOverflow(Data).getZExtValue();
return true; return true;
} }
ConstantInt *llvm::lowerObjectSizeCall(IntrinsicInst *ObjectSize, Value *llvm::lowerObjectSizeCall(IntrinsicInst *ObjectSize,
const DataLayout &DL, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
bool MustSucceed) { bool MustSucceed) {
assert(ObjectSize->getIntrinsicID() == Intrinsic::objectsize && assert(ObjectSize->getIntrinsicID() == Intrinsic::objectsize &&
"ObjectSize must be a call to llvm.objectsize!"); "ObjectSize must be a call to llvm.objectsize!");
bool MaxVal = cast<ConstantInt>(ObjectSize->getArgOperand(1))->isZero(); bool MaxVal = cast<ConstantInt>(ObjectSize->getArgOperand(1))->isZero();
ObjectSizeOpts EvalOptions; ObjectSizeOpts EvalOptions;
// Unless we have to fold this to something, try to be as accurate as // Unless we have to fold this to something, try to be as accurate as
// possible. // possible.
if (MustSucceed) if (MustSucceed)
EvalOptions.EvalMode = EvalOptions.EvalMode =
MaxVal ? ObjectSizeOpts::Mode::Max : ObjectSizeOpts::Mode::Min; MaxVal ? ObjectSizeOpts::Mode::Max : ObjectSizeOpts::Mode::Min;
else else
EvalOptions.EvalMode = ObjectSizeOpts::Mode::Exact; EvalOptions.EvalMode = ObjectSizeOpts::Mode::Exact;
EvalOptions.NullIsUnknownSize = EvalOptions.NullIsUnknownSize =
cast<ConstantInt>(ObjectSize->getArgOperand(2))->isOne(); cast<ConstantInt>(ObjectSize->getArgOperand(2))->isOne();
auto *ResultType = cast<IntegerType>(ObjectSize->getType());
bool StaticOnly = cast<ConstantInt>(ObjectSize->getArgOperand(3))->isZero();
if (StaticOnly) {
// FIXME: Does it make sense to just return a failure value if the size won't // FIXME: Does it make sense to just return a failure value if the size won't
// fit in the output and `!MustSucceed`? // fit in the output and `!MustSucceed`?
uint64_t Size; uint64_t Size;
auto *ResultType = cast<IntegerType>(ObjectSize->getType());
if (getObjectSize(ObjectSize->getArgOperand(0), Size, DL, TLI, EvalOptions) && if (getObjectSize(ObjectSize->getArgOperand(0), Size, DL, TLI, EvalOptions) &&
isUIntN(ResultType->getBitWidth(), Size)) isUIntN(ResultType->getBitWidth(), Size))
return ConstantInt::get(ResultType, Size); return ConstantInt::get(ResultType, Size);
} else {
LLVMContext &Ctx = ObjectSize->getFunction()->getContext();
ObjectSizeOffsetEvaluator Eval(DL, TLI, Ctx, EvalOptions);
SizeOffsetEvalType SizeOffsetPair =
Eval.compute(ObjectSize->getArgOperand(0));
if (SizeOffsetPair != ObjectSizeOffsetEvaluator::unknown()) {
IRBuilder<TargetFolder> Builder(Ctx, TargetFolder(DL));
Builder.SetInsertPoint(ObjectSize);
// If we've outside the end of the object, then we can always access
// exactly 0 bytes.
Value *ResultSize =
Builder.CreateSub(SizeOffsetPair.first, SizeOffsetPair.second);
Value *UseZero =
Builder.CreateICmpULT(SizeOffsetPair.first, SizeOffsetPair.second);
return Builder.CreateSelect(UseZero, ConstantInt::get(ResultType, 0),
ResultSize);
}
}
if (!MustSucceed) if (!MustSucceed)
return nullptr; return nullptr;
return ConstantInt::get(ResultType, MaxVal ? -1ULL : 0); return ConstantInt::get(ResultType, MaxVal ? -1ULL : 0);
} }
STATISTIC(ObjectVisitorArgument, STATISTIC(ObjectVisitorArgument,
▲ Show 20 Lines • Show All 258 Lines • ▼ Show 20 Lines
SizeOffsetType ObjectSizeOffsetVisitor::visitInstruction(Instruction &I) { SizeOffsetType ObjectSizeOffsetVisitor::visitInstruction(Instruction &I) {
LLVM_DEBUG(dbgs() << "ObjectSizeOffsetVisitor unknown instruction:" << I LLVM_DEBUG(dbgs() << "ObjectSizeOffsetVisitor unknown instruction:" << I
<< '\n'); << '\n');
return unknown(); return unknown();
} }
ObjectSizeOffsetEvaluator::ObjectSizeOffsetEvaluator( ObjectSizeOffsetEvaluator::ObjectSizeOffsetEvaluator(
const DataLayout &DL, const TargetLibraryInfo *TLI, LLVMContext &Context, const DataLayout &DL, const TargetLibraryInfo *TLI, LLVMContext &Context,
bool RoundToAlign) ObjectSizeOpts EvalOpts)
: DL(DL), TLI(TLI), Context(Context), Builder(Context, TargetFolder(DL)), : DL(DL), TLI(TLI), Context(Context), Builder(Context, TargetFolder(DL)),
RoundToAlign(RoundToAlign) { EvalOpts(EvalOpts) {
// IntTy and Zero must be set for each compute() since the address space may // IntTy and Zero must be set for each compute() since the address space may
// be different for later objects. // be different for later objects.
} }
SizeOffsetEvalType ObjectSizeOffsetEvaluator::compute(Value *V) { SizeOffsetEvalType ObjectSizeOffsetEvaluator::compute(Value *V) {
// XXX - Are vectors of pointers possible here? // XXX - Are vectors of pointers possible here?
IntTy = cast<IntegerType>(DL.getIntPtrType(V->getType())); IntTy = cast<IntegerType>(DL.getIntPtrType(V->getType()));
Zero = ConstantInt::get(IntTy, 0); Zero = ConstantInt::get(IntTy, 0);
Show All 12 Lines if (!bothKnown(Result)) {
} }
} }
SeenVals.clear(); SeenVals.clear();
return Result; return Result;
} }
SizeOffsetEvalType ObjectSizeOffsetEvaluator::compute_(Value *V) { SizeOffsetEvalType ObjectSizeOffsetEvaluator::compute_(Value *V) {
ObjectSizeOpts ObjSizeOptions; ObjectSizeOffsetVisitor Visitor(DL, TLI, Context, EvalOpts);
ObjSizeOptions.RoundToAlign = RoundToAlign;
ObjectSizeOffsetVisitor Visitor(DL, TLI, Context, ObjSizeOptions);
SizeOffsetType Const = Visitor.compute(V); SizeOffsetType Const = Visitor.compute(V);
if (Visitor.bothKnown(Const)) if (Visitor.bothKnown(Const))
return std::make_pair(ConstantInt::get(Context, Const.first), return std::make_pair(ConstantInt::get(Context, Const.first),
ConstantInt::get(Context, Const.second)); ConstantInt::get(Context, Const.second));
V = V->stripPointerCasts(); V = V->stripPointerCasts();
// Check cache. // Check cache.
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/CodeGenPrepare.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,699 Lines • ▼ Show 20 Lines if (!OptSize && CI->hasFnAttr(Attribute::Cold))
} }
IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI); IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI);
if (II) { if (II) {
switch (II->getIntrinsicID()) { switch (II->getIntrinsicID()) {
default: break; default: break;
case Intrinsic::objectsize: { case Intrinsic::objectsize: {
// Lower all uses of llvm.objectsize.* // Lower all uses of llvm.objectsize.*
ConstantInt *RetVal = Value *RetVal =
lowerObjectSizeCall(II, *DL, TLInfo, /*MustSucceed=*/true); lowerObjectSizeCall(II, *DL, TLInfo, /*MustSucceed=*/true);
resetIteratorIfInvalidatedWhileCalling(BB, [&]() { resetIteratorIfInvalidatedWhileCalling(BB, [&]() {
replaceAndRecursivelySimplify(CI, RetVal, TLInfo, nullptr); replaceAndRecursivelySimplify(CI, RetVal, TLInfo, nullptr);
}); });
return true; return true;
} }
case Intrinsic::is_constant: { case Intrinsic::is_constant: {
▲ Show 20 Lines • Show All 5,374 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/AutoUpgrade.cpp

Show First 20 Lines • Show All 3,453 Lines • ▼ Show 20 Lines case Intrinsic::cttz:
NewCall = NewCall =
Builder.CreateCall(NewFn, {CI->getArgOperand(0), Builder.getFalse()}); Builder.CreateCall(NewFn, {CI->getArgOperand(0), Builder.getFalse()});
break; break;
case Intrinsic::objectsize: { case Intrinsic::objectsize: {
Value *NullIsUnknownSize = CI->getNumArgOperands() == 2 Value *NullIsUnknownSize = CI->getNumArgOperands() == 2
? Builder.getFalse() ? Builder.getFalse()
: CI->getArgOperand(2); : CI->getArgOperand(2);
Value *Dynamic =
CI->getNumArgOperands() < 3 ? Builder.getFalse() : CI->getArgOperand(3);
NewCall = Builder.CreateCall( NewCall = Builder.CreateCall(
NewFn, {CI->getArgOperand(0), CI->getArgOperand(1), NullIsUnknownSize}); NewFn, {CI->getArgOperand(0), CI->getArgOperand(1), NullIsUnknownSize, Dynamic});
break; break;
} }
case Intrinsic::ctpop: case Intrinsic::ctpop:
NewCall = Builder.CreateCall(NewFn, {CI->getArgOperand(0)}); NewCall = Builder.CreateCall(NewFn, {CI->getArgOperand(0)});
break; break;
case Intrinsic::convert_from_fp16: case Intrinsic::convert_from_fp16:
▲ Show 20 Lines • Show All 447 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

Show First 20 Lines • Show All 912 Lines • ▼ Show 20 Lines case Intrinsic::objectsize: {
Value *Src = Intr->getOperand(0); Value *Src = Intr->getOperand(0);
Type *SrcTy = Src->getType()->getPointerElementType(); Type *SrcTy = Src->getType()->getPointerElementType();
Function *ObjectSize = Intrinsic::getDeclaration(Mod, Function *ObjectSize = Intrinsic::getDeclaration(Mod,
Intrinsic::objectsize, Intrinsic::objectsize,
{ Intr->getType(), PointerType::get(SrcTy, AMDGPUAS::LOCAL_ADDRESS) } { Intr->getType(), PointerType::get(SrcTy, AMDGPUAS::LOCAL_ADDRESS) }
); );
CallInst *NewCall = Builder.CreateCall( CallInst *NewCall = Builder.CreateCall(
ObjectSize, {Src, Intr->getOperand(1), Intr->getOperand(2)}); ObjectSize,
{Src, Intr->getOperand(1), Intr->getOperand(2), Intr->getOperand(3)});
Intr->replaceAllUsesWith(NewCall); Intr->replaceAllUsesWith(NewCall);
Intr->eraseFromParent(); Intr->eraseFromParent();
continue; continue;
} }
default: default:
Intr->print(errs()); Intr->print(errs());
llvm_unreachable("Don't know how to promote alloca intrinsic use."); llvm_unreachable("Don't know how to promote alloca intrinsic use.");
} }
} }
return true; return true;
} }
FunctionPass *llvm::createAMDGPUPromoteAlloca() { FunctionPass *llvm::createAMDGPUPromoteAlloca() {
return new AMDGPUPromoteAlloca(); return new AMDGPUPromoteAlloca();
} }

llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp

Show First 20 Lines • Show All 1,888 Lines • ▼ Show 20 Lines auto SimplifyDemandedVectorEltsLow = [this](Value *Op, unsigned Width,
APInt UndefElts(Width, 0); APInt UndefElts(Width, 0);
APInt DemandedElts = APInt::getLowBitsSet(Width, DemandedWidth); APInt DemandedElts = APInt::getLowBitsSet(Width, DemandedWidth);
return SimplifyDemandedVectorElts(Op, DemandedElts, UndefElts); return SimplifyDemandedVectorElts(Op, DemandedElts, UndefElts);
}; };
switch (II->getIntrinsicID()) { switch (II->getIntrinsicID()) {
default: break; default: break;
case Intrinsic::objectsize: case Intrinsic::objectsize:
if (ConstantInt *N = if (Value *V = lowerObjectSizeCall(II, DL, &TLI, /*MustSucceed=*/false))
lowerObjectSizeCall(II, DL, &TLI, /*MustSucceed=*/false)) return replaceInstUsesWith(CI, V);
return replaceInstUsesWith(CI, N);
return nullptr; return nullptr;
case Intrinsic::bswap: { case Intrinsic::bswap: {
Value *IIOperand = II->getArgOperand(0); Value *IIOperand = II->getArgOperand(0);
Value *X = nullptr; Value *X = nullptr;
// bswap(trunc(bswap(x))) -> trunc(lshr(x, c)) // bswap(trunc(bswap(x))) -> trunc(lshr(x, c))
if (match(IIOperand, m_Trunc(m_BSwap(m_Value(X))))) { if (match(IIOperand, m_Trunc(m_BSwap(m_Value(X))))) {
unsigned C = X->getType()->getPrimitiveSizeInBits() - unsigned C = X->getType()->getPrimitiveSizeInBits() -
▲ Show 20 Lines • Show All 2,759 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp

Show First 20 Lines • Show All 2,289 Lines • ▼ Show 20 Lines for (unsigned i = 0, e = Users.size(); i != e; ++i) {
// use a bitcast/GEP of the alloca we are removing. // use a bitcast/GEP of the alloca we are removing.
if (!Users[i]) if (!Users[i])
continue; continue;
Instruction *I = cast<Instruction>(&*Users[i]); Instruction *I = cast<Instruction>(&*Users[i]);
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) { if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
if (II->getIntrinsicID() == Intrinsic::objectsize) { if (II->getIntrinsicID() == Intrinsic::objectsize) {
ConstantInt *Result = lowerObjectSizeCall(II, DL, &TLI, Value *Result =
/*MustSucceed=*/true); lowerObjectSizeCall(II, DL, &TLI, /*MustSucceed=*/true);
replaceInstUsesWith(*I, Result); replaceInstUsesWith(*I, Result);
eraseInstFromFunction(*I); eraseInstFromFunction(*I);
Users[i] = nullptr; // Skip examining in the next loop. Users[i] = nullptr; // Skip examining in the next loop.
} }
} }
} }
for (unsigned i = 0, e = Users.size(); i != e; ++i) { for (unsigned i = 0, e = Users.size(); i != e; ++i) {
if (!Users[i]) if (!Users[i])
▲ Show 20 Lines • Show All 1,229 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Instrumentation/BoundsChecking.cpp

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Linesstatic void insertBoundsCheck(Value *Or, BuilderTy IRB, GetTrapBBT GetTrapBB) {
// Create the conditional branch. // Create the conditional branch.
BranchInst::Create(GetTrapBB(IRB), Cont, Or, OldBB); BranchInst::Create(GetTrapBB(IRB), Cont, Or, OldBB);
} }
static bool addBoundsChecking(Function &F, TargetLibraryInfo &TLI, static bool addBoundsChecking(Function &F, TargetLibraryInfo &TLI,
ScalarEvolution &SE) { ScalarEvolution &SE) {
const DataLayout &DL = F.getParent()->getDataLayout(); const DataLayout &DL = F.getParent()->getDataLayout();
ObjectSizeOffsetEvaluator ObjSizeEval(DL, &TLI, F.getContext(), ObjectSizeOpts EvalOpts;
/*RoundToAlign=*/true); EvalOpts.RoundToAlign = true;
ObjectSizeOffsetEvaluator ObjSizeEval(DL, &TLI, F.getContext(), EvalOpts);
// check HANDLE_MEMORY_INST in include/llvm/Instruction.def for memory // check HANDLE_MEMORY_INST in include/llvm/Instruction.def for memory
// touching instructions // touching instructions
SmallVector<std::pair<Instruction *, Value *>, 4> TrapInfo; SmallVector<std::pair<Instruction *, Value *>, 4> TrapInfo;
for (Instruction &I : instructions(F)) { for (Instruction &I : instructions(F)) {
Value *Or = nullptr; Value *Or = nullptr;
BuilderTy IRB(I.getParent(), BasicBlock::iterator(&I), TargetFolder(DL)); BuilderTy IRB(I.getParent(), BasicBlock::iterator(&I), TargetFolder(DL));
if (LoadInst *LI = dyn_cast<LoadInst>(&I)) { if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

llvm/trunk/test/Assembler/auto_upgrade_intrinsics.ll

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Linesentry:
ret void ret void
} }
@a = private global [60 x i8] zeroinitializer, align 1 @a = private global [60 x i8] zeroinitializer, align 1
define i32 @test.objectsize() { define i32 @test.objectsize() {
; CHECK-LABEL: @test.objectsize( ; CHECK-LABEL: @test.objectsize(
; CHECK: @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false, i1 false) ; CHECK: @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false, i1 false, i1 false)
%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), i1 false)
ret i32 %s ret i32 %s
} }
declare i64 @llvm.objectsize.i64.p0i8(i8*, i1) nounwind readonly declare i64 @llvm.objectsize.i64.p0i8(i8*, i1) nounwind readonly
define i64 @test.objectsize.2() { define i64 @test.objectsize.2() {
; CHECK-LABEL: @test.objectsize.2( ; CHECK-LABEL: @test.objectsize.2(
; CHECK: @llvm.objectsize.i64.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false, i1 false) ; CHECK: @llvm.objectsize.i64.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false, i1 false, i1 false)
%s = call i64 @llvm.objectsize.i64.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false) %s = call i64 @llvm.objectsize.i64.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false)
ret i64 %s ret i64 %s
} }
declare <2 x double> @llvm.masked.load.v2f64(<2 x double>* %ptrs, i32, <2 x i1> %mask, <2 x double> %src0) declare <2 x double> @llvm.masked.load.v2f64(<2 x double>* %ptrs, i32, <2 x i1> %mask, <2 x double> %src0)
define <2 x double> @tests.masked.load(<2 x double>* %ptr, <2 x i1> %mask, <2 x double> %passthru) { define <2 x double> @tests.masked.load(<2 x double>* %ptr, <2 x i1> %mask, <2 x double> %passthru) {
; CHECK-LABEL: @tests.masked.load( ; CHECK-LABEL: @tests.masked.load(
; CHECK: @llvm.masked.load.v2f64.p0v2f64 ; CHECK: @llvm.masked.load.v2f64.p0v2f64
%res = call <2 x double> @llvm.masked.load.v2f64(<2 x double>* %ptr, i32 1, <2 x i1> %mask, <2 x double> %passthru) %res = call <2 x double> @llvm.masked.load.v2f64(<2 x double>* %ptr, i32 1, <2 x i1> %mask, <2 x double> %passthru)
ret <2 x double> %res ret <2 x double> %res
} }
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/AMDGPU/promote-alloca-mem-intrinsics.ll

; RUN: opt -S -mtriple=amdgcn-unknown-amdhsa -mcpu=kaveri -amdgpu-promote-alloca < %s | FileCheck %s ; RUN: opt -S -mtriple=amdgcn-unknown-amdhsa -mcpu=kaveri -amdgpu-promote-alloca < %s | FileCheck %s
declare void @llvm.memcpy.p0i8.p1i8.i32(i8* nocapture, i8 addrspace(1)* nocapture, i32, i1) #0 declare void @llvm.memcpy.p0i8.p1i8.i32(i8* nocapture, i8 addrspace(1)* nocapture, i32, i1) #0
declare void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* nocapture, i8* nocapture, i32, i1) #0 declare void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* nocapture, i8* nocapture, i32, i1) #0
declare void @llvm.memmove.p0i8.p1i8.i32(i8* nocapture, i8 addrspace(1)* nocapture, i32, i1) #0 declare void @llvm.memmove.p0i8.p1i8.i32(i8* nocapture, i8 addrspace(1)* nocapture, i32, i1) #0
declare void @llvm.memmove.p1i8.p0i8.i32(i8 addrspace(1)* nocapture, i8* nocapture, i32, i1) #0 declare void @llvm.memmove.p1i8.p0i8.i32(i8 addrspace(1)* nocapture, i8* nocapture, i32, i1) #0
declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1) #0 declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1) #0
declare i32 @llvm.objectsize.i32.p0i8(i8*, i1, i1) #1 declare i32 @llvm.objectsize.i32.p0i8(i8*, i1, i1, i1) #1
; CHECK-LABEL: @promote_with_memcpy( ; CHECK-LABEL: @promote_with_memcpy(
; CHECK: getelementptr inbounds [64 x [17 x i32]], [64 x [17 x i32]] addrspace(3)* @promote_with_memcpy.alloca, i32 0, i32 %{{[0-9]+}} ; CHECK: getelementptr inbounds [64 x [17 x i32]], [64 x [17 x i32]] addrspace(3)* @promote_with_memcpy.alloca, i32 0, i32 %{{[0-9]+}}
; CHECK: call void @llvm.memcpy.p3i8.p1i8.i32(i8 addrspace(3)* align 4 %alloca.bc, i8 addrspace(1)* align 4 %in.bc, i32 68, i1 false) ; CHECK: call void @llvm.memcpy.p3i8.p1i8.i32(i8 addrspace(3)* align 4 %alloca.bc, i8 addrspace(1)* align 4 %in.bc, i32 68, i1 false)
; CHECK: call void @llvm.memcpy.p1i8.p3i8.i32(i8 addrspace(1)* align 4 %out.bc, i8 addrspace(3)* align 4 %alloca.bc, i32 68, i1 false) ; CHECK: call void @llvm.memcpy.p1i8.p3i8.i32(i8 addrspace(1)* align 4 %out.bc, i8 addrspace(3)* align 4 %alloca.bc, i32 68, i1 false)
define amdgpu_kernel void @promote_with_memcpy(i32 addrspace(1)* %out, i32 addrspace(1)* %in) #0 { define amdgpu_kernel void @promote_with_memcpy(i32 addrspace(1)* %out, i32 addrspace(1)* %in) #0 {
%alloca = alloca [17 x i32], align 4 %alloca = alloca [17 x i32], align 4
%alloca.bc = bitcast [17 x i32]* %alloca to i8* %alloca.bc = bitcast [17 x i32]* %alloca to i8*
Show All 27 Linesdefine amdgpu_kernel void @promote_with_memset(i32 addrspace(1)* %out, i32 addrspace(1)* %in) #0 {
%in.bc = bitcast i32 addrspace(1)* %in to i8 addrspace(1)* %in.bc = bitcast i32 addrspace(1)* %in to i8 addrspace(1)*
%out.bc = bitcast i32 addrspace(1)* %out to i8 addrspace(1)* %out.bc = bitcast i32 addrspace(1)* %out to i8 addrspace(1)*
call void @llvm.memset.p0i8.i32(i8* align 4 %alloca.bc, i8 7, i32 68, i1 false) call void @llvm.memset.p0i8.i32(i8* align 4 %alloca.bc, i8 7, i32 68, i1 false)
ret void ret void
} }
; CHECK-LABEL: @promote_with_objectsize( ; CHECK-LABEL: @promote_with_objectsize(
; CHECK: [[PTR:%[0-9]+]] = getelementptr inbounds [64 x [17 x i32]], [64 x [17 x i32]] addrspace(3)* @promote_with_objectsize.alloca, i32 0, i32 %{{[0-9]+}} ; CHECK: [[PTR:%[0-9]+]] = getelementptr inbounds [64 x [17 x i32]], [64 x [17 x i32]] addrspace(3)* @promote_with_objectsize.alloca, i32 0, i32 %{{[0-9]+}}
; CHECK: call i32 @llvm.objectsize.i32.p3i8(i8 addrspace(3)* %alloca.bc, i1 false, i1 false) ; CHECK: call i32 @llvm.objectsize.i32.p3i8(i8 addrspace(3)* %alloca.bc, i1 false, i1 false, i1 false)
define amdgpu_kernel void @promote_with_objectsize(i32 addrspace(1)* %out) #0 { define amdgpu_kernel void @promote_with_objectsize(i32 addrspace(1)* %out) #0 {
%alloca = alloca [17 x i32], align 4 %alloca = alloca [17 x i32], align 4
%alloca.bc = bitcast [17 x i32]* %alloca to i8* %alloca.bc = bitcast [17 x i32]* %alloca to i8*
%size = call i32 @llvm.objectsize.i32.p0i8(i8* %alloca.bc, i1 false, i1 false) %size = call i32 @llvm.objectsize.i32.p0i8(i8* %alloca.bc, i1 false, i1 false, i1 false)
store i32 %size, i32 addrspace(1)* %out store i32 %size, i32 addrspace(1)* %out
ret void ret void
} }
attributes #0 = { nounwind "amdgpu-flat-work-group-size"="64,64" "amdgpu-waves-per-eu"="1,3" } attributes #0 = { nounwind "amdgpu-flat-work-group-size"="64,64" "amdgpu-waves-per-eu"="1,3" }
attributes #1 = { nounwind readnone } attributes #1 = { nounwind readnone }

llvm/trunk/test/CodeGen/X86/is-constant.ll

Show All 9 Lines
;; This isn't asserting any specific output from non-optimized runs, ;; This isn't asserting any specific output from non-optimized runs,
;; (e.g., currently the not-taken branch does not get eliminated). But ;; (e.g., currently the not-taken branch does not get eliminated). But
;; it does ensure that lowering succeeds in all 3 codegen paths. ;; it does ensure that lowering succeeds in all 3 codegen paths.
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare i1 @llvm.is.constant.i32(i32 %a) nounwind readnone declare i1 @llvm.is.constant.i32(i32 %a) nounwind readnone
declare i1 @llvm.is.constant.i64(i64 %a) nounwind readnone declare i1 @llvm.is.constant.i64(i64 %a) nounwind readnone
declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1) nounwind readnone declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1, i1) nounwind readnone
declare i32 @subfun_1() declare i32 @subfun_1()
declare i32 @subfun_2() declare i32 @subfun_2()
define i32 @test_branch(i32 %in) nounwind { define i32 @test_branch(i32 %in) nounwind {
; CHECK-LABEL: test_branch: ; CHECK-LABEL: test_branch:
; CHECK-O2: %bb.0: ; CHECK-O2: %bb.0:
; CHECK-O2-NEXT: jmp subfun_2 ; CHECK-O2-NEXT: jmp subfun_2
Show All 12 Lines
;; llvm.objectsize is another tricky case which gets folded to -1 very ;; llvm.objectsize is another tricky case which gets folded to -1 very
;; late in the game. We'd like to ensure that llvm.is.constant of ;; late in the game. We'd like to ensure that llvm.is.constant of
;; llvm.objectsize is true. ;; llvm.objectsize is true.
define i1 @test_objectsize(i8* %obj) nounwind { define i1 @test_objectsize(i8* %obj) nounwind {
; CHECK-LABEL: test_objectsize: ; CHECK-LABEL: test_objectsize:
; CHECK-O2: %bb.0: ; CHECK-O2: %bb.0:
; CHECK-O2: movb $1, %al ; CHECK-O2: movb $1, %al
; CHECK-O2-NEXT: retq ; CHECK-O2-NEXT: retq
%os = call i64 @llvm.objectsize.i64.p0i8(i8* %obj, i1 false, i1 false) %os = call i64 @llvm.objectsize.i64.p0i8(i8* %obj, i1 false, i1 false, i1 false)
%v = call i1 @llvm.is.constant.i64(i64 %os) %v = call i1 @llvm.is.constant.i64(i64 %os)
ret i1 %v ret i1 %v
} }

llvm/trunk/test/Other/cgscc-libcall-update.ll

Show All 9 Lines
define i8* @wibble(i8* %arg1, i8* %arg2) { define i8* @wibble(i8* %arg1, i8* %arg2) {
; CHECK-LABEL: define i8* @wibble( ; CHECK-LABEL: define i8* @wibble(
bb: bb:
%tmp = alloca [1024 x i8], align 16 %tmp = alloca [1024 x i8], align 16
%tmp2 = getelementptr inbounds [1024 x i8], [1024 x i8]* %tmp, i64 0, i64 0 %tmp2 = getelementptr inbounds [1024 x i8], [1024 x i8]* %tmp, i64 0, i64 0
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp2, i8* %arg1, i64 1024, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp2, i8* %arg1, i64 1024, i1 false)
; CHECK: call void @llvm.memcpy ; CHECK: call void @llvm.memcpy
%tmp3 = call i64 @llvm.objectsize.i64.p0i8(i8* %tmp2, i1 false, i1 true) %tmp3 = call i64 @llvm.objectsize.i64.p0i8(i8* %tmp2, i1 false, i1 true, i1 false)
%tmp4 = call i8* @__strncpy_chk(i8* %arg2, i8* %tmp2, i64 1023, i64 %tmp3) %tmp4 = call i8* @__strncpy_chk(i8* %arg2, i8* %tmp2, i64 1023, i64 %tmp3)
; CHECK-NOT: call ; CHECK-NOT: call
; CHECK: call i8* @strncpy(i8* %arg2, i8* nonnull %tmp2, i64 1023) ; CHECK: call i8* @strncpy(i8* %arg2, i8* nonnull %tmp2, i64 1023)
; CHECK-NOT: call ; CHECK-NOT: call
ret i8* %tmp4 ret i8* %tmp4
; CHECK: ret ; CHECK: ret
} }
define i8* @strncpy(i8* %arg1, i8* %arg2, i64 %size) noinline { define i8* @strncpy(i8* %arg1, i8* %arg2, i64 %size) noinline {
bb: bb:
%result = call i8* @my_special_strncpy(i8* %arg1, i8* %arg2, i64 %size) %result = call i8* @my_special_strncpy(i8* %arg1, i8* %arg2, i64 %size)
ret i8* %result ret i8* %result
} }
declare i8* @my_special_strncpy(i8* %arg1, i8* %arg2, i64 %size) declare i8* @my_special_strncpy(i8* %arg1, i8* %arg2, i64 %size)
declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1) declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1, i1)
declare i8* @__strncpy_chk(i8*, i8*, i64, i64) declare i8* @__strncpy_chk(i8*, i8*, i64, i64)
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
; Check that even when we completely remove a libcall we don't get the call ; Check that even when we completely remove a libcall we don't get the call
; graph wrong once we handle libcalls in the call graph specially to address ; graph wrong once we handle libcalls in the call graph specially to address
; the above case. ; the above case.
Show All 32 Lines

llvm/trunk/test/Transforms/CodeGenPrepare/basic.ll

; RUN: opt -codegenprepare -S < %s | FileCheck %s ; 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 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" target triple = "x86_64-apple-darwin10.0.0"
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; objectsize should fold to a constant, which causes the branch to fold to an ; objectsize should fold to a constant, which causes the branch to fold to an
; uncond branch. Next, we fold the control flow alltogether. ; uncond branch. Next, we fold the control flow alltogether.
; rdar://8785296 ; rdar://8785296
define i32 @test1(i8* %ptr) nounwind ssp noredzone align 2 { define i32 @test1(i8* %ptr) nounwind ssp noredzone align 2 {
entry: entry:
%0 = tail call i64 @llvm.objectsize.i64(i8* %ptr, i1 false, i1 false) %0 = tail call i64 @llvm.objectsize.i64(i8* %ptr, i1 false, i1 false, i1 false)
%1 = icmp ugt i64 %0, 3 %1 = icmp ugt i64 %0, 3
br i1 %1, label %T, label %trap br i1 %1, label %T, label %trap
; CHECK: entry: ; CHECK: entry:
; CHECK-NOT: br label % ; CHECK-NOT: br label %
trap: ; preds = %0, %entry trap: ; preds = %0, %entry
tail call void @llvm.trap() noreturn nounwind tail call void @llvm.trap() noreturn nounwind
unreachable unreachable
T: T:
; CHECK: ret i32 4 ; CHECK: ret i32 4
ret i32 4 ret i32 4
} }
; CHECK-LABEL: @test_objectsize_null_flag( ; CHECK-LABEL: @test_objectsize_null_flag(
define i64 @test_objectsize_null_flag(i8* %ptr) { define i64 @test_objectsize_null_flag(i8* %ptr) {
entry: entry:
; CHECK: ret i64 -1 ; CHECK: ret i64 -1
%0 = tail call i64 @llvm.objectsize.i64(i8* null, i1 false, i1 true) %0 = tail call i64 @llvm.objectsize.i64(i8* null, i1 false, i1 true, i1 false)
ret i64 %0 ret i64 %0
} }
; CHECK-LABEL: @test_objectsize_null_flag_min( ; CHECK-LABEL: @test_objectsize_null_flag_min(
define i64 @test_objectsize_null_flag_min(i8* %ptr) { define i64 @test_objectsize_null_flag_min(i8* %ptr) {
entry: entry:
; CHECK: ret i64 0 ; CHECK: ret i64 0
%0 = tail call i64 @llvm.objectsize.i64(i8* null, i1 true, i1 true) %0 = tail call i64 @llvm.objectsize.i64(i8* null, i1 true, i1 true, i1 false)
ret i64 %0 ret i64 %0
} }
; Test foldable null pointers because we evaluate them with non-exact modes in ; Test foldable null pointers because we evaluate them with non-exact modes in
; CodeGenPrepare. ; CodeGenPrepare.
; CHECK-LABEL: @test_objectsize_null_flag_noas0( ; CHECK-LABEL: @test_objectsize_null_flag_noas0(
define i64 @test_objectsize_null_flag_noas0() { define i64 @test_objectsize_null_flag_noas0() {
entry: entry:
; CHECK: ret i64 -1 ; CHECK: ret i64 -1
%0 = tail call i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)* null, i1 false, %0 = tail call i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)* null, i1 false,
i1 true) i1 true, i1 false)
ret i64 %0 ret i64 %0
} }
; CHECK-LABEL: @test_objectsize_null_flag_min_noas0( ; CHECK-LABEL: @test_objectsize_null_flag_min_noas0(
define i64 @test_objectsize_null_flag_min_noas0() { define i64 @test_objectsize_null_flag_min_noas0() {
entry: entry:
; CHECK: ret i64 0 ; CHECK: ret i64 0
%0 = tail call i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)* null, i1 true, %0 = tail call i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)* null, i1 true,
i1 true) i1 true, i1 false)
ret i64 %0 ret i64 %0
} }
; CHECK-LABEL: @test_objectsize_null_known_flag_noas0 ; CHECK-LABEL: @test_objectsize_null_known_flag_noas0
define i64 @test_objectsize_null_known_flag_noas0() { define i64 @test_objectsize_null_known_flag_noas0() {
entry: entry:
; CHECK: ret i64 -1 ; CHECK: ret i64 -1
%0 = tail call i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)* null, i1 false, %0 = tail call i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)* null, i1 false,
i1 false) i1 false, i1 false)
ret i64 %0 ret i64 %0
} }
; CHECK-LABEL: @test_objectsize_null_known_flag_min_noas0 ; CHECK-LABEL: @test_objectsize_null_known_flag_min_noas0
define i64 @test_objectsize_null_known_flag_min_noas0() { define i64 @test_objectsize_null_known_flag_min_noas0() {
entry: entry:
; CHECK: ret i64 0 ; CHECK: ret i64 0
%0 = tail call i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)* null, i1 true, %0 = tail call i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)* null, i1 true,
i1 false) i1 false, i1 false)
ret i64 %0 ret i64 %0
} }
declare i64 @llvm.objectsize.i64(i8*, i1, i1) nounwind readonly declare i64 @llvm.objectsize.i64(i8*, i1, i1, i1) nounwind readonly
declare i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)*, i1, i1) nounwind readonly declare i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)*, i1, i1, i1) nounwind readonly
declare void @llvm.trap() nounwind declare void @llvm.trap() nounwind

llvm/trunk/test/Transforms/CodeGenPrepare/crash-on-large-allocas.ll

; RUN: opt -S -codegenprepare %s -o - | FileCheck %s ; RUN: opt -S -codegenprepare %s -o - | FileCheck %s
; ;
; Ensure that we don't {crash,return a bad value} when given an alloca larger ; Ensure that we don't {crash,return a bad value} when given an alloca larger
; than what a pointer can represent. ; than what a pointer can represent.
target datalayout = "p:16:16" target datalayout = "p:16:16"
; CHECK-LABEL: @alloca_overflow_is_unknown( ; CHECK-LABEL: @alloca_overflow_is_unknown(
define i16 @alloca_overflow_is_unknown() { define i16 @alloca_overflow_is_unknown() {
%i = alloca i8, i32 65537 %i = alloca i8, i32 65537
%j = call i16 @llvm.objectsize.i16.p0i8(i8* %i, i1 false, i1 false) %j = call i16 @llvm.objectsize.i16.p0i8(i8* %i, i1 false, i1 false, i1 false)
; CHECK: ret i16 -1 ; CHECK: ret i16 -1
ret i16 %j ret i16 %j
} }
declare i16 @llvm.objectsize.i16.p0i8(i8*, i1, i1) declare i16 @llvm.objectsize.i16.p0i8(i8*, i1, i1, i1)

llvm/trunk/test/Transforms/InferAddressSpaces/AMDGPU/intrinsics.ll

; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -infer-address-spaces %s | FileCheck %s ; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -infer-address-spaces %s | FileCheck %s
; CHECK-LABEL: @objectsize_group_to_flat_i32( ; CHECK-LABEL: @objectsize_group_to_flat_i32(
; CHECK: %val = call i32 @llvm.objectsize.i32.p3i8(i8 addrspace(3)* %group.ptr, i1 true, i1 false) ; CHECK: %val = call i32 @llvm.objectsize.i32.p3i8(i8 addrspace(3)* %group.ptr, i1 true, i1 false, i1 false)
define i32 @objectsize_group_to_flat_i32(i8 addrspace(3)* %group.ptr) #0 { define i32 @objectsize_group_to_flat_i32(i8 addrspace(3)* %group.ptr) #0 {
%cast = addrspacecast i8 addrspace(3)* %group.ptr to i8* %cast = addrspacecast i8 addrspace(3)* %group.ptr to i8*
%val = call i32 @llvm.objectsize.i32.p0i8(i8* %cast, i1 true, i1 false) %val = call i32 @llvm.objectsize.i32.p0i8(i8* %cast, i1 true, i1 false, i1 false)
ret i32 %val ret i32 %val
} }
; CHECK-LABEL: @objectsize_global_to_flat_i64( ; CHECK-LABEL: @objectsize_global_to_flat_i64(
; CHECK: %val = call i64 @llvm.objectsize.i64.p3i8(i8 addrspace(3)* %global.ptr, i1 true, i1 false) ; CHECK: %val = call i64 @llvm.objectsize.i64.p3i8(i8 addrspace(3)* %global.ptr, i1 true, i1 false, i1 false)
define i64 @objectsize_global_to_flat_i64(i8 addrspace(3)* %global.ptr) #0 { define i64 @objectsize_global_to_flat_i64(i8 addrspace(3)* %global.ptr) #0 {
%cast = addrspacecast i8 addrspace(3)* %global.ptr to i8* %cast = addrspacecast i8 addrspace(3)* %global.ptr to i8*
%val = call i64 @llvm.objectsize.i64.p0i8(i8* %cast, i1 true, i1 false) %val = call i64 @llvm.objectsize.i64.p0i8(i8* %cast, i1 true, i1 false, i1 false)
ret i64 %val ret i64 %val
} }
; CHECK-LABEL: @atomicinc_global_to_flat_i32( ; CHECK-LABEL: @atomicinc_global_to_flat_i32(
; CHECK: call i32 @llvm.amdgcn.atomic.inc.i32.p1i32(i32 addrspace(1)* %global.ptr, i32 %y, i32 0, i32 0, i1 false) ; CHECK: call i32 @llvm.amdgcn.atomic.inc.i32.p1i32(i32 addrspace(1)* %global.ptr, i32 %y, i32 0, i32 0, i1 false)
define i32 @atomicinc_global_to_flat_i32(i32 addrspace(1)* %global.ptr, i32 %y) #0 { define i32 @atomicinc_global_to_flat_i32(i32 addrspace(1)* %global.ptr, i32 %y) #0 {
%cast = addrspacecast i32 addrspace(1)* %global.ptr to i32* %cast = addrspacecast i32 addrspace(1)* %global.ptr to i32*
%ret = call i32 @llvm.amdgcn.atomic.inc.i32.p0i32(i32* %cast, i32 %y, i32 0, i32 0, i1 false) %ret = call i32 @llvm.amdgcn.atomic.inc.i32.p0i32(i32* %cast, i32 %y, i32 0, i32 0, i1 false)
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
; CHECK-NEXT: %1 = addrspacecast i64 addrspace(3)* %group.ptr to i64* ; CHECK-NEXT: %1 = addrspacecast i64 addrspace(3)* %group.ptr to i64*
; CHECK-NEXT: %ret = call i64 @llvm.amdgcn.atomic.inc.i64.p0i64(i64* %1, i64 %y, i32 0, i32 0, i1 %volatile.var) ; CHECK-NEXT: %ret = call i64 @llvm.amdgcn.atomic.inc.i64.p0i64(i64* %1, i64 %y, i32 0, i32 0, i1 %volatile.var)
define i64 @invalid_variable_volatile_atomicinc_group_to_flat_i64(i64 addrspace(3)* %group.ptr, i64 %y, i1 %volatile.var) #0 { define i64 @invalid_variable_volatile_atomicinc_group_to_flat_i64(i64 addrspace(3)* %group.ptr, i64 %y, i1 %volatile.var) #0 {
%cast = addrspacecast i64 addrspace(3)* %group.ptr to i64* %cast = addrspacecast i64 addrspace(3)* %group.ptr to i64*
%ret = call i64 @llvm.amdgcn.atomic.inc.i64.p0i64(i64* %cast, i64 %y, i32 0, i32 0, i1 %volatile.var) %ret = call i64 @llvm.amdgcn.atomic.inc.i64.p0i64(i64* %cast, i64 %y, i32 0, i32 0, i1 %volatile.var)
ret i64 %ret ret i64 %ret
} }
declare i32 @llvm.objectsize.i32.p0i8(i8*, i1, i1) #1 declare i32 @llvm.objectsize.i32.p0i8(i8*, i1, i1, i1) #1
declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1) #1 declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1, i1) #1
declare i32 @llvm.amdgcn.atomic.inc.i32.p0i32(i32* nocapture, i32, i32, i32, i1) #2 declare i32 @llvm.amdgcn.atomic.inc.i32.p0i32(i32* nocapture, i32, i32, i32, i1) #2
declare i64 @llvm.amdgcn.atomic.inc.i64.p0i64(i64* nocapture, i64, i32, i32, i1) #2 declare i64 @llvm.amdgcn.atomic.inc.i64.p0i64(i64* nocapture, i64, i32, i32, i1) #2
declare i32 @llvm.amdgcn.atomic.dec.i32.p0i32(i32* nocapture, i32, i32, i32, i1) #2 declare i32 @llvm.amdgcn.atomic.dec.i32.p0i32(i32* nocapture, i32, i32, i32, i1) #2
declare i64 @llvm.amdgcn.atomic.dec.i64.p0i64(i64* nocapture, i64, i32, i32, i1) #2 declare i64 @llvm.amdgcn.atomic.dec.i64.p0i64(i64* nocapture, i64, i32, i32, i1) #2
attributes #0 = { nounwind } attributes #0 = { nounwind }
attributes #1 = { nounwind readnone } attributes #1 = { nounwind readnone }
attributes #2 = { nounwind argmemonly } attributes #2 = { nounwind argmemonly }

llvm/trunk/test/Transforms/InstCombine/builtin-dynamic-object-size.ll

; RUN: opt -instcombine -S < %s | FileCheck %s --dump-input-on-failure
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.14.0"
; Function Attrs: nounwind ssp uwtable
define i64 @weird_identity_but_ok(i64 %sz) {
entry:
%call = tail call i8* @malloc(i64 %sz)
%calc_size = tail call i64 @llvm.objectsize.i64.p0i8(i8* %call, i1 false, i1 true, i1 true)
tail call void @free(i8* %call)
ret i64 %calc_size
}
; CHECK: define i64 @weird_identity_but_ok(i64 %sz)
; CHECK-NEXT: entry:
; CHECK-NEXT: ret i64 %sz
; CHECK-NEXT: }
define i64 @phis_are_neat(i1 %which) {
entry:
br i1 %which, label %first_label, label %second_label
first_label:
%first_call = call i8* @malloc(i64 10)
br label %join_label
second_label:
%second_call = call i8* @malloc(i64 30)
br label %join_label
join_label:
%joined = phi i8* [ %first_call, %first_label ], [ %second_call, %second_label ]
%calc_size = tail call i64 @llvm.objectsize.i64.p0i8(i8* %joined, i1 false, i1 true, i1 true)
ret i64 %calc_size
}
; CHECK: %0 = phi i64 [ 10, %first_label ], [ 30, %second_label ]
; CHECK-NEXT: ret i64 %0
define i64 @internal_pointer(i64 %sz) {
entry:
%ptr = call i8* @malloc(i64 %sz)
%ptr2 = getelementptr inbounds i8, i8* %ptr, i32 2
%calc_size = call i64 @llvm.objectsize.i64.p0i8(i8* %ptr2, i1 false, i1 true, i1 true)
ret i64 %calc_size
}
; CHECK: define i64 @internal_pointer(i64 %sz)
; CHECK-NEXT: entry:
; CHECK-NEXT: %0 = add i64 %sz, -2
; CHECK-NEXT: %1 = icmp ult i64 %sz, 2
; CHECK-NEXT: %2 = select i1 %1, i64 0, i64 %0
; CHECK-NEXT: ret i64 %2
; CHECK-NEXT: }
define i64 @uses_nullptr_no_fold() {
entry:
%res = call i64 @llvm.objectsize.i64.p0i8(i8* null, i1 false, i1 true, i1 true)
ret i64 %res
}
; CHECK: %res = call i64 @llvm.objectsize.i64.p0i8(i8* null, i1 false, i1 true, i1 true)
define i64 @uses_nullptr_fold() {
entry:
; NOTE: the third parameter to this call is false, unlike above.
%res = call i64 @llvm.objectsize.i64.p0i8(i8* null, i1 false, i1 false, i1 true)
ret i64 %res
}
; CHECK: ret i64 0
; Function Attrs: nounwind allocsize(0)
declare i8* @malloc(i64)
declare i8* @get_unknown_buffer()
; Function Attrs: nounwind
declare void @free(i8* nocapture)
; Function Attrs: nounwind readnone speculatable
declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1, i1)

llvm/trunk/test/Transforms/InstCombine/invoke.ll

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
; CHECK-LABEL: @f2_no_null_opt( ; CHECK-LABEL: @f2_no_null_opt(
define i64 @f2_no_null_opt() nounwind uwtable ssp #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { define i64 @f2_no_null_opt() nounwind uwtable ssp #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
entry: entry:
; CHECK: invoke noalias i8* null() ; CHECK: invoke noalias i8* null()
%call = invoke noalias i8* null() %call = invoke noalias i8* null()
to label %invoke.cont unwind label %lpad to label %invoke.cont unwind label %lpad
invoke.cont: invoke.cont:
; CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %call, i1 false, i1 false) ; CHECK: call i64 @llvm.objectsize.i64.p0i8(i8* %call, i1 false, i1 false, i1 false)
%0 = tail call i64 @llvm.objectsize.i64(i8* %call, i1 false) %0 = tail call i64 @llvm.objectsize.i64(i8* %call, i1 false)
ret i64 %0 ret i64 %0
lpad: lpad:
%1 = landingpad { i8*, i32 } %1 = landingpad { i8*, i32 }
filter [0 x i8*] zeroinitializer filter [0 x i8*] zeroinitializer
%2 = extractvalue { i8*, i32 } %1, 0 %2 = extractvalue { i8*, i32 } %1, 0
tail call void @__cxa_call_unexpected(i8* %2) noreturn nounwind tail call void @__cxa_call_unexpected(i8* %2) noreturn nounwind
Show All 20 Lines

llvm/trunk/test/Transforms/InstCombine/memset_chk-1.ll

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
} }
; Test that RAUW in SimplifyLibCalls for __memset_chk generates valid IR ; Test that RAUW in SimplifyLibCalls for __memset_chk generates valid IR
define i32 @test_rauw(i8* %a, i8* %b, i8** %c) { define i32 @test_rauw(i8* %a, i8* %b, i8** %c) {
; CHECK-LABEL: test_rauw ; CHECK-LABEL: test_rauw
entry: entry:
%call49 = call i64 @strlen(i8* %a) %call49 = call i64 @strlen(i8* %a)
%add180 = add i64 %call49, 1 %add180 = add i64 %call49, 1
%yo107 = call i64 @llvm.objectsize.i64.p0i8(i8* %b, i1 false, i1 false) %yo107 = call i64 @llvm.objectsize.i64.p0i8(i8* %b, i1 false, i1 false, i1 false)
%call50 = call i8* @__memmove_chk(i8* %b, i8* %a, i64 %add180, i64 %yo107) %call50 = call i8* @__memmove_chk(i8* %b, i8* %a, i64 %add180, i64 %yo107)
; CHECK: %strlen = call i64 @strlen(i8* %b) ; CHECK: %strlen = call i64 @strlen(i8* %b)
; CHECK-NEXT: %strchr2 = getelementptr i8, i8* %b, i64 %strlen ; CHECK-NEXT: %strchr2 = getelementptr i8, i8* %b, i64 %strlen
%call51i = call i8* @strrchr(i8* %b, i32 0) %call51i = call i8* @strrchr(i8* %b, i32 0)
%d = load i8*, i8** %c, align 8 %d = load i8*, i8** %c, align 8
%sub182 = ptrtoint i8* %d to i64 %sub182 = ptrtoint i8* %d to i64
%sub183 = ptrtoint i8* %b to i64 %sub183 = ptrtoint i8* %b to i64
%sub184 = sub i64 %sub182, %sub183 %sub184 = sub i64 %sub182, %sub183
%add52.i.i = add nsw i64 %sub184, 1 %add52.i.i = add nsw i64 %sub184, 1
; CHECK: call void @llvm.memset.p0i8.i64(i8* align 1 %strchr2 ; CHECK: call void @llvm.memset.p0i8.i64(i8* align 1 %strchr2
%call185 = call i8* @__memset_chk(i8* %call51i, i32 0, i64 %add52.i.i, i64 -1) %call185 = call i8* @__memset_chk(i8* %call51i, i32 0, i64 %add52.i.i, i64 -1)
ret i32 4 ret i32 4
} }
declare i8* @__memmove_chk(i8*, i8*, i64, i64) declare i8* @__memmove_chk(i8*, i8*, i64, i64)
declare i8* @strrchr(i8*, i32) declare i8* @strrchr(i8*, i32)
declare i64 @strlen(i8* nocapture) declare i64 @strlen(i8* nocapture)
declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1) declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1, i1)
declare i8* @__memset_chk(i8*, i32, i64, i64) declare i8* @__memset_chk(i8*, i32, i64, i64)
; FIXME: memset(malloc(x), 0, x) -> calloc(1, x) ; FIXME: memset(malloc(x), 0, x) -> calloc(1, x)
define float* @pr25892(i64 %size) #0 { define float* @pr25892(i64 %size) #0 {
entry: entry:
%call = tail call i8* @malloc(i64 %size) #1 %call = tail call i8* @malloc(i64 %size) #1
%cmp = icmp eq i8* %call, null %cmp = icmp eq i8* %call, null
br i1 %cmp, label %cleanup, label %if.end br i1 %cmp, label %cleanup, label %if.end
if.end: if.end:
%bc = bitcast i8* %call to float* %bc = bitcast i8* %call to float*
%call2 = tail call i64 @llvm.objectsize.i64.p0i8(i8* nonnull %call, i1 false, i1 false) %call2 = tail call i64 @llvm.objectsize.i64.p0i8(i8* nonnull %call, i1 false, i1 false, i1 false)
%call3 = tail call i8* @__memset_chk(i8* nonnull %call, i32 0, i64 %size, i64 %call2) #1 %call3 = tail call i8* @__memset_chk(i8* nonnull %call, i32 0, i64 %size, i64 %call2) #1
br label %cleanup br label %cleanup
cleanup: cleanup:
%retval.0 = phi float* [ %bc, %if.end ], [ null, %entry ] %retval.0 = phi float* [ %bc, %if.end ], [ null, %entry ]
ret float* %retval.0 ret float* %retval.0
; CHECK-LABEL: @pr25892( ; CHECK-LABEL: @pr25892(
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: %call = tail call i8* @malloc(i64 %size) ; CHECK-NEXT: %call = tail call i8* @malloc(i64 %size)
; CHECK-NEXT: %cmp = icmp eq i8* %call, null ; CHECK-NEXT: %cmp = icmp eq i8* %call, null
; CHECK-NEXT: br i1 %cmp, label %cleanup, label %if.end ; CHECK-NEXT: br i1 %cmp, label %cleanup, label %if.end
; CHECK: if.end: ; CHECK: if.end:
; CHECK-NEXT: %bc = bitcast i8* %call to float* ; CHECK-NEXT: %bc = bitcast i8* %call to float*
; CHECK-NEXT: %call2 = tail call i64 @llvm.objectsize.i64.p0i8(i8* nonnull %call, i1 false, i1 false) ; CHECK-NEXT: %call2 = tail call i64 @llvm.objectsize.i64.p0i8(i8* nonnull %call, i1 false, i1 false, i1 false)
; CHECK-NEXT: %call3 = tail call i8* @__memset_chk(i8* nonnull %call, i32 0, i64 %size, i64 %call2) ; CHECK-NEXT: %call3 = tail call i8* @__memset_chk(i8* nonnull %call, i32 0, i64 %size, i64 %call2)
; CHECK-NEXT: br label %cleanup ; CHECK-NEXT: br label %cleanup
; CHECK: cleanup: ; CHECK: cleanup:
; CHECK-NEXT: %retval.0 = phi float* [ %bc, %if.end ], [ null, %entry ] ; CHECK-NEXT: %retval.0 = phi float* [ %bc, %if.end ], [ null, %entry ]
; CHECK-NEXT: ret float* %retval.0 ; CHECK-NEXT: ret float* %retval.0
} }
declare noalias i8* @malloc(i64) #1 declare noalias i8* @malloc(i64) #1
attributes #0 = { nounwind ssp uwtable } attributes #0 = { nounwind ssp uwtable }
attributes #1 = { nounwind } attributes #1 = { nounwind }
attributes #2 = { nounwind readnone } attributes #2 = { nounwind readnone }

llvm/trunk/test/Transforms/InstCombine/objsize.ll

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

llvm/trunk/test/Transforms/InstCombine/stpcpy_chk-1.ll

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
; Check case where the string length is not constant. ; Check case where the string length is not constant.
define i8* @test_simplify5() { define i8* @test_simplify5() {
; CHECK-LABEL: @test_simplify5( ; CHECK-LABEL: @test_simplify5(
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %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 %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, 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), i1 false, i1 false, i1 false)
; 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: %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) ; 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, i1 false) %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i1 false, i1 false, i1 false)
%ret = call i8* @__stpcpy_chk(i8* %dst, i8* %src, i32 %len) %ret = call i8* @__stpcpy_chk(i8* %dst, i8* %src, i32 %len)
ret i8* %ret ret i8* %ret
} }
; Check case where the source and destination are the same. ; Check case where the source and destination are the same.
define i8* @test_simplify6() { define i8* @test_simplify6() {
; CHECK-LABEL: @test_simplify6( ; CHECK-LABEL: @test_simplify6(
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %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: %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: %1 = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 %strlen
; CHECK-NEXT: ret i8* %1 ; CHECK-NEXT: ret i8* %1
%len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i1 false, i1 false) %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i1 false, i1 false, i1 false)
%ret = call i8* @__stpcpy_chk(i8* %dst, i8* %dst, i32 %len) %ret = call i8* @__stpcpy_chk(i8* %dst, i8* %dst, i32 %len)
ret i8* %ret ret i8* %ret
} }
; Check case where slen < strlen (src). ; Check case where slen < strlen (src).
define i8* @test_no_simplify1() { define i8* @test_no_simplify1() {
; CHECK-LABEL: @test_no_simplify1( ; CHECK-LABEL: @test_no_simplify1(
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %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 %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 = 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 ; CHECK-NEXT: ret i8* %ret
%ret = call i8* @__stpcpy_chk(i8* %dst, i8* %src, i32 8) %ret = call i8* @__stpcpy_chk(i8* %dst, i8* %src, i32 8)
ret i8* %ret ret i8* %ret
} }
declare i8* @__stpcpy_chk(i8*, i8*, i32) nounwind declare i8* @__stpcpy_chk(i8*, i8*, i32) nounwind
declare i32 @llvm.objectsize.i32.p0i8(i8*, i1, i1) nounwind readonly declare i32 @llvm.objectsize.i32.p0i8(i8*, i1, i1, i1) nounwind readonly

llvm/trunk/test/Transforms/InstCombine/strcpy_chk-1.ll

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
; Check case where the string length is not constant. ; Check case where the string length is not constant.
define i8* @test_simplify5() { define i8* @test_simplify5() {
; CHECK-LABEL: @test_simplify5( ; CHECK-LABEL: @test_simplify5(
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %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 %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, 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), i1 false, i1 false, i1 false)
; 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: %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 ; CHECK-NEXT: ret i8* %1
%len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i1 false, i1 false) %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i1 false, i1 false, i1 false)
%ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 %len) %ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 %len)
ret i8* %ret ret i8* %ret
} }
; Check case where the source and destination are the same. ; Check case where the source and destination are the same.
define i8* @test_simplify6() { define i8* @test_simplify6() {
; CHECK-LABEL: @test_simplify6( ; CHECK-LABEL: @test_simplify6(
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %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, 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), i1 false, i1 false, i1 false)
; 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 = 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 ; CHECK-NEXT: ret i8* %ret
%len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i1 false, i1 false) %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i1 false, i1 false, i1 false)
%ret = call i8* @__strcpy_chk(i8* %dst, i8* %dst, i32 %len) %ret = call i8* @__strcpy_chk(i8* %dst, i8* %dst, i32 %len)
ret i8* %ret ret i8* %ret
} }
; Check case where slen < strlen (src). ; Check case where slen < strlen (src).
define i8* @test_no_simplify1() { define i8* @test_no_simplify1() {
; CHECK-LABEL: @test_no_simplify1( ; CHECK-LABEL: @test_no_simplify1(
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %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 %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 = 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 ; CHECK-NEXT: ret i8* %ret
%ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 8) %ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 8)
ret i8* %ret ret i8* %ret
} }
declare i8* @__strcpy_chk(i8*, i8*, i32) nounwind declare i8* @__strcpy_chk(i8*, i8*, i32) nounwind
declare i32 @llvm.objectsize.i32.p0i8(i8*, i1, i1) nounwind readonly declare i32 @llvm.objectsize.i32.p0i8(i8*, i1, i1, i1) nounwind readonly