llvm/test/Transforms/InstCombine/div-shift.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
   3
   4 declare void @use(i8)
   5 declare void @use32(i32)
   6
   7 declare i8 @llvm.umin.i8(i8, i8)
   8 declare i8 @llvm.umax.i8(i8, i8)
   9 declare i8 @llvm.smin.i8(i8, i8)
  10 declare i8 @llvm.smax.i8(i8, i8)
  11
  12 define i32 @t1(i16 zeroext %x, i32 %y) {
  13 ; CHECK-LABEL: @t1(
  14 ; CHECK-NEXT:    [[CONV:%.*]] = zext i16 [[X:%.*]] to i32
  15 ; CHECK-NEXT:    [[TMP1:%.*]] = add i32 [[Y:%.*]], 1
  16 ; CHECK-NEXT:    [[D1:%.*]] = lshr i32 [[CONV]], [[TMP1]]
  17 ; CHECK-NEXT:    ret i32 [[D1]]
  18 ;
  19   %conv = zext i16 %x to i32
  20   %s = shl i32 2, %y
  21   %d = sdiv i32 %conv, %s
  22   ret i32 %d
  23 }
  24
  25 define <2 x i32> @t1vec(<2 x i16> %x, <2 x i32> %y) {
  26 ; CHECK-LABEL: @t1vec(
  27 ; CHECK-NEXT:    [[CONV:%.*]] = zext <2 x i16> [[X:%.*]] to <2 x i32>
  28 ; CHECK-NEXT:    [[TMP1:%.*]] = add <2 x i32> [[Y:%.*]], <i32 1, i32 1>
  29 ; CHECK-NEXT:    [[D1:%.*]] = lshr <2 x i32> [[CONV]], [[TMP1]]
  30 ; CHECK-NEXT:    ret <2 x i32> [[D1]]
  31 ;
  32   %conv = zext <2 x i16> %x to <2 x i32>
  33   %s = shl <2 x i32> <i32 2, i32 2>, %y
  34   %d = sdiv <2 x i32> %conv, %s
  35   ret <2 x i32> %d
  36 }
  37
  38 ; rdar://11721329
  39 define i64 @t2(i64 %x, i32 %y) {
  40 ; CHECK-LABEL: @t2(
  41 ; CHECK-NEXT:    [[TMP1:%.*]] = zext nneg i32 [[Y:%.*]] to i64
  42 ; CHECK-NEXT:    [[TMP2:%.*]] = lshr i64 [[X:%.*]], [[TMP1]]
  43 ; CHECK-NEXT:    ret i64 [[TMP2]]
  44 ;
  45   %1 = shl i32 1, %y
  46   %2 = zext i32 %1 to i64
  47   %3 = udiv i64 %x, %2
  48   ret i64 %3
  49 }
  50
  51 ; PR13250
  52 define i64 @t3(i64 %x, i32 %y) {
  53 ; CHECK-LABEL: @t3(
  54 ; CHECK-NEXT:    [[TMP1:%.*]] = add i32 [[Y:%.*]], 2
  55 ; CHECK-NEXT:    [[TMP2:%.*]] = zext nneg i32 [[TMP1]] to i64
  56 ; CHECK-NEXT:    [[TMP3:%.*]] = lshr i64 [[X:%.*]], [[TMP2]]
  57 ; CHECK-NEXT:    ret i64 [[TMP3]]
  58 ;
  59   %1 = shl i32 4, %y
  60   %2 = zext i32 %1 to i64
  61   %3 = udiv i64 %x, %2
  62   ret i64 %3
  63 }
  64
  65 define i32 @t4(i32 %x, i32 %y) {
  66 ; CHECK-LABEL: @t4(
  67 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.umax.i32(i32 [[Y:%.*]], i32 5)
  68 ; CHECK-NEXT:    [[TMP2:%.*]] = lshr i32 [[X:%.*]], [[TMP1]]
  69 ; CHECK-NEXT:    ret i32 [[TMP2]]
  70 ;
  71   %1 = shl i32 1, %y
  72   %2 = icmp ult i32 %1, 32
  73   %3 = select i1 %2, i32 32, i32 %1
  74   %4 = udiv i32 %x, %3
  75   ret i32 %4
  76 }
  77
  78 define i32 @t5(i1 %x, i1 %y, i32 %V) {
  79 ; CHECK-LABEL: @t5(
  80 ; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[X:%.*]], i32 5, i32 6
  81 ; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[Y:%.*]], i32 [[TMP1]], i32 [[V:%.*]]
  82 ; CHECK-NEXT:    [[TMP3:%.*]] = lshr i32 [[V]], [[TMP2]]
  83 ; CHECK-NEXT:    ret i32 [[TMP3]]
  84 ;
  85   %1 = shl i32 1, %V
  86   %2 = select i1 %x, i32 32, i32 64
  87   %3 = select i1 %y, i32 %2, i32 %1
  88   %4 = udiv i32 %V, %3
  89   ret i32 %4
  90 }
  91
  92 define i32 @t6(i32 %x, i32 %z) {
  93 ; CHECK-LABEL: @t6(
  94 ; CHECK-NEXT:    [[DIVISOR:%.*]] = call i32 @llvm.umax.i32(i32 [[X:%.*]], i32 1)
  95 ; CHECK-NEXT:    [[Y:%.*]] = udiv i32 [[Z:%.*]], [[DIVISOR]]
  96 ; CHECK-NEXT:    ret i32 [[Y]]
  97 ;
  98   %x_is_zero = icmp eq i32 %x, 0
  99   %divisor = select i1 %x_is_zero, i32 1, i32 %x
 100   %y = udiv i32 %z, %divisor
 101   ret i32 %y
 102 }
 103
 104 define i8 @udiv_umin(i8 %x, i8 %y, i8 %z) {
 105 ; CHECK-LABEL: @udiv_umin(
 106 ; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[Z:%.*]])
 107 ; CHECK-NEXT:    [[D1:%.*]] = lshr i8 [[X:%.*]], [[TMP1]]
 108 ; CHECK-NEXT:    ret i8 [[D1]]
 109 ;
 110   %y2 = shl i8 1, %y
 111   %z2 = shl i8 1, %z
 112   %m = call i8 @llvm.umin.i8(i8 %y2, i8 %z2)
 113   %d = udiv i8 %x, %m
 114   ret i8 %d
 115 }
 116
 117 define i8 @udiv_umax(i8 %x, i8 %y, i8 %z) {
 118 ; CHECK-LABEL: @udiv_umax(
 119 ; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[Z:%.*]])
 120 ; CHECK-NEXT:    [[D1:%.*]] = lshr i8 [[X:%.*]], [[TMP1]]
 121 ; CHECK-NEXT:    ret i8 [[D1]]
 122 ;
 123   %y2 = shl i8 1, %y
 124   %z2 = shl i8 1, %z
 125   %m = call i8 @llvm.umax.i8(i8 %y2, i8 %z2)
 126   %d = udiv i8 %x, %m
 127   ret i8 %d
 128 }
 129
 130 ; Negative test, cannot take exact log2
 131 define i8 @udiv_umin_(i8 %x, i8 %y, i8 %z) {
 132 ; CHECK-LABEL: @udiv_umin_(
 133 ; CHECK-NEXT:    [[Y2:%.*]] = shl nuw i8 1, [[Y:%.*]]
 134 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[Y2]], i8 [[Z:%.*]])
 135 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[X:%.*]], [[M]]
 136 ; CHECK-NEXT:    ret i8 [[D]]
 137 ;
 138   %y2 = shl i8 1, %y
 139   %m = call i8 @llvm.umin.i8(i8 %y2, i8 %z)
 140   %d = udiv i8 %x, %m
 141   ret i8 %d
 142 }
 143
 144 ; Negative test, extra use
 145 define i8 @udiv_umin_extra_use(i8 %x, i8 %y, i8 %z) {
 146 ; CHECK-LABEL: @udiv_umin_extra_use(
 147 ; CHECK-NEXT:    [[Y2:%.*]] = shl nuw i8 1, [[Y:%.*]]
 148 ; CHECK-NEXT:    [[Z2:%.*]] = shl nuw i8 1, [[Z:%.*]]
 149 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[Y2]], i8 [[Z2]])
 150 ; CHECK-NEXT:    call void @use(i8 [[M]])
 151 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[X:%.*]], [[M]]
 152 ; CHECK-NEXT:    ret i8 [[D]]
 153 ;
 154   %y2 = shl i8 1, %y
 155   %z2 = shl i8 1, %z
 156   %m = call i8 @llvm.umin.i8(i8 %y2, i8 %z2)
 157   call void @use(i8 %m)
 158   %d = udiv i8 %x, %m
 159   ret i8 %d
 160 }
 161
 162 ; Negative test, signed min/max
 163 define i8 @udiv_smin(i8 %x, i8 %y, i8 %z) {
 164 ; CHECK-LABEL: @udiv_smin(
 165 ; CHECK-NEXT:    [[Y2:%.*]] = shl nuw i8 1, [[Y:%.*]]
 166 ; CHECK-NEXT:    [[Z2:%.*]] = shl nuw i8 1, [[Z:%.*]]
 167 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[Y2]], i8 [[Z2]])
 168 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[X:%.*]], [[M]]
 169 ; CHECK-NEXT:    ret i8 [[D]]
 170 ;
 171   %y2 = shl i8 1, %y
 172   %z2 = shl i8 1, %z
 173   %m = call i8 @llvm.smin.i8(i8 %y2, i8 %z2)
 174   %d = udiv i8 %x, %m
 175   ret i8 %d
 176 }
 177
 178 ; Negative test, signed min/max
 179 define i8 @udiv_smax(i8 %x, i8 %y, i8 %z) {
 180 ; CHECK-LABEL: @udiv_smax(
 181 ; CHECK-NEXT:    [[Y2:%.*]] = shl nuw i8 1, [[Y:%.*]]
 182 ; CHECK-NEXT:    [[Z2:%.*]] = shl nuw i8 1, [[Z:%.*]]
 183 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[Y2]], i8 [[Z2]])
 184 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[X:%.*]], [[M]]
 185 ; CHECK-NEXT:    ret i8 [[D]]
 186 ;
 187   %y2 = shl i8 1, %y
 188   %z2 = shl i8 1, %z
 189   %m = call i8 @llvm.smax.i8(i8 %y2, i8 %z2)
 190   %d = udiv i8 %x, %m
 191   ret i8 %d
 192 }
 193
 194 ; (X << C1) / X -> 1 << C1 optimizations
 195
 196 define i32 @t7(i32 %x) {
 197 ; CHECK-LABEL: @t7(
 198 ; CHECK-NEXT:    ret i32 4
 199 ;
 200   %shl = shl nsw i32 %x, 2
 201   %r = sdiv i32 %shl, %x
 202   ret i32 %r
 203 }
 204
 205 ; make sure the previous opt doesn't take place for wrapped shifts
 206
 207 define i32 @t8(i32 %x) {
 208 ; CHECK-LABEL: @t8(
 209 ; CHECK-NEXT:    [[SHL:%.*]] = shl i32 [[X:%.*]], 2
 210 ; CHECK-NEXT:    [[R:%.*]] = sdiv i32 [[SHL]], [[X]]
 211 ; CHECK-NEXT:    ret i32 [[R]]
 212 ;
 213   %shl = shl i32 %x, 2
 214   %r = sdiv i32 %shl, %x
 215   ret i32 %r
 216 }
 217
 218 define <2 x i32> @t9(<2 x i32> %x) {
 219 ; CHECK-LABEL: @t9(
 220 ; CHECK-NEXT:    ret <2 x i32> <i32 4, i32 8>
 221 ;
 222   %shl = shl nsw <2 x i32> %x, <i32 2, i32 3>
 223   %r = sdiv <2 x i32> %shl, %x
 224   ret <2 x i32> %r
 225 }
 226
 227 define i32 @t10(i32 %x, i32 %y) {
 228 ; CHECK-LABEL: @t10(
 229 ; CHECK-NEXT:    [[R:%.*]] = shl nuw nsw i32 1, [[Y:%.*]]
 230 ; CHECK-NEXT:    ret i32 [[R]]
 231 ;
 232   %shl = shl nsw i32 %x, %y
 233   %r = sdiv i32 %shl, %x
 234   ret i32 %r
 235 }
 236
 237 define <2 x i32> @t11(<2 x i32> %x, <2 x i32> %y) {
 238 ; CHECK-LABEL: @t11(
 239 ; CHECK-NEXT:    [[R:%.*]] = shl nuw nsw <2 x i32> <i32 1, i32 1>, [[Y:%.*]]
 240 ; CHECK-NEXT:    ret <2 x i32> [[R]]
 241 ;
 242   %shl = shl nsw <2 x i32> %x, %y
 243   %r = sdiv <2 x i32> %shl, %x
 244   ret <2 x i32> %r
 245 }
 246
 247 define i32 @t12(i32 %x) {
 248 ; CHECK-LABEL: @t12(
 249 ; CHECK-NEXT:    ret i32 4
 250 ;
 251   %shl = shl nuw i32 %x, 2
 252   %r = udiv i32 %shl, %x
 253   ret i32 %r
 254 }
 255
 256 ; make sure the previous opt doesn't take place for wrapped shifts
 257
 258 define i32 @t13(i32 %x) {
 259 ; CHECK-LABEL: @t13(
 260 ; CHECK-NEXT:    [[SHL:%.*]] = shl i32 [[X:%.*]], 2
 261 ; CHECK-NEXT:    [[R:%.*]] = udiv i32 [[SHL]], [[X]]
 262 ; CHECK-NEXT:    ret i32 [[R]]
 263 ;
 264   %shl = shl i32 %x, 2
 265   %r = udiv i32 %shl, %x
 266   ret i32 %r
 267 }
 268
 269 define <2 x i32> @t14(<2 x i32> %x) {
 270 ; CHECK-LABEL: @t14(
 271 ; CHECK-NEXT:    ret <2 x i32> <i32 4, i32 8>
 272 ;
 273   %shl = shl nuw <2 x i32> %x, <i32 2, i32 3>
 274   %r = udiv <2 x i32> %shl, %x
 275   ret <2 x i32> %r
 276 }
 277
 278 define i32 @t15(i32 %x, i32 %y) {
 279 ; CHECK-LABEL: @t15(
 280 ; CHECK-NEXT:    [[R:%.*]] = shl nuw i32 1, [[Y:%.*]]
 281 ; CHECK-NEXT:    ret i32 [[R]]
 282 ;
 283   %shl = shl nuw i32 %x, %y
 284   %r = udiv i32 %shl, %x
 285   ret i32 %r
 286 }
 287
 288 define <2 x i32> @t16(<2 x i32> %x, <2 x i32> %y) {
 289 ; CHECK-LABEL: @t16(
 290 ; CHECK-NEXT:    [[R:%.*]] = shl nuw <2 x i32> <i32 1, i32 1>, [[Y:%.*]]
 291 ; CHECK-NEXT:    ret <2 x i32> [[R]]
 292 ;
 293   %shl = shl nuw <2 x i32> %x, %y
 294   %r = udiv <2 x i32> %shl, %x
 295   ret <2 x i32> %r
 296 }
 297
 298 ; (X * Y) s/ (X << Z) --> Y s/ (1 << Z)
 299
 300 define i5 @sdiv_mul_shl_nsw(i5 %x, i5 %y, i5 %z) {
 301 ; CHECK-LABEL: @sdiv_mul_shl_nsw(
 302 ; CHECK-NEXT:    [[TMP1:%.*]] = shl nuw i5 1, [[Z:%.*]]
 303 ; CHECK-NEXT:    [[D:%.*]] = sdiv i5 [[Y:%.*]], [[TMP1]]
 304 ; CHECK-NEXT:    ret i5 [[D]]
 305 ;
 306   %m1 = mul nsw i5 %x, %y
 307   %m2 = shl nsw i5 %x, %z
 308   %d = sdiv i5 %m1, %m2
 309   ret i5 %d
 310 }
 311
 312 ; (Y * Z) s/ (X << Z) --> Y s/ (1 << Z)
 313
 314 define i5 @sdiv_mul_shl_nsw_exact_commute1(i5 %x, i5 %y, i5 %z) {
 315 ; CHECK-LABEL: @sdiv_mul_shl_nsw_exact_commute1(
 316 ; CHECK-NEXT:    [[TMP1:%.*]] = shl nuw i5 1, [[Z:%.*]]
 317 ; CHECK-NEXT:    [[D:%.*]] = sdiv exact i5 [[Y:%.*]], [[TMP1]]
 318 ; CHECK-NEXT:    ret i5 [[D]]
 319 ;
 320   %m1 = mul nsw i5 %y, %x
 321   %m2 = shl nsw i5 %x, %z
 322   %d = sdiv exact i5 %m1, %m2
 323   ret i5 %d
 324 }
 325
 326 ; negative test - shl is not commutative
 327
 328 define i5 @sdiv_mul_shl_nsw_commute2(i5 %x, i5 %y, i5 %z) {
 329 ; CHECK-LABEL: @sdiv_mul_shl_nsw_commute2(
 330 ; CHECK-NEXT:    [[M1:%.*]] = mul nsw i5 [[Y:%.*]], [[X:%.*]]
 331 ; CHECK-NEXT:    [[M2:%.*]] = shl nsw i5 [[Z:%.*]], [[X]]
 332 ; CHECK-NEXT:    [[D:%.*]] = sdiv i5 [[M1]], [[M2]]
 333 ; CHECK-NEXT:    ret i5 [[D]]
 334 ;
 335   %m1 = mul nsw i5 %y, %x
 336   %m2 = shl nsw i5 %z, %x
 337   %d = sdiv i5 %m1, %m2
 338   ret i5 %d
 339 }
 340
 341 ; extra use is ok
 342
 343 define i8 @sdiv_mul_shl_nsw_use1(i8 %x, i8 %y, i8 %z) {
 344 ; CHECK-LABEL: @sdiv_mul_shl_nsw_use1(
 345 ; CHECK-NEXT:    [[M1:%.*]] = mul nsw i8 [[X:%.*]], [[Y:%.*]]
 346 ; CHECK-NEXT:    call void @use(i8 [[M1]])
 347 ; CHECK-NEXT:    [[TMP1:%.*]] = shl nuw i8 1, [[Z:%.*]]
 348 ; CHECK-NEXT:    [[D:%.*]] = sdiv i8 [[Y]], [[TMP1]]
 349 ; CHECK-NEXT:    ret i8 [[D]]
 350 ;
 351   %m1 = mul nsw i8 %x, %y
 352   call void @use(i8 %m1)
 353   %m2 = shl nsw i8 %x, %z
 354   %d = sdiv i8 %m1, %m2
 355   ret i8 %d
 356 }
 357
 358 ; extra use is ok
 359
 360 define i8 @sdiv_mul_shl_nsw_use2(i8 %x, i8 %y, i8 %z) {
 361 ; CHECK-LABEL: @sdiv_mul_shl_nsw_use2(
 362 ; CHECK-NEXT:    [[M2:%.*]] = shl nsw i8 [[X:%.*]], [[Z:%.*]]
 363 ; CHECK-NEXT:    call void @use(i8 [[M2]])
 364 ; CHECK-NEXT:    [[TMP1:%.*]] = shl nuw i8 1, [[Z]]
 365 ; CHECK-NEXT:    [[D:%.*]] = sdiv i8 [[Y:%.*]], [[TMP1]]
 366 ; CHECK-NEXT:    ret i8 [[D]]
 367 ;
 368   %m1 = mul nsw i8 %x, %y
 369   %m2 = shl nsw i8 %x, %z
 370   call void @use(i8 %m2)
 371   %d = sdiv i8 %m1, %m2
 372   ret i8 %d
 373 }
 374
 375 ; negative test - both operands can't have extra uses
 376
 377 define i8 @sdiv_mul_shl_nsw_use3(i8 %x, i8 %y, i8 %z) {
 378 ; CHECK-LABEL: @sdiv_mul_shl_nsw_use3(
 379 ; CHECK-NEXT:    [[M1:%.*]] = mul nsw i8 [[X:%.*]], [[Y:%.*]]
 380 ; CHECK-NEXT:    call void @use(i8 [[M1]])
 381 ; CHECK-NEXT:    [[M2:%.*]] = shl nsw i8 [[X]], [[Z:%.*]]
 382 ; CHECK-NEXT:    call void @use(i8 [[M2]])
 383 ; CHECK-NEXT:    [[D:%.*]] = sdiv i8 [[M1]], [[M2]]
 384 ; CHECK-NEXT:    ret i8 [[D]]
 385 ;
 386   %m1 = mul nsw i8 %x, %y
 387   call void @use(i8 %m1)
 388   %m2 = shl nsw i8 %x, %z
 389   call void @use(i8 %m2)
 390   %d = sdiv i8 %m1, %m2
 391   ret i8 %d
 392 }
 393
 394 ; negative test - shl must be divisor
 395
 396 define i5 @sdiv_shl_mul_nsw(i5 %x, i5 %y, i5 %z) {
 397 ; CHECK-LABEL: @sdiv_shl_mul_nsw(
 398 ; CHECK-NEXT:    [[M1:%.*]] = shl nsw i5 [[Z:%.*]], [[X:%.*]]
 399 ; CHECK-NEXT:    [[M2:%.*]] = mul nsw i5 [[X]], [[Y:%.*]]
 400 ; CHECK-NEXT:    [[D:%.*]] = sdiv i5 [[M1]], [[M2]]
 401 ; CHECK-NEXT:    ret i5 [[D]]
 402 ;
 403   %m1 = shl nsw i5 %z, %x
 404   %m2 = mul nsw i5 %x, %y
 405   %d = sdiv i5 %m1, %m2
 406   ret i5 %d
 407 }
 408
 409 ; negative test - wrong no-wrap
 410
 411 define i5 @sdiv_mul_shl_missing_nsw1(i5 %x, i5 %y, i5 %z) {
 412 ; CHECK-LABEL: @sdiv_mul_shl_missing_nsw1(
 413 ; CHECK-NEXT:    [[M1:%.*]] = mul nsw i5 [[X:%.*]], [[Y:%.*]]
 414 ; CHECK-NEXT:    [[M2:%.*]] = shl nuw i5 [[Y]], [[Z:%.*]]
 415 ; CHECK-NEXT:    [[D:%.*]] = sdiv i5 [[M1]], [[M2]]
 416 ; CHECK-NEXT:    ret i5 [[D]]
 417 ;
 418   %m1 = mul nsw i5 %x, %y
 419   %m2 = shl nuw i5 %y, %z
 420   %d = sdiv i5 %m1, %m2
 421   ret i5 %d
 422 }
 423
 424 ; negative test - wrong no-wrap
 425
 426 define i5 @sdiv_mul_shl_missing_nsw2(i5 %x, i5 %y, i5 %z) {
 427 ; CHECK-LABEL: @sdiv_mul_shl_missing_nsw2(
 428 ; CHECK-NEXT:    [[M1:%.*]] = mul nuw i5 [[X:%.*]], [[Y:%.*]]
 429 ; CHECK-NEXT:    [[M2:%.*]] = shl nsw i5 [[Y]], [[Z:%.*]]
 430 ; CHECK-NEXT:    [[D:%.*]] = sdiv i5 [[M1]], [[M2]]
 431 ; CHECK-NEXT:    ret i5 [[D]]
 432 ;
 433   %m1 = mul nuw i5 %x, %y
 434   %m2 = shl nsw i5 %y, %z
 435   %d = sdiv i5 %m1, %m2
 436   ret i5 %d
 437 }
 438
 439 ; (X * Y) u/ (X << Z) --> Y u>> Z
 440
 441 define i5 @udiv_mul_shl_nuw(i5 %x, i5 %y, i5 %z) {
 442 ; CHECK-LABEL: @udiv_mul_shl_nuw(
 443 ; CHECK-NEXT:    [[D:%.*]] = lshr i5 [[Y:%.*]], [[Z:%.*]]
 444 ; CHECK-NEXT:    ret i5 [[D]]
 445 ;
 446   %m1 = mul nuw i5 %x, %y
 447   %m2 = shl nuw i5 %x, %z
 448   %d = udiv i5 %m1, %m2
 449   ret i5 %d
 450 }
 451
 452 ; (Y * X) u/ (X << Z) --> Y u>> Z
 453
 454 define i5 @udiv_mul_shl_nuw_exact_commute1(i5 %x, i5 %y, i5 %z) {
 455 ; CHECK-LABEL: @udiv_mul_shl_nuw_exact_commute1(
 456 ; CHECK-NEXT:    [[D:%.*]] = lshr exact i5 [[Y:%.*]], [[Z:%.*]]
 457 ; CHECK-NEXT:    ret i5 [[D]]
 458 ;
 459   %m1 = mul nuw i5 %y, %x
 460   %m2 = shl nuw i5 %x, %z
 461   %d = udiv exact i5 %m1, %m2
 462   ret i5 %d
 463 }
 464
 465 ; negative test - shl is not commutative
 466
 467 define i5 @udiv_mul_shl_nuw_commute2(i5 %x, i5 %y, i5 %z) {
 468 ; CHECK-LABEL: @udiv_mul_shl_nuw_commute2(
 469 ; CHECK-NEXT:    [[M1:%.*]] = mul nuw i5 [[X:%.*]], [[Y:%.*]]
 470 ; CHECK-NEXT:    [[M2:%.*]] = shl nuw i5 [[Z:%.*]], [[X]]
 471 ; CHECK-NEXT:    [[D:%.*]] = udiv i5 [[M1]], [[M2]]
 472 ; CHECK-NEXT:    ret i5 [[D]]
 473 ;
 474   %m1 = mul nuw i5 %x, %y
 475   %m2 = shl nuw i5 %z, %x
 476   %d = udiv i5 %m1, %m2
 477   ret i5 %d
 478 }
 479
 480 ; extra uses are ok
 481
 482 define i8 @udiv_mul_shl_nsw_use1(i8 %x, i8 %y, i8 %z) {
 483 ; CHECK-LABEL: @udiv_mul_shl_nsw_use1(
 484 ; CHECK-NEXT:    [[M1:%.*]] = mul nuw i8 [[X:%.*]], [[Y:%.*]]
 485 ; CHECK-NEXT:    call void @use(i8 [[M1]])
 486 ; CHECK-NEXT:    [[D:%.*]] = lshr i8 [[Y]], [[Z:%.*]]
 487 ; CHECK-NEXT:    ret i8 [[D]]
 488 ;
 489   %m1 = mul nuw i8 %x, %y
 490   call void @use(i8 %m1)
 491   %m2 = shl nuw i8 %x, %z
 492   %d = udiv i8 %m1, %m2
 493   ret i8 %d
 494 }
 495
 496 ; extra uses are ok
 497
 498 define i8 @udiv_mul_shl_nsw_use2(i8 %x, i8 %y, i8 %z) {
 499 ; CHECK-LABEL: @udiv_mul_shl_nsw_use2(
 500 ; CHECK-NEXT:    [[M2:%.*]] = shl nuw i8 [[X:%.*]], [[Z:%.*]]
 501 ; CHECK-NEXT:    call void @use(i8 [[M2]])
 502 ; CHECK-NEXT:    [[D:%.*]] = lshr i8 [[Y:%.*]], [[Z]]
 503 ; CHECK-NEXT:    ret i8 [[D]]
 504 ;
 505   %m1 = mul nuw i8 %x, %y
 506   %m2 = shl nuw i8 %x, %z
 507   call void @use(i8 %m2)
 508   %d = udiv i8 %m1, %m2
 509   ret i8 %d
 510 }
 511
 512 ; extra uses are ok
 513
 514 define i8 @udiv_mul_shl_nsw_use3(i8 %x, i8 %y, i8 %z) {
 515 ; CHECK-LABEL: @udiv_mul_shl_nsw_use3(
 516 ; CHECK-NEXT:    [[M1:%.*]] = mul nuw i8 [[X:%.*]], [[Y:%.*]]
 517 ; CHECK-NEXT:    call void @use(i8 [[M1]])
 518 ; CHECK-NEXT:    [[M2:%.*]] = shl nuw i8 [[X]], [[Z:%.*]]
 519 ; CHECK-NEXT:    call void @use(i8 [[M2]])
 520 ; CHECK-NEXT:    [[D:%.*]] = lshr i8 [[Y]], [[Z]]
 521 ; CHECK-NEXT:    ret i8 [[D]]
 522 ;
 523   %m1 = mul nuw i8 %x, %y
 524   call void @use(i8 %m1)
 525   %m2 = shl nuw i8 %x, %z
 526   call void @use(i8 %m2)
 527   %d = udiv i8 %m1, %m2
 528   ret i8 %d
 529 }
 530
 531 ; (X << Z) / (X * Y) -> (1 << Z) / Y
 532
 533 define i5 @udiv_shl_mul_nuw(i5 %x, i5 %y, i5 %z) {
 534 ; CHECK-LABEL: @udiv_shl_mul_nuw(
 535 ; CHECK-NEXT:    [[TMP1:%.*]] = shl nuw i5 1, [[Z:%.*]]
 536 ; CHECK-NEXT:    [[D:%.*]] = udiv i5 [[TMP1]], [[Y:%.*]]
 537 ; CHECK-NEXT:    ret i5 [[D]]
 538 ;
 539   %m1 = shl nuw i5 %x, %z
 540   %m2 = mul nuw i5 %x, %y
 541   %d = udiv i5 %m1, %m2
 542   ret i5 %d
 543 }
 544
 545 define i5 @udiv_shl_mul_nuw_swap(i5 %x, i5 %y, i5 %z) {
 546 ; CHECK-LABEL: @udiv_shl_mul_nuw_swap(
 547 ; CHECK-NEXT:    [[TMP1:%.*]] = shl nuw i5 1, [[Z:%.*]]
 548 ; CHECK-NEXT:    [[D:%.*]] = udiv i5 [[TMP1]], [[Y:%.*]]
 549 ; CHECK-NEXT:    ret i5 [[D]]
 550 ;
 551   %m1 = shl nuw i5 %x, %z
 552   %m2 = mul nuw i5 %y, %x
 553   %d = udiv i5 %m1, %m2
 554   ret i5 %d
 555 }
 556
 557 define i5 @udiv_shl_mul_nuw_exact(i5 %x, i5 %y, i5 %z) {
 558 ; CHECK-LABEL: @udiv_shl_mul_nuw_exact(
 559 ; CHECK-NEXT:    [[TMP1:%.*]] = shl nuw i5 1, [[Z:%.*]]
 560 ; CHECK-NEXT:    [[D:%.*]] = udiv exact i5 [[TMP1]], [[Y:%.*]]
 561 ; CHECK-NEXT:    ret i5 [[D]]
 562 ;
 563   %m1 = shl nuw i5 %x, %z
 564   %m2 = mul nuw i5 %x, %y
 565   %d = udiv exact i5 %m1, %m2
 566   ret i5 %d
 567 }
 568
 569 define <2 x i4> @udiv_shl_mul_nuw_vec(<2 x i4> %x, <2 x i4> %y, <2 x i4> %z) {
 570 ; CHECK-LABEL: @udiv_shl_mul_nuw_vec(
 571 ; CHECK-NEXT:    [[TMP1:%.*]] = shl nuw <2 x i4> <i4 1, i4 1>, [[Z:%.*]]
 572 ; CHECK-NEXT:    [[D:%.*]] = udiv <2 x i4> [[TMP1]], [[Y:%.*]]
 573 ; CHECK-NEXT:    ret <2 x i4> [[D]]
 574 ;
 575   %m1 = shl nuw <2 x i4> %x, %z
 576   %m2 = mul nuw <2 x i4> %y, %x
 577   %d = udiv <2 x i4> %m1, %m2
 578   ret <2 x i4> %d
 579 }
 580
 581 define i8 @udiv_shl_mul_nuw_extra_use_of_shl(i8 %x, i8 %y, i8 %z) {
 582 ; CHECK-LABEL: @udiv_shl_mul_nuw_extra_use_of_shl(
 583 ; CHECK-NEXT:    [[M1:%.*]] = shl nuw i8 [[X:%.*]], [[Z:%.*]]
 584 ; CHECK-NEXT:    call void @use(i8 [[M1]])
 585 ; CHECK-NEXT:    [[TMP1:%.*]] = shl nuw i8 1, [[Z]]
 586 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[TMP1]], [[Y:%.*]]
 587 ; CHECK-NEXT:    ret i8 [[D]]
 588 ;
 589   %m1 = shl nuw i8 %x, %z
 590   call void @use(i8 %m1)
 591   %m2 = mul nuw i8 %y, %x
 592   %d = udiv i8 %m1, %m2
 593   ret i8 %d
 594 }
 595
 596 ; negative test - extra use
 597
 598 define i8 @udiv_shl_mul_nuw_extra_use_of_mul(i8 %x, i8 %y, i8 %z) {
 599 ; CHECK-LABEL: @udiv_shl_mul_nuw_extra_use_of_mul(
 600 ; CHECK-NEXT:    [[M1:%.*]] = shl nuw i8 [[X:%.*]], [[Z:%.*]]
 601 ; CHECK-NEXT:    [[M2:%.*]] = mul nuw i8 [[Y:%.*]], [[X]]
 602 ; CHECK-NEXT:    call void @use(i8 [[M2]])
 603 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[M1]], [[M2]]
 604 ; CHECK-NEXT:    ret i8 [[D]]
 605 ;
 606   %m1 = shl nuw i8 %x, %z
 607   %m2 = mul nuw i8 %y, %x
 608   call void @use(i8 %m2)
 609   %d = udiv i8 %m1, %m2
 610   ret i8 %d
 611 }
 612
 613 define i8 @udiv_shl_mul_nuw_extra_use(i8 %x, i8 %y, i8 %z) {
 614 ; CHECK-LABEL: @udiv_shl_mul_nuw_extra_use(
 615 ; CHECK-NEXT:    [[M1:%.*]] = shl nuw i8 [[X:%.*]], [[Z:%.*]]
 616 ; CHECK-NEXT:    call void @use(i8 [[M1]])
 617 ; CHECK-NEXT:    [[M2:%.*]] = mul nuw i8 [[Y:%.*]], [[X]]
 618 ; CHECK-NEXT:    call void @use(i8 [[M2]])
 619 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[M1]], [[M2]]
 620 ; CHECK-NEXT:    ret i8 [[D]]
 621 ;
 622   %m1 = shl nuw i8 %x, %z
 623   call void @use(i8 %m1)
 624   %m2 = mul nuw i8 %y, %x
 625   call void @use(i8 %m2)
 626   %d = udiv i8 %m1, %m2
 627   ret i8 %d
 628 }
 629
 630 ; negative test - sdiv
 631
 632 define i5 @sdiv_shl_mul_nuw(i5 %x, i5 %y, i5 %z) {
 633 ; CHECK-LABEL: @sdiv_shl_mul_nuw(
 634 ; CHECK-NEXT:    [[M1:%.*]] = shl nuw i5 [[X:%.*]], [[Z:%.*]]
 635 ; CHECK-NEXT:    [[M2:%.*]] = mul nuw i5 [[X]], [[Y:%.*]]
 636 ; CHECK-NEXT:    [[D:%.*]] = sdiv i5 [[M1]], [[M2]]
 637 ; CHECK-NEXT:    ret i5 [[D]]
 638 ;
 639   %m1 = shl nuw i5 %x, %z
 640   %m2 = mul nuw i5 %x, %y
 641   %d = sdiv i5 %m1, %m2
 642   ret i5 %d
 643 }
 644
 645 ; negative test - wrong no-wrap
 646
 647 define i5 @udiv_mul_shl_missing_nsw1(i5 %x, i5 %y, i5 %z) {
 648 ; CHECK-LABEL: @udiv_mul_shl_missing_nsw1(
 649 ; CHECK-NEXT:    [[M1:%.*]] = mul nsw i5 [[X:%.*]], [[Y:%.*]]
 650 ; CHECK-NEXT:    [[M2:%.*]] = shl nuw i5 [[Y]], [[Z:%.*]]
 651 ; CHECK-NEXT:    [[D:%.*]] = udiv i5 [[M1]], [[M2]]
 652 ; CHECK-NEXT:    ret i5 [[D]]
 653 ;
 654   %m1 = mul nsw i5 %x, %y
 655   %m2 = shl nuw i5 %y, %z
 656   %d = udiv i5 %m1, %m2
 657   ret i5 %d
 658 }
 659
 660 ; negative test - wrong no-wrap
 661
 662 define i5 @udiv_mul_shl_missing_nsw2(i5 %x, i5 %y, i5 %z) {
 663 ; CHECK-LABEL: @udiv_mul_shl_missing_nsw2(
 664 ; CHECK-NEXT:    [[M1:%.*]] = mul nuw i5 [[X:%.*]], [[Y:%.*]]
 665 ; CHECK-NEXT:    [[M2:%.*]] = shl nsw i5 [[Y]], [[Z:%.*]]
 666 ; CHECK-NEXT:    [[D:%.*]] = udiv i5 [[M1]], [[M2]]
 667 ; CHECK-NEXT:    ret i5 [[D]]
 668 ;
 669   %m1 = mul nuw i5 %x, %y
 670   %m2 = shl nsw i5 %y, %z
 671   %d = udiv i5 %m1, %m2
 672   ret i5 %d
 673 }
 674
 675 define i8 @udiv_shl_nuw(i8 %x, i8 %y, i8 %z) {
 676 ; CHECK-LABEL: @udiv_shl_nuw(
 677 ; CHECK-NEXT:    [[S:%.*]] = shl nuw i8 [[Y:%.*]], [[Z:%.*]]
 678 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[X:%.*]], [[S]]
 679 ; CHECK-NEXT:    ret i8 [[D]]
 680 ;
 681   %s = shl nuw i8 %y, %z
 682   %d = udiv i8 %x, %s
 683   ret i8 %d
 684 }
 685
 686 define <2 x i4> @udiv_shl_nuw_exact(<2 x i4> %x, <2 x i4> %y, <2 x i4> %z) {
 687 ; CHECK-LABEL: @udiv_shl_nuw_exact(
 688 ; CHECK-NEXT:    [[S:%.*]] = shl nuw <2 x i4> [[Y:%.*]], [[Z:%.*]]
 689 ; CHECK-NEXT:    [[D:%.*]] = udiv exact <2 x i4> [[X:%.*]], [[S]]
 690 ; CHECK-NEXT:    ret <2 x i4> [[D]]
 691 ;
 692   %s = shl nuw <2 x i4> %y, %z
 693   %d = udiv exact <2 x i4> %x, %s
 694   ret <2 x i4> %d
 695 }
 696
 697 define i8 @udiv_shl(i8 %x, i8 %y, i8 %z) {
 698 ; CHECK-LABEL: @udiv_shl(
 699 ; CHECK-NEXT:    [[S:%.*]] = shl i8 [[Y:%.*]], [[Z:%.*]]
 700 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[X:%.*]], [[S]]
 701 ; CHECK-NEXT:    ret i8 [[D]]
 702 ;
 703   %s = shl i8 %y, %z
 704   %d = udiv i8 %x, %s
 705   ret i8 %d
 706 }
 707
 708 define i8 @udiv_shl_nuw_use(i8 %x, i8 %y, i8 %z) {
 709 ; CHECK-LABEL: @udiv_shl_nuw_use(
 710 ; CHECK-NEXT:    [[S:%.*]] = shl nuw i8 [[Y:%.*]], [[Z:%.*]]
 711 ; CHECK-NEXT:    call void @use(i8 [[S]])
 712 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[X:%.*]], [[S]]
 713 ; CHECK-NEXT:    ret i8 [[D]]
 714 ;
 715   %s = shl nuw i8 %y, %z
 716   call void @use(i8 %s)
 717   %d = udiv i8 %x, %s
 718   ret i8 %d
 719 }
 720
 721 ; ((X * Y) >> Z) / X --> Y >> Z
 722
 723 define i8 @udiv_lshr_mul_nuw(i8 %x, i8 %y, i8 %z) {
 724 ; CHECK-LABEL: @udiv_lshr_mul_nuw(
 725 ; CHECK-NEXT:    [[DIV:%.*]] = lshr i8 [[Y:%.*]], [[Z:%.*]]
 726 ; CHECK-NEXT:    ret i8 [[DIV]]
 727 ;
 728   %m = mul nuw i8 %x, %y
 729   %s = lshr i8 %m, %z
 730   %div = udiv i8 %s, %x
 731   ret i8 %div
 732 }
 733
 734 ; ((Y * X) >> Z) / X --> Y >> Z
 735
 736 define <2 x i4> @udiv_lshr_mul_nuw_exact_commute1(<2 x i4> %x, <2 x i4> %y, <2 x i4> %z) {
 737 ; CHECK-LABEL: @udiv_lshr_mul_nuw_exact_commute1(
 738 ; CHECK-NEXT:    [[DIV:%.*]] = lshr exact <2 x i4> [[Y:%.*]], [[Z:%.*]]
 739 ; CHECK-NEXT:    ret <2 x i4> [[DIV]]
 740 ;
 741   %m = mul nuw <2 x i4> %y, %x
 742   %s = lshr exact <2 x i4> %m, %z
 743   %div = udiv exact <2 x i4> %s, %x
 744   ret <2 x i4> %div
 745 }
 746
 747 ; negative test - mul is shifted amount, not shifted value
 748
 749 define i8 @udiv_lshr_mul_nuw_commute2(i8 %x, i8 %y, i8 %z) {
 750 ; CHECK-LABEL: @udiv_lshr_mul_nuw_commute2(
 751 ; CHECK-NEXT:    [[M:%.*]] = mul nuw i8 [[Y:%.*]], [[X:%.*]]
 752 ; CHECK-NEXT:    [[S:%.*]] = lshr i8 [[Z:%.*]], [[M]]
 753 ; CHECK-NEXT:    [[DIV:%.*]] = udiv i8 [[S]], [[X]]
 754 ; CHECK-NEXT:    ret i8 [[DIV]]
 755 ;
 756   %m = mul nuw i8 %y, %x
 757   %s = lshr i8 %z, %m
 758   %div = udiv i8 %s, %x
 759   ret i8 %div
 760 }
 761
 762 ; extra uses are ok
 763
 764 define i8 @udiv_lshr_mul_nuw_use1(i8 %x, i8 %y, i8 %z) {
 765 ; CHECK-LABEL: @udiv_lshr_mul_nuw_use1(
 766 ; CHECK-NEXT:    [[M:%.*]] = mul nuw i8 [[X:%.*]], [[Y:%.*]]
 767 ; CHECK-NEXT:    call void @use(i8 [[M]])
 768 ; CHECK-NEXT:    [[DIV:%.*]] = lshr i8 [[Y]], [[Z:%.*]]
 769 ; CHECK-NEXT:    ret i8 [[DIV]]
 770 ;
 771   %m = mul nuw i8 %x, %y
 772   call void @use(i8 %m)
 773   %s = lshr i8 %m, %z
 774   %div = udiv i8 %s, %x
 775   ret i8 %div
 776 }
 777
 778 ; extra uses are ok
 779
 780 define i8 @udiv_lshr_mul_nuw_use2(i8 %x, i8 %y, i8 %z) {
 781 ; CHECK-LABEL: @udiv_lshr_mul_nuw_use2(
 782 ; CHECK-NEXT:    [[M:%.*]] = mul nuw i8 [[X:%.*]], [[Y:%.*]]
 783 ; CHECK-NEXT:    [[S:%.*]] = lshr i8 [[M]], [[Z:%.*]]
 784 ; CHECK-NEXT:    call void @use(i8 [[S]])
 785 ; CHECK-NEXT:    [[DIV:%.*]] = lshr i8 [[Y]], [[Z]]
 786 ; CHECK-NEXT:    ret i8 [[DIV]]
 787 ;
 788   %m = mul nuw i8 %x, %y
 789   %s = lshr i8 %m, %z
 790   call void @use(i8 %s)
 791   %div = udiv i8 %s, %x
 792   ret i8 %div
 793 }
 794
 795 ; extra uses are ok
 796
 797 define i8 @udiv_lshr_mul_nuw_use3(i8 %x, i8 %y, i8 %z) {
 798 ; CHECK-LABEL: @udiv_lshr_mul_nuw_use3(
 799 ; CHECK-NEXT:    [[M:%.*]] = mul nuw i8 [[X:%.*]], [[Y:%.*]]
 800 ; CHECK-NEXT:    call void @use(i8 [[M]])
 801 ; CHECK-NEXT:    [[S:%.*]] = lshr i8 [[M]], [[Z:%.*]]
 802 ; CHECK-NEXT:    call void @use(i8 [[S]])
 803 ; CHECK-NEXT:    [[DIV:%.*]] = lshr i8 [[Y]], [[Z]]
 804 ; CHECK-NEXT:    ret i8 [[DIV]]
 805 ;
 806   %m = mul nuw i8 %x, %y
 807   call void @use(i8 %m)
 808   %s = lshr i8 %m, %z
 809   call void @use(i8 %s)
 810   %div = udiv i8 %s, %x
 811   ret i8 %div
 812 }
 813
 814 ; negative test - must have nuw
 815
 816 define i8 @udiv_lshr_mul_nsw(i8 %x, i8 %y, i8 %z) {
 817 ; CHECK-LABEL: @udiv_lshr_mul_nsw(
 818 ; CHECK-NEXT:    [[M:%.*]] = mul nsw i8 [[X:%.*]], [[Y:%.*]]
 819 ; CHECK-NEXT:    [[S:%.*]] = lshr i8 [[M]], [[Z:%.*]]
 820 ; CHECK-NEXT:    [[DIV:%.*]] = udiv i8 [[S]], [[X]]
 821 ; CHECK-NEXT:    ret i8 [[DIV]]
 822 ;
 823   %m = mul nsw i8 %x, %y
 824   %s = lshr i8 %m, %z
 825   %div = udiv i8 %s, %x
 826   ret i8 %div
 827 }
 828
 829 ; negative test - doesn't fold with signed div
 830
 831 define i8 @sdiv_lshr_mul_nsw(i8 %x, i8 %y, i8 %z) {
 832 ; CHECK-LABEL: @sdiv_lshr_mul_nsw(
 833 ; CHECK-NEXT:    [[M:%.*]] = mul nsw i8 [[X:%.*]], [[Y:%.*]]
 834 ; CHECK-NEXT:    [[S:%.*]] = lshr i8 [[M]], [[Z:%.*]]
 835 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i8 [[S]], [[X]]
 836 ; CHECK-NEXT:    ret i8 [[DIV]]
 837 ;
 838   %m = mul nsw i8 %x, %y
 839   %s = lshr i8 %m, %z
 840   %div = sdiv i8 %s, %x
 841   ret i8 %div
 842 }
 843
 844 ; (X << Z) / (Y << Z) --> X / Y
 845
 846 define i8 @sdiv_shl_shl_nsw2_nuw(i8 %x, i8 %y, i8 %z) {
 847 ; CHECK-LABEL: @sdiv_shl_shl_nsw2_nuw(
 848 ; CHECK-NEXT:    [[D:%.*]] = sdiv i8 [[X:%.*]], [[Y:%.*]]
 849 ; CHECK-NEXT:    ret i8 [[D]]
 850 ;
 851   %xz = shl nsw i8 %x, %z
 852   %yz = shl nsw nuw i8 %y, %z
 853   %d = sdiv i8 %xz, %yz
 854   ret i8 %d
 855 }
 856
 857 ; extra uses are ok and 'exact' propagates
 858
 859 define i8 @sdiv_shl_shl_nsw2_nuw_exact_use(i8 %x, i8 %y, i8 %z) {
 860 ; CHECK-LABEL: @sdiv_shl_shl_nsw2_nuw_exact_use(
 861 ; CHECK-NEXT:    [[XZ:%.*]] = shl nsw i8 [[X:%.*]], [[Z:%.*]]
 862 ; CHECK-NEXT:    call void @use(i8 [[XZ]])
 863 ; CHECK-NEXT:    [[D:%.*]] = sdiv exact i8 [[X]], [[Y:%.*]]
 864 ; CHECK-NEXT:    ret i8 [[D]]
 865 ;
 866   %xz = shl nsw i8 %x, %z
 867   call void @use(i8 %xz)
 868   %yz = shl nsw nuw i8 %y, %z
 869   %d = sdiv exact i8 %xz, %yz
 870   ret i8 %d
 871 }
 872
 873 ; negative test - wrong wrap
 874
 875 define i8 @sdiv_shl_shl_nsw_nuw2(i8 %x, i8 %y, i8 %z) {
 876 ; CHECK-LABEL: @sdiv_shl_shl_nsw_nuw2(
 877 ; CHECK-NEXT:    [[XZ:%.*]] = shl nuw i8 [[X:%.*]], [[Z:%.*]]
 878 ; CHECK-NEXT:    [[YZ:%.*]] = shl nuw nsw i8 [[Y:%.*]], [[Z]]
 879 ; CHECK-NEXT:    [[D:%.*]] = sdiv i8 [[XZ]], [[YZ]]
 880 ; CHECK-NEXT:    ret i8 [[D]]
 881 ;
 882   %xz = shl nuw i8 %x, %z
 883   %yz = shl nsw nuw i8 %y, %z
 884   %d = sdiv i8 %xz, %yz
 885   ret i8 %d
 886 }
 887
 888 ; negative test - wrong wrap
 889
 890 define i8 @sdiv_shl_shl_nsw_nuw(i8 %x, i8 %y, i8 %z) {
 891 ; CHECK-LABEL: @sdiv_shl_shl_nsw_nuw(
 892 ; CHECK-NEXT:    [[XZ:%.*]] = shl nsw i8 [[X:%.*]], [[Z:%.*]]
 893 ; CHECK-NEXT:    [[YZ:%.*]] = shl nuw i8 [[Y:%.*]], [[Z]]
 894 ; CHECK-NEXT:    [[D:%.*]] = sdiv i8 [[XZ]], [[YZ]]
 895 ; CHECK-NEXT:    ret i8 [[D]]
 896 ;
 897   %xz = shl nsw i8 %x, %z
 898   %yz = shl nuw i8 %y, %z
 899   %d = sdiv i8 %xz, %yz
 900   ret i8 %d
 901 }
 902
 903 ; negative test - wrong wrap
 904
 905 define i8 @sdiv_shl_shl_nuw_nsw2(i8 %x, i8 %y, i8 %z) {
 906 ; CHECK-LABEL: @sdiv_shl_shl_nuw_nsw2(
 907 ; CHECK-NEXT:    [[XZ:%.*]] = shl nuw nsw i8 [[X:%.*]], [[Z:%.*]]
 908 ; CHECK-NEXT:    [[YZ:%.*]] = shl nsw i8 [[Y:%.*]], [[Z]]
 909 ; CHECK-NEXT:    [[D:%.*]] = sdiv i8 [[XZ]], [[YZ]]
 910 ; CHECK-NEXT:    ret i8 [[D]]
 911 ;
 912   %xz = shl nuw nsw i8 %x, %z
 913   %yz = shl nsw i8 %y, %z
 914   %d = sdiv i8 %xz, %yz
 915   ret i8 %d
 916 }
 917
 918 ; (X << Z) / (Y << Z) --> X / Y
 919
 920 define <2 x i8> @udiv_shl_shl_nuw2(<2 x i8> %x, <2 x i8> %y, <2 x i8> %z) {
 921 ; CHECK-LABEL: @udiv_shl_shl_nuw2(
 922 ; CHECK-NEXT:    [[D:%.*]] = udiv <2 x i8> [[X:%.*]], [[Y:%.*]]
 923 ; CHECK-NEXT:    ret <2 x i8> [[D]]
 924 ;
 925   %xz = shl nuw <2 x i8> %x, %z
 926   %yz = shl nuw <2 x i8> %y, %z
 927   %d = udiv <2 x i8> %xz, %yz
 928   ret <2 x i8> %d
 929 }
 930
 931 ; extra uses are ok and 'exact' propagates
 932
 933 define i8 @udiv_shl_shl_nuw2_exact_use2(i8 %x, i8 %y, i8 %z) {
 934 ; CHECK-LABEL: @udiv_shl_shl_nuw2_exact_use2(
 935 ; CHECK-NEXT:    [[XZ:%.*]] = shl nuw i8 [[X:%.*]], [[Z:%.*]]
 936 ; CHECK-NEXT:    call void @use(i8 [[XZ]])
 937 ; CHECK-NEXT:    [[YZ:%.*]] = shl nuw i8 [[Y:%.*]], [[Z]]
 938 ; CHECK-NEXT:    call void @use(i8 [[YZ]])
 939 ; CHECK-NEXT:    [[D:%.*]] = udiv exact i8 [[X]], [[Y]]
 940 ; CHECK-NEXT:    ret i8 [[D]]
 941 ;
 942   %xz = shl nuw i8 %x, %z
 943   call void @use(i8 %xz)
 944   %yz = shl nuw i8 %y, %z
 945   call void @use(i8 %yz)
 946   %d = udiv exact i8 %xz, %yz
 947   ret i8 %d
 948 }
 949
 950 ; negative test - wrong wrap
 951
 952 define i8 @udiv_shl_shl_nuw_nsw(i8 %x, i8 %y, i8 %z) {
 953 ; CHECK-LABEL: @udiv_shl_shl_nuw_nsw(
 954 ; CHECK-NEXT:    [[XZ:%.*]] = shl nuw i8 [[X:%.*]], [[Z:%.*]]
 955 ; CHECK-NEXT:    [[YZ:%.*]] = shl nsw i8 [[Y:%.*]], [[Z]]
 956 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[XZ]], [[YZ]]
 957 ; CHECK-NEXT:    ret i8 [[D]]
 958 ;
 959   %xz = shl nuw i8 %x, %z
 960   %yz = shl nsw i8 %y, %z
 961   %d = udiv i8 %xz, %yz
 962   ret i8 %d
 963 }
 964
 965 ; negative test - wrong wrap
 966
 967 define i8 @udiv_shl_shl_nsw_nuw(i8 %x, i8 %y, i8 %z) {
 968 ; CHECK-LABEL: @udiv_shl_shl_nsw_nuw(
 969 ; CHECK-NEXT:    [[XZ:%.*]] = shl nsw i8 [[X:%.*]], [[Z:%.*]]
 970 ; CHECK-NEXT:    [[YZ:%.*]] = shl nuw i8 [[Y:%.*]], [[Z]]
 971 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[XZ]], [[YZ]]
 972 ; CHECK-NEXT:    ret i8 [[D]]
 973 ;
 974   %xz = shl nsw i8 %x, %z
 975   %yz = shl nuw i8 %y, %z
 976   %d = udiv i8 %xz, %yz
 977   ret i8 %d
 978 }
 979
 980 define i8 @udiv_shl_shl_nuw_nsw2(i8 %x, i8 %y, i8 %z) {
 981 ; CHECK-LABEL: @udiv_shl_shl_nuw_nsw2(
 982 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[X:%.*]], [[Y:%.*]]
 983 ; CHECK-NEXT:    ret i8 [[D]]
 984 ;
 985   %xz = shl nuw nsw i8 %x, %z
 986   %yz = shl nsw i8 %y, %z
 987   %d = udiv i8 %xz, %yz
 988   ret i8 %d
 989 }
 990
 991 ; TODO: X / (Y << Z) --> (X >> Z) / Y
 992 ; https://alive2.llvm.org/ce/z/FjoN_A
 993
 994 define i8 @udiv_shl_nuw_divisor(i8 %x, i8 %y, i8 %z) {
 995 ; CHECK-LABEL: @udiv_shl_nuw_divisor(
 996 ; CHECK-NEXT:    [[S:%.*]] = shl nuw i8 [[Y:%.*]], [[Z:%.*]]
 997 ; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[X:%.*]], [[S]]
 998 ; CHECK-NEXT:    ret i8 [[D]]
 999 ;
1000   %s = shl nuw i8 %y, %z
1001   %d = udiv i8 %x, %s
1002   ret i8 %d
1003 }
1004
1005 define i8 @udiv_fail_shl_overflow(i8 %x, i8 %y) {
1006 ; CHECK-LABEL: @udiv_fail_shl_overflow(
1007 ; CHECK-NEXT:    [[SHL:%.*]] = shl i8 2, [[Y:%.*]]
1008 ; CHECK-NEXT:    [[MIN:%.*]] = call i8 @llvm.umax.i8(i8 [[SHL]], i8 1)
1009 ; CHECK-NEXT:    [[MUL:%.*]] = udiv i8 [[X:%.*]], [[MIN]]
1010 ; CHECK-NEXT:    ret i8 [[MUL]]
1011 ;
1012   %shl = shl i8 2, %y
1013   %min = call i8 @llvm.umax.i8(i8 %shl, i8 1)
1014   %mul = udiv i8 %x, %min
1015   ret i8 %mul
1016 }
1017
1018 define i8 @udiv_shl_no_overflow(i8 %x, i8 %y) {
1019 ; CHECK-LABEL: @udiv_shl_no_overflow(
1020 ; CHECK-NEXT:    [[TMP1:%.*]] = add i8 [[Y:%.*]], 1
1021 ; CHECK-NEXT:    [[MUL1:%.*]] = lshr i8 [[X:%.*]], [[TMP1]]
1022 ; CHECK-NEXT:    ret i8 [[MUL1]]
1023 ;
1024   %shl = shl nuw i8 2, %y
1025   %min = call i8 @llvm.umax.i8(i8 %shl, i8 1)
1026   %mul = udiv i8 %x, %min
1027   ret i8 %mul
1028 }
1029
1030 ; (X<<Y) / (X<<Z) -> 1 << Y >> Z
1031
1032 define i32 @sdiv_shl_pair_const(i32 %a) {
1033 ; CHECK-LABEL: @sdiv_shl_pair_const(
1034 ; CHECK-NEXT:  entry:
1035 ; CHECK-NEXT:    ret i32 2
1036 ;
1037 entry:
1038   %lhs = shl nsw i32 %a, 2
1039   %rhs = shl nsw i32 %a, 1
1040   %div = sdiv i32 %lhs, %rhs
1041   ret i32 %div
1042 }
1043
1044 define i32 @udiv_shl_pair_const(i32 %a) {
1045 ; CHECK-LABEL: @udiv_shl_pair_const(
1046 ; CHECK-NEXT:  entry:
1047 ; CHECK-NEXT:    ret i32 2
1048 ;
1049 entry:
1050   %lhs = shl nuw i32 %a, 2
1051   %rhs = shl nuw i32 %a, 1
1052   %div = udiv i32 %lhs, %rhs
1053   ret i32 %div
1054 }
1055
1056 define i32 @sdiv_shl_pair1(i32 %a, i32 %x, i32 %y) {
1057 ; CHECK-LABEL: @sdiv_shl_pair1(
1058 ; CHECK-NEXT:  entry:
1059 ; CHECK-NEXT:    [[SHL_DIVIDEND:%.*]] = shl nuw nsw i32 1, [[X:%.*]]
1060 ; CHECK-NEXT:    [[DIV:%.*]] = lshr i32 [[SHL_DIVIDEND]], [[Y:%.*]]
1061 ; CHECK-NEXT:    ret i32 [[DIV]]
1062 ;
1063 entry:
1064   %lhs = shl nsw i32 %a, %x
1065   %rhs = shl nuw nsw i32 %a, %y
1066   %div = sdiv i32 %lhs, %rhs
1067   ret i32 %div
1068 }
1069
1070 define i32 @sdiv_shl_pair2(i32 %a, i32 %x, i32 %y) {
1071 ; CHECK-LABEL: @sdiv_shl_pair2(
1072 ; CHECK-NEXT:  entry:
1073 ; CHECK-NEXT:    [[SHL_DIVIDEND:%.*]] = shl nuw nsw i32 1, [[X:%.*]]
1074 ; CHECK-NEXT:    [[DIV:%.*]] = lshr i32 [[SHL_DIVIDEND]], [[Y:%.*]]
1075 ; CHECK-NEXT:    ret i32 [[DIV]]
1076 ;
1077 entry:
1078   %lhs = shl nuw nsw i32 %a, %x
1079   %rhs = shl nsw i32 %a, %y
1080   %div = sdiv i32 %lhs, %rhs
1081   ret i32 %div
1082 }
1083
1084 define i32 @sdiv_shl_pair3(i32 %a, i32 %x, i32 %y) {
1085 ; CHECK-LABEL: @sdiv_shl_pair3(
1086 ; CHECK-NEXT:  entry:
1087 ; CHECK-NEXT:    [[SHL_DIVIDEND:%.*]] = shl nuw i32 1, [[X:%.*]]
1088 ; CHECK-NEXT:    [[DIV:%.*]] = lshr i32 [[SHL_DIVIDEND]], [[Y:%.*]]
1089 ; CHECK-NEXT:    ret i32 [[DIV]]
1090 ;
1091 entry:
1092   %lhs = shl nsw i32 %a, %x
1093   %rhs = shl nsw i32 %a, %y
1094   %div = sdiv i32 %lhs, %rhs
1095   ret i32 %div
1096 }
1097
1098 define i32 @sdiv_shl_no_pair_fail(i32 %a, i32 %b, i32 %x, i32 %y) {
1099 ; CHECK-LABEL: @sdiv_shl_no_pair_fail(
1100 ; CHECK-NEXT:  entry:
1101 ; CHECK-NEXT:    [[LHS:%.*]] = shl nuw nsw i32 [[A:%.*]], [[X:%.*]]
1102 ; CHECK-NEXT:    [[RHS:%.*]] = shl nuw i32 [[B:%.*]], [[Y:%.*]]
1103 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 [[LHS]], [[RHS]]
1104 ; CHECK-NEXT:    ret i32 [[DIV]]
1105 ;
1106 entry:
1107   %lhs = shl nuw nsw i32 %a, %x
1108   %rhs = shl nuw i32 %b, %y
1109   %div = sdiv i32 %lhs, %rhs
1110   ret i32 %div
1111 }
1112
1113 define i32 @udiv_shl_pair1(i32 %a, i32 %x, i32 %y) {
1114 ; CHECK-LABEL: @udiv_shl_pair1(
1115 ; CHECK-NEXT:  entry:
1116 ; CHECK-NEXT:    [[SHL_DIVIDEND:%.*]] = shl nuw i32 1, [[X:%.*]]
1117 ; CHECK-NEXT:    [[DIV:%.*]] = lshr i32 [[SHL_DIVIDEND]], [[Y:%.*]]
1118 ; CHECK-NEXT:    ret i32 [[DIV]]
1119 ;
1120 entry:
1121   %lhs = shl nuw i32 %a, %x
1122   %rhs = shl nuw i32 %a, %y
1123   %div = udiv i32 %lhs, %rhs
1124   ret i32 %div
1125 }
1126
1127 define i32 @udiv_shl_pair2(i32 %a, i32 %x, i32 %y) {
1128 ; CHECK-LABEL: @udiv_shl_pair2(
1129 ; CHECK-NEXT:  entry:
1130 ; CHECK-NEXT:    [[SHL_DIVIDEND:%.*]] = shl nuw nsw i32 1, [[X:%.*]]
1131 ; CHECK-NEXT:    [[DIV:%.*]] = lshr i32 [[SHL_DIVIDEND]], [[Y:%.*]]
1132 ; CHECK-NEXT:    ret i32 [[DIV]]
1133 ;
1134 entry:
1135   %lhs = shl nuw nsw i32 %a, %x
1136   %rhs = shl nuw i32 %a, %y
1137   %div = udiv i32 %lhs, %rhs
1138   ret i32 %div
1139 }
1140
1141 define i32 @udiv_shl_pair3(i32 %a, i32 %x, i32 %y) {
1142 ; CHECK-LABEL: @udiv_shl_pair3(
1143 ; CHECK-NEXT:  entry:
1144 ; CHECK-NEXT:    [[SHL_DIVIDEND:%.*]] = shl nuw i32 1, [[X:%.*]]
1145 ; CHECK-NEXT:    [[DIV:%.*]] = lshr i32 [[SHL_DIVIDEND]], [[Y:%.*]]
1146 ; CHECK-NEXT:    ret i32 [[DIV]]
1147 ;
1148 entry:
1149   %lhs = shl nuw i32 %a, %x
1150   %rhs = shl nuw nsw i32 %a, %y
1151   %div = udiv i32 %lhs, %rhs
1152   ret i32 %div
1153 }
1154
1155 define i32 @sdiv_shl_pair_overflow_fail1(i32 %a, i32 %x, i32 %y) {
1156 ; CHECK-LABEL: @sdiv_shl_pair_overflow_fail1(
1157 ; CHECK-NEXT:  entry:
1158 ; CHECK-NEXT:    [[LHS:%.*]] = shl i32 [[A:%.*]], [[X:%.*]]
1159 ; CHECK-NEXT:    [[RHS:%.*]] = shl nsw i32 [[A]], [[Y:%.*]]
1160 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 [[LHS]], [[RHS]]
1161 ; CHECK-NEXT:    ret i32 [[DIV]]
1162 ;
1163 entry:
1164   %lhs = shl i32 %a, %x
1165   %rhs = shl nsw i32 %a, %y
1166   %div = sdiv i32 %lhs, %rhs
1167   ret i32 %div
1168 }
1169
1170 define i32 @sdiv_shl_pair_overflow_fail2(i32 %a, i32 %x, i32 %y) {
1171 ; CHECK-LABEL: @sdiv_shl_pair_overflow_fail2(
1172 ; CHECK-NEXT:  entry:
1173 ; CHECK-NEXT:    [[LHS:%.*]] = shl nsw i32 [[A:%.*]], [[X:%.*]]
1174 ; CHECK-NEXT:    [[RHS:%.*]] = shl nuw i32 [[A]], [[Y:%.*]]
1175 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 [[LHS]], [[RHS]]
1176 ; CHECK-NEXT:    ret i32 [[DIV]]
1177 ;
1178 entry:
1179   %lhs = shl nsw i32 %a, %x
1180   %rhs = shl nuw i32 %a, %y
1181   %div = sdiv i32 %lhs, %rhs
1182   ret i32 %div
1183 }
1184
1185 define i32 @udiv_shl_pair_overflow_fail1(i32 %a, i32 %x, i32 %y) {
1186 ; CHECK-LABEL: @udiv_shl_pair_overflow_fail1(
1187 ; CHECK-NEXT:  entry:
1188 ; CHECK-NEXT:    [[LHS:%.*]] = shl nsw i32 [[A:%.*]], [[X:%.*]]
1189 ; CHECK-NEXT:    [[RHS:%.*]] = shl nuw i32 [[A]], [[Y:%.*]]
1190 ; CHECK-NEXT:    [[DIV:%.*]] = udiv i32 [[LHS]], [[RHS]]
1191 ; CHECK-NEXT:    ret i32 [[DIV]]
1192 ;
1193 entry:
1194   %lhs = shl nsw i32 %a, %x
1195   %rhs = shl nuw i32 %a, %y
1196   %div = udiv i32 %lhs, %rhs
1197   ret i32 %div
1198 }
1199
1200 define i32 @udiv_shl_pair_overflow_fail2(i32 %a, i32 %x, i32 %y) {
1201 ; CHECK-LABEL: @udiv_shl_pair_overflow_fail2(
1202 ; CHECK-NEXT:  entry:
1203 ; CHECK-NEXT:    [[LHS:%.*]] = shl nsw i32 [[A:%.*]], [[X:%.*]]
1204 ; CHECK-NEXT:    [[RHS:%.*]] = shl i32 [[A]], [[Y:%.*]]
1205 ; CHECK-NEXT:    [[DIV:%.*]] = udiv i32 [[LHS]], [[RHS]]
1206 ; CHECK-NEXT:    ret i32 [[DIV]]
1207 ;
1208 entry:
1209   %lhs = shl nsw i32 %a, %x
1210   %rhs = shl i32 %a, %y
1211   %div = udiv i32 %lhs, %rhs
1212   ret i32 %div
1213 }
1214
1215 define i32 @udiv_shl_pair_overflow_fail3(i32 %a, i32 %x, i32 %y) {
1216 ; CHECK-LABEL: @udiv_shl_pair_overflow_fail3(
1217 ; CHECK-NEXT:  entry:
1218 ; CHECK-NEXT:    [[LHS:%.*]] = shl nuw nsw i32 [[A:%.*]], [[X:%.*]]
1219 ; CHECK-NEXT:    [[RHS:%.*]] = shl i32 [[A]], [[Y:%.*]]
1220 ; CHECK-NEXT:    [[DIV:%.*]] = udiv i32 [[LHS]], [[RHS]]
1221 ; CHECK-NEXT:    ret i32 [[DIV]]
1222 ;
1223 entry:
1224   %lhs = shl nuw nsw i32 %a, %x
1225   %rhs = shl i32 %a, %y
1226   %div = udiv i32 %lhs, %rhs
1227   ret i32 %div
1228 }
1229
1230 define i32 @sdiv_shl_pair_multiuse1(i32 %a, i32 %x, i32 %y) {
1231 ; CHECK-LABEL: @sdiv_shl_pair_multiuse1(
1232 ; CHECK-NEXT:  entry:
1233 ; CHECK-NEXT:    [[LHS:%.*]] = shl nuw nsw i32 [[A:%.*]], [[X:%.*]]
1234 ; CHECK-NEXT:    call void @use32(i32 [[LHS]])
1235 ; CHECK-NEXT:    [[SHL_DIVIDEND:%.*]] = shl nuw nsw i32 1, [[X]]
1236 ; CHECK-NEXT:    [[DIV:%.*]] = lshr i32 [[SHL_DIVIDEND]], [[Y:%.*]]
1237 ; CHECK-NEXT:    ret i32 [[DIV]]
1238 ;
1239 entry:
1240   %lhs = shl nuw nsw i32 %a, %x
1241   call void @use32(i32 %lhs)
1242   %rhs = shl nsw i32 %a, %y
1243   %div = sdiv i32 %lhs, %rhs
1244   ret i32 %div
1245 }
1246
1247 define i32 @sdiv_shl_pair_multiuse2(i32 %a, i32 %x, i32 %y) {
1248 ; CHECK-LABEL: @sdiv_shl_pair_multiuse2(
1249 ; CHECK-NEXT:  entry:
1250 ; CHECK-NEXT:    [[RHS:%.*]] = shl nsw i32 [[A:%.*]], [[Y:%.*]]
1251 ; CHECK-NEXT:    call void @use32(i32 [[RHS]])
1252 ; CHECK-NEXT:    [[SHL_DIVIDEND:%.*]] = shl nuw nsw i32 1, [[X:%.*]]
1253 ; CHECK-NEXT:    [[DIV:%.*]] = lshr i32 [[SHL_DIVIDEND]], [[Y]]
1254 ; CHECK-NEXT:    ret i32 [[DIV]]
1255 ;
1256 entry:
1257   %lhs = shl nuw nsw i32 %a, %x
1258   %rhs = shl nsw i32 %a, %y
1259   call void @use32(i32 %rhs)
1260   %div = sdiv i32 %lhs, %rhs
1261   ret i32 %div
1262 }
1263
1264 define i32 @sdiv_shl_pair_multiuse3(i32 %a, i32 %x, i32 %y) {
1265 ; CHECK-LABEL: @sdiv_shl_pair_multiuse3(
1266 ; CHECK-NEXT:  entry:
1267 ; CHECK-NEXT:    [[LHS:%.*]] = shl nuw nsw i32 [[A:%.*]], [[X:%.*]]
1268 ; CHECK-NEXT:    [[RHS:%.*]] = shl nsw i32 [[A]], [[Y:%.*]]
1269 ; CHECK-NEXT:    call void @use32(i32 [[LHS]])
1270 ; CHECK-NEXT:    call void @use32(i32 [[RHS]])
1271 ; CHECK-NEXT:    [[SHL_DIVIDEND:%.*]] = shl nuw nsw i32 1, [[X]]
1272 ; CHECK-NEXT:    [[DIV:%.*]] = lshr i32 [[SHL_DIVIDEND]], [[Y]]
1273 ; CHECK-NEXT:    ret i32 [[DIV]]
1274 ;
1275 entry:
1276   %lhs = shl nuw nsw i32 %a, %x
1277   %rhs = shl nsw i32 %a, %y
1278   call void @use32(i32 %lhs)
1279   call void @use32(i32 %rhs)
1280   %div = sdiv i32 %lhs, %rhs
1281   ret i32 %div
1282 }
1283
1284 @a = external global i32
1285 define i32 @pr69291() {
1286 ; CHECK-LABEL: @pr69291(
1287 ; CHECK-NEXT:  entry:
1288 ; CHECK-NEXT:    ret i32 1
1289 ;
1290 entry:
1291   %conv = load i32, ptr @a, align 1
1292   %add = shl nuw nsw i32 %conv, 1
1293   %add2 = shl nuw nsw i32 %conv, 1
1294   %div = sdiv i32 %add, %add2
1295   ret i32 %div
1296 }