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