1 // Test CodeGen for Security Check Overflow Builtins. 2 3 // RUN: %clang_cc1 -triple "i686-unknown-unknown" -emit-llvm -x c %s -o - | FileCheck -DLONG_TYPE=i32 -DLONG_MAX=2147483647 %s 4 // RUN: %clang_cc1 -triple "x86_64-unknown-unknown" -emit-llvm -x c %s -o - | FileCheck -DLONG_TYPE=i64 -DLONG_MAX=9223372036854775807 %s 5 // RUN: %clang_cc1 -triple "x86_64-mingw32" -emit-llvm -x c %s -o - | FileCheck -DLONG_TYPE=i32 -DLONG_MAX=2147483647 %s 6 7 extern unsigned UnsignedErrorCode; 8 extern unsigned long UnsignedLongErrorCode; 9 extern unsigned long long UnsignedLongLongErrorCode; 10 extern int IntErrorCode; 11 extern long LongErrorCode; 12 extern long long LongLongErrorCode; 13 void overflowed(void); 14 15 unsigned test_add_overflow_uint_uint_uint(unsigned x, unsigned y) { 16 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_add_overflow_uint_uint_uint 17 // CHECK-NOT: ext 18 // CHECK: [[S:%.+]] = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 19 // CHECK-DAG: [[Q:%.+]] = extractvalue { i32, i1 } [[S]], 0 20 // CHECK-DAG: [[C:%.+]] = extractvalue { i32, i1 } [[S]], 1 21 // CHECK: store i32 [[Q]], ptr 22 // CHECK: br i1 [[C]] 23 unsigned r; 24 if (__builtin_add_overflow(x, y, &r)) 25 overflowed(); 26 return r; 27 } 28 29 int test_add_overflow_int_int_int(int x, int y) { 30 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_add_overflow_int_int_int 31 // CHECK-NOT: ext 32 // CHECK: [[S:%.+]] = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 33 // CHECK-DAG: [[C:%.+]] = extractvalue { i32, i1 } [[S]], 1 34 // CHECK-DAG: [[Q:%.+]] = extractvalue { i32, i1 } [[S]], 0 35 // CHECK: store i32 [[Q]], ptr 36 // CHECK: br i1 [[C]] 37 int r; 38 if (__builtin_add_overflow(x, y, &r)) 39 overflowed(); 40 return r; 41 } 42 43 int test_add_overflow_xint31_xint31_xint31(_BitInt(31) x, _BitInt(31) y) { 44 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_add_overflow_xint31_xint31_xint31({{.+}}) 45 // CHECK-NOT: ext 46 // CHECK: [[S:%.+]] = call { i31, i1 } @llvm.sadd.with.overflow.i31(i31 %{{.+}}, i31 %{{.+}}) 47 // CHECK-DAG: [[C:%.+]] = extractvalue { i31, i1 } [[S]], 1 48 // CHECK-DAG: [[Q:%.+]] = extractvalue { i31, i1 } [[S]], 0 49 // CHECK: store i31 [[Q]], ptr 50 // CHECK: br i1 [[C]] 51 _BitInt(31) r; 52 if (__builtin_add_overflow(x, y, &r)) 53 overflowed(); 54 return r; 55 } 56 57 unsigned test_sub_overflow_uint_uint_uint(unsigned x, unsigned y) { 58 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_sub_overflow_uint_uint_uint 59 // CHECK-NOT: ext 60 // CHECK: [[S:%.+]] = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 61 // CHECK-DAG: [[Q:%.+]] = extractvalue { i32, i1 } [[S]], 0 62 // CHECK-DAG: [[C:%.+]] = extractvalue { i32, i1 } [[S]], 1 63 // CHECK: store i32 [[Q]], ptr 64 // CHECK: br i1 [[C]] 65 unsigned r; 66 if (__builtin_sub_overflow(x, y, &r)) 67 overflowed(); 68 return r; 69 } 70 71 int test_sub_overflow_int_int_int(int x, int y) { 72 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_sub_overflow_int_int_int 73 // CHECK-NOT: ext 74 // CHECK: [[S:%.+]] = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 75 // CHECK-DAG: [[C:%.+]] = extractvalue { i32, i1 } [[S]], 1 76 // CHECK-DAG: [[Q:%.+]] = extractvalue { i32, i1 } [[S]], 0 77 // CHECK: store i32 [[Q]], ptr 78 // CHECK: br i1 [[C]] 79 int r; 80 if (__builtin_sub_overflow(x, y, &r)) 81 overflowed(); 82 return r; 83 } 84 85 int test_sub_overflow_xint31_xint31_xint31(_BitInt(31) x, _BitInt(31) y) { 86 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_sub_overflow_xint31_xint31_xint31({{.+}}) 87 // CHECK-NOT: ext 88 // CHECK: [[S:%.+]] = call { i31, i1 } @llvm.ssub.with.overflow.i31(i31 %{{.+}}, i31 %{{.+}}) 89 // CHECK-DAG: [[C:%.+]] = extractvalue { i31, i1 } [[S]], 1 90 // CHECK-DAG: [[Q:%.+]] = extractvalue { i31, i1 } [[S]], 0 91 // CHECK: store i31 [[Q]], ptr 92 // CHECK: br i1 [[C]] 93 _BitInt(31) r; 94 if (__builtin_sub_overflow(x, y, &r)) 95 overflowed(); 96 return r; 97 } 98 99 unsigned test_mul_overflow_uint_uint_uint(unsigned x, unsigned y) { 100 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_mul_overflow_uint_uint_uint 101 // CHECK-NOT: ext 102 // CHECK: [[S:%.+]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 103 // CHECK-DAG: [[Q:%.+]] = extractvalue { i32, i1 } [[S]], 0 104 // CHECK-DAG: [[C:%.+]] = extractvalue { i32, i1 } [[S]], 1 105 // CHECK: store i32 [[Q]], ptr 106 // CHECK: br i1 [[C]] 107 unsigned r; 108 if (__builtin_mul_overflow(x, y, &r)) 109 overflowed(); 110 return r; 111 } 112 113 int test_mul_overflow_uint_uint_int(unsigned x, unsigned y) { 114 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_mul_overflow_uint_uint_int 115 // CHECK: [[S:%.+]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 116 // CHECK-DAG: [[Q:%.+]] = extractvalue { i32, i1 } [[S]], 0 117 // CHECK-DAG: [[C:%.+]] = extractvalue { i32, i1 } [[S]], 1 118 // CHECK: [[C1:%.+]] = icmp ugt i32 [[Q]], 2147483647 119 // CHECK: [[C2:%.+]] = or i1 [[C]], [[C1]] 120 // CHECK: store i32 [[Q]], ptr 121 // CHECK: br i1 [[C2]] 122 int r; 123 if (__builtin_mul_overflow(x, y, &r)) 124 overflowed(); 125 return r; 126 } 127 128 int test_mul_overflow_uint_uint_int_volatile(unsigned x, unsigned y) { 129 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_mul_overflow_uint_uint_int_volatile 130 // CHECK: [[S:%.+]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 131 // CHECK-DAG: [[Q:%.+]] = extractvalue { i32, i1 } [[S]], 0 132 // CHECK-DAG: [[C:%.+]] = extractvalue { i32, i1 } [[S]], 1 133 // CHECK: [[C1:%.+]] = icmp ugt i32 [[Q]], 2147483647 134 // CHECK: [[C2:%.+]] = or i1 [[C]], [[C1]] 135 // CHECK: store volatile i32 [[Q]], ptr 136 // CHECK: br i1 [[C2]] 137 volatile int r; 138 if (__builtin_mul_overflow(x, y, &r)) 139 overflowed(); 140 return r; 141 } 142 143 long test_mul_overflow_ulong_ulong_long(unsigned long x, unsigned long y) { 144 // CHECK-LABEL: @test_mul_overflow_ulong_ulong_long 145 // CHECK: [[S:%.+]] = call { [[LONG_TYPE]], i1 } @llvm.umul.with.overflow.[[LONG_TYPE]]([[LONG_TYPE]] %{{.+}}, [[LONG_TYPE]] %{{.+}}) 146 // CHECK-DAG: [[Q:%.+]] = extractvalue { [[LONG_TYPE]], i1 } [[S]], 0 147 // CHECK-DAG: [[C:%.+]] = extractvalue { [[LONG_TYPE]], i1 } [[S]], 1 148 // CHECK: [[C1:%.+]] = icmp ugt [[LONG_TYPE]] [[Q]], [[LONG_MAX]] 149 // CHECK: [[C2:%.+]] = or i1 [[C]], [[C1]] 150 // LONG64: store [[LONG_TYPE]] [[Q]], ptr 151 // LONG64: br i1 [[C2]] 152 long r; 153 if (__builtin_mul_overflow(x, y, &r)) 154 overflowed(); 155 return r; 156 } 157 158 int test_mul_overflow_int_int_int(int x, int y) { 159 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_mul_overflow_int_int_int 160 // CHECK-NOT: ext 161 // CHECK: [[S:%.+]] = call { i32, i1 } @llvm.smul.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 162 // CHECK-DAG: [[C:%.+]] = extractvalue { i32, i1 } [[S]], 1 163 // CHECK-DAG: [[Q:%.+]] = extractvalue { i32, i1 } [[S]], 0 164 // CHECK: store i32 [[Q]], ptr 165 // CHECK: br i1 [[C]] 166 int r; 167 if (__builtin_mul_overflow(x, y, &r)) 168 overflowed(); 169 return r; 170 } 171 172 int test_mul_overflow_xint31_xint31_xint31(_BitInt(31) x, _BitInt(31) y) { 173 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_mul_overflow_xint31_xint31_xint31({{.+}}) 174 // CHECK-NOT: ext 175 // CHECK: [[S:%.+]] = call { i31, i1 } @llvm.smul.with.overflow.i31(i31 %{{.+}}, i31 %{{.+}}) 176 // CHECK-DAG: [[C:%.+]] = extractvalue { i31, i1 } [[S]], 1 177 // CHECK-DAG: [[Q:%.+]] = extractvalue { i31, i1 } [[S]], 0 178 // CHECK: store i31 [[Q]], ptr 179 // CHECK: br i1 [[C]] 180 _BitInt(31) r; 181 if (__builtin_mul_overflow(x, y, &r)) 182 overflowed(); 183 return r; 184 } 185 186 int test_mul_overflow_xint127_xint127_xint127(_BitInt(127) x, _BitInt(127) y) { 187 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_mul_overflow_xint127_xint127_xint127({{.+}}) 188 // CHECK-NOT: ext 189 // CHECK: [[S:%.+]] = call { i127, i1 } @llvm.smul.with.overflow.i127(i127 %{{.+}}, i127 %{{.+}}) 190 // CHECK-DAG: [[C:%.+]] = extractvalue { i127, i1 } [[S]], 1 191 // CHECK-DAG: [[Q:%.+]] = extractvalue { i127, i1 } [[S]], 0 192 // CHECK: store i127 [[Q]], ptr 193 // CHECK: br i1 [[C]] 194 _BitInt(127) r; 195 if (__builtin_mul_overflow(x, y, &r)) 196 overflowed(); 197 return r; 198 } 199 200 int test_mul_overflow_xint128_xint128_xint128(_BitInt(128) x, _BitInt(128) y) { 201 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_mul_overflow_xint128_xint128_xint128({{.+}}) 202 // CHECK-NOT: ext 203 // CHECK: [[S:%.+]] = call { i128, i1 } @llvm.smul.with.overflow.i128(i128 %{{.+}}, i128 %{{.+}}) 204 // CHECK-DAG: [[C:%.+]] = extractvalue { i128, i1 } [[S]], 1 205 // CHECK-DAG: [[Q:%.+]] = extractvalue { i128, i1 } [[S]], 0 206 // CHECK: store i128 [[Q]], ptr 207 // CHECK: br i1 [[C]] 208 _BitInt(128) r; 209 if (__builtin_mul_overflow(x, y, &r)) 210 overflowed(); 211 return r; 212 } 213 214 int test_add_overflow_uint_int_int(unsigned x, int y) { 215 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_add_overflow_uint_int_int 216 // CHECK: [[XE:%.+]] = zext i32 %{{.+}} to i33 217 // CHECK: [[YE:%.+]] = sext i32 %{{.+}} to i33 218 // CHECK: [[S:%.+]] = call { i33, i1 } @llvm.sadd.with.overflow.i33(i33 [[XE]], i33 [[YE]]) 219 // CHECK-DAG: [[Q:%.+]] = extractvalue { i33, i1 } [[S]], 0 220 // CHECK-DAG: [[C1:%.+]] = extractvalue { i33, i1 } [[S]], 1 221 // CHECK: [[QT:%.+]] = trunc i33 [[Q]] to i32 222 // CHECK: [[QTE:%.+]] = sext i32 [[QT]] to i33 223 // CHECK: [[C2:%.+]] = icmp ne i33 [[Q]], [[QTE]] 224 // CHECK: [[C3:%.+]] = or i1 [[C1]], [[C2]] 225 // CHECK: store i32 [[QT]], ptr 226 // CHECK: br i1 [[C3]] 227 int r; 228 if (__builtin_add_overflow(x, y, &r)) 229 overflowed(); 230 return r; 231 } 232 233 _Bool test_add_overflow_uint_uint_bool(unsigned x, unsigned y) { 234 // CHECK-LABEL: define {{.*}} i1 @test_add_overflow_uint_uint_bool 235 // CHECK-NOT: ext 236 // CHECK: [[S:%.+]] = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 237 // CHECK-DAG: [[Q:%.+]] = extractvalue { i32, i1 } [[S]], 0 238 // CHECK-DAG: [[C1:%.+]] = extractvalue { i32, i1 } [[S]], 1 239 // CHECK: [[QT:%.+]] = trunc i32 [[Q]] to i1 240 // CHECK: [[QTE:%.+]] = zext i1 [[QT]] to i32 241 // CHECK: [[C2:%.+]] = icmp ne i32 [[Q]], [[QTE]] 242 // CHECK: [[C3:%.+]] = or i1 [[C1]], [[C2]] 243 // CHECK: [[QT2:%.+]] = zext i1 [[QT]] to i8 244 // CHECK: store i8 [[QT2]], ptr 245 // CHECK: br i1 [[C3]] 246 _Bool r; 247 if (__builtin_add_overflow(x, y, &r)) 248 overflowed(); 249 return r; 250 } 251 252 unsigned test_add_overflow_bool_bool_uint(_Bool x, _Bool y) { 253 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_add_overflow_bool_bool_uint 254 // CHECK: [[XE:%.+]] = zext i1 %{{.+}} to i32 255 // CHECK: [[YE:%.+]] = zext i1 %{{.+}} to i32 256 // CHECK: [[S:%.+]] = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 [[XE]], i32 [[YE]]) 257 // CHECK-DAG: [[Q:%.+]] = extractvalue { i32, i1 } [[S]], 0 258 // CHECK-DAG: [[C:%.+]] = extractvalue { i32, i1 } [[S]], 1 259 // CHECK: store i32 [[Q]], ptr 260 // CHECK: br i1 [[C]] 261 unsigned r; 262 if (__builtin_add_overflow(x, y, &r)) 263 overflowed(); 264 return r; 265 } 266 267 _Bool test_add_overflow_bool_bool_bool(_Bool x, _Bool y) { 268 // CHECK-LABEL: define {{.*}} i1 @test_add_overflow_bool_bool_bool 269 // CHECK: [[S:%.+]] = call { i1, i1 } @llvm.uadd.with.overflow.i1(i1 %{{.+}}, i1 %{{.+}}) 270 // CHECK-DAG: [[Q:%.+]] = extractvalue { i1, i1 } [[S]], 0 271 // CHECK-DAG: [[C:%.+]] = extractvalue { i1, i1 } [[S]], 1 272 // CHECK: [[QT2:%.+]] = zext i1 [[Q]] to i8 273 // CHECK: store i8 [[QT2]], ptr 274 // CHECK: br i1 [[C]] 275 _Bool r; 276 if (__builtin_add_overflow(x, y, &r)) 277 overflowed(); 278 return r; 279 } 280 281 int test_add_overflow_volatile(int x, int y) { 282 // CHECK-LABEL: define {{(dso_local )?}}i32 @test_add_overflow_volatile 283 // CHECK: [[S:%.+]] = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 284 // CHECK-DAG: [[Q:%.+]] = extractvalue { i32, i1 } [[S]], 0 285 // CHECK-DAG: [[C:%.+]] = extractvalue { i32, i1 } [[S]], 1 286 // CHECK: store volatile i32 [[Q]], ptr 287 // CHECK: br i1 [[C]] 288 volatile int result; 289 if (__builtin_add_overflow(x, y, &result)) 290 overflowed(); 291 return result; 292 } 293 294 unsigned test_uadd_overflow(unsigned x, unsigned y) { 295 // CHECK: @test_uadd_overflow 296 // CHECK: %{{.+}} = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 297 unsigned result; 298 if (__builtin_uadd_overflow(x, y, &result)) 299 return UnsignedErrorCode; 300 return result; 301 } 302 303 unsigned long test_uaddl_overflow(unsigned long x, unsigned long y) { 304 // CHECK: @test_uaddl_overflow([[UL:i32|i64]] noundef %x 305 // CHECK: %{{.+}} = call { [[UL]], i1 } @llvm.uadd.with.overflow.[[UL]]([[UL]] %{{.+}}, [[UL]] %{{.+}}) 306 unsigned long result; 307 if (__builtin_uaddl_overflow(x, y, &result)) 308 return UnsignedLongErrorCode; 309 return result; 310 } 311 312 unsigned long long test_uaddll_overflow(unsigned long long x, unsigned long long y) { 313 // CHECK: @test_uaddll_overflow 314 // CHECK: %{{.+}} = call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 %{{.+}}, i64 %{{.+}}) 315 unsigned long long result; 316 if (__builtin_uaddll_overflow(x, y, &result)) 317 return UnsignedLongLongErrorCode; 318 return result; 319 } 320 321 unsigned test_usub_overflow(unsigned x, unsigned y) { 322 // CHECK: @test_usub_overflow 323 // CHECK: %{{.+}} = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 324 unsigned result; 325 if (__builtin_usub_overflow(x, y, &result)) 326 return UnsignedErrorCode; 327 return result; 328 } 329 330 unsigned long test_usubl_overflow(unsigned long x, unsigned long y) { 331 // CHECK: @test_usubl_overflow([[UL:i32|i64]] noundef %x 332 // CHECK: %{{.+}} = call { [[UL]], i1 } @llvm.usub.with.overflow.[[UL]]([[UL]] %{{.+}}, [[UL]] %{{.+}}) 333 unsigned long result; 334 if (__builtin_usubl_overflow(x, y, &result)) 335 return UnsignedLongErrorCode; 336 return result; 337 } 338 339 unsigned long long test_usubll_overflow(unsigned long long x, unsigned long long y) { 340 // CHECK: @test_usubll_overflow 341 // CHECK: %{{.+}} = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %{{.+}}, i64 %{{.+}}) 342 unsigned long long result; 343 if (__builtin_usubll_overflow(x, y, &result)) 344 return UnsignedLongLongErrorCode; 345 return result; 346 } 347 348 unsigned test_umul_overflow(unsigned x, unsigned y) { 349 // CHECK: @test_umul_overflow 350 // CHECK: %{{.+}} = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 351 unsigned result; 352 if (__builtin_umul_overflow(x, y, &result)) 353 return UnsignedErrorCode; 354 return result; 355 } 356 357 unsigned long test_umull_overflow(unsigned long x, unsigned long y) { 358 // CHECK: @test_umull_overflow([[UL:i32|i64]] noundef %x 359 // CHECK: %{{.+}} = call { [[UL]], i1 } @llvm.umul.with.overflow.[[UL]]([[UL]] %{{.+}}, [[UL]] %{{.+}}) 360 unsigned long result; 361 if (__builtin_umull_overflow(x, y, &result)) 362 return UnsignedLongErrorCode; 363 return result; 364 } 365 366 unsigned long long test_umulll_overflow(unsigned long long x, unsigned long long y) { 367 // CHECK: @test_umulll_overflow 368 // CHECK: %{{.+}} = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %{{.+}}, i64 %{{.+}}) 369 unsigned long long result; 370 if (__builtin_umulll_overflow(x, y, &result)) 371 return UnsignedLongLongErrorCode; 372 return result; 373 } 374 375 int test_sadd_overflow(int x, int y) { 376 // CHECK: @test_sadd_overflow 377 // CHECK: %{{.+}} = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 378 int result; 379 if (__builtin_sadd_overflow(x, y, &result)) 380 return IntErrorCode; 381 return result; 382 } 383 384 long test_saddl_overflow(long x, long y) { 385 // CHECK: @test_saddl_overflow([[UL:i32|i64]] noundef %x 386 // CHECK: %{{.+}} = call { [[UL]], i1 } @llvm.sadd.with.overflow.[[UL]]([[UL]] %{{.+}}, [[UL]] %{{.+}}) 387 long result; 388 if (__builtin_saddl_overflow(x, y, &result)) 389 return LongErrorCode; 390 return result; 391 } 392 393 long long test_saddll_overflow(long long x, long long y) { 394 // CHECK: @test_saddll_overflow 395 // CHECK: %{{.+}} = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %{{.+}}, i64 %{{.+}}) 396 long long result; 397 if (__builtin_saddll_overflow(x, y, &result)) 398 return LongLongErrorCode; 399 return result; 400 } 401 402 int test_ssub_overflow(int x, int y) { 403 // CHECK: @test_ssub_overflow 404 // CHECK: %{{.+}} = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 405 int result; 406 if (__builtin_ssub_overflow(x, y, &result)) 407 return IntErrorCode; 408 return result; 409 } 410 411 long test_ssubl_overflow(long x, long y) { 412 // CHECK: @test_ssubl_overflow([[UL:i32|i64]] noundef %x 413 // CHECK: %{{.+}} = call { [[UL]], i1 } @llvm.ssub.with.overflow.[[UL]]([[UL]] %{{.+}}, [[UL]] %{{.+}}) 414 long result; 415 if (__builtin_ssubl_overflow(x, y, &result)) 416 return LongErrorCode; 417 return result; 418 } 419 420 long long test_ssubll_overflow(long long x, long long y) { 421 // CHECK: @test_ssubll_overflow 422 // CHECK: %{{.+}} = call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 %{{.+}}, i64 %{{.+}}) 423 long long result; 424 if (__builtin_ssubll_overflow(x, y, &result)) 425 return LongLongErrorCode; 426 return result; 427 } 428 429 int test_smul_overflow(int x, int y) { 430 // CHECK: @test_smul_overflow 431 // CHECK: %{{.+}} = call { i32, i1 } @llvm.smul.with.overflow.i32(i32 %{{.+}}, i32 %{{.+}}) 432 int result; 433 if (__builtin_smul_overflow(x, y, &result)) 434 return IntErrorCode; 435 return result; 436 } 437 438 long test_smull_overflow(long x, long y) { 439 // CHECK: @test_smull_overflow([[UL:i32|i64]] noundef %x 440 // CHECK: %{{.+}} = call { [[UL]], i1 } @llvm.smul.with.overflow.[[UL]]([[UL]] %{{.+}}, [[UL]] %{{.+}}) 441 long result; 442 if (__builtin_smull_overflow(x, y, &result)) 443 return LongErrorCode; 444 return result; 445 } 446 447 long long test_smulll_overflow(long long x, long long y) { 448 // CHECK: @test_smulll_overflow 449 // CHECK: %{{.+}} = call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %{{.+}}, i64 %{{.+}}) 450 long long result; 451 if (__builtin_smulll_overflow(x, y, &result)) 452 return LongLongErrorCode; 453 return result; 454 } 455 456 int test_mixed_sign_mul_overflow_sext_signed_op(int x, unsigned long long y) { 457 // CHECK: @test_mixed_sign_mul_overflow_sext_signed_op 458 // CHECK: [[SignedOp:%.*]] = sext i32 %0 to i64 459 // CHECK: [[IsNeg:%.*]] = icmp slt i64 [[SignedOp]], 0 460 int result; 461 if (__builtin_mul_overflow(x, y, &result)) 462 return LongErrorCode; 463 return result; 464 } 465 466 int test_mixed_sign_mul_overflow_zext_unsigned_op(long long x, unsigned y) { 467 // CHECK: @test_mixed_sign_mul_overflow_zext_unsigned_op 468 // CHECK: [[UnsignedOp:%.*]] = zext i32 %1 to i64 469 // CHECK: [[IsNeg:%.*]] = icmp slt i64 %0, 0 470 // CHECK: @llvm.umul.with.overflow.i64({{.*}}, i64 [[UnsignedOp]]) 471 int result; 472 if (__builtin_mul_overflow(x, y, &result)) 473 return LongErrorCode; 474 return result; 475 } 476 477 int test_mixed_sign_mull_overflow(int x, unsigned y) { 478 // CHECK: @test_mixed_sign_mull_overflow 479 // CHECK: [[IsNeg:%.*]] = icmp slt i32 [[Op1:%.*]], 0 480 // CHECK-NEXT: [[Signed:%.*]] = sub i32 0, [[Op1]] 481 // CHECK-NEXT: [[AbsSigned:%.*]] = select i1 [[IsNeg]], i32 [[Signed]], i32 [[Op1]] 482 // CHECK-NEXT: call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[AbsSigned]], i32 %{{.*}}) 483 // CHECK-NEXT: [[UnsignedOFlow:%.*]] = extractvalue { i32, i1 } %{{.*}}, 1 484 // CHECK-NEXT: [[UnsignedResult:%.*]] = extractvalue { i32, i1 } %{{.*}}, 0 485 // CHECK-NEXT: [[IsNegZext:%.*]] = zext i1 [[IsNeg]] to i32 486 // CHECK-NEXT: [[MaxResult:%.*]] = add i32 2147483647, [[IsNegZext]] 487 // CHECK-NEXT: [[SignedOFlow:%.*]] = icmp ugt i32 [[UnsignedResult]], [[MaxResult]] 488 // CHECK-NEXT: [[OFlow:%.*]] = or i1 [[UnsignedOFlow]], [[SignedOFlow]] 489 // CHECK-NEXT: [[NegativeResult:%.*]] = sub i32 0, [[UnsignedResult]] 490 // CHECK-NEXT: [[Result:%.*]] = select i1 [[IsNeg]], i32 [[NegativeResult]], i32 [[UnsignedResult]] 491 // CHECK-NEXT: store i32 [[Result]], ptr %{{.*}}, align 4 492 // CHECK: br i1 [[OFlow]] 493 494 int result; 495 if (__builtin_mul_overflow(x, y, &result)) 496 return LongErrorCode; 497 return result; 498 } 499 500 int test_mixed_sign_mull_overflow_unsigned(int x, unsigned y) { 501 // CHECK: @test_mixed_sign_mull_overflow_unsigned 502 // CHECK: [[IsNeg:%.*]] = icmp slt i32 [[Op1:%.*]], 0 503 // CHECK-NEXT: [[Signed:%.*]] = sub i32 0, [[Op1]] 504 // CHECK-NEXT: [[AbsSigned:%.*]] = select i1 [[IsNeg]], i32 [[Signed]], i32 [[Op1]] 505 // CHECK-NEXT: call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[AbsSigned]], i32 %{{.*}}) 506 // CHECK-NEXT: [[UnsignedOFlow:%.*]] = extractvalue { i32, i1 } %{{.*}}, 1 507 // CHECK-NEXT: [[UnsignedResult:%.*]] = extractvalue { i32, i1 } %{{.*}}, 0 508 // CHECK-NEXT: [[NotNull:%.*]] = icmp ne i32 [[UnsignedResult]], 0 509 // CHECK-NEXT: [[Underflow:%.*]] = and i1 [[IsNeg]], [[NotNull]] 510 // CHECK-NEXT: [[OFlow:%.*]] = or i1 [[UnsignedOFlow]], [[Underflow]] 511 // CHECK-NEXT: [[NegatedResult:%.*]] = sub i32 0, [[UnsignedResult]] 512 // CHECK-NEXT: [[Result:%.*]] = select i1 [[IsNeg]], i32 [[NegatedResult]], i32 [[UnsignedResult]] 513 // CHECK-NEXT: store i32 [[Result]], ptr %{{.*}}, align 4 514 // CHECK: br i1 [[OFlow]] 515 516 unsigned result; 517 if (__builtin_mul_overflow(x, y, &result)) 518 return LongErrorCode; 519 return result; 520 } 521 522 int test_mixed_sign_mull_overflow_swapped(int x, unsigned y) { 523 // CHECK: @test_mixed_sign_mull_overflow_swapped 524 // CHECK: call { i32, i1 } @llvm.umul.with.overflow.i32 525 // CHECK: add i32 2147483647 526 int result; 527 if (__builtin_mul_overflow(y, x, &result)) 528 return LongErrorCode; 529 return result; 530 } 531 532 long long test_mixed_sign_mulll_overflow(long long x, unsigned long long y) { 533 // CHECK: @test_mixed_sign_mulll_overflow 534 // CHECK: call { i64, i1 } @llvm.umul.with.overflow.i64 535 // CHECK: add i64 92233720368547 536 long long result; 537 if (__builtin_mul_overflow(x, y, &result)) 538 return LongLongErrorCode; 539 return result; 540 } 541 542 long long test_mixed_sign_mulll_overflow_swapped(long long x, unsigned long long y) { 543 // CHECK: @test_mixed_sign_mulll_overflow_swapped 544 // CHECK: call { i64, i1 } @llvm.umul.with.overflow.i64 545 // CHECK: add i64 92233720368547 546 long long result; 547 if (__builtin_mul_overflow(y, x, &result)) 548 return LongLongErrorCode; 549 return result; 550 } 551 552 long long test_mixed_sign_mulll_overflow_trunc_signed(long long x, unsigned long long y) { 553 // CHECK: @test_mixed_sign_mulll_overflow_trunc_signed 554 // CHECK: call { i64, i1 } @llvm.umul.with.overflow.i64 555 // CHECK: add i64 2147483647 556 // CHECK: trunc 557 // CHECK: store 558 int result; 559 if (__builtin_mul_overflow(y, x, &result)) 560 return LongLongErrorCode; 561 return result; 562 } 563 564 long long test_mixed_sign_mulll_overflow_trunc_unsigned(long long x, unsigned long long y) { 565 // CHECK: @test_mixed_sign_mulll_overflow_trunc_unsigned 566 // CHECK: call { i64, i1 } @llvm.umul.with.overflow.i64 567 // CHECK: [[NON_ZERO:%.*]] = icmp ne i64 [[UNSIGNED_RESULT:%.*]], 0 568 // CHECK-NEXT: [[UNDERFLOW:%.*]] = and i1 {{.*}}, [[NON_ZERO]] 569 // CHECK-NEXT: [[OVERFLOW_PRE_TRUNC:%.*]] = or i1 {{.*}}, [[UNDERFLOW]] 570 // CHECK-NEXT: [[TRUNC_OVERFLOW:%.*]] = icmp ugt i64 [[UNSIGNED_RESULT]], 4294967295 571 // CHECK-NEXT: [[OVERFLOW:%.*]] = or i1 [[OVERFLOW_PRE_TRUNC]], [[TRUNC_OVERFLOW]] 572 // CHECK-NEXT: [[NEGATED:%.*]] = sub i64 0, [[UNSIGNED_RESULT]] 573 // CHECK-NEXT: [[RESULT:%.*]] = select i1 {{.*}}, i64 [[NEGATED]], i64 [[UNSIGNED_RESULT]] 574 // CHECK-NEXT: trunc i64 [[RESULT]] to i32 575 // CHECK-NEXT: store 576 unsigned result; 577 if (__builtin_mul_overflow(y, x, &result)) 578 return LongLongErrorCode; 579 return result; 580 } 581 582 long long test_mixed_sign_mul_overflow_extend_signed(int x, unsigned y) { 583 // CHECK: @test_mixed_sign_mul_overflow_extend_signed 584 // CHECK: call { i64, i1 } @llvm.smul.with.overflow.i64 585 long long result; 586 if (__builtin_mul_overflow(y, x, &result)) 587 return LongLongErrorCode; 588 return result; 589 } 590 591 long long test_mixed_sign_mul_overflow_extend_unsigned(int x, unsigned y) { 592 // CHECK: @test_mixed_sign_mul_overflow_extend_unsigned 593 // CHECK: call { i65, i1 } @llvm.smul.with.overflow.i65 594 unsigned long long result; 595 if (__builtin_mul_overflow(y, x, &result)) 596 return LongLongErrorCode; 597 return result; 598 } 599