test/CodeGen/AArch64/urem-seteq.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc -mtriple=aarch64-unknown-linux-gnu < %s | FileCheck %s
   3
   4 ;------------------------------------------------------------------------------;
   5 ; Odd divisors
   6 ;------------------------------------------------------------------------------;
   7
   8 define i32 @test_urem_odd(i32 %X) nounwind {
   9 ; CHECK-LABEL: test_urem_odd:
  10 ; CHECK:       // %bb.0:
  11 ; CHECK-NEXT:    mov w8, #52429
  12 ; CHECK-NEXT:    movk w8, #52428, lsl #16
  13 ; CHECK-NEXT:    mov w9, #13108
  14 ; CHECK-NEXT:    mul w8, w0, w8
  15 ; CHECK-NEXT:    movk w9, #13107, lsl #16
  16 ; CHECK-NEXT:    cmp w8, w9
  17 ; CHECK-NEXT:    cset w0, lo
  18 ; CHECK-NEXT:    ret
  19   %urem = urem i32 %X, 5
  20   %cmp = icmp eq i32 %urem, 0
  21   %ret = zext i1 %cmp to i32
  22   ret i32 %ret
  23 }
  24
  25 define i32 @test_urem_odd_25(i32 %X) nounwind {
  26 ; CHECK-LABEL: test_urem_odd_25:
  27 ; CHECK:       // %bb.0:
  28 ; CHECK-NEXT:    mov w8, #23593
  29 ; CHECK-NEXT:    movk w8, #49807, lsl #16
  30 ; CHECK-NEXT:    mov w9, #28836
  31 ; CHECK-NEXT:    mul w8, w0, w8
  32 ; CHECK-NEXT:    movk w9, #2621, lsl #16
  33 ; CHECK-NEXT:    cmp w8, w9
  34 ; CHECK-NEXT:    cset w0, lo
  35 ; CHECK-NEXT:    ret
  36   %urem = urem i32 %X, 25
  37   %cmp = icmp eq i32 %urem, 0
  38   %ret = zext i1 %cmp to i32
  39   ret i32 %ret
  40 }
  41
  42 ; This is like test_urem_odd, except the divisor has bit 30 set.
  43 define i32 @test_urem_odd_bit30(i32 %X) nounwind {
  44 ; CHECK-LABEL: test_urem_odd_bit30:
  45 ; CHECK:       // %bb.0:
  46 ; CHECK-NEXT:    mov w8, #43691
  47 ; CHECK-NEXT:    movk w8, #27306, lsl #16
  48 ; CHECK-NEXT:    mul w8, w0, w8
  49 ; CHECK-NEXT:    cmp w8, #4 // =4
  50 ; CHECK-NEXT:    cset w0, lo
  51 ; CHECK-NEXT:    ret
  52   %urem = urem i32 %X, 1073741827
  53   %cmp = icmp eq i32 %urem, 0
  54   %ret = zext i1 %cmp to i32
  55   ret i32 %ret
  56 }
  57
  58 ; This is like test_urem_odd, except the divisor has bit 31 set.
  59 define i32 @test_urem_odd_bit31(i32 %X) nounwind {
  60 ; CHECK-LABEL: test_urem_odd_bit31:
  61 ; CHECK:       // %bb.0:
  62 ; CHECK-NEXT:    mov w8, #43691
  63 ; CHECK-NEXT:    movk w8, #10922, lsl #16
  64 ; CHECK-NEXT:    mul w8, w0, w8
  65 ; CHECK-NEXT:    cmp w8, #2 // =2
  66 ; CHECK-NEXT:    cset w0, lo
  67 ; CHECK-NEXT:    ret
  68   %urem = urem i32 %X, 2147483651
  69   %cmp = icmp eq i32 %urem, 0
  70   %ret = zext i1 %cmp to i32
  71   ret i32 %ret
  72 }
  73
  74 ;------------------------------------------------------------------------------;
  75 ; Even divisors
  76 ;------------------------------------------------------------------------------;
  77
  78 define i16 @test_urem_even(i16 %X) nounwind {
  79 ; CHECK-LABEL: test_urem_even:
  80 ; CHECK:       // %bb.0:
  81 ; CHECK-NEXT:    mov w9, #28087
  82 ; CHECK-NEXT:    and w8, w0, #0xffff
  83 ; CHECK-NEXT:    movk w9, #46811, lsl #16
  84 ; CHECK-NEXT:    mul w8, w8, w9
  85 ; CHECK-NEXT:    mov w9, #9362
  86 ; CHECK-NEXT:    ror w8, w8, #1
  87 ; CHECK-NEXT:    movk w9, #4681, lsl #16
  88 ; CHECK-NEXT:    cmp w8, w9
  89 ; CHECK-NEXT:    cset w0, hi
  90 ; CHECK-NEXT:    ret
  91   %urem = urem i16 %X, 14
  92   %cmp = icmp ne i16 %urem, 0
  93   %ret = zext i1 %cmp to i16
  94   ret i16 %ret
  95 }
  96
  97 define i32 @test_urem_even_100(i32 %X) nounwind {
  98 ; CHECK-LABEL: test_urem_even_100:
  99 ; CHECK:       // %bb.0:
 100 ; CHECK-NEXT:    mov w8, #23593
 101 ; CHECK-NEXT:    movk w8, #49807, lsl #16
 102 ; CHECK-NEXT:    mul w8, w0, w8
 103 ; CHECK-NEXT:    mov w9, #23593
 104 ; CHECK-NEXT:    ror w8, w8, #2
 105 ; CHECK-NEXT:    movk w9, #655, lsl #16
 106 ; CHECK-NEXT:    cmp w8, w9
 107 ; CHECK-NEXT:    cset w0, lo
 108 ; CHECK-NEXT:    ret
 109   %urem = urem i32 %X, 100
 110   %cmp = icmp eq i32 %urem, 0
 111   %ret = zext i1 %cmp to i32
 112   ret i32 %ret
 113 }
 114
 115 ; This is like test_urem_even, except the divisor has bit 30 set.
 116 define i32 @test_urem_even_bit30(i32 %X) nounwind {
 117 ; CHECK-LABEL: test_urem_even_bit30:
 118 ; CHECK:       // %bb.0:
 119 ; CHECK-NEXT:    mov w8, #20165
 120 ; CHECK-NEXT:    movk w8, #64748, lsl #16
 121 ; CHECK-NEXT:    mul w8, w0, w8
 122 ; CHECK-NEXT:    ror w8, w8, #3
 123 ; CHECK-NEXT:    cmp w8, #4 // =4
 124 ; CHECK-NEXT:    cset w0, lo
 125 ; CHECK-NEXT:    ret
 126   %urem = urem i32 %X, 1073741928
 127   %cmp = icmp eq i32 %urem, 0
 128   %ret = zext i1 %cmp to i32
 129   ret i32 %ret
 130 }
 131
 132 ; This is like test_urem_odd, except the divisor has bit 31 set.
 133 define i32 @test_urem_even_bit31(i32 %X) nounwind {
 134 ; CHECK-LABEL: test_urem_even_bit31:
 135 ; CHECK:       // %bb.0:
 136 ; CHECK-NEXT:    mov w8, #64251
 137 ; CHECK-NEXT:    movk w8, #47866, lsl #16
 138 ; CHECK-NEXT:    mul w8, w0, w8
 139 ; CHECK-NEXT:    ror w8, w8, #1
 140 ; CHECK-NEXT:    cmp w8, #2 // =2
 141 ; CHECK-NEXT:    cset w0, lo
 142 ; CHECK-NEXT:    ret
 143   %urem = urem i32 %X, 2147483750
 144   %cmp = icmp eq i32 %urem, 0
 145   %ret = zext i1 %cmp to i32
 146   ret i32 %ret
 147 }
 148
 149 ;------------------------------------------------------------------------------;
 150 ; Special case
 151 ;------------------------------------------------------------------------------;
 152
 153 ; 'NE' predicate is fine too.
 154 define i32 @test_urem_odd_setne(i32 %X) nounwind {
 155 ; CHECK-LABEL: test_urem_odd_setne:
 156 ; CHECK:       // %bb.0:
 157 ; CHECK-NEXT:    mov w8, #52429
 158 ; CHECK-NEXT:    movk w8, #52428, lsl #16
 159 ; CHECK-NEXT:    mul w8, w0, w8
 160 ; CHECK-NEXT:    mov w9, #858993459
 161 ; CHECK-NEXT:    cmp w8, w9
 162 ; CHECK-NEXT:    cset w0, hi
 163 ; CHECK-NEXT:    ret
 164   %urem = urem i32 %X, 5
 165   %cmp = icmp ne i32 %urem, 0
 166   %ret = zext i1 %cmp to i32
 167   ret i32 %ret
 168 }
 169
 170 ; The fold is only valid for positive divisors, negative-ones should be negated.
 171 define i32 @test_urem_negative_odd(i32 %X) nounwind {
 172 ; CHECK-LABEL: test_urem_negative_odd:
 173 ; CHECK:       // %bb.0:
 174 ; CHECK-NEXT:    mov w8, #858993459
 175 ; CHECK-NEXT:    mul w8, w0, w8
 176 ; CHECK-NEXT:    cmp w8, #1 // =1
 177 ; CHECK-NEXT:    cset w0, hi
 178 ; CHECK-NEXT:    ret
 179   %urem = urem i32 %X, -5
 180   %cmp = icmp ne i32 %urem, 0
 181   %ret = zext i1 %cmp to i32
 182   ret i32 %ret
 183 }
 184 define i32 @test_urem_negative_even(i32 %X) nounwind {
 185 ; CHECK-LABEL: test_urem_negative_even:
 186 ; CHECK:       // %bb.0:
 187 ; CHECK-NEXT:    mov w8, #37449
 188 ; CHECK-NEXT:    movk w8, #51492, lsl #16
 189 ; CHECK-NEXT:    mul w8, w0, w8
 190 ; CHECK-NEXT:    ror w8, w8, #1
 191 ; CHECK-NEXT:    cmp w8, #1 // =1
 192 ; CHECK-NEXT:    cset w0, hi
 193 ; CHECK-NEXT:    ret
 194   %urem = urem i32 %X, -14
 195   %cmp = icmp ne i32 %urem, 0
 196   %ret = zext i1 %cmp to i32
 197   ret i32 %ret
 198 }
 199
 200 ;------------------------------------------------------------------------------;
 201 ; Negative tests
 202 ;------------------------------------------------------------------------------;
 203
 204 ; We can lower remainder of division by one much better elsewhere.
 205 define i32 @test_urem_one(i32 %X) nounwind {
 206 ; CHECK-LABEL: test_urem_one:
 207 ; CHECK:       // %bb.0:
 208 ; CHECK-NEXT:    mov w0, #1
 209 ; CHECK-NEXT:    ret
 210   %urem = urem i32 %X, 1
 211   %cmp = icmp eq i32 %urem, 0
 212   %ret = zext i1 %cmp to i32
 213   ret i32 %ret
 214 }
 215
 216 ; We can lower remainder of division by powers of two much better elsewhere.
 217 define i32 @test_urem_pow2(i32 %X) nounwind {
 218 ; CHECK-LABEL: test_urem_pow2:
 219 ; CHECK:       // %bb.0:
 220 ; CHECK-NEXT:    tst w0, #0xf
 221 ; CHECK-NEXT:    cset w0, eq
 222 ; CHECK-NEXT:    ret
 223   %urem = urem i32 %X, 16
 224   %cmp = icmp eq i32 %urem, 0
 225   %ret = zext i1 %cmp to i32
 226   ret i32 %ret
 227 }
 228
 229 ; The fold is only valid for positive divisors, and we can't negate INT_MIN.
 230 define i32 @test_urem_int_min(i32 %X) nounwind {
 231 ; CHECK-LABEL: test_urem_int_min:
 232 ; CHECK:       // %bb.0:
 233 ; CHECK-NEXT:    tst w0, #0x7fffffff
 234 ; CHECK-NEXT:    cset w0, eq
 235 ; CHECK-NEXT:    ret
 236   %urem = urem i32 %X, 2147483648
 237   %cmp = icmp eq i32 %urem, 0
 238   %ret = zext i1 %cmp to i32
 239   ret i32 %ret
 240 }
 241
 242 ; We can lower remainder of division by all-ones much better elsewhere.
 243 define i32 @test_urem_allones(i32 %X) nounwind {
 244 ; CHECK-LABEL: test_urem_allones:
 245 ; CHECK:       // %bb.0:
 246 ; CHECK-NEXT:    neg w8, w0
 247 ; CHECK-NEXT:    cmp w8, #2 // =2
 248 ; CHECK-NEXT:    cset w0, lo
 249 ; CHECK-NEXT:    ret
 250   %urem = urem i32 %X, 4294967295
 251   %cmp = icmp eq i32 %urem, 0
 252   %ret = zext i1 %cmp to i32
 253   ret i32 %ret
 254 }