test/Transforms/InstCombine/intrinsics.ll

   1 ; RUN: opt -instcombine -S < %s | FileCheck %s
   2
   3 %overflow.result = type {i8, i1}
   4 %ov.result.32 = type { i32, i1 }
   5
   6
   7 declare %overflow.result @llvm.uadd.with.overflow.i8(i8, i8) nounwind readnone
   8 declare %overflow.result @llvm.umul.with.overflow.i8(i8, i8) nounwind readnone
   9 declare %ov.result.32 @llvm.sadd.with.overflow.i32(i32, i32) nounwind readnone
  10 declare %ov.result.32 @llvm.uadd.with.overflow.i32(i32, i32) nounwind readnone
  11 declare %ov.result.32 @llvm.ssub.with.overflow.i32(i32, i32) nounwind readnone
  12 declare %ov.result.32 @llvm.usub.with.overflow.i32(i32, i32) nounwind readnone
  13 declare %ov.result.32 @llvm.smul.with.overflow.i32(i32, i32) nounwind readnone
  14 declare %ov.result.32 @llvm.umul.with.overflow.i32(i32, i32) nounwind readnone
  15 declare double @llvm.powi.f64(double, i32) nounwind readonly
  16 declare i32 @llvm.cttz.i32(i32, i1) nounwind readnone
  17 declare i32 @llvm.ctlz.i32(i32, i1) nounwind readnone
  18 declare i32 @llvm.ctpop.i32(i32) nounwind readnone
  19 declare i8 @llvm.ctlz.i8(i8, i1) nounwind readnone
  20 declare double @llvm.cos.f64(double %Val) nounwind readonly
  21 declare double @llvm.sin.f64(double %Val) nounwind readonly
  22
  23 define i8 @uaddtest1(i8 %A, i8 %B) {
  24   %x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 %A, i8 %B)
  25   %y = extractvalue %overflow.result %x, 0
  26   ret i8 %y
  27 ; CHECK-LABEL: @uaddtest1(
  28 ; CHECK-NEXT: %y = add i8 %A, %B
  29 ; CHECK-NEXT: ret i8 %y
  30 }
  31
  32 define i8 @uaddtest2(i8 %A, i8 %B, i1* %overflowPtr) {
  33   %and.A = and i8 %A, 127
  34   %and.B = and i8 %B, 127
  35   %x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 %and.A, i8 %and.B)
  36   %y = extractvalue %overflow.result %x, 0
  37   %z = extractvalue %overflow.result %x, 1
  38   store i1 %z, i1* %overflowPtr
  39   ret i8 %y
  40 ; CHECK-LABEL: @uaddtest2(
  41 ; CHECK-NEXT: %and.A = and i8 %A, 127
  42 ; CHECK-NEXT: %and.B = and i8 %B, 127
  43 ; CHECK-NEXT: %x = add nuw i8 %and.A, %and.B
  44 ; CHECK-NEXT: store i1 false, i1* %overflowPtr
  45 ; CHECK-NEXT: ret i8 %x
  46 }
  47
  48 define i8 @uaddtest3(i8 %A, i8 %B, i1* %overflowPtr) {
  49   %or.A = or i8 %A, -128
  50   %or.B = or i8 %B, -128
  51   %x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 %or.A, i8 %or.B)
  52   %y = extractvalue %overflow.result %x, 0
  53   %z = extractvalue %overflow.result %x, 1
  54   store i1 %z, i1* %overflowPtr
  55   ret i8 %y
  56 ; CHECK-LABEL: @uaddtest3(
  57 ; CHECK-NEXT: %or.A = or i8 %A, -128
  58 ; CHECK-NEXT: %or.B = or i8 %B, -128
  59 ; CHECK-NEXT: %x = add i8 %or.A, %or.B
  60 ; CHECK-NEXT: store i1 true, i1* %overflowPtr
  61 ; CHECK-NEXT: ret i8 %x
  62 }
  63
  64 define i8 @uaddtest4(i8 %A, i1* %overflowPtr) {
  65   %x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 undef, i8 %A)
  66   %y = extractvalue %overflow.result %x, 0
  67   %z = extractvalue %overflow.result %x, 1
  68   store i1 %z, i1* %overflowPtr
  69   ret i8 %y
  70 ; CHECK-LABEL: @uaddtest4(
  71 ; CHECK-NEXT: ret i8 undef
  72 }
  73
  74 define i8 @uaddtest5(i8 %A, i1* %overflowPtr) {
  75   %x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 0, i8 %A)
  76   %y = extractvalue %overflow.result %x, 0
  77   %z = extractvalue %overflow.result %x, 1
  78   store i1 %z, i1* %overflowPtr
  79   ret i8 %y
  80 ; CHECK-LABEL: @uaddtest5(
  81 ; CHECK: ret i8 %A
  82 }
  83
  84 define i1 @uaddtest6(i8 %A, i8 %B) {
  85   %x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 %A, i8 -4)
  86   %z = extractvalue %overflow.result %x, 1
  87   ret i1 %z
  88 ; CHECK-LABEL: @uaddtest6(
  89 ; CHECK-NEXT: %z = icmp ugt i8 %A, 3
  90 ; CHECK-NEXT: ret i1 %z
  91 }
  92
  93 define i8 @uaddtest7(i8 %A, i8 %B) {
  94   %x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 %A, i8 %B)
  95   %z = extractvalue %overflow.result %x, 0
  96   ret i8 %z
  97 ; CHECK-LABEL: @uaddtest7(
  98 ; CHECK-NEXT: %z = add i8 %A, %B
  99 ; CHECK-NEXT: ret i8 %z
 100 }
 101
 102 ; PR20194
 103 define %ov.result.32 @saddtest_nsw(i8 %a, i8 %b) {
 104   %A = sext i8 %a to i32
 105   %B = sext i8 %b to i32
 106   %x = call %ov.result.32 @llvm.sadd.with.overflow.i32(i32 %A, i32 %B)
 107   ret %ov.result.32 %x
 108 ; CHECK-LABEL: @saddtest_nsw
 109 ; CHECK: %x = add nsw i32 %A, %B
 110 ; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
 111 ; CHECK-NEXT:  ret %ov.result.32 %1
 112 }
 113
 114 define %ov.result.32 @uaddtest_nuw(i32 %a, i32 %b) {
 115   %A = and i32 %a, 2147483647
 116   %B = and i32 %b, 2147483647
 117   %x = call %ov.result.32 @llvm.uadd.with.overflow.i32(i32 %A, i32 %B)
 118   ret %ov.result.32 %x
 119 ; CHECK-LABEL: @uaddtest_nuw
 120 ; CHECK: %x = add nuw i32 %A, %B
 121 ; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
 122 ; CHECK-NEXT:  ret %ov.result.32 %1
 123 }
 124
 125 define %ov.result.32 @ssubtest_nsw(i8 %a, i8 %b) {
 126   %A = sext i8 %a to i32
 127   %B = sext i8 %b to i32
 128   %x = call %ov.result.32 @llvm.ssub.with.overflow.i32(i32 %A, i32 %B)
 129   ret %ov.result.32 %x
 130 ; CHECK-LABEL: @ssubtest_nsw
 131 ; CHECK: %x = sub nsw i32 %A, %B
 132 ; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
 133 ; CHECK-NEXT:  ret %ov.result.32 %1
 134 }
 135
 136 define %ov.result.32 @usubtest_nuw(i32 %a, i32 %b) {
 137   %A = or i32 %a, 2147483648
 138   %B = and i32 %b, 2147483647
 139   %x = call %ov.result.32 @llvm.usub.with.overflow.i32(i32 %A, i32 %B)
 140   ret %ov.result.32 %x
 141 ; CHECK-LABEL: @usubtest_nuw
 142 ; CHECK: %x = sub nuw i32 %A, %B
 143 ; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
 144 ; CHECK-NEXT:  ret %ov.result.32 %1
 145 }
 146
 147 define %ov.result.32 @smultest1_nsw(i32 %a, i32 %b) {
 148   %A = and i32 %a, 4095 ; 0xfff
 149   %B = and i32 %b, 524287; 0x7ffff
 150   %x = call %ov.result.32 @llvm.smul.with.overflow.i32(i32 %A, i32 %B)
 151   ret %ov.result.32 %x
 152 ; CHECK-LABEL: @smultest1_nsw
 153 ; CHECK: %x = mul nuw nsw i32 %A, %B
 154 ; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
 155 ; CHECK-NEXT:  ret %ov.result.32 %1
 156 }
 157
 158 define %ov.result.32 @smultest2_nsw(i32 %a, i32 %b) {
 159   %A = ashr i32 %a, 16
 160   %B = ashr i32 %b, 16
 161   %x = call %ov.result.32 @llvm.smul.with.overflow.i32(i32 %A, i32 %B)
 162   ret %ov.result.32 %x
 163 ; CHECK-LABEL: @smultest2_nsw
 164 ; CHECK: %x = mul nsw i32 %A, %B
 165 ; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
 166 ; CHECK-NEXT:  ret %ov.result.32 %1
 167 }
 168
 169 define %ov.result.32 @smultest3_sw(i32 %a, i32 %b) {
 170   %A = ashr i32 %a, 16
 171   %B = ashr i32 %b, 15
 172   %x = call %ov.result.32 @llvm.smul.with.overflow.i32(i32 %A, i32 %B)
 173   ret %ov.result.32 %x
 174 ; CHECK-LABEL: @smultest3_sw
 175 ; CHECK: %x = call %ov.result.32 @llvm.smul.with.overflow.i32(i32 %A, i32 %B)
 176 ; CHECK-NEXT:  ret %ov.result.32 %x
 177 }
 178
 179 define %ov.result.32 @umultest_nuw(i32 %a, i32 %b) {
 180   %A = and i32 %a, 65535 ; 0xffff
 181   %B = and i32 %b, 65535 ; 0xffff
 182   %x = call %ov.result.32 @llvm.umul.with.overflow.i32(i32 %A, i32 %B)
 183   ret %ov.result.32 %x
 184 ; CHECK-LABEL: @umultest_nuw
 185 ; CHECK: %x = mul nuw i32 %A, %B
 186 ; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
 187 ; CHECK-NEXT:  ret %ov.result.32 %1
 188 }
 189
 190 define i8 @umultest1(i8 %A, i1* %overflowPtr) {
 191   %x = call %overflow.result @llvm.umul.with.overflow.i8(i8 0, i8 %A)
 192   %y = extractvalue %overflow.result %x, 0
 193   %z = extractvalue %overflow.result %x, 1
 194   store i1 %z, i1* %overflowPtr
 195   ret i8 %y
 196 ; CHECK-LABEL: @umultest1(
 197 ; CHECK-NEXT: store i1 false, i1* %overflowPtr
 198 ; CHECK-NEXT: ret i8 0
 199 }
 200
 201 define i8 @umultest2(i8 %A, i1* %overflowPtr) {
 202   %x = call %overflow.result @llvm.umul.with.overflow.i8(i8 1, i8 %A)
 203   %y = extractvalue %overflow.result %x, 0
 204   %z = extractvalue %overflow.result %x, 1
 205   store i1 %z, i1* %overflowPtr
 206   ret i8 %y
 207 ; CHECK-LABEL: @umultest2(
 208 ; CHECK-NEXT: store i1 false, i1* %overflowPtr
 209 ; CHECK-NEXT: ret i8 %A
 210 }
 211
 212 define i32 @umultest3(i32 %n) nounwind {
 213   %shr = lshr i32 %n, 2
 214   %mul = call %ov.result.32 @llvm.umul.with.overflow.i32(i32 %shr, i32 3)
 215   %ov = extractvalue %ov.result.32 %mul, 1
 216   %res = extractvalue %ov.result.32 %mul, 0
 217   %ret = select i1 %ov, i32 -1, i32 %res
 218   ret i32 %ret
 219 ; CHECK-LABEL: @umultest3(
 220 ; CHECK-NEXT: shr
 221 ; CHECK-NEXT: mul nuw
 222 ; CHECK-NEXT: ret
 223 }
 224
 225 define i32 @umultest4(i32 %n) nounwind {
 226   %shr = lshr i32 %n, 1
 227   %mul = call %ov.result.32 @llvm.umul.with.overflow.i32(i32 %shr, i32 4)
 228   %ov = extractvalue %ov.result.32 %mul, 1
 229   %res = extractvalue %ov.result.32 %mul, 0
 230   %ret = select i1 %ov, i32 -1, i32 %res
 231   ret i32 %ret
 232 ; CHECK-LABEL: @umultest4(
 233 ; CHECK: umul.with.overflow
 234 }
 235
 236 define %ov.result.32 @umultest5(i32 %x, i32 %y) nounwind {
 237   %or_x = or i32 %x, 2147483648
 238   %or_y = or i32 %y, 2147483648
 239   %mul = call %ov.result.32 @llvm.umul.with.overflow.i32(i32 %or_x, i32 %or_y)
 240   ret %ov.result.32 %mul
 241 ; CHECK-LABEL: @umultest5(
 242 ; CHECK-NEXT: %[[or_x:.*]] = or i32 %x, -2147483648
 243 ; CHECK-NEXT: %[[or_y:.*]] = or i32 %y, -2147483648
 244 ; CHECK-NEXT: %[[mul:.*]] = mul i32 %[[or_x]], %[[or_y]]
 245 ; CHECK-NEXT: %[[ret:.*]] = insertvalue %ov.result.32 { i32 undef, i1 true }, i32 %[[mul]], 0
 246 ; CHECK-NEXT: ret %ov.result.32 %[[ret]]
 247 }
 248
 249 define void @powi(double %V, double *%P) {
 250 entry:
 251   %A = tail call double @llvm.powi.f64(double %V, i32 -1) nounwind
 252   store volatile double %A, double* %P
 253
 254   %B = tail call double @llvm.powi.f64(double %V, i32 0) nounwind
 255   store volatile double %B, double* %P
 256
 257   %C = tail call double @llvm.powi.f64(double %V, i32 1) nounwind
 258   store volatile double %C, double* %P
 259   ret void
 260 ; CHECK-LABEL: @powi(
 261 ; CHECK: %A = fdiv double 1.0{{.*}}, %V
 262 ; CHECK: store volatile double %A,
 263 ; CHECK: store volatile double 1.0
 264 ; CHECK: store volatile double %V
 265 }
 266
 267 define i32 @cttz(i32 %a) {
 268 entry:
 269   %or = or i32 %a, 8
 270   %and = and i32 %or, -8
 271   %count = tail call i32 @llvm.cttz.i32(i32 %and, i1 true) nounwind readnone
 272   ret i32 %count
 273 ; CHECK-LABEL: @cttz(
 274 ; CHECK-NEXT: entry:
 275 ; CHECK-NEXT: ret i32 3
 276 }
 277
 278 define i8 @ctlz(i8 %a) {
 279 entry:
 280   %or = or i8 %a, 32
 281   %and = and i8 %or, 63
 282   %count = tail call i8 @llvm.ctlz.i8(i8 %and, i1 true) nounwind readnone
 283   ret i8 %count
 284 ; CHECK-LABEL: @ctlz(
 285 ; CHECK-NEXT: entry:
 286 ; CHECK-NEXT: ret i8 2
 287 }
 288
 289 define void @cmp.simplify(i32 %a, i32 %b, i1* %c) {
 290 entry:
 291   %lz = tail call i32 @llvm.ctlz.i32(i32 %a, i1 false) nounwind readnone
 292   %lz.cmp = icmp eq i32 %lz, 32
 293   store volatile i1 %lz.cmp, i1* %c
 294   %tz = tail call i32 @llvm.cttz.i32(i32 %a, i1 false) nounwind readnone
 295   %tz.cmp = icmp ne i32 %tz, 32
 296   store volatile i1 %tz.cmp, i1* %c
 297   %pop = tail call i32 @llvm.ctpop.i32(i32 %b) nounwind readnone
 298   %pop.cmp = icmp eq i32 %pop, 0
 299   store volatile i1 %pop.cmp, i1* %c
 300   ret void
 301 ; CHECK: @cmp.simplify
 302 ; CHECK-NEXT: entry:
 303 ; CHECK-NEXT: %lz.cmp = icmp eq i32 %a, 0
 304 ; CHECK-NEXT: store volatile i1 %lz.cmp, i1* %c
 305 ; CHECK-NEXT: %tz.cmp = icmp ne i32 %a, 0
 306 ; CHECK-NEXT: store volatile i1 %tz.cmp, i1* %c
 307 ; CHECK-NEXT: %pop.cmp = icmp eq i32 %b, 0
 308 ; CHECK-NEXT: store volatile i1 %pop.cmp, i1* %c
 309 }
 310
 311 define i32 @cttz_simplify1a(i32 %x) nounwind readnone ssp {
 312   %tmp1 = tail call i32 @llvm.ctlz.i32(i32 %x, i1 false)
 313   %shr3 = lshr i32 %tmp1, 5
 314   ret i32 %shr3
 315
 316 ; CHECK-LABEL: @cttz_simplify1a(
 317 ; CHECK: icmp eq i32 %x, 0
 318 ; CHECK-NEXT: zext i1
 319 ; CHECK-NEXT: ret i32
 320 }
 321
 322 define i32 @cttz_simplify1b(i32 %x) nounwind readnone ssp {
 323   %tmp1 = tail call i32 @llvm.ctlz.i32(i32 %x, i1 true)
 324   %shr3 = lshr i32 %tmp1, 5
 325   ret i32 %shr3
 326
 327 ; CHECK-LABEL: @cttz_simplify1b(
 328 ; CHECK-NEXT: ret i32 0
 329 }
 330
 331 define i32 @ctlz_undef(i32 %Value) nounwind {
 332   %ctlz = call i32 @llvm.ctlz.i32(i32 0, i1 true)
 333   ret i32 %ctlz
 334
 335 ; CHECK-LABEL: @ctlz_undef(
 336 ; CHECK-NEXT: ret i32 undef
 337 }
 338
 339 define i32 @cttz_undef(i32 %Value) nounwind {
 340   %cttz = call i32 @llvm.cttz.i32(i32 0, i1 true)
 341   ret i32 %cttz
 342
 343 ; CHECK-LABEL: @cttz_undef(
 344 ; CHECK-NEXT: ret i32 undef
 345 }
 346
 347 define i32 @ctlz_select(i32 %Value) nounwind {
 348   %tobool = icmp ne i32 %Value, 0
 349   %ctlz = call i32 @llvm.ctlz.i32(i32 %Value, i1 true)
 350   %s = select i1 %tobool, i32 %ctlz, i32 32
 351   ret i32 %s
 352
 353 ; CHECK-LABEL: @ctlz_select(
 354 ; CHECK-NEXT: call i32 @llvm.ctlz.i32(i32 %Value, i1 false)
 355 ; CHECK-NEXT: ret i32
 356 }
 357
 358 define i32 @cttz_select(i32 %Value) nounwind {
 359   %tobool = icmp ne i32 %Value, 0
 360   %cttz = call i32 @llvm.cttz.i32(i32 %Value, i1 true)
 361   %s = select i1 %tobool, i32 %cttz, i32 32
 362   ret i32 %s
 363
 364 ; CHECK-LABEL: @cttz_select(
 365 ; CHECK-NEXT: call i32 @llvm.cttz.i32(i32 %Value, i1 false)
 366 ; CHECK-NEXT: ret i32
 367 }
 368
 369 ; CHECK-LABEL: @overflow_div_add(
 370 ; CHECK: ret i1 false
 371 define i1 @overflow_div_add(i32 %v1, i32 %v2) nounwind {
 372 entry:
 373   %div = sdiv i32 %v1, 2
 374   %t = call %ov.result.32 @llvm.sadd.with.overflow.i32(i32 %div, i32 1)
 375   %obit = extractvalue %ov.result.32 %t, 1
 376   ret i1 %obit
 377 }
 378
 379 ; CHECK-LABEL: @overflow_div_sub(
 380 ; CHECK: ret i1 false
 381 define i1 @overflow_div_sub(i32 %v1, i32 %v2) nounwind {
 382 entry:
 383   ; Check cases where the known sign bits are larger than the word size.
 384   %a = ashr i32 %v1, 18
 385   %div = sdiv i32 %a, 65536
 386   %t = call %ov.result.32 @llvm.ssub.with.overflow.i32(i32 %div, i32 1)
 387   %obit = extractvalue %ov.result.32 %t, 1
 388   ret i1 %obit
 389 }
 390
 391 ; CHECK-LABEL: @overflow_mod_mul(
 392 ; CHECK: ret i1 false
 393 define i1 @overflow_mod_mul(i32 %v1, i32 %v2) nounwind {
 394 entry:
 395   %rem = srem i32 %v1, 1000
 396   %t = call %ov.result.32 @llvm.smul.with.overflow.i32(i32 %rem, i32 %rem)
 397   %obit = extractvalue %ov.result.32 %t, 1
 398   ret i1 %obit
 399 }
 400
 401 ; CHECK-LABEL: @overflow_mod_overflow_mul(
 402 ; CHECK-NOT: ret i1 false
 403 define i1 @overflow_mod_overflow_mul(i32 %v1, i32 %v2) nounwind {
 404 entry:
 405   %rem = srem i32 %v1, 65537
 406   ; This may overflow because the result of the mul operands may be greater than 16bits
 407   ; and the result greater than 32.
 408   %t = call %ov.result.32 @llvm.smul.with.overflow.i32(i32 %rem, i32 %rem)
 409   %obit = extractvalue %ov.result.32 %t, 1
 410   ret i1 %obit
 411 }
 412
 413 define %ov.result.32 @ssubtest_reorder(i8 %a) {
 414   %A = sext i8 %a to i32
 415   %x = call %ov.result.32 @llvm.ssub.with.overflow.i32(i32 0, i32 %A)
 416   ret %ov.result.32 %x
 417 ; CHECK-LABEL: @ssubtest_reorder
 418 ; CHECK: %x = sub nsw i32 0, %A
 419 ; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
 420 ; CHECK-NEXT:  ret %ov.result.32 %1
 421 }
 422
 423 define %ov.result.32 @never_overflows_ssub_test0(i32 %a) {
 424   %x = call %ov.result.32 @llvm.ssub.with.overflow.i32(i32 %a, i32 0)
 425   ret %ov.result.32 %x
 426 ; CHECK-LABEL: @never_overflows_ssub_test0
 427 ; CHECK-NEXT: %[[x:.*]] = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %a, 0
 428 ; CHECK-NEXT:  ret %ov.result.32 %[[x]]
 429 }
 430
 431 define void @cos(double *%P) {
 432 entry:
 433   %B = tail call double @llvm.cos.f64(double 0.0) nounwind
 434   store volatile double %B, double* %P
 435
 436   ret void
 437 ; CHECK-LABEL: @cos(
 438 ; CHECK: store volatile double 1.000000e+00, double* %P
 439 }
 440
 441 define void @sin(double *%P) {
 442 entry:
 443   %B = tail call double @llvm.sin.f64(double 0.0) nounwind
 444   store volatile double %B, double* %P
 445
 446   ret void
 447 ; CHECK-LABEL: @sin(
 448 ; CHECK: store volatile double 0.000000e+00, double* %P
 449 }