llvm/test/Transforms/CorrelatedValuePropagation/srem.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -passes=correlated-propagation -S | FileCheck %s
   3
   4 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
   5 target triple = "thumbv7m-arm-none-eabi"
   6
   7 define void @h(ptr nocapture %p, i32 %x) local_unnamed_addr #0 {
   8 ; CHECK-LABEL: @h(
   9 ; CHECK-NEXT:  entry:
  10 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[X:%.*]], 0
  11 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
  12 ; CHECK:       if.then:
  13 ; CHECK-NEXT:    [[REM21:%.*]] = urem i32 [[X]], 10
  14 ; CHECK-NEXT:    store i32 [[REM21]], ptr [[P:%.*]], align 4
  15 ; CHECK-NEXT:    br label [[IF_END]]
  16 ; CHECK:       if.end:
  17 ; CHECK-NEXT:    ret void
  18 ;
  19 entry:
  20
  21   %cmp = icmp sgt i32 %x, 0
  22   br i1 %cmp, label %if.then, label %if.end
  23
  24 if.then:
  25   %rem2 = srem i32 %x, 10
  26   store i32 %rem2, ptr %p, align 4
  27   br label %if.end
  28
  29 if.end:
  30   ret void
  31 }
  32
  33 ; looping case where loop has exactly one block
  34 ; at the point of srem, we know that %a is always greater than 0,
  35 ; because of the assume before it, so we can transform it to urem.
  36 declare void @llvm.assume(i1)
  37 define void @test4(i32 %n) {
  38 ; CHECK-LABEL: @test4(
  39 ; CHECK-NEXT:  entry:
  40 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[N:%.*]], 0
  41 ; CHECK-NEXT:    br i1 [[CMP]], label [[LOOP:%.*]], label [[EXIT:%.*]]
  42 ; CHECK:       loop:
  43 ; CHECK-NEXT:    [[A:%.*]] = phi i32 [ [[N]], [[ENTRY:%.*]] ], [ [[REM1:%.*]], [[LOOP]] ]
  44 ; CHECK-NEXT:    [[COND:%.*]] = icmp samesign ugt i32 [[A]], 4
  45 ; CHECK-NEXT:    call void @llvm.assume(i1 [[COND]])
  46 ; CHECK-NEXT:    [[REM1]] = urem i32 [[A]], 17
  47 ; CHECK-NEXT:    [[LOOPCOND:%.*]] = icmp samesign ugt i32 [[REM1]], 8
  48 ; CHECK-NEXT:    br i1 [[LOOPCOND]], label [[LOOP]], label [[EXIT]]
  49 ; CHECK:       exit:
  50 ; CHECK-NEXT:    ret void
  51 ;
  52 entry:
  53   %cmp = icmp sgt i32 %n, 0
  54   br i1 %cmp, label %loop, label %exit
  55
  56 loop:
  57   %a = phi i32 [ %n, %entry ], [ %rem, %loop ]
  58   %cond = icmp sgt i32 %a, 4
  59   call void @llvm.assume(i1 %cond)
  60   %rem = srem i32 %a, 17
  61   %loopcond = icmp sgt i32 %rem, 8
  62   br i1 %loopcond, label %loop, label %exit
  63
  64 exit:
  65   ret void
  66 }
  67
  68 ; Now, let's try various domain combinations for operands.
  69
  70 define i8 @test5_pos_pos(i8 %x, i8 %y) {
  71 ; CHECK-LABEL: @test5_pos_pos(
  72 ; CHECK-NEXT:    [[C0:%.*]] = icmp sge i8 [[X:%.*]], 0
  73 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
  74 ; CHECK-NEXT:    [[C1:%.*]] = icmp sge i8 [[Y:%.*]], 0
  75 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
  76 ; CHECK-NEXT:    [[REM1:%.*]] = urem i8 [[X]], [[Y]]
  77 ; CHECK-NEXT:    ret i8 [[REM1]]
  78 ;
  79   %c0 = icmp sge i8 %x, 0
  80   call void @llvm.assume(i1 %c0)
  81   %c1 = icmp sge i8 %y, 0
  82   call void @llvm.assume(i1 %c1)
  83
  84   %rem = srem i8 %x, %y
  85   ret i8 %rem
  86 }
  87 define i8 @test6_pos_neg(i8 %x, i8 %y) {
  88 ; CHECK-LABEL: @test6_pos_neg(
  89 ; CHECK-NEXT:    [[C0:%.*]] = icmp sge i8 [[X:%.*]], 0
  90 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
  91 ; CHECK-NEXT:    [[C1:%.*]] = icmp sle i8 [[Y:%.*]], 0
  92 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
  93 ; CHECK-NEXT:    [[Y_NONNEG:%.*]] = sub i8 0, [[Y]]
  94 ; CHECK-NEXT:    [[REM1:%.*]] = urem i8 [[X]], [[Y_NONNEG]]
  95 ; CHECK-NEXT:    ret i8 [[REM1]]
  96 ;
  97   %c0 = icmp sge i8 %x, 0
  98   call void @llvm.assume(i1 %c0)
  99   %c1 = icmp sle i8 %y, 0
 100   call void @llvm.assume(i1 %c1)
 101
 102   %rem = srem i8 %x, %y
 103   ret i8 %rem
 104 }
 105 define i8 @test7_neg_pos(i8 %x, i8 %y) {
 106 ; CHECK-LABEL: @test7_neg_pos(
 107 ; CHECK-NEXT:    [[C0:%.*]] = icmp sle i8 [[X:%.*]], 0
 108 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 109 ; CHECK-NEXT:    [[C1:%.*]] = icmp sge i8 [[Y:%.*]], 0
 110 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 111 ; CHECK-NEXT:    [[X_NONNEG:%.*]] = sub i8 0, [[X]]
 112 ; CHECK-NEXT:    [[REM1:%.*]] = urem i8 [[X_NONNEG]], [[Y]]
 113 ; CHECK-NEXT:    [[REM1_NEG:%.*]] = sub i8 0, [[REM1]]
 114 ; CHECK-NEXT:    ret i8 [[REM1_NEG]]
 115 ;
 116   %c0 = icmp sle i8 %x, 0
 117   call void @llvm.assume(i1 %c0)
 118   %c1 = icmp sge i8 %y, 0
 119   call void @llvm.assume(i1 %c1)
 120
 121   %rem = srem i8 %x, %y
 122   ret i8 %rem
 123 }
 124 define i8 @test8_neg_neg(i8 %x, i8 %y) {
 125 ; CHECK-LABEL: @test8_neg_neg(
 126 ; CHECK-NEXT:    [[C0:%.*]] = icmp sle i8 [[X:%.*]], 0
 127 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 128 ; CHECK-NEXT:    [[C1:%.*]] = icmp sle i8 [[Y:%.*]], 0
 129 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 130 ; CHECK-NEXT:    [[X_NONNEG:%.*]] = sub i8 0, [[X]]
 131 ; CHECK-NEXT:    [[Y_NONNEG:%.*]] = sub i8 0, [[Y]]
 132 ; CHECK-NEXT:    [[REM1:%.*]] = urem i8 [[X_NONNEG]], [[Y_NONNEG]]
 133 ; CHECK-NEXT:    [[REM1_NEG:%.*]] = sub i8 0, [[REM1]]
 134 ; CHECK-NEXT:    ret i8 [[REM1_NEG]]
 135 ;
 136   %c0 = icmp sle i8 %x, 0
 137   call void @llvm.assume(i1 %c0)
 138   %c1 = icmp sle i8 %y, 0
 139   call void @llvm.assume(i1 %c1)
 140
 141   %rem = srem i8 %x, %y
 142   ret i8 %rem
 143 }
 144
 145 ; After making remainder unsigned, can we narrow it?
 146 define i16 @test9_narrow(i16 %x, i16 %y) {
 147 ; CHECK-LABEL: @test9_narrow(
 148 ; CHECK-NEXT:    [[C0:%.*]] = icmp ult i16 [[X:%.*]], 128
 149 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 150 ; CHECK-NEXT:    [[C1:%.*]] = icmp ult i16 [[Y:%.*]], 128
 151 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 152 ; CHECK-NEXT:    [[REM1_LHS_TRUNC:%.*]] = trunc i16 [[X]] to i8
 153 ; CHECK-NEXT:    [[REM1_RHS_TRUNC:%.*]] = trunc i16 [[Y]] to i8
 154 ; CHECK-NEXT:    [[REM12:%.*]] = urem i8 [[REM1_LHS_TRUNC]], [[REM1_RHS_TRUNC]]
 155 ; CHECK-NEXT:    [[REM1_ZEXT:%.*]] = zext i8 [[REM12]] to i16
 156 ; CHECK-NEXT:    ret i16 [[REM1_ZEXT]]
 157 ;
 158   %c0 = icmp ult i16 %x, 128
 159   call void @llvm.assume(i1 %c0)
 160   %c1 = icmp ult i16 %y, 128
 161   call void @llvm.assume(i1 %c1)
 162
 163   %rem = srem i16 %x, %y
 164   ret i16 %rem
 165 }
 166
 167 ; Ok, but what about narrowing srem in general?
 168
 169 ; If both operands are i15, it's uncontroversial - we can truncate to i16
 170 define i64 @test11_i15_i15(i64 %x, i64 %y) {
 171 ; CHECK-LABEL: @test11_i15_i15(
 172 ; CHECK-NEXT:  entry:
 173 ; CHECK-NEXT:    [[C0:%.*]] = icmp sle i64 [[X:%.*]], 16383
 174 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 175 ; CHECK-NEXT:    [[C1:%.*]] = icmp sge i64 [[X]], -16384
 176 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 177 ; CHECK-NEXT:    [[C2:%.*]] = icmp sle i64 [[Y:%.*]], 16383
 178 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C2]])
 179 ; CHECK-NEXT:    [[C3:%.*]] = icmp sge i64 [[Y]], -16384
 180 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C3]])
 181 ; CHECK-NEXT:    [[DIV_LHS_TRUNC:%.*]] = trunc i64 [[X]] to i16
 182 ; CHECK-NEXT:    [[DIV_RHS_TRUNC:%.*]] = trunc i64 [[Y]] to i16
 183 ; CHECK-NEXT:    [[DIV1:%.*]] = srem i16 [[DIV_LHS_TRUNC]], [[DIV_RHS_TRUNC]]
 184 ; CHECK-NEXT:    [[DIV_SEXT:%.*]] = sext i16 [[DIV1]] to i64
 185 ; CHECK-NEXT:    ret i64 [[DIV_SEXT]]
 186 ;
 187 entry:
 188   %c0 = icmp sle i64 %x, 16383
 189   call void @llvm.assume(i1 %c0)
 190   %c1 = icmp sge i64 %x, -16384
 191   call void @llvm.assume(i1 %c1)
 192
 193   %c2 = icmp sle i64 %y, 16383
 194   call void @llvm.assume(i1 %c2)
 195   %c3 = icmp sge i64 %y, -16384
 196   call void @llvm.assume(i1 %c3)
 197
 198   %div = srem i64 %x, %y
 199   ret i64 %div
 200 }
 201
 202 ; But if operands are i16, we can only truncate to i32, because we can't
 203 ; rule out UB of  i16 INT_MIN s/ i16 -1
 204 define i64 @test12_i16_i16(i64 %x, i64 %y) {
 205 ; CHECK-LABEL: @test12_i16_i16(
 206 ; CHECK-NEXT:  entry:
 207 ; CHECK-NEXT:    [[C0:%.*]] = icmp sle i64 [[X:%.*]], 32767
 208 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 209 ; CHECK-NEXT:    [[C1:%.*]] = icmp sge i64 [[X]], -32768
 210 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 211 ; CHECK-NEXT:    [[C2:%.*]] = icmp sle i64 [[Y:%.*]], 32767
 212 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C2]])
 213 ; CHECK-NEXT:    [[C3:%.*]] = icmp sge i64 [[Y]], -32768
 214 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C3]])
 215 ; CHECK-NEXT:    [[DIV_LHS_TRUNC:%.*]] = trunc i64 [[X]] to i32
 216 ; CHECK-NEXT:    [[DIV_RHS_TRUNC:%.*]] = trunc i64 [[Y]] to i32
 217 ; CHECK-NEXT:    [[DIV1:%.*]] = srem i32 [[DIV_LHS_TRUNC]], [[DIV_RHS_TRUNC]]
 218 ; CHECK-NEXT:    [[DIV_SEXT:%.*]] = sext i32 [[DIV1]] to i64
 219 ; CHECK-NEXT:    ret i64 [[DIV_SEXT]]
 220 ;
 221 entry:
 222   %c0 = icmp sle i64 %x, 32767
 223   call void @llvm.assume(i1 %c0)
 224   %c1 = icmp sge i64 %x, -32768
 225   call void @llvm.assume(i1 %c1)
 226
 227   %c2 = icmp sle i64 %y, 32767
 228   call void @llvm.assume(i1 %c2)
 229   %c3 = icmp sge i64 %y, -32768
 230   call void @llvm.assume(i1 %c3)
 231
 232   %div = srem i64 %x, %y
 233   ret i64 %div
 234 }
 235
 236 ; But if divident is i16, and divisor is u15, then we know that i16 is UB-safe.
 237 define i64 @test13_i16_u15(i64 %x, i64 %y) {
 238 ; CHECK-LABEL: @test13_i16_u15(
 239 ; CHECK-NEXT:  entry:
 240 ; CHECK-NEXT:    [[C0:%.*]] = icmp sle i64 [[X:%.*]], 32767
 241 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 242 ; CHECK-NEXT:    [[C1:%.*]] = icmp sge i64 [[X]], -32768
 243 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 244 ; CHECK-NEXT:    [[C2:%.*]] = icmp ule i64 [[Y:%.*]], 32767
 245 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C2]])
 246 ; CHECK-NEXT:    [[DIV_LHS_TRUNC:%.*]] = trunc i64 [[X]] to i16
 247 ; CHECK-NEXT:    [[DIV_RHS_TRUNC:%.*]] = trunc i64 [[Y]] to i16
 248 ; CHECK-NEXT:    [[DIV1:%.*]] = srem i16 [[DIV_LHS_TRUNC]], [[DIV_RHS_TRUNC]]
 249 ; CHECK-NEXT:    [[DIV_SEXT:%.*]] = sext i16 [[DIV1]] to i64
 250 ; CHECK-NEXT:    ret i64 [[DIV_SEXT]]
 251 ;
 252 entry:
 253   %c0 = icmp sle i64 %x, 32767
 254   call void @llvm.assume(i1 %c0)
 255   %c1 = icmp sge i64 %x, -32768
 256   call void @llvm.assume(i1 %c1)
 257
 258   %c2 = icmp ule i64 %y, 32767
 259   call void @llvm.assume(i1 %c2)
 260
 261   %div = srem i64 %x, %y
 262   ret i64 %div
 263 }
 264
 265 ; And likewise, if we know that if the divident is never i16 INT_MIN,
 266 ; we can truncate to i16.
 267 define i64 @test14_i16safe_i16(i64 %x, i64 %y) {
 268 ; CHECK-LABEL: @test14_i16safe_i16(
 269 ; CHECK-NEXT:  entry:
 270 ; CHECK-NEXT:    [[C0:%.*]] = icmp sle i64 [[X:%.*]], 32767
 271 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 272 ; CHECK-NEXT:    [[C1:%.*]] = icmp sgt i64 [[X]], -32768
 273 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 274 ; CHECK-NEXT:    [[C2:%.*]] = icmp sle i64 [[Y:%.*]], 32767
 275 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C2]])
 276 ; CHECK-NEXT:    [[C3:%.*]] = icmp sge i64 [[Y]], -32768
 277 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C3]])
 278 ; CHECK-NEXT:    [[DIV_LHS_TRUNC:%.*]] = trunc i64 [[X]] to i16
 279 ; CHECK-NEXT:    [[DIV_RHS_TRUNC:%.*]] = trunc i64 [[Y]] to i16
 280 ; CHECK-NEXT:    [[DIV1:%.*]] = srem i16 [[DIV_LHS_TRUNC]], [[DIV_RHS_TRUNC]]
 281 ; CHECK-NEXT:    [[DIV_SEXT:%.*]] = sext i16 [[DIV1]] to i64
 282 ; CHECK-NEXT:    ret i64 [[DIV_SEXT]]
 283 ;
 284 entry:
 285   %c0 = icmp sle i64 %x, 32767
 286   call void @llvm.assume(i1 %c0)
 287   %c1 = icmp sgt i64 %x, -32768
 288   call void @llvm.assume(i1 %c1)
 289
 290   %c2 = icmp sle i64 %y, 32767
 291   call void @llvm.assume(i1 %c2)
 292   %c3 = icmp sge i64 %y, -32768
 293   call void @llvm.assume(i1 %c3)
 294
 295   %div = srem i64 %x, %y
 296   ret i64 %div
 297 }
 298
 299 ; Of course, both of the conditions can happen at once.
 300 define i64 @test15_i16safe_u15(i64 %x, i64 %y) {
 301 ; CHECK-LABEL: @test15_i16safe_u15(
 302 ; CHECK-NEXT:  entry:
 303 ; CHECK-NEXT:    [[C0:%.*]] = icmp sle i64 [[X:%.*]], 32767
 304 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 305 ; CHECK-NEXT:    [[C1:%.*]] = icmp sgt i64 [[X]], -32768
 306 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 307 ; CHECK-NEXT:    [[C2:%.*]] = icmp ule i64 [[Y:%.*]], 32767
 308 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C2]])
 309 ; CHECK-NEXT:    [[DIV_LHS_TRUNC:%.*]] = trunc i64 [[X]] to i16
 310 ; CHECK-NEXT:    [[DIV_RHS_TRUNC:%.*]] = trunc i64 [[Y]] to i16
 311 ; CHECK-NEXT:    [[DIV1:%.*]] = srem i16 [[DIV_LHS_TRUNC]], [[DIV_RHS_TRUNC]]
 312 ; CHECK-NEXT:    [[DIV_SEXT:%.*]] = sext i16 [[DIV1]] to i64
 313 ; CHECK-NEXT:    ret i64 [[DIV_SEXT]]
 314 ;
 315 entry:
 316   %c0 = icmp sle i64 %x, 32767
 317   call void @llvm.assume(i1 %c0)
 318   %c1 = icmp sgt i64 %x, -32768
 319   call void @llvm.assume(i1 %c1)
 320
 321   %c2 = icmp ule i64 %y, 32767
 322   call void @llvm.assume(i1 %c2)
 323
 324   %div = srem i64 %x, %y
 325   ret i64 %div
 326 }
 327
 328 ; We at most truncate to i8
 329 define i64 @test16_i4_i4(i64 %x, i64 %y) {
 330 ; CHECK-LABEL: @test16_i4_i4(
 331 ; CHECK-NEXT:  entry:
 332 ; CHECK-NEXT:    [[C0:%.*]] = icmp sle i64 [[X:%.*]], 3
 333 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 334 ; CHECK-NEXT:    [[C1:%.*]] = icmp sge i64 [[X]], -4
 335 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 336 ; CHECK-NEXT:    [[C2:%.*]] = icmp sle i64 [[Y:%.*]], 3
 337 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C2]])
 338 ; CHECK-NEXT:    [[C3:%.*]] = icmp sge i64 [[Y]], -4
 339 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C3]])
 340 ; CHECK-NEXT:    [[DIV_LHS_TRUNC:%.*]] = trunc i64 [[X]] to i8
 341 ; CHECK-NEXT:    [[DIV_RHS_TRUNC:%.*]] = trunc i64 [[Y]] to i8
 342 ; CHECK-NEXT:    [[DIV1:%.*]] = srem i8 [[DIV_LHS_TRUNC]], [[DIV_RHS_TRUNC]]
 343 ; CHECK-NEXT:    [[DIV_SEXT:%.*]] = sext i8 [[DIV1]] to i64
 344 ; CHECK-NEXT:    ret i64 [[DIV_SEXT]]
 345 ;
 346 entry:
 347   %c0 = icmp sle i64 %x, 3
 348   call void @llvm.assume(i1 %c0)
 349   %c1 = icmp sge i64 %x, -4
 350   call void @llvm.assume(i1 %c1)
 351
 352   %c2 = icmp sle i64 %y, 3
 353   call void @llvm.assume(i1 %c2)
 354   %c3 = icmp sge i64 %y, -4
 355   call void @llvm.assume(i1 %c3)
 356
 357   %div = srem i64 %x, %y
 358   ret i64 %div
 359 }
 360
 361 ; And we round up to the powers of two
 362 define i64 @test17_i9_i9(i64 %x, i64 %y) {
 363 ; CHECK-LABEL: @test17_i9_i9(
 364 ; CHECK-NEXT:  entry:
 365 ; CHECK-NEXT:    [[C0:%.*]] = icmp sle i64 [[X:%.*]], 255
 366 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 367 ; CHECK-NEXT:    [[C1:%.*]] = icmp sge i64 [[X]], -256
 368 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 369 ; CHECK-NEXT:    [[C2:%.*]] = icmp sle i64 [[Y:%.*]], 255
 370 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C2]])
 371 ; CHECK-NEXT:    [[C3:%.*]] = icmp sge i64 [[Y]], -256
 372 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C3]])
 373 ; CHECK-NEXT:    [[DIV_LHS_TRUNC:%.*]] = trunc i64 [[X]] to i16
 374 ; CHECK-NEXT:    [[DIV_RHS_TRUNC:%.*]] = trunc i64 [[Y]] to i16
 375 ; CHECK-NEXT:    [[DIV1:%.*]] = srem i16 [[DIV_LHS_TRUNC]], [[DIV_RHS_TRUNC]]
 376 ; CHECK-NEXT:    [[DIV_SEXT:%.*]] = sext i16 [[DIV1]] to i64
 377 ; CHECK-NEXT:    ret i64 [[DIV_SEXT]]
 378 ;
 379 entry:
 380   %c0 = icmp sle i64 %x, 255
 381   call void @llvm.assume(i1 %c0)
 382   %c1 = icmp sge i64 %x, -256
 383   call void @llvm.assume(i1 %c1)
 384
 385   %c2 = icmp sle i64 %y, 255
 386   call void @llvm.assume(i1 %c2)
 387   %c3 = icmp sge i64 %y, -256
 388   call void @llvm.assume(i1 %c3)
 389
 390   %div = srem i64 %x, %y
 391   ret i64 %div
 392 }
 393
 394 ; Don't widen the operation to the next power of two if it wasn't a power of two.
 395 define i9 @test18_i9_i9(i9 %x, i9 %y) {
 396 ; CHECK-LABEL: @test18_i9_i9(
 397 ; CHECK-NEXT:  entry:
 398 ; CHECK-NEXT:    [[C0:%.*]] = icmp sle i9 [[X:%.*]], 255
 399 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 400 ; CHECK-NEXT:    [[C1:%.*]] = icmp sge i9 [[X]], -256
 401 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 402 ; CHECK-NEXT:    [[C2:%.*]] = icmp sle i9 [[Y:%.*]], 255
 403 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C2]])
 404 ; CHECK-NEXT:    [[C3:%.*]] = icmp sge i9 [[Y]], -256
 405 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C3]])
 406 ; CHECK-NEXT:    [[DIV:%.*]] = srem i9 [[X]], [[Y]]
 407 ; CHECK-NEXT:    ret i9 [[DIV]]
 408 ;
 409 entry:
 410   %c0 = icmp sle i9 %x, 255
 411   call void @llvm.assume(i1 %c0)
 412   %c1 = icmp sge i9 %x, -256
 413   call void @llvm.assume(i1 %c1)
 414
 415   %c2 = icmp sle i9 %y, 255
 416   call void @llvm.assume(i1 %c2)
 417   %c3 = icmp sge i9 %y, -256
 418   call void @llvm.assume(i1 %c3)
 419
 420   %div = srem i9 %x, %y
 421   ret i9 %div
 422 }
 423 define i10 @test19_i10_i10(i10 %x, i10 %y) {
 424 ; CHECK-LABEL: @test19_i10_i10(
 425 ; CHECK-NEXT:  entry:
 426 ; CHECK-NEXT:    [[C0:%.*]] = icmp sle i10 [[X:%.*]], 255
 427 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 428 ; CHECK-NEXT:    [[C1:%.*]] = icmp sge i10 [[X]], -256
 429 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 430 ; CHECK-NEXT:    [[C2:%.*]] = icmp sle i10 [[Y:%.*]], 255
 431 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C2]])
 432 ; CHECK-NEXT:    [[C3:%.*]] = icmp sge i10 [[Y]], -256
 433 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C3]])
 434 ; CHECK-NEXT:    [[DIV:%.*]] = srem i10 [[X]], [[Y]]
 435 ; CHECK-NEXT:    ret i10 [[DIV]]
 436 ;
 437 entry:
 438   %c0 = icmp sle i10 %x, 255
 439   call void @llvm.assume(i1 %c0)
 440   %c1 = icmp sge i10 %x, -256
 441   call void @llvm.assume(i1 %c1)
 442
 443   %c2 = icmp sle i10 %y, 255
 444   call void @llvm.assume(i1 %c2)
 445   %c3 = icmp sge i10 %y, -256
 446   call void @llvm.assume(i1 %c3)
 447
 448   %div = srem i10 %x, %y
 449   ret i10 %div
 450 }
 451
 452 ; Note that we need to take the maximal bitwidth, in which both of the operands are representable!
 453 define i64 @test20_i16_i18(i64 %x, i64 %y) {
 454 ; CHECK-LABEL: @test20_i16_i18(
 455 ; CHECK-NEXT:  entry:
 456 ; CHECK-NEXT:    [[C0:%.*]] = icmp sle i64 [[X:%.*]], 16383
 457 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 458 ; CHECK-NEXT:    [[C1:%.*]] = icmp sge i64 [[X]], -16384
 459 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 460 ; CHECK-NEXT:    [[C2:%.*]] = icmp sle i64 [[Y:%.*]], 65535
 461 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C2]])
 462 ; CHECK-NEXT:    [[C3:%.*]] = icmp sge i64 [[Y]], -65536
 463 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C3]])
 464 ; CHECK-NEXT:    [[DIV_LHS_TRUNC:%.*]] = trunc i64 [[X]] to i32
 465 ; CHECK-NEXT:    [[DIV_RHS_TRUNC:%.*]] = trunc i64 [[Y]] to i32
 466 ; CHECK-NEXT:    [[DIV1:%.*]] = srem i32 [[DIV_LHS_TRUNC]], [[DIV_RHS_TRUNC]]
 467 ; CHECK-NEXT:    [[DIV_SEXT:%.*]] = sext i32 [[DIV1]] to i64
 468 ; CHECK-NEXT:    ret i64 [[DIV_SEXT]]
 469 ;
 470 entry:
 471   %c0 = icmp sle i64 %x, 16383
 472   call void @llvm.assume(i1 %c0)
 473   %c1 = icmp sge i64 %x, -16384
 474   call void @llvm.assume(i1 %c1)
 475
 476   %c2 = icmp sle i64 %y, 65535
 477   call void @llvm.assume(i1 %c2)
 478   %c3 = icmp sge i64 %y, -65536
 479   call void @llvm.assume(i1 %c3)
 480
 481   %div = srem i64 %x, %y
 482   ret i64 %div
 483 }
 484 define i64 @test21_i18_i16(i64 %x, i64 %y) {
 485 ; CHECK-LABEL: @test21_i18_i16(
 486 ; CHECK-NEXT:  entry:
 487 ; CHECK-NEXT:    [[C0:%.*]] = icmp sle i64 [[X:%.*]], 65535
 488 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C0]])
 489 ; CHECK-NEXT:    [[C1:%.*]] = icmp sge i64 [[X]], -65536
 490 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C1]])
 491 ; CHECK-NEXT:    [[C2:%.*]] = icmp sle i64 [[Y:%.*]], 16383
 492 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C2]])
 493 ; CHECK-NEXT:    [[C3:%.*]] = icmp sge i64 [[Y]], -16384
 494 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C3]])
 495 ; CHECK-NEXT:    [[DIV_LHS_TRUNC:%.*]] = trunc i64 [[X]] to i32
 496 ; CHECK-NEXT:    [[DIV_RHS_TRUNC:%.*]] = trunc i64 [[Y]] to i32
 497 ; CHECK-NEXT:    [[DIV1:%.*]] = srem i32 [[DIV_LHS_TRUNC]], [[DIV_RHS_TRUNC]]
 498 ; CHECK-NEXT:    [[DIV_SEXT:%.*]] = sext i32 [[DIV1]] to i64
 499 ; CHECK-NEXT:    ret i64 [[DIV_SEXT]]
 500 ;
 501 entry:
 502   %c0 = icmp sle i64 %x, 65535
 503   call void @llvm.assume(i1 %c0)
 504   %c1 = icmp sge i64 %x, -65536
 505   call void @llvm.assume(i1 %c1)
 506
 507   %c2 = icmp sle i64 %y, 16383
 508   call void @llvm.assume(i1 %c2)
 509   %c3 = icmp sge i64 %y, -16384
 510   call void @llvm.assume(i1 %c3)
 511
 512   %div = srem i64 %x, %y
 513   ret i64 %div
 514 }
 515
 516 define dso_local i8 @abs_x_lt_abs_y_positive(i8 %x, i8 %y) {
 517 ; CHECK-LABEL: @abs_x_lt_abs_y_positive(
 518 ; CHECK-NEXT:  entry:
 519 ; CHECK-NEXT:    [[X_CMP:%.*]] = icmp slt i8 [[X:%.*]], 10
 520 ; CHECK-NEXT:    [[X_CMP2:%.*]] = icmp sgt i8 [[X]], -10
 521 ; CHECK-NEXT:    [[AND_X:%.*]] = and i1 [[X_CMP]], [[X_CMP2]]
 522 ; CHECK-NEXT:    [[Y_CMP:%.*]] = icmp sge i8 [[Y:%.*]], 10
 523 ; CHECK-NEXT:    [[AND_COND:%.*]] = and i1 [[AND_X]], [[Y_CMP]]
 524 ; CHECK-NEXT:    br i1 [[AND_COND]], label [[IF_ELSE:%.*]], label [[IF_THEN:%.*]]
 525 ; CHECK:       if.else:
 526 ; CHECK-NEXT:    ret i8 [[X]]
 527 ; CHECK:       if.then:
 528 ; CHECK-NEXT:    ret i8 0
 529 ;
 530 entry:
 531   %x.cmp = icmp slt i8 %x, 10
 532   %x.cmp2 = icmp sgt i8 %x, -10
 533   %and.x = and i1 %x.cmp, %x.cmp2
 534   %y.cmp = icmp sge i8 %y, 10
 535   %and.cond = and i1 %and.x, %y.cmp
 536   br i1 %and.cond, label %if.else, label %if.then
 537
 538 if.else:                                          ; preds = %entry
 539   %rem = srem i8 %x, %y
 540   ret i8 %rem
 541
 542 if.then:                                          ; preds = %entry, %if.then6, %if.end4
 543   ret i8 0
 544 }
 545
 546 define dso_local i8 @abs_x_lt_abs_y_positive_unsigned_cmp(i8 %x, i8 %y) {
 547 ; CHECK-LABEL: @abs_x_lt_abs_y_positive_unsigned_cmp(
 548 ; CHECK-NEXT:  entry:
 549 ; CHECK-NEXT:    [[X_CMP:%.*]] = icmp slt i8 [[X:%.*]], 10
 550 ; CHECK-NEXT:    [[X_CMP2:%.*]] = icmp sgt i8 [[X]], -10
 551 ; CHECK-NEXT:    [[AND_X:%.*]] = and i1 [[X_CMP]], [[X_CMP2]]
 552 ; CHECK-NEXT:    [[Y_CMP:%.*]] = icmp uge i8 [[Y:%.*]], 10
 553 ; CHECK-NEXT:    [[Y_CMP2:%.*]] = icmp ule i8 [[Y]], 20
 554 ; CHECK-NEXT:    [[AND_Y:%.*]] = and i1 [[Y_CMP]], [[Y_CMP2]]
 555 ; CHECK-NEXT:    [[AND_COND:%.*]] = and i1 [[AND_X]], [[AND_Y]]
 556 ; CHECK-NEXT:    br i1 [[AND_COND]], label [[IF_ELSE:%.*]], label [[IF_THEN:%.*]]
 557 ; CHECK:       if.else:
 558 ; CHECK-NEXT:    ret i8 [[X]]
 559 ; CHECK:       if.then:
 560 ; CHECK-NEXT:    ret i8 0
 561 ;
 562 entry:
 563   %x.cmp = icmp slt i8 %x, 10
 564   %x.cmp2 = icmp sgt i8 %x, -10
 565   %and.x = and i1 %x.cmp, %x.cmp2
 566   %y.cmp = icmp uge i8 %y, 10
 567   %y.cmp2 = icmp ule i8 %y, 20
 568   %and.y = and i1 %y.cmp, %y.cmp2
 569   %and.cond = and i1 %and.x, %and.y
 570   br i1 %and.cond, label %if.else, label %if.then
 571
 572 if.else:                                          ; preds = %entry
 573   %rem = srem i8 %x, %y
 574   ret i8 %rem
 575
 576 if.then:                                          ; preds = %entry, %if.then6, %if.end4
 577   ret i8 0
 578 }
 579
 580 define dso_local i8 @abs_x_lt_abs_y_negative(i8 %x, i8 %y) {
 581 ; CHECK-LABEL: @abs_x_lt_abs_y_negative(
 582 ; CHECK-NEXT:  entry:
 583 ; CHECK-NEXT:    [[X_CMP:%.*]] = icmp slt i8 [[X:%.*]], 10
 584 ; CHECK-NEXT:    [[X_CMP2:%.*]] = icmp sgt i8 [[X]], -10
 585 ; CHECK-NEXT:    [[AND_X:%.*]] = and i1 [[X_CMP]], [[X_CMP2]]
 586 ; CHECK-NEXT:    [[Y_CMP:%.*]] = icmp sge i8 [[Y:%.*]], -20
 587 ; CHECK-NEXT:    [[Y_CMP2:%.*]] = icmp sle i8 [[Y]], -11
 588 ; CHECK-NEXT:    [[AND_Y:%.*]] = and i1 [[Y_CMP]], [[Y_CMP2]]
 589 ; CHECK-NEXT:    [[AND_COND:%.*]] = and i1 [[AND_X]], [[AND_Y]]
 590 ; CHECK-NEXT:    br i1 [[AND_COND]], label [[IF_ELSE:%.*]], label [[IF_THEN:%.*]]
 591 ; CHECK:       if.else:
 592 ; CHECK-NEXT:    ret i8 [[X]]
 593 ; CHECK:       if.then:
 594 ; CHECK-NEXT:    ret i8 0
 595 ;
 596 entry:
 597   %x.cmp = icmp slt i8 %x, 10
 598   %x.cmp2 = icmp sgt i8 %x, -10
 599   %and.x = and i1 %x.cmp, %x.cmp2
 600   %y.cmp = icmp sge i8 %y, -20
 601   %y.cmp2 = icmp sle i8 %y, -11
 602   %and.y = and i1 %y.cmp, %y.cmp2
 603   %and.cond = and i1 %and.x, %and.y
 604   br i1 %and.cond, label %if.else, label %if.then
 605
 606 if.else:                                          ; preds = %entry
 607   %rem = srem i8 %x, %y
 608   ret i8 %rem
 609
 610 if.then:                                          ; preds = %entry, %if.then6, %if.end4
 611   ret i8 0
 612 }
 613
 614 ; Negative test: abs(x) less than or equal abs(y)
 615
 616 define dso_local i8 @abs_x_lte_abs_y(i8 %x, i8 %y) {
 617 ; CHECK-LABEL: @abs_x_lte_abs_y(
 618 ; CHECK-NEXT:  entry:
 619 ; CHECK-NEXT:    [[X_CMP:%.*]] = icmp slt i8 [[X:%.*]], 10
 620 ; CHECK-NEXT:    [[X_CMP2:%.*]] = icmp sgt i8 [[X]], -10
 621 ; CHECK-NEXT:    [[AND_X:%.*]] = and i1 [[X_CMP]], [[X_CMP2]]
 622 ; CHECK-NEXT:    [[Y_CMP:%.*]] = icmp sge i8 [[Y:%.*]], -20
 623 ; CHECK-NEXT:    [[Y_CMP2:%.*]] = icmp sle i8 [[Y]], -9
 624 ; CHECK-NEXT:    [[AND_Y:%.*]] = and i1 [[Y_CMP]], [[Y_CMP2]]
 625 ; CHECK-NEXT:    [[AND_COND:%.*]] = and i1 [[AND_X]], [[AND_Y]]
 626 ; CHECK-NEXT:    br i1 [[AND_COND]], label [[IF_ELSE:%.*]], label [[IF_THEN:%.*]]
 627 ; CHECK:       if.else:
 628 ; CHECK-NEXT:    [[REM:%.*]] = srem i8 [[X]], [[Y]]
 629 ; CHECK-NEXT:    ret i8 [[REM]]
 630 ; CHECK:       if.then:
 631 ; CHECK-NEXT:    ret i8 0
 632 ;
 633 entry:
 634   %x.cmp = icmp slt i8 %x, 10
 635   %x.cmp2 = icmp sgt i8 %x, -10
 636   %and.x = and i1 %x.cmp, %x.cmp2
 637   %y.cmp = icmp sge i8 %y, -20
 638   %y.cmp2 = icmp sle i8 %y, -9
 639   %and.y = and i1 %y.cmp, %y.cmp2
 640   %and.cond = and i1 %and.x, %and.y
 641   br i1 %and.cond, label %if.else, label %if.then
 642
 643 if.else:                                          ; preds = %entry
 644   %rem = srem i8 %x, %y
 645   ret i8 %rem
 646
 647 if.then:                                          ; preds = %entry, %if.then6, %if.end4
 648   ret i8 0
 649 }
 650
 651 ; Negative test: abs(x) has unknown predication with abs(y)
 652
 653 define dso_local i8 @abs_x_unknown_abs_y(i8 %x, i8 %y) {
 654 ; CHECK-LABEL: @abs_x_unknown_abs_y(
 655 ; CHECK-NEXT:  entry:
 656 ; CHECK-NEXT:    [[X_CMP:%.*]] = icmp slt i8 [[X:%.*]], 10
 657 ; CHECK-NEXT:    [[X_CMP2:%.*]] = icmp sgt i8 [[X]], -10
 658 ; CHECK-NEXT:    [[AND_X:%.*]] = and i1 [[X_CMP]], [[X_CMP2]]
 659 ; CHECK-NEXT:    [[Y_CMP:%.*]] = icmp sge i8 [[Y:%.*]], -20
 660 ; CHECK-NEXT:    [[Y_CMP2:%.*]] = icmp sle i8 [[Y]], -9
 661 ; CHECK-NEXT:    [[AND_Y:%.*]] = and i1 [[Y_CMP]], [[Y_CMP2]]
 662 ; CHECK-NEXT:    [[AND_COND:%.*]] = and i1 [[AND_X]], [[AND_Y]]
 663 ; CHECK-NEXT:    br i1 [[AND_COND]], label [[IF_ELSE:%.*]], label [[IF_THEN:%.*]]
 664 ; CHECK:       if.else:
 665 ; CHECK-NEXT:    [[REM:%.*]] = srem i8 [[X]], [[Y]]
 666 ; CHECK-NEXT:    ret i8 [[REM]]
 667 ; CHECK:       if.then:
 668 ; CHECK-NEXT:    ret i8 0
 669 ;
 670 entry:
 671   %x.cmp = icmp slt i8 %x, 10
 672   %x.cmp2 = icmp sgt i8 %x, -10
 673   %and.x = and i1 %x.cmp, %x.cmp2
 674   %y.cmp = icmp sge i8 %y, -20
 675   %y.cmp2 = icmp sle i8 %y, -9
 676   %and.y = and i1 %y.cmp, %y.cmp2
 677   %and.cond = and i1 %and.x, %and.y
 678   br i1 %and.cond, label %if.else, label %if.then
 679
 680 if.else:                                          ; preds = %entry
 681   %rem = srem i8 %x, %y
 682   ret i8 %rem
 683
 684 if.then:                                          ; preds = %entry, %if.then6, %if.end4
 685   ret i8 0
 686 }