1 // RUN: %clangxx %gmlt -fsanitize=alignment %s -O3 -o %t
2 // RUN: %run %t l0 && %run %t s0 && %run %t r0 && %run %t m0 && %run %t f0 && %run %t n0 && %run %t u0
3 // RUN: %run %t l1 2>&1 | FileCheck %s --check-prefix=CHECK-LOAD --strict-whitespace
4 // RUN: %run %t L1 2>&1 | FileCheck %s --check-prefix=CHECK-MEMCPY-LOAD
5 // RUN: %run %t S1 2>&1 | FileCheck %s --check-prefix=CHECK-MEMCPY-STORE
6 // RUN: %run %t r1 2>&1 | FileCheck %s --check-prefix=CHECK-REFERENCE
7 // RUN: %run %t m1 2>&1 | FileCheck %s --check-prefix=CHECK-MEMBER
8 // RUN: %run %t f1 2>&1 | FileCheck %s --check-prefix=CHECK-MEMFUN
9 // RUN: %run %t n1 2>&1 | FileCheck %s --check-prefix=CHECK-NEW
10 // RUN: %run %t u1 2>&1 | FileCheck %s --check-prefix=CHECK-UPCAST
11 // RUN: %env_ubsan_opts=print_stacktrace=1 %run %t l1 2>&1 | FileCheck %s --check-prefix=CHECK-LOAD --check-prefix=CHECK-STACK-LOAD
12
13 // RUN: %clangxx -fsanitize=alignment -fno-sanitize-recover=alignment %s -O3 -o %t
14 // RUN: not %run %t s1 2>&1 | FileCheck %s --check-prefix=CHECK-STORE
15 // RUN: not %run %t w1 2>&1 | FileCheck %s --check-prefix=CHECK-WILD
16 // Compilation error make the test fails.
17 // XFAIL: target={{.*openbsd.*}}
18
19 #include <new>
20 #include <string.h>
21
22 struct S {
SS23 S() {}
fS24 int f() { return 0; }
25 int k;
26 };
27
28 struct T : S {
29 int t;
30 };
31
main(int,char ** argv)32 int main(int, char **argv) {
33 char c[] __attribute__((aligned(8))) = { 0, 0, 0, 0, 1, 2, 3, 4, 5 };
34
35 // Pointer value may be unspecified here, but behavior is not undefined.
36 int *p = (int*)&c[4 + argv[1][1] - '0'];
37 S *s = (S*)p;
38 T *t = (T*)p;
39
40 void *wild = reinterpret_cast<void *>(0x123L);
41
42 (void)*p; // ok!
43
44 switch (argv[1][0]) {
45 case 'l':
46 // CHECK-LOAD: misaligned.cpp:[[@LINE+4]]{{(:12)?}}: runtime error: load of misaligned address [[PTR:0x[0-9a-f]*]] for type 'int', which requires 4 byte alignment
47 // CHECK-LOAD-NEXT: [[PTR]]: note: pointer points here
48 // CHECK-LOAD-NEXT: {{^ 00 00 00 01 02 03 04 05}}
49 // CHECK-LOAD-NEXT: {{^ \^}}
50 return *p && 0;
51 // CHECK-STACK-LOAD: #0 {{.*}}main{{.*}}misaligned.cpp
52
53 case 'L': {
54 int x;
55 // CHECK-MEMCPY-LOAD: misaligned.cpp:[[#@LINE+4]]{{(:16)?}}: runtime error: load of misaligned address [[PTR:0x[0-9a-f]*]] for type 'int *', which requires 4 byte alignment
56 // CHECK-MEMCPY-LOAD-NEXT: [[PTR]]: note: pointer points here
57 // CHECK-MEMCPY-LOAD-NEXT: {{^ 00 00 00 01 02 03 04 05}}
58 // CHECK-MEMCPY-LOAD-NEXT: {{^ \^}}
59 memcpy(&x, p, sizeof(x));
60 return x && 0;
61 }
62
63 case 's':
64 // CHECK-STORE: misaligned.cpp:[[@LINE+4]]{{(:5)?}}: runtime error: store to misaligned address [[PTR:0x[0-9a-f]*]] for type 'int', which requires 4 byte alignment
65 // CHECK-STORE-NEXT: [[PTR]]: note: pointer points here
66 // CHECK-STORE-NEXT: {{^ 00 00 00 01 02 03 04 05}}
67 // CHECK-STORE-NEXT: {{^ \^}}
68 *p = 1;
69 break;
70
71 case 'S': {
72 int x = 1;
73 // CHECK-MEMCPY-STORE: misaligned.cpp:[[#@LINE+4]]{{(:12)?}}: runtime error: store to misaligned address [[PTR:0x[0-9a-f]*]] for type 'int *', which requires 4 byte alignment
74 // CHECK-MEMCPY-STORE-NEXT: [[PTR]]: note: pointer points here
75 // CHECK-MEMCPY-STORE-NEXT: {{^ 00 00 00 01 02 03 04 05}}
76 // CHECK-MEMCPY-STORE-NEXT: {{^ \^}}
77 memcpy(p, &x, sizeof(x));
78 break;
79 }
80
81 case 'r':
82 // CHECK-REFERENCE: misaligned.cpp:[[@LINE+4]]{{(:(5|15))?}}: runtime error: reference binding to misaligned address [[PTR:0x[0-9a-f]*]] for type 'int', which requires 4 byte alignment
83 // CHECK-REFERENCE-NEXT: [[PTR]]: note: pointer points here
84 // CHECK-REFERENCE-NEXT: {{^ 00 00 00 01 02 03 04 05}}
85 // CHECK-REFERENCE-NEXT: {{^ \^}}
86 {int &r = *p;}
87 break;
88
89 case 'm':
90 // CHECK-MEMBER: misaligned.cpp:[[@LINE+4]]{{(:15)?}}: runtime error: member access within misaligned address [[PTR:0x[0-9a-f]*]] for type 'S', which requires 4 byte alignment
91 // CHECK-MEMBER-NEXT: [[PTR]]: note: pointer points here
92 // CHECK-MEMBER-NEXT: {{^ 00 00 00 01 02 03 04 05}}
93 // CHECK-MEMBER-NEXT: {{^ \^}}
94 return s->k && 0;
95
96 case 'f':
97 // CHECK-MEMFUN: misaligned.cpp:[[@LINE+4]]{{(:15)?}}: runtime error: member call on misaligned address [[PTR:0x[0-9a-f]*]] for type 'S', which requires 4 byte alignment
98 // CHECK-MEMFUN-NEXT: [[PTR]]: note: pointer points here
99 // CHECK-MEMFUN-NEXT: {{^ 00 00 00 01 02 03 04 05}}
100 // CHECK-MEMFUN-NEXT: {{^ \^}}
101 return s->f() && 0;
102
103 case 'n':
104 // CHECK-NEW: misaligned.cpp:[[@LINE+4]]{{(:21)?}}: runtime error: constructor call on misaligned address [[PTR:0x[0-9a-f]*]] for type 'S', which requires 4 byte alignment
105 // CHECK-NEW-NEXT: [[PTR]]: note: pointer points here
106 // CHECK-NEW-NEXT: {{^ 00 00 00 01 02 03 04 05}}
107 // CHECK-NEW-NEXT: {{^ \^}}
108 return (new (s) S)->k && 0;
109
110 case 'u': {
111 // CHECK-UPCAST: misaligned.cpp:[[@LINE+4]]{{(:17)?}}: runtime error: upcast of misaligned address [[PTR:0x[0-9a-f]*]] for type 'T', which requires 4 byte alignment
112 // CHECK-UPCAST-NEXT: [[PTR]]: note: pointer points here
113 // CHECK-UPCAST-NEXT: {{^ 00 00 00 01 02 03 04 05}}
114 // CHECK-UPCAST-NEXT: {{^ \^}}
115 S *s2 = (S*)t;
116 return s2->f();
117 }
118
119 case 'w':
120 // CHECK-WILD: misaligned.cpp:[[@LINE+3]]{{(:35)?}}: runtime error: member access within misaligned address 0x{{0+}}123 for type 'S', which requires 4 byte alignment
121 // CHECK-WILD-NEXT: 0x{{0+}}123: note: pointer points here
122 // CHECK-WILD-NEXT: <memory cannot be printed>
123 return static_cast<S*>(wild)->k;
124 }
125 }
126