llvm/test/Transforms/InstCombine/icmp-shl-nsw.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
   3
   4 ; If the (shl x, C) preserved the sign and this is a sign test,
   5 ; compare the LHS operand instead
   6
   7 define i1 @icmp_shl_nsw_sgt(i32 %x) {
   8 ; CHECK-LABEL: @icmp_shl_nsw_sgt(
   9 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[X:%.*]], 0
  10 ; CHECK-NEXT:    ret i1 [[CMP]]
  11 ;
  12   %shl = shl nsw i32 %x, 21
  13   %cmp = icmp sgt i32 %shl, 0
  14   ret i1 %cmp
  15 }
  16
  17 define i1 @icmp_shl_nsw_sge0(i32 %x) {
  18 ; CHECK-LABEL: @icmp_shl_nsw_sge0(
  19 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[X:%.*]], -1
  20 ; CHECK-NEXT:    ret i1 [[CMP]]
  21 ;
  22   %shl = shl nsw i32 %x, 21
  23   %cmp = icmp sge i32 %shl, 0
  24   ret i1 %cmp
  25 }
  26
  27 define i1 @icmp_shl_nsw_sge1(i32 %x) {
  28 ; CHECK-LABEL: @icmp_shl_nsw_sge1(
  29 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[X:%.*]], 0
  30 ; CHECK-NEXT:    ret i1 [[CMP]]
  31 ;
  32   %shl = shl nsw i32 %x, 21
  33   %cmp = icmp sge i32 %shl, 1
  34   ret i1 %cmp
  35 }
  36
  37 define <2 x i1> @icmp_shl_nsw_sge1_vec(<2 x i32> %x) {
  38 ; CHECK-LABEL: @icmp_shl_nsw_sge1_vec(
  39 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i32> [[X:%.*]], zeroinitializer
  40 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
  41 ;
  42   %shl = shl nsw <2 x i32> %x, <i32 21, i32 21>
  43   %cmp = icmp sge <2 x i32> %shl, <i32 1, i32 1>
  44   ret <2 x i1> %cmp
  45 }
  46
  47 ; Checks for icmp (eq|ne) (shl x, C), 0
  48
  49 define i1 @icmp_shl_nsw_eq(i32 %x) {
  50 ; CHECK-LABEL: @icmp_shl_nsw_eq(
  51 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[X:%.*]], 0
  52 ; CHECK-NEXT:    ret i1 [[CMP]]
  53 ;
  54   %mul = shl nsw i32 %x, 5
  55   %cmp = icmp eq i32 %mul, 0
  56   ret i1 %cmp
  57 }
  58
  59 define <2 x i1> @icmp_shl_nsw_eq_vec(<2 x i32> %x) {
  60 ; CHECK-LABEL: @icmp_shl_nsw_eq_vec(
  61 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i32> [[X:%.*]], zeroinitializer
  62 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
  63 ;
  64   %mul = shl nsw <2 x i32> %x, <i32 5, i32 5>
  65   %cmp = icmp eq <2 x i32> %mul, zeroinitializer
  66   ret <2 x i1> %cmp
  67 }
  68
  69 ; icmp sgt with shl nsw with a constant compare operand and constant
  70 ; shift amount can always be reduced to icmp sgt alone.
  71
  72 ; Known bits analysis turns this into an equality predicate.
  73
  74 define i1 @icmp_sgt1(i8 %x) {
  75 ; CHECK-LABEL: @icmp_sgt1(
  76 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i8 [[X:%.*]], -64
  77 ; CHECK-NEXT:    ret i1 [[CMP]]
  78 ;
  79   %shl = shl nsw i8 %x, 1
  80   %cmp = icmp sgt i8 %shl, -128
  81   ret i1 %cmp
  82 }
  83
  84 define i1 @icmp_sgt2(i8 %x) {
  85 ; CHECK-LABEL: @icmp_sgt2(
  86 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], -64
  87 ; CHECK-NEXT:    ret i1 [[CMP]]
  88 ;
  89   %shl = shl nsw i8 %x, 1
  90   %cmp = icmp sgt i8 %shl, -127
  91   ret i1 %cmp
  92 }
  93
  94 define i1 @icmp_sgt3(i8 %x) {
  95 ; CHECK-LABEL: @icmp_sgt3(
  96 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], -8
  97 ; CHECK-NEXT:    ret i1 [[CMP]]
  98 ;
  99   %shl = shl nsw i8 %x, 1
 100   %cmp = icmp sgt i8 %shl, -16
 101   ret i1 %cmp
 102 }
 103
 104 define i1 @icmp_sgt4(i8 %x) {
 105 ; CHECK-LABEL: @icmp_sgt4(
 106 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], -1
 107 ; CHECK-NEXT:    ret i1 [[CMP]]
 108 ;
 109   %shl = shl nsw i8 %x, 1
 110   %cmp = icmp sgt i8 %shl, -2
 111   ret i1 %cmp
 112 }
 113
 114 ; x >s -1 is a sign bit test.
 115 ; x >s 0 is a sign bit test.
 116
 117 define i1 @icmp_sgt5(i8 %x) {
 118 ; CHECK-LABEL: @icmp_sgt5(
 119 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], 0
 120 ; CHECK-NEXT:    ret i1 [[CMP]]
 121 ;
 122   %shl = shl nsw i8 %x, 1
 123   %cmp = icmp sgt i8 %shl, 1
 124   ret i1 %cmp
 125 }
 126
 127 define i1 @icmp_sgt6(i8 %x) {
 128 ; CHECK-LABEL: @icmp_sgt6(
 129 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], 8
 130 ; CHECK-NEXT:    ret i1 [[CMP]]
 131 ;
 132   %shl = shl nsw i8 %x, 1
 133   %cmp = icmp sgt i8 %shl, 16
 134   ret i1 %cmp
 135 }
 136
 137 define i1 @icmp_sgt7(i8 %x) {
 138 ; CHECK-LABEL: @icmp_sgt7(
 139 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], 62
 140 ; CHECK-NEXT:    ret i1 [[CMP]]
 141 ;
 142   %shl = shl nsw i8 %x, 1
 143   %cmp = icmp sgt i8 %shl, 124
 144   ret i1 %cmp
 145 }
 146
 147 ; Known bits analysis turns this into an equality predicate.
 148
 149 define i1 @icmp_sgt8(i8 %x) {
 150 ; CHECK-LABEL: @icmp_sgt8(
 151 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[X:%.*]], 63
 152 ; CHECK-NEXT:    ret i1 [[CMP]]
 153 ;
 154   %shl = shl nsw i8 %x, 1
 155   %cmp = icmp sgt i8 %shl, 125
 156   ret i1 %cmp
 157 }
 158
 159 ; Compares with 126 and 127 are recognized as always false.
 160
 161 ; Known bits analysis turns this into an equality predicate.
 162
 163 define i1 @icmp_sgt9(i8 %x) {
 164 ; CHECK-LABEL: @icmp_sgt9(
 165 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[X:%.*]], 0
 166 ; CHECK-NEXT:    ret i1 [[CMP]]
 167 ;
 168   %shl = shl nsw i8 %x, 7
 169   %cmp = icmp sgt i8 %shl, -128
 170   ret i1 %cmp
 171 }
 172
 173 define i1 @icmp_sgt10(i8 %x) {
 174 ; CHECK-LABEL: @icmp_sgt10(
 175 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], -1
 176 ; CHECK-NEXT:    ret i1 [[CMP]]
 177 ;
 178   %shl = shl nsw i8 %x, 7
 179   %cmp = icmp sgt i8 %shl, -127
 180   ret i1 %cmp
 181 }
 182
 183 define i1 @icmp_sgt11(i8 %x) {
 184 ; CHECK-LABEL: @icmp_sgt11(
 185 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], -1
 186 ; CHECK-NEXT:    ret i1 [[CMP]]
 187 ;
 188   %shl = shl nsw i8 %x, 7
 189   %cmp = icmp sgt i8 %shl, -2
 190   ret i1 %cmp
 191 }
 192
 193 ; Splat vector version should fold the same way.
 194
 195 define <2 x i1> @icmp_sgt11_vec(<2 x i8> %x) {
 196 ; CHECK-LABEL: @icmp_sgt11_vec(
 197 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i8> [[X:%.*]], splat (i8 -1)
 198 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 199 ;
 200   %shl = shl nsw <2 x i8> %x, <i8 7, i8 7>
 201   %cmp = icmp sgt <2 x i8> %shl, <i8 -2, i8 -2>
 202   ret <2 x i1> %cmp
 203 }
 204
 205 ; Known bits analysis returns false for compares with >=0.
 206
 207 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 208 ;
 209 ; Repeat the shl nsw + sgt tests with predicate changed to 'sle'.
 210 ;
 211 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 212
 213 ; Known bits analysis turns this into an equality predicate.
 214
 215 define i1 @icmp_sle1(i8 %x) {
 216 ; CHECK-LABEL: @icmp_sle1(
 217 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[X:%.*]], -64
 218 ; CHECK-NEXT:    ret i1 [[CMP]]
 219 ;
 220   %shl = shl nsw i8 %x, 1
 221   %cmp = icmp sle i8 %shl, -128
 222   ret i1 %cmp
 223 }
 224
 225 define i1 @icmp_sle2(i8 %x) {
 226 ; CHECK-LABEL: @icmp_sle2(
 227 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X:%.*]], -63
 228 ; CHECK-NEXT:    ret i1 [[CMP]]
 229 ;
 230   %shl = shl nsw i8 %x, 1
 231   %cmp = icmp sle i8 %shl, -127
 232   ret i1 %cmp
 233 }
 234
 235 define i1 @icmp_sle3(i8 %x) {
 236 ; CHECK-LABEL: @icmp_sle3(
 237 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X:%.*]], -7
 238 ; CHECK-NEXT:    ret i1 [[CMP]]
 239 ;
 240   %shl = shl nsw i8 %x, 1
 241   %cmp = icmp sle i8 %shl, -16
 242   ret i1 %cmp
 243 }
 244
 245 define i1 @icmp_sle4(i8 %x) {
 246 ; CHECK-LABEL: @icmp_sle4(
 247 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X:%.*]], 0
 248 ; CHECK-NEXT:    ret i1 [[CMP]]
 249 ;
 250   %shl = shl nsw i8 %x, 1
 251   %cmp = icmp sle i8 %shl, -2
 252   ret i1 %cmp
 253 }
 254
 255 ; x <=s -1 is a sign bit test.
 256 ; x <=s 0 is a sign bit test.
 257
 258 define i1 @icmp_sle5(i8 %x) {
 259 ; CHECK-LABEL: @icmp_sle5(
 260 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X:%.*]], 1
 261 ; CHECK-NEXT:    ret i1 [[CMP]]
 262 ;
 263   %shl = shl nsw i8 %x, 1
 264   %cmp = icmp sle i8 %shl, 1
 265   ret i1 %cmp
 266 }
 267
 268 define i1 @icmp_sle6(i8 %x) {
 269 ; CHECK-LABEL: @icmp_sle6(
 270 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X:%.*]], 9
 271 ; CHECK-NEXT:    ret i1 [[CMP]]
 272 ;
 273   %shl = shl nsw i8 %x, 1
 274   %cmp = icmp sle i8 %shl, 16
 275   ret i1 %cmp
 276 }
 277
 278 define i1 @icmp_sle7(i8 %x) {
 279 ; CHECK-LABEL: @icmp_sle7(
 280 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X:%.*]], 63
 281 ; CHECK-NEXT:    ret i1 [[CMP]]
 282 ;
 283   %shl = shl nsw i8 %x, 1
 284   %cmp = icmp sle i8 %shl, 124
 285   ret i1 %cmp
 286 }
 287
 288 ; Known bits analysis turns this into an equality predicate.
 289
 290 define i1 @icmp_sle8(i8 %x) {
 291 ; CHECK-LABEL: @icmp_sle8(
 292 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i8 [[X:%.*]], 63
 293 ; CHECK-NEXT:    ret i1 [[CMP]]
 294 ;
 295   %shl = shl nsw i8 %x, 1
 296   %cmp = icmp sle i8 %shl, 125
 297   ret i1 %cmp
 298 }
 299
 300 ; Compares with 126 and 127 are recognized as always true.
 301
 302 ; Known bits analysis turns this into an equality predicate.
 303
 304 define i1 @icmp_sle9(i8 %x) {
 305 ; CHECK-LABEL: @icmp_sle9(
 306 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i8 [[X:%.*]], 0
 307 ; CHECK-NEXT:    ret i1 [[CMP]]
 308 ;
 309   %shl = shl nsw i8 %x, 7
 310   %cmp = icmp sle i8 %shl, -128
 311   ret i1 %cmp
 312 }
 313
 314 define i1 @icmp_sle10(i8 %x) {
 315 ; CHECK-LABEL: @icmp_sle10(
 316 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X:%.*]], 0
 317 ; CHECK-NEXT:    ret i1 [[CMP]]
 318 ;
 319   %shl = shl nsw i8 %x, 7
 320   %cmp = icmp sle i8 %shl, -127
 321   ret i1 %cmp
 322 }
 323
 324 define i1 @icmp_sle11(i8 %x) {
 325 ; CHECK-LABEL: @icmp_sle11(
 326 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X:%.*]], 0
 327 ; CHECK-NEXT:    ret i1 [[CMP]]
 328 ;
 329   %shl = shl nsw i8 %x, 7
 330   %cmp = icmp sle i8 %shl, -2
 331   ret i1 %cmp
 332 }
 333
 334 ; Some of the earlier sgt/sle tests are transformed to eq/ne, but try a couple
 335 ; of those explicitly, so we know no intermediate transforms are necessary.
 336
 337 define i1 @icmp_eq1(i8 %x) {
 338 ; CHECK-LABEL: @icmp_eq1(
 339 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[X:%.*]], 6
 340 ; CHECK-NEXT:    ret i1 [[CMP]]
 341 ;
 342   %shl = shl nsw i8 %x, 1
 343   %cmp = icmp eq i8 %shl, 12
 344   ret i1 %cmp
 345 }
 346
 347 define i1 @icmp_ne1(i8 %x) {
 348 ; CHECK-LABEL: @icmp_ne1(
 349 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i8 [[X:%.*]], -2
 350 ; CHECK-NEXT:    ret i1 [[CMP]]
 351 ;
 352   %shl = shl nsw i8 %x, 6
 353   %cmp = icmp ne i8 %shl, -128
 354   ret i1 %cmp
 355 }
 356