1 // RUN: %clang_cc1 -fsanitize=alignment,null,object-size,shift,return,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
2 // RUN: %clang_cc1 -fsanitize-undefined-trap-on-error -fsanitize=alignment,null,object-size,shift,return,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-TRAP
3 // RUN: %clang_cc1 -fsanitize=null -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-NULL
4 // RUN: %clang_cc1 -fsanitize=signed-integer-overflow -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-OVERFLOW
5
6 // CHECK: @[[INT:.*]] = private unnamed_addr constant { i16, i16, [6 x i8] } { i16 0, i16 11, [6 x i8] c"'int'\00" }
7
8 // FIXME: When we only emit each type once, use [[INT]] more below.
9 // CHECK: @[[LINE_100:.*]] = private unnamed_addr global {{.*}}, i32 100, i32 5 {{.*}} @[[INT]], i64 4, i8 1
10 // CHECK: @[[LINE_200:.*]] = {{.*}}, i32 200, i32 10 {{.*}}, i64 4, i8 0
11 // CHECK: @[[LINE_300:.*]] = {{.*}}, i32 300, i32 12 {{.*}} @{{.*}}, {{.*}} @{{.*}}
12 // CHECK: @[[LINE_400:.*]] = {{.*}}, i32 400, i32 12 {{.*}} @{{.*}}, {{.*}} @{{.*}}
13 // CHECK: @[[LINE_500:.*]] = {{.*}}, i32 500, i32 10 {{.*}} @{{.*}}, i64 4, i8 0 }
14 // CHECK: @[[LINE_600:.*]] = {{.*}}, i32 600, i32 3 {{.*}} @{{.*}}, i64 4, i8 1 }
15
16 // CHECK: @[[STRUCT_S:.*]] = private unnamed_addr constant { i16, i16, [11 x i8] } { i16 -1, i16 0, [11 x i8] c"'struct S'\00" }
17
18 // CHECK: @[[LINE_700:.*]] = {{.*}}, i32 700, i32 14 {{.*}} @[[STRUCT_S]], i64 4, i8 3 }
19 // CHECK: @[[LINE_800:.*]] = {{.*}}, i32 800, i32 12 {{.*}} @{{.*}} }
20 // CHECK: @[[LINE_900:.*]] = {{.*}}, i32 900, i32 11 {{.*}} @{{.*}} }
21
22 // CHECK-NULL: @[[LINE_100:.*]] = private unnamed_addr global {{.*}}, i32 100, i32 5 {{.*}}
23
24 // PR6805
25 // CHECK: @foo
26 // CHECK-NULL: @foo
27 // CHECK-TRAP: @foo
foo()28 void foo() {
29 union { int i; } u;
30 // CHECK: %[[CHECK0:.*]] = icmp ne {{.*}}* %[[PTR:.*]], null
31 // CHECK-TRAP: %[[CHECK0:.*]] = icmp ne {{.*}}* %[[PTR:.*]], null
32
33 // CHECK: %[[I8PTR:.*]] = bitcast i32* %[[PTR]] to i8*
34 // CHECK-NEXT: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64.p0i8(i8* %[[I8PTR]], i1 false)
35 // CHECK-NEXT: %[[CHECK1:.*]] = icmp uge i64 %[[SIZE]], 4
36 // CHECK-NEXT: %[[CHECK01:.*]] = and i1 %[[CHECK0]], %[[CHECK1]]
37
38 // CHECK-TRAP: %[[I8PTR:.*]] = bitcast i32* %[[PTR]] to i8*
39 // CHECK-TRAP-NEXT: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64.p0i8(i8* %[[I8PTR]], i1 false)
40 // CHECK-TRAP-NEXT: %[[CHECK1:.*]] = icmp uge i64 %[[SIZE]], 4
41 // CHECK-TRAP-NEXT: %[[CHECK01:.*]] = and i1 %[[CHECK0]], %[[CHECK1]]
42
43 // CHECK: %[[PTRTOINT:.*]] = ptrtoint {{.*}}* %[[PTR]] to i64
44 // CHECK-NEXT: %[[MISALIGN:.*]] = and i64 %[[PTRTOINT]], 3
45 // CHECK-NEXT: %[[CHECK2:.*]] = icmp eq i64 %[[MISALIGN]], 0
46
47 // CHECK-TRAP: %[[PTRTOINT:.*]] = ptrtoint {{.*}}* %[[PTR]] to i64
48 // CHECK-TRAP-NEXT: %[[MISALIGN:.*]] = and i64 %[[PTRTOINT]], 3
49 // CHECK-TRAP-NEXT: %[[CHECK2:.*]] = icmp eq i64 %[[MISALIGN]], 0
50
51 // CHECK: %[[OK:.*]] = and i1 %[[CHECK01]], %[[CHECK2]]
52 // CHECK-NEXT: br i1 %[[OK]], {{.*}} !prof ![[WEIGHT_MD:.*]]
53
54 // CHECK-TRAP: %[[OK:.*]] = and i1 %[[CHECK01]], %[[CHECK2]]
55 // CHECK-TRAP-NEXT: br i1 %[[OK]], {{.*}}
56
57 // CHECK: %[[ARG:.*]] = ptrtoint {{.*}} %[[PTR]] to i64
58 // CHECK-NEXT: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_100]] to i8*), i64 %[[ARG]])
59
60 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW:#[0-9]+]]
61 // CHECK-TRAP-NEXT: unreachable
62
63 // With -fsanitize=null, only perform the null check.
64 // CHECK-NULL: %[[NULL:.*]] = icmp ne {{.*}}, null
65 // CHECK-NULL: br i1 %[[NULL]]
66 // CHECK-NULL: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_100]] to i8*), i64 %{{.*}})
67 #line 100
68 u.i=1;
69 }
70
71 // CHECK: @bar
72 // CHECK-TRAP: @bar
bar(int * a)73 int bar(int *a) {
74 // CHECK: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64
75 // CHECK-NEXT: icmp uge i64 %[[SIZE]], 4
76
77 // CHECK-TRAP: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64
78 // CHECK-TRAP-NEXT: icmp uge i64 %[[SIZE]], 4
79
80 // CHECK: %[[PTRINT:.*]] = ptrtoint
81 // CHECK-NEXT: %[[MISALIGN:.*]] = and i64 %[[PTRINT]], 3
82 // CHECK-NEXT: icmp eq i64 %[[MISALIGN]], 0
83
84 // CHECK-TRAP: %[[PTRINT:.*]] = ptrtoint
85 // CHECK-TRAP-NEXT: %[[MISALIGN:.*]] = and i64 %[[PTRINT]], 3
86 // CHECK-TRAP-NEXT: icmp eq i64 %[[MISALIGN]], 0
87
88 // CHECK: %[[ARG:.*]] = ptrtoint
89 // CHECK-NEXT: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_200]] to i8*), i64 %[[ARG]])
90
91 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
92 // CHECK-TRAP-NEXT: unreachable
93
94 #line 200
95 return *a;
96 }
97
98 // CHECK: @addr_space
addr_space(int * a)99 int addr_space(int __attribute__((address_space(256))) *a) {
100 // CHECK-NOT: __ubsan
101 return *a;
102 }
103
104 // CHECK: @lsh_overflow
105 // CHECK-TRAP: @lsh_overflow
lsh_overflow(int a,int b)106 int lsh_overflow(int a, int b) {
107 // CHECK: %[[INBOUNDS:.*]] = icmp ule i32 %[[RHS:.*]], 31
108 // CHECK-NEXT: br i1 %[[INBOUNDS]], label %[[CHECKBB:.*]], label %[[CONTBB:.*]]
109
110 // CHECK-TRAP: %[[INBOUNDS:.*]] = icmp ule i32 %[[RHS:.*]], 31
111 // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]], label %[[CHECKBB:.*]], label %[[CONTBB:.*]]
112
113 // CHECK: %[[SHIFTED_OUT_WIDTH:.*]] = sub nuw nsw i32 31, %[[RHS]]
114 // CHECK-NEXT: %[[SHIFTED_OUT:.*]] = lshr i32 %[[LHS:.*]], %[[SHIFTED_OUT_WIDTH]]
115 // CHECK-NEXT: %[[NO_OVERFLOW:.*]] = icmp eq i32 %[[SHIFTED_OUT]], 0
116 // CHECK-NEXT: br label %[[CONTBB]]
117
118 // CHECK-TRAP: %[[SHIFTED_OUT_WIDTH:.*]] = sub nuw nsw i32 31, %[[RHS]]
119 // CHECK-TRAP-NEXT: %[[SHIFTED_OUT:.*]] = lshr i32 %[[LHS:.*]], %[[SHIFTED_OUT_WIDTH]]
120 // CHECK-TRAP-NEXT: %[[NO_OVERFLOW:.*]] = icmp eq i32 %[[SHIFTED_OUT]], 0
121 // CHECK-TRAP-NEXT: br label %[[CONTBB]]
122
123 // CHECK: %[[VALID:.*]] = phi i1 [ %[[INBOUNDS]], {{.*}} ], [ %[[NO_OVERFLOW]], %[[CHECKBB]] ]
124 // CHECK-NEXT: br i1 %[[VALID]], {{.*}} !prof ![[WEIGHT_MD]]
125
126 // CHECK-TRAP: %[[VALID:.*]] = phi i1 [ %[[INBOUNDS]], {{.*}} ], [ %[[NO_OVERFLOW]], %[[CHECKBB]] ]
127 // CHECK-TRAP-NEXT: br i1 %[[VALID]]
128
129
130 // CHECK: %[[ARG1:.*]] = zext
131 // CHECK-NEXT: %[[ARG2:.*]] = zext
132 // CHECK-NEXT: call void @__ubsan_handle_shift_out_of_bounds(i8* bitcast ({{.*}} @[[LINE_300]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]])
133 // CHECK-NOT: call void @__ubsan_handle_shift_out_of_bounds
134
135 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
136 // CHECK-TRAP: unreachable
137 // CHECK-TRAP-NOT: call void @llvm.trap()
138
139 // CHECK: %[[RET:.*]] = shl i32 %[[LHS]], %[[RHS]]
140 // CHECK-NEXT: ret i32 %[[RET]]
141
142 // CHECK-TRAP: %[[RET:.*]] = shl i32 %[[LHS]], %[[RHS]]
143 // CHECK-TRAP-NEXT: ret i32 %[[RET]]
144 #line 300
145 return a << b;
146 }
147
148 // CHECK: @rsh_inbounds
149 // CHECK-TRAP: @rsh_inbounds
rsh_inbounds(int a,int b)150 int rsh_inbounds(int a, int b) {
151 // CHECK: %[[INBOUNDS:.*]] = icmp ule i32 %[[RHS:.*]], 31
152 // CHECK: br i1 %[[INBOUNDS]]
153
154 // CHECK-TRAP: %[[INBOUNDS:.*]] = icmp ule i32 %[[RHS:.*]], 31
155 // CHECK-TRAP: br i1 %[[INBOUNDS]]
156
157 // CHECK: %[[ARG1:.*]] = zext
158 // CHECK-NEXT: %[[ARG2:.*]] = zext
159 // CHECK-NEXT: call void @__ubsan_handle_shift_out_of_bounds(i8* bitcast ({{.*}} @[[LINE_400]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]])
160
161 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
162 // CHECK-TRAP-NEXT: unreachable
163
164 // CHECK: %[[RET:.*]] = ashr i32 %[[LHS]], %[[RHS]]
165 // CHECK-NEXT: ret i32 %[[RET]]
166
167 // CHECK-TRAP: %[[RET:.*]] = ashr i32 %[[LHS]], %[[RHS]]
168 // CHECK-TRAP-NEXT: ret i32 %[[RET]]
169 #line 400
170 return a >> b;
171 }
172
173 // CHECK: @load
174 // CHECK-TRAP: @load
load(int * p)175 int load(int *p) {
176 // CHECK: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_500]] to i8*), i64 %{{.*}})
177
178 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
179 // CHECK-TRAP-NEXT: unreachable
180 #line 500
181 return *p;
182 }
183
184 // CHECK: @store
185 // CHECK-TRAP: @store
store(int * p,int q)186 void store(int *p, int q) {
187 // CHECK: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_600]] to i8*), i64 %{{.*}})
188
189 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
190 // CHECK-TRAP-NEXT: unreachable
191 #line 600
192 *p = q;
193 }
194
195 struct S { int k; };
196
197 // CHECK: @member_access
198 // CHECK-TRAP: @member_access
member_access(struct S * p)199 int *member_access(struct S *p) {
200 // CHECK: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_700]] to i8*), i64 %{{.*}})
201
202 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
203 // CHECK-TRAP-NEXT: unreachable
204 #line 700
205 return &p->k;
206 }
207
208 // CHECK: @signed_overflow
209 // CHECK-TRAP: @signed_overflow
signed_overflow(int a,int b)210 int signed_overflow(int a, int b) {
211 // CHECK: %[[ARG1:.*]] = zext
212 // CHECK-NEXT: %[[ARG2:.*]] = zext
213 // CHECK-NEXT: call void @__ubsan_handle_add_overflow(i8* bitcast ({{.*}} @[[LINE_800]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]])
214
215 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
216 // CHECK-TRAP-NEXT: unreachable
217 #line 800
218 return a + b;
219 }
220
221 // CHECK: @no_return
222 // CHECK-TRAP: @no_return
no_return()223 int no_return() {
224 // Reaching the end of a noreturn function is fine in C.
225 // FIXME: If the user explicitly requests -fsanitize=return, we should catch
226 // that here even though it's not undefined behavior.
227 // CHECK-NOT: call
228 // CHECK-NOT: unreachable
229 // CHECK: ret i32
230
231 // CHECK-TRAP-NOT: call
232 // CHECK-TRAP-NOT: unreachable
233 // CHECK-TRAP: ret i32
234 }
235
236 // CHECK: @vla_bound
vla_bound(int n)237 void vla_bound(int n) {
238 // CHECK: icmp sgt i32 %[[PARAM:.*]], 0
239 //
240 // CHECK: %[[ARG:.*]] = zext i32 %[[PARAM]] to i64
241 // CHECK-NEXT: call void @__ubsan_handle_vla_bound_not_positive(i8* bitcast ({{.*}} @[[LINE_900]] to i8*), i64 %[[ARG]])
242 #line 900
243 int arr[n * 3];
244 }
245
246 // CHECK: @int_float_no_overflow
int_float_no_overflow(__int128 n)247 float int_float_no_overflow(__int128 n) {
248 // CHECK-NOT: call void @__ubsan_handle
249 return n;
250 }
251
252 // CHECK: @int_float_overflow
253 // CHECK-TRAP: @int_float_overflow
int_float_overflow(unsigned __int128 n)254 float int_float_overflow(unsigned __int128 n) {
255 // This is 2**104. FLT_MAX is 2**128 - 2**104.
256 // CHECK: icmp ule i128 %{{.*}}, -20282409603651670423947251286016
257 // CHECK: call void @__ubsan_handle_float_cast_overflow(
258
259 // CHECK-TRAP: %[[INBOUNDS:.*]] = icmp ule i128 %{{.*}}, -20282409603651670423947251286016
260 // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]]
261
262 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
263 // CHECK-TRAP-NEXT: unreachable
264 return n;
265 }
266
267 // CHECK: @int_fp16_overflow
268 // CHECK-TRAP: @int_fp16_overflow
int_fp16_overflow(int n,__fp16 * p)269 void int_fp16_overflow(int n, __fp16 *p) {
270 // CHECK: %[[GE:.*]] = icmp sge i32 %{{.*}}, -65504
271 // CHECK: %[[LE:.*]] = icmp sle i32 %{{.*}}, 65504
272 // CHECK: and i1 %[[GE]], %[[LE]]
273 // CHECK: call void @__ubsan_handle_float_cast_overflow(
274
275 // CHECK-TRAP: %[[GE:.*]] = icmp sge i32 %{{.*}}, -65504
276 // CHECK-TRAP: %[[LE:.*]] = icmp sle i32 %{{.*}}, 65504
277 // CHECK-TRAP: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]]
278 // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]]
279
280 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
281 // CHECK-TRAP-NEXT: unreachable
282 *p = n;
283 }
284
285 // CHECK: @float_int_overflow
286 // CHECK-TRAP: @float_int_overflow
float_int_overflow(float f)287 int float_int_overflow(float f) {
288 // CHECK: %[[GE:.*]] = fcmp ogt float %[[F:.*]], 0xC1E0000020000000
289 // CHECK: %[[LE:.*]] = fcmp olt float %[[F]], 0x41E0000000000000
290 // CHECK: and i1 %[[GE]], %[[LE]]
291
292 // CHECK: %[[CAST:.*]] = bitcast float %[[F]] to i32
293 // CHECK: %[[ARG:.*]] = zext i32 %[[CAST]] to i64
294 // CHECK: call void @__ubsan_handle_float_cast_overflow({{.*}}, i64 %[[ARG]]
295
296 // CHECK-TRAP: %[[GE:.*]] = fcmp ogt float %[[F:.*]], 0xC1E0000020000000
297 // CHECK-TRAP: %[[LE:.*]] = fcmp olt float %[[F]], 0x41E0000000000000
298 // CHECK-TRAP: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]]
299 // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]]
300
301 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
302 // CHECK-TRAP-NEXT: unreachable
303 return f;
304 }
305
306 // CHECK: @long_double_int_overflow
307 // CHECK-TRAP: @long_double_int_overflow
long_double_int_overflow(long double ld)308 int long_double_int_overflow(long double ld) {
309 // CHECK: alloca x86_fp80
310 // CHECK: %[[GE:.*]] = fcmp ogt x86_fp80 %[[F:.*]], 0xKC01E8000000100000000
311 // CHECK: %[[LE:.*]] = fcmp olt x86_fp80 %[[F]], 0xK401E8000000000000000
312 // CHECK: and i1 %[[GE]], %[[LE]]
313
314 // CHECK: store x86_fp80 %[[F]], x86_fp80* %[[ALLOCA:.*]]
315 // CHECK: %[[ARG:.*]] = ptrtoint x86_fp80* %[[ALLOCA]] to i64
316 // CHECK: call void @__ubsan_handle_float_cast_overflow({{.*}}, i64 %[[ARG]]
317
318 // CHECK-TRAP: %[[GE:.*]] = fcmp ogt x86_fp80 %[[F:.*]], 0xKC01E800000010000000
319 // CHECK-TRAP: %[[LE:.*]] = fcmp olt x86_fp80 %[[F]], 0xK401E800000000000000
320 // CHECK-TRAP: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]]
321 // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]]
322
323 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
324 // CHECK-TRAP-NEXT: unreachable
325 return ld;
326 }
327
328 // CHECK: @float_uint_overflow
329 // CHECK-TRAP: @float_uint_overflow
float_uint_overflow(float f)330 unsigned float_uint_overflow(float f) {
331 // CHECK: %[[GE:.*]] = fcmp ogt float %[[F:.*]], -1.{{0*}}e+00
332 // CHECK: %[[LE:.*]] = fcmp olt float %[[F]], 0x41F0000000000000
333 // CHECK: and i1 %[[GE]], %[[LE]]
334 // CHECK: call void @__ubsan_handle_float_cast_overflow(
335
336 // CHECK-TRAP: %[[GE:.*]] = fcmp ogt float %[[F:.*]], -1.{{0*}}e+00
337 // CHECK-TRAP: %[[LE:.*]] = fcmp olt float %[[F]], 0x41F0000000000000
338 // CHECK-TRAP: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]]
339 // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]]
340
341 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
342 // CHECK-TRAP-NEXT: unreachable
343 return f;
344 }
345
346 // CHECK: @fp16_char_overflow
347 // CHECK-TRAP: @fp16_char_overflow
fp16_char_overflow(__fp16 * p)348 signed char fp16_char_overflow(__fp16 *p) {
349 // CHECK: %[[GE:.*]] = fcmp ogt float %[[F:.*]], -1.29{{0*}}e+02
350 // CHECK: %[[LE:.*]] = fcmp olt float %[[F]], 1.28{{0*}}e+02
351 // CHECK: and i1 %[[GE]], %[[LE]]
352 // CHECK: call void @__ubsan_handle_float_cast_overflow(
353
354 // CHECK-TRAP: %[[GE:.*]] = fcmp ogt float %[[F:.*]], -1.29{{0*}}e+02
355 // CHECK-TRAP: %[[LE:.*]] = fcmp olt float %[[F]], 1.28{{0*}}e+02
356 // CHECK-TRAP: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]]
357 // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]]
358
359 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
360 // CHECK-TRAP-NEXT: unreachable
361 return *p;
362 }
363
364 // CHECK: @float_float_overflow
365 // CHECK-TRAP: @float_float_overflow
float_float_overflow(double f)366 float float_float_overflow(double f) {
367 // CHECK: %[[F:.*]] = call double @llvm.fabs.f64(
368 // CHECK: %[[GE:.*]] = fcmp ogt double %[[F]], 0x47EFFFFFE0000000
369 // CHECK: %[[LE:.*]] = fcmp olt double %[[F]], 0x7FF0000000000000
370 // CHECK: and i1 %[[GE]], %[[LE]]
371 // CHECK: call void @__ubsan_handle_float_cast_overflow(
372
373 // CHECK-TRAP: %[[F:.*]] = call double @llvm.fabs.f64(
374 // CHECK-TRAP: %[[GE:.*]] = fcmp ogt double %[[F]], 0x47EFFFFFE0000000
375 // CHECK-TRAP: %[[LE:.*]] = fcmp olt double %[[F]], 0x7FF0000000000000
376 // CHECK-TRAP: %[[OUTOFBOUNDS:.*]] = and i1 %[[GE]], %[[LE]]
377 // CHECK-TRAP: %[[INBOUNDS:.*]] = xor i1 %[[OUTOFBOUNDS]], true
378 // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]]
379
380 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
381 // CHECK-TRAP-NEXT: unreachable
382 return f;
383 }
384
385 // CHECK: @int_divide_overflow
386 // CHECK-OVERFLOW: @int_divide_overflow
int_divide_overflow(int a,int b)387 int int_divide_overflow(int a, int b) {
388 // CHECK: %[[ZERO:.*]] = icmp ne i32 %[[B:.*]], 0
389 // CHECK-OVERFLOW-NOT: icmp ne i32 %{{.*}}, 0
390 // CHECK-TRAP: %[[ZERO:.*]] = icmp ne i32 %[[B:.*]], 0
391
392 // CHECK: %[[AOK:.*]] = icmp ne i32 %[[A:.*]], -2147483648
393 // CHECK-NEXT: %[[BOK:.*]] = icmp ne i32 %[[B]], -1
394 // CHECK-NEXT: %[[OVER:.*]] = or i1 %[[AOK]], %[[BOK]]
395
396 // CHECK-OVERFLOW: %[[AOK:.*]] = icmp ne i32 %[[A:.*]], -2147483648
397 // CHECK-OVERFLOW-NEXT: %[[BOK:.*]] = icmp ne i32 %[[B:.*]], -1
398 // CHECK-OVERFLOW-NEXT: %[[OK:.*]] = or i1 %[[AOK]], %[[BOK]]
399
400 // CHECK-TRAP: %[[AOK:.*]] = icmp ne i32 %[[A:.*]], -2147483648
401 // CHECK-TRAP-NEXT: %[[BOK:.*]] = icmp ne i32 %[[B]], -1
402 // CHECK-TRAP-NEXT: %[[OVER:.*]] = or i1 %[[AOK]], %[[BOK]]
403
404 // CHECK: %[[OK:.*]] = and i1 %[[ZERO]], %[[OVER]]
405
406 // CHECK: br i1 %[[OK]]
407 // CHECK-OVERFLOW: br i1 %[[OK]]
408
409 // CHECK-TRAP: %[[OK:.*]] = and i1 %[[ZERO]], %[[OVER]]
410 // CHECK-TRAP: br i1 %[[OK]]
411
412 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
413 // CHECK-TRAP: unreachable
414 return a / b;
415
416 // CHECK: }
417 // CHECK-OVERFLOW: }
418 // CHECK-TRAP: }
419 }
420
421 // CHECK: @sour_bool
sour_bool(_Bool * p)422 _Bool sour_bool(_Bool *p) {
423 // CHECK: %[[OK:.*]] = icmp ule i8 {{.*}}, 1
424 // CHECK: br i1 %[[OK]]
425 // CHECK: call void @__ubsan_handle_load_invalid_value(i8* bitcast ({{.*}}), i64 {{.*}})
426
427 // CHECK-TRAP: %[[OK:.*]] = icmp ule i8 {{.*}}, 1
428 // CHECK-TRAP: br i1 %[[OK]]
429
430 // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
431 // CHECK-TRAP: unreachable
432 return *p;
433 }
434
435 // CHECK: ![[WEIGHT_MD]] = metadata !{metadata !"branch_weights", i32 1048575, i32 1}
436
437 // CHECK-TRAP: attributes [[NR_NUW]] = { noreturn nounwind }
438