This is an archive of the discontinued LLVM Phabricator instance.

Differential D53666

[Tests] Updated tests for D53342
AbandonedPublic

Authored by xbolva00 on Oct 24 2018, 12:50 PM.

Details

Reviewers
efriedma

Diff Detail

Repository
rC Clang

Event Timeline

xbolva00 created this revision.Oct 24 2018, 12:50 PM
Herald added subscribers: cfe-commits, nhaehnle, jvesely. · View Herald TranscriptOct 24 2018, 12:50 PM
xbolva00 added a reviewer: efriedma.Oct 24 2018, 12:55 PM
efriedma added inline comments.Oct 24 2018, 1:02 PM
test/CodeGenOpenCL/amdgpu-nullptr.cl
513

This shouldn't change. "null" pointers are potentially valid in non-zero address-spaces. (Sorry, I should have spotted this sooner.)

xbolva00 added inline comments.Oct 24 2018, 1:15 PM
test/CodeGenOpenCL/amdgpu-nullptr.cl
513

Thanks, I will fix this case.

xbolva00 updated this revision to Diff 170963.Oct 24 2018, 1:17 PM
nhaehnle removed a subscriber: nhaehnle.Oct 27 2018, 8:07 AM
xbolva00 updated this revision to Diff 171906.Oct 31 2018, 6:41 AM
xbolva00 updated this revision to Diff 171908.Oct 31 2018, 6:44 AM
xbolva00 abandoned this revision.Aug 18 2019, 9:04 AM

Will be handled as NFC commit after D53342 lands.

Revision Contents

PathSize
test/
CodeGen/
14 lines
CodeGenOpenCL/
2 lines

Diff 170956

test/CodeGen/tbaa-struct.cpp

Show All 11 Linesstruct A {
char c; char c;
int j; int j;
}; };
typedef A __attribute__((may_alias)) AA; typedef A __attribute__((may_alias)) AA;
void copy(A *a1, A *a2) { void copy(A *a1, A *a2) {
// CHECK-LABEL: _Z4copyP1AS0_ // CHECK-LABEL: _Z4copyP1AS0_
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %{{.*}}, i8* align 4 %{{.*}}, i64 16, i1 false) // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 4 %{{.*}}, i8* nonnull align 4 %{{.*}}, i64 16, i1 false)
// CHECK-OLD-SAME: !tbaa.struct [[TS:!.*]] // CHECK-OLD-SAME: !tbaa.struct [[TS:!.*]]
// CHECK-NEW-SAME: !tbaa [[TAG_A:![0-9]*]] // CHECK-NEW-SAME: !tbaa [[TAG_A:![0-9]*]]
*a1 = *a2; *a1 = *a2;
} }
struct B { struct B {
char c; char c;
A a; A a;
int i; int i;
}; };
void copy2(B *b1, B *b2) { void copy2(B *b1, B *b2) {
// CHECK-LABEL: _Z5copy2P1BS0_ // CHECK-LABEL: _Z5copy2P1BS0_
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %{{.*}}, i8* align 4 %{{.*}}, i64 24, i1 false) // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 4 %{{.*}}, i8* nonnull align 4 %{{.*}}, i64 24, i1 false)
// CHECK-OLD-SAME: !tbaa.struct [[TS2:!.*]] // CHECK-OLD-SAME: !tbaa.struct [[TS2:!.*]]
// CHECK-NEW-SAME: !tbaa [[TAG_B:![0-9]*]] // CHECK-NEW-SAME: !tbaa [[TAG_B:![0-9]*]]
*b1 = *b2; *b1 = *b2;
} }
struct S { struct S {
_Complex char cc; _Complex char cc;
_Complex int ci; _Complex int ci;
}; };
union U { union U {
_Complex int ci; _Complex int ci;
S s; S s;
}; };
void copy3(U *u1, U *u2) { void copy3(U *u1, U *u2) {
// CHECK-LABEL: _Z5copy3P1US0_ // CHECK-LABEL: _Z5copy3P1US0_
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %{{.*}}, i8* align 4 %{{.*}}, i64 12, i1 false) // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 4 %{{.*}}, i8* nonnull align 4 %{{.*}}, i64 12, i1 false)
// CHECK-OLD-SAME: !tbaa.struct [[TS3:!.*]] // CHECK-OLD-SAME: !tbaa.struct [[TS3:!.*]]
// CHECK-NEW-SAME: !tbaa [[TAG_U:![0-9]*]] // CHECK-NEW-SAME: !tbaa [[TAG_U:![0-9]*]]
*u1 = *u2; *u1 = *u2;
} }
// Make sure that zero-length bitfield works. // Make sure that zero-length bitfield works.
struct C { struct C {
char a; char a;
int : 0; // Shall not be ignored; see r185018. int : 0; // Shall not be ignored; see r185018.
char b; char b;
char c; char c;
} __attribute__((ms_struct)); } __attribute__((ms_struct));
void copy4(C *c1, C *c2) { void copy4(C *c1, C *c2) {
// CHECK-LABEL: _Z5copy4P1CS0_ // CHECK-LABEL: _Z5copy4P1CS0_
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 3, i1 false) // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull {{.*}}, i8* nonnull {{.*}}, i64 3, i1 false)
// CHECK-OLD-SAME: !tbaa.struct [[TS4:!.*]] // CHECK-OLD-SAME: !tbaa.struct [[TS4:!.*]]
// CHECK-NEW-SAME: !tbaa [[TAG_C:![0-9]*]] // CHECK-NEW-SAME: !tbaa [[TAG_C:![0-9]*]]
*c1 = *c2; *c1 = *c2;
} }
struct D { struct D {
char a; char a;
int : 0; int : 0;
char b; char b;
char c; char c;
}; };
void copy5(D *d1, D *d2) { void copy5(D *d1, D *d2) {
// CHECK-LABEL: _Z5copy5P1DS0_ // CHECK-LABEL: _Z5copy5P1DS0_
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 6, i1 false) // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull {{.*}}, i8* nonnull {{.*}}, i64 6, i1 false)
// CHECK-OLD-SAME: !tbaa.struct [[TS5:!.*]] // CHECK-OLD-SAME: !tbaa.struct [[TS5:!.*]]
// CHECK-NEW-SAME: !tbaa [[TAG_D:![0-9]*]] // CHECK-NEW-SAME: !tbaa [[TAG_D:![0-9]*]]
*d1 = *d2; *d1 = *d2;
} }
void copy6(AA *a1, A *a2) { void copy6(AA *a1, A *a2) {
// CHECK-LABEL: _Z5copy6P1AS0_ // CHECK-LABEL: _Z5copy6P1AS0_
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %{{.*}}, i8* align 4 %{{.*}}, i64 16, i1 false) // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 4 %{{.*}}, i8* nonnull align 4 %{{.*}}, i64 16, i1 false)
// CHECK-OLD-SAME: !tbaa.struct [[TS]] // CHECK-OLD-SAME: !tbaa.struct [[TS]]
// CHECK-NEW-SAME: !tbaa [[TAG_char:![0-9]*]] // CHECK-NEW-SAME: !tbaa [[TAG_char:![0-9]*]]
*a1 = *a2; *a1 = *a2;
} }
void copy7(A *a1, AA *a2) { void copy7(A *a1, AA *a2) {
// CHECK-LABEL: _Z5copy7P1AS0_ // CHECK-LABEL: _Z5copy7P1AS0_
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %{{.*}}, i8* align 4 %{{.*}}, i64 16, i1 false) // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 4 %{{.*}}, i8* nonnull align 4 %{{.*}}, i64 16, i1 false)
// CHECK-OLD-SAME: !tbaa.struct [[TS]] // CHECK-OLD-SAME: !tbaa.struct [[TS]]
// CHECK-NEW-SAME: !tbaa [[TAG_char]] // CHECK-NEW-SAME: !tbaa [[TAG_char]]
*a1 = *a2; *a1 = *a2;
} }
// CHECK-OLD: [[TS]] = !{i64 0, i64 2, !{{.*}}, i64 4, i64 4, !{{.*}}, i64 8, i64 1, !{{.*}}, i64 12, i64 4, !{{.*}}} // CHECK-OLD: [[TS]] = !{i64 0, i64 2, !{{.*}}, i64 4, i64 4, !{{.*}}, i64 8, i64 1, !{{.*}}, i64 12, i64 4, !{{.*}}}
// CHECK-OLD: [[CHAR:!.*]] = !{!"omnipotent char", !{{.*}}} // CHECK-OLD: [[CHAR:!.*]] = !{!"omnipotent char", !{{.*}}}
// CHECK-OLD: [[TAG_INT:!.*]] = !{[[INT:!.*]], [[INT]], i64 0} // CHECK-OLD: [[TAG_INT:!.*]] = !{[[INT:!.*]], [[INT]], i64 0}
Show All 22 Lines

test/CodeGenOpenCL/amdgpu-nullptr.cl

Show First 20 Lines • Show All 504 Lines • ▼ Show 20 Lines
// For large structures which is mostly zero, clang generats llvm.memset for // For large structures which is mostly zero, clang generats llvm.memset for
// the zero part and store for non-zero members. // the zero part and store for non-zero members.
typedef struct { typedef struct {
long a, b, c, d; long a, b, c, d;
private char *p; private char *p;
} StructTy3; } StructTy3;
// CHECK-LABEL: test_memset_private // CHECK-LABEL: test_memset_private
// CHECK: call void @llvm.memset.p5i8.i64(i8 addrspace(5)* align 8 {{.*}}, i8 0, i64 40, i1 false) // CHECK: call void @llvm.memset.p5i8.i64(i8 addrspace(5)* nonnull align 8 {{.*}}, i8 0, i64 40, i1 false)
efriedmaUnsubmitted
Not Done
ReplyInline Actions

This shouldn't change. "null" pointers are potentially valid in non-zero address-spaces. (Sorry, I should have spotted this sooner.)

efriedma: This shouldn't change. "null" pointers are potentially valid in non-zero address-spaces.
xbolva00AuthorUnsubmitted
Not Done
ReplyInline Actions

Thanks, I will fix this case.

xbolva00: Thanks, I will fix this case.
void test_memset_private(private StructTy3 *ptr) { void test_memset_private(private StructTy3 *ptr) {
StructTy3 S3 = {0, 0, 0, 0, 0}; StructTy3 S3 = {0, 0, 0, 0, 0};
*ptr = S3; *ptr = S3;
} }
// Test casting literal 0 to pointer. // Test casting literal 0 to pointer.
// A 0 literal casted to pointer should become a null pointer. // A 0 literal casted to pointer should become a null pointer.
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines