test/Transforms/InstCombine/saturating-add-sub.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -instcombine -S | FileCheck %s
   3
   4 ;
   5 ; Saturating addition.
   6 ;
   7
   8 declare i8 @llvm.uadd.sat.i8(i8, i8)
   9 declare i8 @llvm.sadd.sat.i8(i8, i8)
  10 declare <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8>, <2 x i8>)
  11 declare <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8>, <2 x i8>)
  12
  13 ; Constant uadd argument is canonicalized to the right.
  14 define i8 @test_scalar_uadd_canonical(i8 %a) {
  15 ; CHECK-LABEL: @test_scalar_uadd_canonical(
  16 ; CHECK-NEXT:    [[X:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[A:%.*]], i8 10)
  17 ; CHECK-NEXT:    ret i8 [[X]]
  18 ;
  19   %x = call i8 @llvm.uadd.sat.i8(i8 10, i8 %a)
  20   ret i8 %x
  21 }
  22
  23 define <2 x i8> @test_vector_uadd_canonical(<2 x i8> %a) {
  24 ; CHECK-LABEL: @test_vector_uadd_canonical(
  25 ; CHECK-NEXT:    [[X:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 10, i8 20>)
  26 ; CHECK-NEXT:    ret <2 x i8> [[X]]
  27 ;
  28   %x = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 10, i8 20>, <2 x i8> %a)
  29   ret <2 x i8> %x
  30 }
  31
  32 ; Constant sadd argument is canonicalized to the right.
  33 define i8 @test_scalar_sadd_canonical(i8 %a) {
  34 ; CHECK-LABEL: @test_scalar_sadd_canonical(
  35 ; CHECK-NEXT:    [[X:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 -10)
  36 ; CHECK-NEXT:    ret i8 [[X]]
  37 ;
  38   %x = call i8 @llvm.sadd.sat.i8(i8 -10, i8 %a)
  39   ret i8 %x
  40 }
  41
  42 define <2 x i8> @test_vector_sadd_canonical(<2 x i8> %a) {
  43 ; CHECK-LABEL: @test_vector_sadd_canonical(
  44 ; CHECK-NEXT:    [[X:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 10, i8 -20>)
  45 ; CHECK-NEXT:    ret <2 x i8> [[X]]
  46 ;
  47   %x = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> <i8 10, i8 -20>, <2 x i8> %a)
  48   ret <2 x i8> %x
  49 }
  50
  51 ; Can combine uadds with constant operands.
  52 define i8 @test_scalar_uadd_combine(i8 %a) {
  53 ; CHECK-LABEL: @test_scalar_uadd_combine(
  54 ; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[A:%.*]], i8 30)
  55 ; CHECK-NEXT:    ret i8 [[TMP1]]
  56 ;
  57   %x1 = call i8 @llvm.uadd.sat.i8(i8 %a, i8 10)
  58   %x2 = call i8 @llvm.uadd.sat.i8(i8 %x1, i8 20)
  59   ret i8 %x2
  60 }
  61
  62 define <2 x i8> @test_vector_uadd_combine(<2 x i8> %a) {
  63 ; CHECK-LABEL: @test_vector_uadd_combine(
  64 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 30, i8 30>)
  65 ; CHECK-NEXT:    ret <2 x i8> [[TMP1]]
  66 ;
  67   %x1 = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 10, i8 10>)
  68   %x2 = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %x1, <2 x i8> <i8 20, i8 20>)
  69   ret <2 x i8> %x2
  70 }
  71
  72 ; This could simplify, but currently doesn't.
  73 define <2 x i8> @test_vector_uadd_combine_non_splat(<2 x i8> %a) {
  74 ; CHECK-LABEL: @test_vector_uadd_combine_non_splat(
  75 ; CHECK-NEXT:    [[X1:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 10, i8 20>)
  76 ; CHECK-NEXT:    [[X2:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> [[X1]], <2 x i8> <i8 30, i8 40>)
  77 ; CHECK-NEXT:    ret <2 x i8> [[X2]]
  78 ;
  79   %x1 = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 10, i8 20>)
  80   %x2 = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %x1, <2 x i8> <i8 30, i8 40>)
  81   ret <2 x i8> %x2
  82 }
  83
  84 ; Can combine uadds even if they overflow.
  85 define i8 @test_scalar_uadd_overflow(i8 %a) {
  86 ; CHECK-LABEL: @test_scalar_uadd_overflow(
  87 ; CHECK-NEXT:    ret i8 -1
  88 ;
  89   %y1 = call i8 @llvm.uadd.sat.i8(i8 %a, i8 100)
  90   %y2 = call i8 @llvm.uadd.sat.i8(i8 %y1, i8 200)
  91   ret i8 %y2
  92 }
  93
  94 define <2 x i8> @test_vector_uadd_overflow(<2 x i8> %a) {
  95 ; CHECK-LABEL: @test_vector_uadd_overflow(
  96 ; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
  97 ;
  98   %y1 = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 100, i8 100>)
  99   %y2 = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %y1, <2 x i8> <i8 200, i8 200>)
 100   ret <2 x i8> %y2
 101 }
 102
 103 ; Can combine sadds if sign matches.
 104 define i8 @test_scalar_sadd_both_positive(i8 %a) {
 105 ; CHECK-LABEL: @test_scalar_sadd_both_positive(
 106 ; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 30)
 107 ; CHECK-NEXT:    ret i8 [[TMP1]]
 108 ;
 109   %z1 = call i8 @llvm.sadd.sat.i8(i8 %a, i8 10)
 110   %z2 = call i8 @llvm.sadd.sat.i8(i8 %z1, i8 20)
 111   ret i8 %z2
 112 }
 113
 114 define <2 x i8> @test_vector_sadd_both_positive(<2 x i8> %a) {
 115 ; CHECK-LABEL: @test_vector_sadd_both_positive(
 116 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 30, i8 30>)
 117 ; CHECK-NEXT:    ret <2 x i8> [[TMP1]]
 118 ;
 119   %z1 = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 10, i8 10>)
 120   %z2 = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %z1, <2 x i8> <i8 20, i8 20>)
 121   ret <2 x i8> %z2
 122 }
 123
 124 define i8 @test_scalar_sadd_both_negative(i8 %a) {
 125 ; CHECK-LABEL: @test_scalar_sadd_both_negative(
 126 ; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 -30)
 127 ; CHECK-NEXT:    ret i8 [[TMP1]]
 128 ;
 129   %u1 = call i8 @llvm.sadd.sat.i8(i8 %a, i8 -10)
 130   %u2 = call i8 @llvm.sadd.sat.i8(i8 %u1, i8 -20)
 131   ret i8 %u2
 132 }
 133
 134 define <2 x i8> @test_vector_sadd_both_negative(<2 x i8> %a) {
 135 ; CHECK-LABEL: @test_vector_sadd_both_negative(
 136 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 -30, i8 -30>)
 137 ; CHECK-NEXT:    ret <2 x i8> [[TMP1]]
 138 ;
 139   %u1 = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 -10, i8 -10>)
 140   %u2 = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %u1, <2 x i8> <i8 -20, i8 -20>)
 141   ret <2 x i8> %u2
 142 }
 143
 144 ; Can't combine sadds if constants have different sign.
 145 define i8 @test_scalar_sadd_different_sign(i8 %a) {
 146 ; CHECK-LABEL: @test_scalar_sadd_different_sign(
 147 ; CHECK-NEXT:    [[V1:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 10)
 148 ; CHECK-NEXT:    [[V2:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[V1]], i8 -20)
 149 ; CHECK-NEXT:    ret i8 [[V2]]
 150 ;
 151   %v1 = call i8 @llvm.sadd.sat.i8(i8 %a, i8 10)
 152   %v2 = call i8 @llvm.sadd.sat.i8(i8 %v1, i8 -20)
 153   ret i8 %v2
 154 }
 155
 156 ; Can't combine sadds if they overflow.
 157 define i8 @test_scalar_sadd_overflow(i8 %a) {
 158 ; CHECK-LABEL: @test_scalar_sadd_overflow(
 159 ; CHECK-NEXT:    [[W1:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 100)
 160 ; CHECK-NEXT:    [[W2:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[W1]], i8 100)
 161 ; CHECK-NEXT:    ret i8 [[W2]]
 162 ;
 163   %w1 = call i8 @llvm.sadd.sat.i8(i8 %a, i8 100)
 164   %w2 = call i8 @llvm.sadd.sat.i8(i8 %w1, i8 100)
 165   ret i8 %w2
 166 }
 167
 168 ; neg uadd neg always overflows.
 169 define i8 @test_scalar_uadd_neg_neg(i8 %a) {
 170 ; CHECK-LABEL: @test_scalar_uadd_neg_neg(
 171 ; CHECK-NEXT:    ret i8 -1
 172 ;
 173   %a_neg = or i8 %a, -128
 174   %r = call i8 @llvm.uadd.sat.i8(i8 %a_neg, i8 -10)
 175   ret i8 %r
 176 }
 177
 178 define <2 x i8> @test_vector_uadd_neg_neg(<2 x i8> %a) {
 179 ; CHECK-LABEL: @test_vector_uadd_neg_neg(
 180 ; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 181 ;
 182   %a_neg = or <2 x i8> %a, <i8 -128, i8 -128>
 183   %r = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a_neg, <2 x i8> <i8 -10, i8 -20>)
 184   ret <2 x i8> %r
 185 }
 186
 187 ; nneg uadd nneg never overflows.
 188 define i8 @test_scalar_uadd_nneg_nneg(i8 %a) {
 189 ; CHECK-LABEL: @test_scalar_uadd_nneg_nneg(
 190 ; CHECK-NEXT:    [[A_NNEG:%.*]] = and i8 [[A:%.*]], 127
 191 ; CHECK-NEXT:    [[R:%.*]] = add nuw i8 [[A_NNEG]], 10
 192 ; CHECK-NEXT:    ret i8 [[R]]
 193 ;
 194   %a_nneg = and i8 %a, 127
 195   %r = call i8 @llvm.uadd.sat.i8(i8 %a_nneg, i8 10)
 196   ret i8 %r
 197 }
 198
 199 define <2 x i8> @test_vector_uadd_nneg_nneg(<2 x i8> %a) {
 200 ; CHECK-LABEL: @test_vector_uadd_nneg_nneg(
 201 ; CHECK-NEXT:    [[A_NNEG:%.*]] = and <2 x i8> [[A:%.*]], <i8 127, i8 127>
 202 ; CHECK-NEXT:    [[R:%.*]] = add nuw <2 x i8> [[A_NNEG]], <i8 10, i8 20>
 203 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 204 ;
 205   %a_nneg = and <2 x i8> %a, <i8 127, i8 127>
 206   %r = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a_nneg, <2 x i8> <i8 10, i8 20>)
 207   ret <2 x i8> %r
 208 }
 209
 210 ; neg uadd nneg might overflow.
 211 define i8 @test_scalar_uadd_neg_nneg(i8 %a) {
 212 ; CHECK-LABEL: @test_scalar_uadd_neg_nneg(
 213 ; CHECK-NEXT:    [[A_NEG:%.*]] = or i8 [[A:%.*]], -128
 214 ; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[A_NEG]], i8 10)
 215 ; CHECK-NEXT:    ret i8 [[R]]
 216 ;
 217   %a_neg = or i8 %a, -128
 218   %r = call i8 @llvm.uadd.sat.i8(i8 %a_neg, i8 10)
 219   ret i8 %r
 220 }
 221
 222 define <2 x i8> @test_vector_uadd_neg_nneg(<2 x i8> %a) {
 223 ; CHECK-LABEL: @test_vector_uadd_neg_nneg(
 224 ; CHECK-NEXT:    [[A_NEG:%.*]] = or <2 x i8> [[A:%.*]], <i8 -128, i8 -128>
 225 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> [[A_NEG]], <2 x i8> <i8 10, i8 20>)
 226 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 227 ;
 228   %a_neg = or <2 x i8> %a, <i8 -128, i8 -128>
 229   %r = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a_neg, <2 x i8> <i8 10, i8 20>)
 230   ret <2 x i8> %r
 231 }
 232
 233 define i8 @test_scalar_uadd_never_overflows(i8 %a) {
 234 ; CHECK-LABEL: @test_scalar_uadd_never_overflows(
 235 ; CHECK-NEXT:    [[A_MASKED:%.*]] = and i8 [[A:%.*]], -127
 236 ; CHECK-NEXT:    [[R:%.*]] = add nuw nsw i8 [[A_MASKED]], 1
 237 ; CHECK-NEXT:    ret i8 [[R]]
 238 ;
 239   %a_masked = and i8 %a, 129
 240   %r = call i8 @llvm.uadd.sat.i8(i8 %a_masked, i8 1)
 241   ret i8 %r
 242 }
 243
 244 define <2 x i8> @test_vector_uadd_never_overflows(<2 x i8> %a) {
 245 ; CHECK-LABEL: @test_vector_uadd_never_overflows(
 246 ; CHECK-NEXT:    [[A_MASKED:%.*]] = and <2 x i8> [[A:%.*]], <i8 -127, i8 -127>
 247 ; CHECK-NEXT:    [[R:%.*]] = add nuw nsw <2 x i8> [[A_MASKED]], <i8 1, i8 1>
 248 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 249 ;
 250   %a_masked = and <2 x i8> %a, <i8 129, i8 129>
 251   %r = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a_masked, <2 x i8> <i8 1, i8 1>)
 252   ret <2 x i8> %r
 253 }
 254
 255 define i8 @test_scalar_uadd_always_overflows(i8 %a) {
 256 ; CHECK-LABEL: @test_scalar_uadd_always_overflows(
 257 ; CHECK-NEXT:    ret i8 -1
 258 ;
 259   %a_masked = or i8 %a, 192
 260   %r = call i8 @llvm.uadd.sat.i8(i8 %a_masked, i8 64)
 261   ret i8 %r
 262 }
 263
 264 define <2 x i8> @test_vector_uadd_always_overflows(<2 x i8> %a) {
 265 ; CHECK-LABEL: @test_vector_uadd_always_overflows(
 266 ; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 267 ;
 268   %a_masked = or <2 x i8> %a, <i8 192, i8 192>
 269   %r = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a_masked, <2 x i8> <i8 64, i8 64>)
 270   ret <2 x i8> %r
 271 }
 272
 273 ; neg sadd nneg never overflows.
 274 define i8 @test_scalar_sadd_neg_nneg(i8 %a) {
 275 ; CHECK-LABEL: @test_scalar_sadd_neg_nneg(
 276 ; CHECK-NEXT:    [[A_NEG:%.*]] = or i8 [[A:%.*]], -128
 277 ; CHECK-NEXT:    [[R:%.*]] = add nsw i8 [[A_NEG]], 10
 278 ; CHECK-NEXT:    ret i8 [[R]]
 279 ;
 280   %a_neg = or i8 %a, -128
 281   %r = call i8 @llvm.sadd.sat.i8(i8 %a_neg, i8 10)
 282   ret i8 %r
 283 }
 284
 285 define <2 x i8> @test_vector_sadd_neg_nneg(<2 x i8> %a) {
 286 ; CHECK-LABEL: @test_vector_sadd_neg_nneg(
 287 ; CHECK-NEXT:    [[A_NEG:%.*]] = or <2 x i8> [[A:%.*]], <i8 -128, i8 -128>
 288 ; CHECK-NEXT:    [[R:%.*]] = add nsw <2 x i8> [[A_NEG]], <i8 10, i8 20>
 289 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 290 ;
 291   %a_neg = or <2 x i8> %a, <i8 -128, i8 -128>
 292   %r = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %a_neg, <2 x i8> <i8 10, i8 20>)
 293   ret <2 x i8> %r
 294 }
 295
 296 ; nneg sadd neg never overflows.
 297 define i8 @test_scalar_sadd_nneg_neg(i8 %a) {
 298 ; CHECK-LABEL: @test_scalar_sadd_nneg_neg(
 299 ; CHECK-NEXT:    [[A_NNEG:%.*]] = and i8 [[A:%.*]], 127
 300 ; CHECK-NEXT:    [[R:%.*]] = add nsw i8 [[A_NNEG]], -10
 301 ; CHECK-NEXT:    ret i8 [[R]]
 302 ;
 303   %a_nneg = and i8 %a, 127
 304   %r = call i8 @llvm.sadd.sat.i8(i8 %a_nneg, i8 -10)
 305   ret i8 %r
 306 }
 307
 308 define <2 x i8> @test_vector_sadd_nneg_neg(<2 x i8> %a) {
 309 ; CHECK-LABEL: @test_vector_sadd_nneg_neg(
 310 ; CHECK-NEXT:    [[A_NNEG:%.*]] = and <2 x i8> [[A:%.*]], <i8 127, i8 127>
 311 ; CHECK-NEXT:    [[R:%.*]] = add nsw <2 x i8> [[A_NNEG]], <i8 -10, i8 -20>
 312 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 313 ;
 314   %a_nneg = and <2 x i8> %a, <i8 127, i8 127>
 315   %r = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %a_nneg, <2 x i8> <i8 -10, i8 -20>)
 316   ret <2 x i8> %r
 317 }
 318
 319 ; neg sadd neg might overflow.
 320 define i8 @test_scalar_sadd_neg_neg(i8 %a) {
 321 ; CHECK-LABEL: @test_scalar_sadd_neg_neg(
 322 ; CHECK-NEXT:    [[A_NEG:%.*]] = or i8 [[A:%.*]], -128
 323 ; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A_NEG]], i8 -10)
 324 ; CHECK-NEXT:    ret i8 [[R]]
 325 ;
 326   %a_neg = or i8 %a, -128
 327   %r = call i8 @llvm.sadd.sat.i8(i8 %a_neg, i8 -10)
 328   ret i8 %r
 329 }
 330
 331 define <2 x i8> @test_vector_sadd_neg_neg(<2 x i8> %a) {
 332 ; CHECK-LABEL: @test_vector_sadd_neg_neg(
 333 ; CHECK-NEXT:    [[A_NEG:%.*]] = or <2 x i8> [[A:%.*]], <i8 -128, i8 -128>
 334 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A_NEG]], <2 x i8> <i8 -10, i8 -20>)
 335 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 336 ;
 337   %a_neg = or <2 x i8> %a, <i8 -128, i8 -128>
 338   %r = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %a_neg, <2 x i8> <i8 -10, i8 -20>)
 339   ret <2 x i8> %r
 340 }
 341
 342 define i8 @test_scalar_sadd_always_overflows_low(i8 %a) {
 343 ; CHECK-LABEL: @test_scalar_sadd_always_overflows_low(
 344 ; CHECK-NEXT:    ret i8 -128
 345 ;
 346   %cmp = icmp slt i8 %a, -120
 347   %min = select i1 %cmp, i8 %a, i8 -120
 348   %r = call i8 @llvm.sadd.sat.i8(i8 %min, i8 -10)
 349   ret i8 %r
 350 }
 351
 352 define i8 @test_scalar_sadd_always_overflows_high(i8 %a) {
 353 ; CHECK-LABEL: @test_scalar_sadd_always_overflows_high(
 354 ; CHECK-NEXT:    ret i8 127
 355 ;
 356   %cmp = icmp sgt i8 %a, 120
 357   %max = select i1 %cmp, i8 %a, i8 120
 358   %r = call i8 @llvm.sadd.sat.i8(i8 %max, i8 10)
 359   ret i8 %r
 360 }
 361
 362 ; While this is a no-overflow condition, the nuw flag gets lost due to
 363 ; canonicalization and we can no longer determine this
 364 define i8 @test_scalar_uadd_sub_nuw_lost_no_ov(i8 %a) {
 365 ; CHECK-LABEL: @test_scalar_uadd_sub_nuw_lost_no_ov(
 366 ; CHECK-NEXT:    [[B:%.*]] = add i8 [[A:%.*]], -10
 367 ; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[B]], i8 9)
 368 ; CHECK-NEXT:    ret i8 [[R]]
 369 ;
 370   %b = sub nuw i8 %a, 10
 371   %r = call i8 @llvm.uadd.sat.i8(i8 %b, i8 9)
 372   ret i8 %r
 373 }
 374
 375 define i8 @test_scalar_uadd_urem_no_ov(i8 %a) {
 376 ; CHECK-LABEL: @test_scalar_uadd_urem_no_ov(
 377 ; CHECK-NEXT:    [[B:%.*]] = urem i8 [[A:%.*]], 100
 378 ; CHECK-NEXT:    [[R:%.*]] = add nuw nsw i8 [[B]], -100
 379 ; CHECK-NEXT:    ret i8 [[R]]
 380 ;
 381   %b = urem i8 %a, 100
 382   %r = call i8 @llvm.uadd.sat.i8(i8 %b, i8 156)
 383   ret i8 %r
 384 }
 385
 386 define i8 @test_scalar_uadd_urem_may_ov(i8 %a) {
 387 ; CHECK-LABEL: @test_scalar_uadd_urem_may_ov(
 388 ; CHECK-NEXT:    [[B:%.*]] = urem i8 [[A:%.*]], 100
 389 ; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[B]], i8 -99)
 390 ; CHECK-NEXT:    ret i8 [[R]]
 391 ;
 392   %b = urem i8 %a, 100
 393   %r = call i8 @llvm.uadd.sat.i8(i8 %b, i8 157)
 394   ret i8 %r
 395 }
 396
 397 ; We have a constant range for the LHS, but only known bits for the RHS
 398 define i8 @test_scalar_uadd_udiv_known_bits(i8 %a, i8 %b) {
 399 ; CHECK-LABEL: @test_scalar_uadd_udiv_known_bits(
 400 ; CHECK-NEXT:    [[AA:%.*]] = udiv i8 -66, [[A:%.*]]
 401 ; CHECK-NEXT:    [[BB:%.*]] = and i8 [[B:%.*]], 63
 402 ; CHECK-NEXT:    [[R:%.*]] = add nuw i8 [[AA]], [[BB]]
 403 ; CHECK-NEXT:    ret i8 [[R]]
 404 ;
 405   %aa = udiv i8 190, %a
 406   %bb = and i8 %b, 63
 407   %r = call i8 @llvm.uadd.sat.i8(i8 %aa, i8 %bb)
 408   ret i8 %r
 409 }
 410
 411 define i8 @test_scalar_sadd_srem_no_ov(i8 %a) {
 412 ; CHECK-LABEL: @test_scalar_sadd_srem_no_ov(
 413 ; CHECK-NEXT:    [[B:%.*]] = srem i8 [[A:%.*]], 100
 414 ; CHECK-NEXT:    [[R:%.*]] = add nsw i8 [[B]], 28
 415 ; CHECK-NEXT:    ret i8 [[R]]
 416 ;
 417   %b = srem i8 %a, 100
 418   %r = call i8 @llvm.sadd.sat.i8(i8 %b, i8 28)
 419   ret i8 %r
 420 }
 421
 422 define i8 @test_scalar_sadd_srem_may_ov(i8 %a) {
 423 ; CHECK-LABEL: @test_scalar_sadd_srem_may_ov(
 424 ; CHECK-NEXT:    [[B:%.*]] = srem i8 [[A:%.*]], 100
 425 ; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[B]], i8 29)
 426 ; CHECK-NEXT:    ret i8 [[R]]
 427 ;
 428   %b = srem i8 %a, 100
 429   %r = call i8 @llvm.sadd.sat.i8(i8 %b, i8 29)
 430   ret i8 %r
 431 }
 432
 433 define i8 @test_scalar_sadd_srem_and_no_ov(i8 %a, i8 %b) {
 434 ; CHECK-LABEL: @test_scalar_sadd_srem_and_no_ov(
 435 ; CHECK-NEXT:    [[AA:%.*]] = srem i8 [[A:%.*]], 100
 436 ; CHECK-NEXT:    [[BB:%.*]] = and i8 [[B:%.*]], 15
 437 ; CHECK-NEXT:    [[R:%.*]] = add nsw i8 [[AA]], [[BB]]
 438 ; CHECK-NEXT:    ret i8 [[R]]
 439 ;
 440   %aa = srem i8 %a, 100
 441   %bb = and i8 %b, 15
 442   %r = call i8 @llvm.sadd.sat.i8(i8 %aa, i8 %bb)
 443   ret i8 %r
 444 }
 445
 446 ;
 447 ; Saturating subtraction.
 448 ;
 449
 450 declare i8 @llvm.usub.sat.i8(i8, i8)
 451 declare i8 @llvm.ssub.sat.i8(i8, i8)
 452 declare <2 x i8> @llvm.usub.sat.v2i8(<2 x i8>, <2 x i8>)
 453 declare <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8>, <2 x i8>)
 454
 455 ; Cannot canonicalize usub to uadd.
 456 define i8 @test_scalar_usub_canonical(i8 %a) {
 457 ; CHECK-LABEL: @test_scalar_usub_canonical(
 458 ; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 10)
 459 ; CHECK-NEXT:    ret i8 [[R]]
 460 ;
 461   %r = call i8 @llvm.usub.sat.i8(i8 %a, i8 10)
 462   ret i8 %r
 463 }
 464
 465 ; Canonicalize ssub to sadd.
 466 define i8 @test_scalar_ssub_canonical(i8 %a) {
 467 ; CHECK-LABEL: @test_scalar_ssub_canonical(
 468 ; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 -10)
 469 ; CHECK-NEXT:    ret i8 [[TMP1]]
 470 ;
 471   %r = call i8 @llvm.ssub.sat.i8(i8 %a, i8 10)
 472   ret i8 %r
 473 }
 474
 475 define <2 x i8> @test_vector_ssub_canonical(<2 x i8> %a) {
 476 ; CHECK-LABEL: @test_vector_ssub_canonical(
 477 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 -10, i8 -10>)
 478 ; CHECK-NEXT:    ret <2 x i8> [[TMP1]]
 479 ;
 480   %r = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 10, i8 10>)
 481   ret <2 x i8> %r
 482 }
 483
 484 define <2 x i8> @test_vector_ssub_canonical_min_non_splat(<2 x i8> %a) {
 485 ; CHECK-LABEL: @test_vector_ssub_canonical_min_non_splat(
 486 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 -10, i8 10>)
 487 ; CHECK-NEXT:    ret <2 x i8> [[TMP1]]
 488 ;
 489   %r = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 10, i8 -10>)
 490   ret <2 x i8> %r
 491 }
 492
 493 ; Cannot canonicalize signed min.
 494 define i8 @test_scalar_ssub_canonical_min(i8 %a) {
 495 ; CHECK-LABEL: @test_scalar_ssub_canonical_min(
 496 ; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[A:%.*]], i8 -128)
 497 ; CHECK-NEXT:    ret i8 [[R]]
 498 ;
 499   %r = call i8 @llvm.ssub.sat.i8(i8 %a, i8 -128)
 500   ret i8 %r
 501 }
 502
 503 define <2 x i8> @test_vector_ssub_canonical_min(<2 x i8> %a) {
 504 ; CHECK-LABEL: @test_vector_ssub_canonical_min(
 505 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 -128, i8 -10>)
 506 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 507 ;
 508   %r = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 -128, i8 -10>)
 509   ret <2 x i8> %r
 510 }
 511
 512 ; Can combine usubs with constant operands.
 513 define i8 @test_scalar_usub_combine(i8 %a) {
 514 ; CHECK-LABEL: @test_scalar_usub_combine(
 515 ; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 30)
 516 ; CHECK-NEXT:    ret i8 [[TMP1]]
 517 ;
 518   %x1 = call i8 @llvm.usub.sat.i8(i8 %a, i8 10)
 519   %x2 = call i8 @llvm.usub.sat.i8(i8 %x1, i8 20)
 520   ret i8 %x2
 521 }
 522
 523 define <2 x i8> @test_vector_usub_combine(<2 x i8> %a) {
 524 ; CHECK-LABEL: @test_vector_usub_combine(
 525 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 30, i8 30>)
 526 ; CHECK-NEXT:    ret <2 x i8> [[TMP1]]
 527 ;
 528   %x1 = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 10, i8 10>)
 529   %x2 = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %x1, <2 x i8> <i8 20, i8 20>)
 530   ret <2 x i8> %x2
 531 }
 532
 533 ; This could simplify, but currently doesn't.
 534 define <2 x i8> @test_vector_usub_combine_non_splat(<2 x i8> %a) {
 535 ; CHECK-LABEL: @test_vector_usub_combine_non_splat(
 536 ; CHECK-NEXT:    [[X1:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 10, i8 20>)
 537 ; CHECK-NEXT:    [[X2:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[X1]], <2 x i8> <i8 30, i8 40>)
 538 ; CHECK-NEXT:    ret <2 x i8> [[X2]]
 539 ;
 540   %x1 = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 10, i8 20>)
 541   %x2 = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %x1, <2 x i8> <i8 30, i8 40>)
 542   ret <2 x i8> %x2
 543 }
 544
 545 ; Can combine usubs even if they overflow.
 546 define i8 @test_scalar_usub_overflow(i8 %a) {
 547 ; CHECK-LABEL: @test_scalar_usub_overflow(
 548 ; CHECK-NEXT:    ret i8 0
 549 ;
 550   %y1 = call i8 @llvm.usub.sat.i8(i8 %a, i8 100)
 551   %y2 = call i8 @llvm.usub.sat.i8(i8 %y1, i8 200)
 552   ret i8 %y2
 553 }
 554
 555 define <2 x i8> @test_vector_usub_overflow(<2 x i8> %a) {
 556 ; CHECK-LABEL: @test_vector_usub_overflow(
 557 ; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 558 ;
 559   %y1 = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 100, i8 100>)
 560   %y2 = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %y1, <2 x i8> <i8 200, i8 200>)
 561   ret <2 x i8> %y2
 562 }
 563
 564 ; Can combine ssubs if sign matches.
 565 define i8 @test_scalar_ssub_both_positive(i8 %a) {
 566 ; CHECK-LABEL: @test_scalar_ssub_both_positive(
 567 ; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 -30)
 568 ; CHECK-NEXT:    ret i8 [[TMP1]]
 569 ;
 570   %z1 = call i8 @llvm.ssub.sat.i8(i8 %a, i8 10)
 571   %z2 = call i8 @llvm.ssub.sat.i8(i8 %z1, i8 20)
 572   ret i8 %z2
 573 }
 574
 575 define <2 x i8> @test_vector_ssub_both_positive(<2 x i8> %a) {
 576 ; CHECK-LABEL: @test_vector_ssub_both_positive(
 577 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 -30, i8 -30>)
 578 ; CHECK-NEXT:    ret <2 x i8> [[TMP1]]
 579 ;
 580   %z1 = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 10, i8 10>)
 581   %z2 = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %z1, <2 x i8> <i8 20, i8 20>)
 582   ret <2 x i8> %z2
 583 }
 584
 585 define i8 @test_scalar_ssub_both_negative(i8 %a) {
 586 ; CHECK-LABEL: @test_scalar_ssub_both_negative(
 587 ; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 30)
 588 ; CHECK-NEXT:    ret i8 [[TMP1]]
 589 ;
 590   %u1 = call i8 @llvm.ssub.sat.i8(i8 %a, i8 -10)
 591   %u2 = call i8 @llvm.ssub.sat.i8(i8 %u1, i8 -20)
 592   ret i8 %u2
 593 }
 594
 595 define <2 x i8> @test_vector_ssub_both_negative(<2 x i8> %a) {
 596 ; CHECK-LABEL: @test_vector_ssub_both_negative(
 597 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 30, i8 30>)
 598 ; CHECK-NEXT:    ret <2 x i8> [[TMP1]]
 599 ;
 600   %u1 = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 -10, i8 -10>)
 601   %u2 = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %u1, <2 x i8> <i8 -20, i8 -20>)
 602   ret <2 x i8> %u2
 603 }
 604
 605 ; Can't combine ssubs if constants have different sign.
 606 define i8 @test_scalar_ssub_different_sign(i8 %a) {
 607 ; CHECK-LABEL: @test_scalar_ssub_different_sign(
 608 ; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 -10)
 609 ; CHECK-NEXT:    [[TMP2:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[TMP1]], i8 20)
 610 ; CHECK-NEXT:    ret i8 [[TMP2]]
 611 ;
 612   %v1 = call i8 @llvm.ssub.sat.i8(i8 %a, i8 10)
 613   %v2 = call i8 @llvm.ssub.sat.i8(i8 %v1, i8 -20)
 614   ret i8 %v2
 615 }
 616
 617 ; Can combine sadd and ssub with appropriate signs.
 618 define i8 @test_scalar_sadd_ssub(i8 %a) {
 619 ; CHECK-LABEL: @test_scalar_sadd_ssub(
 620 ; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 30)
 621 ; CHECK-NEXT:    ret i8 [[TMP1]]
 622 ;
 623   %v1 = call i8 @llvm.sadd.sat.i8(i8 10, i8 %a)
 624   %v2 = call i8 @llvm.ssub.sat.i8(i8 %v1, i8 -20)
 625   ret i8 %v2
 626 }
 627
 628 define <2 x i8> @test_vector_sadd_ssub(<2 x i8> %a) {
 629 ; CHECK-LABEL: @test_vector_sadd_ssub(
 630 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 -30, i8 -30>)
 631 ; CHECK-NEXT:    ret <2 x i8> [[TMP1]]
 632 ;
 633   %v1 = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> <i8 -10, i8 -10>, <2 x i8> %a)
 634   %v2 = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %v1, <2 x i8> <i8 20, i8 20>)
 635   ret <2 x i8> %v2
 636 }
 637
 638 ; Can't combine ssubs if they overflow.
 639 define i8 @test_scalar_ssub_overflow(i8 %a) {
 640 ; CHECK-LABEL: @test_scalar_ssub_overflow(
 641 ; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 -100)
 642 ; CHECK-NEXT:    [[TMP2:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[TMP1]], i8 -100)
 643 ; CHECK-NEXT:    ret i8 [[TMP2]]
 644 ;
 645   %w1 = call i8 @llvm.ssub.sat.i8(i8 %a, i8 100)
 646   %w2 = call i8 @llvm.ssub.sat.i8(i8 %w1, i8 100)
 647   ret i8 %w2
 648 }
 649
 650 ; nneg usub neg always overflows.
 651 define i8 @test_scalar_usub_nneg_neg(i8 %a) {
 652 ; CHECK-LABEL: @test_scalar_usub_nneg_neg(
 653 ; CHECK-NEXT:    ret i8 0
 654 ;
 655   %a_nneg = and i8 %a, 127
 656   %r = call i8 @llvm.usub.sat.i8(i8 %a_nneg, i8 -10)
 657   ret i8 %r
 658 }
 659
 660 define <2 x i8> @test_vector_usub_nneg_neg(<2 x i8> %a) {
 661 ; CHECK-LABEL: @test_vector_usub_nneg_neg(
 662 ; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 663 ;
 664   %a_nneg = and <2 x i8> %a, <i8 127, i8 127>
 665   %r = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a_nneg, <2 x i8> <i8 -10, i8 -20>)
 666   ret <2 x i8> %r
 667 }
 668
 669 ; neg usub nneg never overflows.
 670 define i8 @test_scalar_usub_neg_nneg(i8 %a) {
 671 ; CHECK-LABEL: @test_scalar_usub_neg_nneg(
 672 ; CHECK-NEXT:    [[A_NEG:%.*]] = or i8 [[A:%.*]], -128
 673 ; CHECK-NEXT:    [[R:%.*]] = add i8 [[A_NEG]], -10
 674 ; CHECK-NEXT:    ret i8 [[R]]
 675 ;
 676   %a_neg = or i8 %a, -128
 677   %r = call i8 @llvm.usub.sat.i8(i8 %a_neg, i8 10)
 678   ret i8 %r
 679 }
 680
 681 define <2 x i8> @test_vector_usub_neg_nneg(<2 x i8> %a) {
 682 ; CHECK-LABEL: @test_vector_usub_neg_nneg(
 683 ; CHECK-NEXT:    [[A_NEG:%.*]] = or <2 x i8> [[A:%.*]], <i8 -128, i8 -128>
 684 ; CHECK-NEXT:    [[R:%.*]] = add <2 x i8> [[A_NEG]], <i8 -10, i8 -20>
 685 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 686 ;
 687   %a_neg = or <2 x i8> %a, <i8 -128, i8 -128>
 688   %r = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a_neg, <2 x i8> <i8 10, i8 20>)
 689   ret <2 x i8> %r
 690 }
 691
 692 ; nneg usub nneg never may overflow.
 693 define i8 @test_scalar_usub_nneg_nneg(i8 %a) {
 694 ; CHECK-LABEL: @test_scalar_usub_nneg_nneg(
 695 ; CHECK-NEXT:    [[A_NNEG:%.*]] = and i8 [[A:%.*]], 127
 696 ; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A_NNEG]], i8 10)
 697 ; CHECK-NEXT:    ret i8 [[R]]
 698 ;
 699   %a_nneg = and i8 %a, 127
 700   %r = call i8 @llvm.usub.sat.i8(i8 %a_nneg, i8 10)
 701   ret i8 %r
 702 }
 703
 704 define <2 x i8> @test_vector_usub_nneg_nneg(<2 x i8> %a) {
 705 ; CHECK-LABEL: @test_vector_usub_nneg_nneg(
 706 ; CHECK-NEXT:    [[A_NNEG:%.*]] = and <2 x i8> [[A:%.*]], <i8 127, i8 127>
 707 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[A_NNEG]], <2 x i8> <i8 10, i8 20>)
 708 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 709 ;
 710   %a_nneg = and <2 x i8> %a, <i8 127, i8 127>
 711   %r = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a_nneg, <2 x i8> <i8 10, i8 20>)
 712   ret <2 x i8> %r
 713 }
 714
 715 define i8 @test_scalar_usub_never_overflows(i8 %a) {
 716 ; CHECK-LABEL: @test_scalar_usub_never_overflows(
 717 ; CHECK-NEXT:    [[A_MASKED:%.*]] = or i8 [[A:%.*]], 64
 718 ; CHECK-NEXT:    [[R:%.*]] = add nsw i8 [[A_MASKED]], -10
 719 ; CHECK-NEXT:    ret i8 [[R]]
 720 ;
 721   %a_masked = or i8 %a, 64
 722   %r = call i8 @llvm.usub.sat.i8(i8 %a_masked, i8 10)
 723   ret i8 %r
 724 }
 725
 726 define <2 x i8> @test_vector_usub_never_overflows(<2 x i8> %a) {
 727 ; CHECK-LABEL: @test_vector_usub_never_overflows(
 728 ; CHECK-NEXT:    [[A_MASKED:%.*]] = or <2 x i8> [[A:%.*]], <i8 64, i8 64>
 729 ; CHECK-NEXT:    [[R:%.*]] = add nsw <2 x i8> [[A_MASKED]], <i8 -10, i8 -10>
 730 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 731 ;
 732   %a_masked = or <2 x i8> %a, <i8 64, i8 64>
 733   %r = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a_masked, <2 x i8> <i8 10, i8 10>)
 734   ret <2 x i8> %r
 735 }
 736
 737 define i8 @test_scalar_usub_always_overflows(i8 %a) {
 738 ; CHECK-LABEL: @test_scalar_usub_always_overflows(
 739 ; CHECK-NEXT:    ret i8 0
 740 ;
 741   %a_masked = and i8 %a, 64
 742   %r = call i8 @llvm.usub.sat.i8(i8 %a_masked, i8 100)
 743   ret i8 %r
 744 }
 745
 746 define <2 x i8> @test_vector_usub_always_overflows(<2 x i8> %a) {
 747 ; CHECK-LABEL: @test_vector_usub_always_overflows(
 748 ; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 749 ;
 750   %a_masked = and <2 x i8> %a, <i8 64, i8 64>
 751   %r = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a_masked, <2 x i8> <i8 100, i8 100>)
 752   ret <2 x i8> %r
 753 }
 754
 755 ; neg ssub neg never overflows.
 756 define i8 @test_scalar_ssub_neg_neg(i8 %a) {
 757 ; CHECK-LABEL: @test_scalar_ssub_neg_neg(
 758 ; CHECK-NEXT:    [[A_NEG:%.*]] = or i8 [[A:%.*]], -128
 759 ; CHECK-NEXT:    [[R:%.*]] = add nsw i8 [[A_NEG]], 10
 760 ; CHECK-NEXT:    ret i8 [[R]]
 761 ;
 762   %a_neg = or i8 %a, -128
 763   %r = call i8 @llvm.ssub.sat.i8(i8 %a_neg, i8 -10)
 764   ret i8 %r
 765 }
 766
 767 define <2 x i8> @test_vector_ssub_neg_neg(<2 x i8> %a) {
 768 ; CHECK-LABEL: @test_vector_ssub_neg_neg(
 769 ; CHECK-NEXT:    [[A_NEG:%.*]] = or <2 x i8> [[A:%.*]], <i8 -128, i8 -128>
 770 ; CHECK-NEXT:    [[R:%.*]] = add nsw <2 x i8> [[A_NEG]], <i8 10, i8 20>
 771 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 772 ;
 773   %a_neg = or <2 x i8> %a, <i8 -128, i8 -128>
 774   %r = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a_neg, <2 x i8> <i8 -10, i8 -20>)
 775   ret <2 x i8> %r
 776 }
 777
 778 ; nneg ssub nneg never overflows.
 779 define i8 @test_scalar_ssub_nneg_nneg(i8 %a) {
 780 ; CHECK-LABEL: @test_scalar_ssub_nneg_nneg(
 781 ; CHECK-NEXT:    [[A_NNEG:%.*]] = and i8 [[A:%.*]], 127
 782 ; CHECK-NEXT:    [[R:%.*]] = add nsw i8 [[A_NNEG]], -10
 783 ; CHECK-NEXT:    ret i8 [[R]]
 784 ;
 785   %a_nneg = and i8 %a, 127
 786   %r = call i8 @llvm.ssub.sat.i8(i8 %a_nneg, i8 10)
 787   ret i8 %r
 788 }
 789
 790 define <2 x i8> @test_vector_ssub_nneg_nneg(<2 x i8> %a) {
 791 ; CHECK-LABEL: @test_vector_ssub_nneg_nneg(
 792 ; CHECK-NEXT:    [[A_NNEG:%.*]] = and <2 x i8> [[A:%.*]], <i8 127, i8 127>
 793 ; CHECK-NEXT:    [[R:%.*]] = add nsw <2 x i8> [[A_NNEG]], <i8 -10, i8 -20>
 794 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 795 ;
 796   %a_nneg = and <2 x i8> %a, <i8 127, i8 127>
 797   %r = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a_nneg, <2 x i8> <i8 10, i8 20>)
 798   ret <2 x i8> %r
 799 }
 800
 801 ; neg ssub nneg may overflow.
 802 define i8 @test_scalar_ssub_neg_nneg(i8 %a) {
 803 ; CHECK-LABEL: @test_scalar_ssub_neg_nneg(
 804 ; CHECK-NEXT:    [[A_NEG:%.*]] = or i8 [[A:%.*]], -128
 805 ; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A_NEG]], i8 -10)
 806 ; CHECK-NEXT:    ret i8 [[TMP1]]
 807 ;
 808   %a_neg = or i8 %a, -128
 809   %r = call i8 @llvm.ssub.sat.i8(i8 %a_neg, i8 10)
 810   ret i8 %r
 811 }
 812
 813 define <2 x i8> @test_vector_ssub_neg_nneg(<2 x i8> %a) {
 814 ; CHECK-LABEL: @test_vector_ssub_neg_nneg(
 815 ; CHECK-NEXT:    [[A_NEG:%.*]] = or <2 x i8> [[A:%.*]], <i8 -128, i8 -128>
 816 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A_NEG]], <2 x i8> <i8 -10, i8 -20>)
 817 ; CHECK-NEXT:    ret <2 x i8> [[TMP1]]
 818 ;
 819   %a_neg = or <2 x i8> %a, <i8 -128, i8 -128>
 820   %r = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a_neg, <2 x i8> <i8 10, i8 20>)
 821   ret <2 x i8> %r
 822 }
 823
 824 define i8 @test_scalar_ssub_always_overflows_low(i8 %a) {
 825 ; CHECK-LABEL: @test_scalar_ssub_always_overflows_low(
 826 ; CHECK-NEXT:    ret i8 -128
 827 ;
 828   %cmp = icmp sgt i8 %a, 120
 829   %max = select i1 %cmp, i8 %a, i8 120
 830   %r = call i8 @llvm.ssub.sat.i8(i8 -10, i8 %max)
 831   ret i8 %r
 832 }
 833
 834 define i8 @test_scalar_ssub_always_overflows_high(i8 %a) {
 835 ; CHECK-LABEL: @test_scalar_ssub_always_overflows_high(
 836 ; CHECK-NEXT:    ret i8 127
 837 ;
 838   %cmp = icmp slt i8 %a, -120
 839   %min = select i1 %cmp, i8 %a, i8 -120
 840   %r = call i8 @llvm.ssub.sat.i8(i8 10, i8 %min)
 841   ret i8 %r
 842 }
 843
 844 define i8 @test_scalar_usub_add_nuw_no_ov(i8 %a) {
 845 ; CHECK-LABEL: @test_scalar_usub_add_nuw_no_ov(
 846 ; CHECK-NEXT:    [[R:%.*]] = add i8 [[A:%.*]], 1
 847 ; CHECK-NEXT:    ret i8 [[R]]
 848 ;
 849   %b = add nuw i8 %a, 10
 850   %r = call i8 @llvm.usub.sat.i8(i8 %b, i8 9)
 851   ret i8 %r
 852 }
 853
 854 define i8 @test_scalar_usub_add_nuw_eq(i8 %a) {
 855 ; CHECK-LABEL: @test_scalar_usub_add_nuw_eq(
 856 ; CHECK-NEXT:    ret i8 [[A:%.*]]
 857 ;
 858   %b = add nuw i8 %a, 10
 859   %r = call i8 @llvm.usub.sat.i8(i8 %b, i8 10)
 860   ret i8 %r
 861 }
 862
 863 define i8 @test_scalar_usub_add_nuw_may_ov(i8 %a) {
 864 ; CHECK-LABEL: @test_scalar_usub_add_nuw_may_ov(
 865 ; CHECK-NEXT:    [[B:%.*]] = add nuw i8 [[A:%.*]], 10
 866 ; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[B]], i8 11)
 867 ; CHECK-NEXT:    ret i8 [[R]]
 868 ;
 869   %b = add nuw i8 %a, 10
 870   %r = call i8 @llvm.usub.sat.i8(i8 %b, i8 11)
 871   ret i8 %r
 872 }
 873
 874 define i8 @test_scalar_usub_urem_must_ov(i8 %a) {
 875 ; CHECK-LABEL: @test_scalar_usub_urem_must_ov(
 876 ; CHECK-NEXT:    ret i8 0
 877 ;
 878   %b = urem i8 %a, 10
 879   %r = call i8 @llvm.usub.sat.i8(i8 %b, i8 10)
 880   ret i8 %r
 881 }
 882
 883 ; Like the previous case, the result is always zero here. However, as there's
 884 ; no actual overflow, we won't know about it.
 885 define i8 @test_scalar_usub_urem_must_zero(i8 %a) {
 886 ; CHECK-LABEL: @test_scalar_usub_urem_must_zero(
 887 ; CHECK-NEXT:    [[B:%.*]] = urem i8 [[A:%.*]], 10
 888 ; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[B]], i8 9)
 889 ; CHECK-NEXT:    ret i8 [[R]]
 890 ;
 891   %b = urem i8 %a, 10
 892   %r = call i8 @llvm.usub.sat.i8(i8 %b, i8 9)
 893   ret i8 %r
 894 }
 895
 896 ; We have a constant range for the LHS, but only known bits for the RHS
 897 define i8 @test_scalar_usub_add_nuw_known_bits(i8 %a, i8 %b) {
 898 ; CHECK-LABEL: @test_scalar_usub_add_nuw_known_bits(
 899 ; CHECK-NEXT:    [[AA:%.*]] = add nuw i8 [[A:%.*]], 10
 900 ; CHECK-NEXT:    [[BB:%.*]] = and i8 [[B:%.*]], 7
 901 ; CHECK-NEXT:    [[R:%.*]] = sub nuw i8 [[AA]], [[BB]]
 902 ; CHECK-NEXT:    ret i8 [[R]]
 903 ;
 904   %aa = add nuw i8 %a, 10
 905   %bb = and i8 %b, 7
 906   %r = call i8 @llvm.usub.sat.i8(i8 %aa, i8 %bb)
 907   ret i8 %r
 908 }
 909
 910 define i8 @test_scalar_usub_add_nuw_inferred(i8 %a) {
 911 ; CHECK-LABEL: @test_scalar_usub_add_nuw_inferred(
 912 ; CHECK-NEXT:    [[B:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 10)
 913 ; CHECK-NEXT:    [[R:%.*]] = add nuw i8 [[B]], 9
 914 ; CHECK-NEXT:    ret i8 [[R]]
 915 ;
 916   %b = call i8 @llvm.usub.sat.i8(i8 %a, i8 10)
 917   %r = add i8 %b, 9
 918   ret i8 %r
 919 }
 920
 921 define <2 x i8> @test_vector_usub_add_nuw_no_ov(<2 x i8> %a) {
 922 ; CHECK-LABEL: @test_vector_usub_add_nuw_no_ov(
 923 ; CHECK-NEXT:    [[R:%.*]] = add <2 x i8> [[A:%.*]], <i8 1, i8 1>
 924 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 925 ;
 926   %b = add nuw <2 x i8> %a, <i8 10, i8 10>
 927   %r = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %b, <2 x i8> <i8 9, i8 9>)
 928   ret <2 x i8> %r
 929 }
 930
 931 ; Can be optimized if the usub.sat RHS constant range handles non-splat vectors.
 932 define <2 x i8> @test_vector_usub_add_nuw_no_ov_nonsplat1(<2 x i8> %a) {
 933 ; CHECK-LABEL: @test_vector_usub_add_nuw_no_ov_nonsplat1(
 934 ; CHECK-NEXT:    [[B:%.*]] = add nuw <2 x i8> [[A:%.*]], <i8 10, i8 10>
 935 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[B]], <2 x i8> <i8 10, i8 9>)
 936 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 937 ;
 938   %b = add nuw <2 x i8> %a, <i8 10, i8 10>
 939   %r = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %b, <2 x i8> <i8 10, i8 9>)
 940   ret <2 x i8> %r
 941 }
 942
 943 ; Can be optimized if the add nuw RHS constant range handles non-splat vectors.
 944 define <2 x i8> @test_vector_usub_add_nuw_no_ov_nonsplat2(<2 x i8> %a) {
 945 ; CHECK-LABEL: @test_vector_usub_add_nuw_no_ov_nonsplat2(
 946 ; CHECK-NEXT:    [[B:%.*]] = add nuw <2 x i8> [[A:%.*]], <i8 10, i8 9>
 947 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[B]], <2 x i8> <i8 9, i8 9>)
 948 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 949 ;
 950   %b = add nuw <2 x i8> %a, <i8 10, i8 9>
 951   %r = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %b, <2 x i8> <i8 9, i8 9>)
 952   ret <2 x i8> %r
 953 }
 954
 955 ; Can be optimized if constant range is tracked per-element.
 956 define <2 x i8> @test_vector_usub_add_nuw_no_ov_nonsplat3(<2 x i8> %a) {
 957 ; CHECK-LABEL: @test_vector_usub_add_nuw_no_ov_nonsplat3(
 958 ; CHECK-NEXT:    [[B:%.*]] = add nuw <2 x i8> [[A:%.*]], <i8 10, i8 9>
 959 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[B]], <2 x i8> <i8 10, i8 9>)
 960 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 961 ;
 962   %b = add nuw <2 x i8> %a, <i8 10, i8 9>
 963   %r = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %b, <2 x i8> <i8 10, i8 9>)
 964   ret <2 x i8> %r
 965 }
 966
 967 define i8 @test_scalar_ssub_add_nsw_no_ov(i8 %a, i8 %b) {
 968 ; CHECK-LABEL: @test_scalar_ssub_add_nsw_no_ov(
 969 ; CHECK-NEXT:    [[AA:%.*]] = add nsw i8 [[A:%.*]], 7
 970 ; CHECK-NEXT:    [[BB:%.*]] = and i8 [[B:%.*]], 7
 971 ; CHECK-NEXT:    [[R:%.*]] = sub nsw i8 [[AA]], [[BB]]
 972 ; CHECK-NEXT:    ret i8 [[R]]
 973 ;
 974   %aa = add nsw i8 %a, 7
 975   %bb = and i8 %b, 7
 976   %r = call i8 @llvm.ssub.sat.i8(i8 %aa, i8 %bb)
 977   ret i8 %r
 978 }
 979
 980 define i8 @test_scalar_ssub_add_nsw_may_ov(i8 %a, i8 %b) {
 981 ; CHECK-LABEL: @test_scalar_ssub_add_nsw_may_ov(
 982 ; CHECK-NEXT:    [[AA:%.*]] = add nsw i8 [[A:%.*]], 6
 983 ; CHECK-NEXT:    [[BB:%.*]] = and i8 [[B:%.*]], 7
 984 ; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[AA]], i8 [[BB]])
 985 ; CHECK-NEXT:    ret i8 [[R]]
 986 ;
 987   %aa = add nsw i8 %a, 6
 988   %bb = and i8 %b, 7
 989   %r = call i8 @llvm.ssub.sat.i8(i8 %aa, i8 %bb)
 990   ret i8 %r
 991 }
 992
 993 define <2 x i8> @test_vector_ssub_add_nsw_no_ov_splat(<2 x i8> %a, <2 x i8> %b) {
 994 ; CHECK-LABEL: @test_vector_ssub_add_nsw_no_ov_splat(
 995 ; CHECK-NEXT:    [[AA:%.*]] = add nsw <2 x i8> [[A:%.*]], <i8 7, i8 7>
 996 ; CHECK-NEXT:    [[BB:%.*]] = and <2 x i8> [[B:%.*]], <i8 7, i8 7>
 997 ; CHECK-NEXT:    [[R:%.*]] = sub nsw <2 x i8> [[AA]], [[BB]]
 998 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 999 ;
1000   %aa = add nsw <2 x i8> %a, <i8 7, i8 7>
1001   %bb = and <2 x i8> %b, <i8 7, i8 7>
1002   %r = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %aa, <2 x i8> %bb)
1003   ret <2 x i8> %r
1004 }
1005
1006 define <2 x i8> @test_vector_ssub_add_nsw_no_ov_nonsplat1(<2 x i8> %a, <2 x i8> %b) {
1007 ; CHECK-LABEL: @test_vector_ssub_add_nsw_no_ov_nonsplat1(
1008 ; CHECK-NEXT:    [[AA:%.*]] = add nsw <2 x i8> [[A:%.*]], <i8 7, i8 7>
1009 ; CHECK-NEXT:    [[BB:%.*]] = and <2 x i8> [[B:%.*]], <i8 7, i8 6>
1010 ; CHECK-NEXT:    [[R:%.*]] = sub nsw <2 x i8> [[AA]], [[BB]]
1011 ; CHECK-NEXT:    ret <2 x i8> [[R]]
1012 ;
1013   %aa = add nsw <2 x i8> %a, <i8 7, i8 7>
1014   %bb = and <2 x i8> %b, <i8 7, i8 6>
1015   %r = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %aa, <2 x i8> %bb)
1016   ret <2 x i8> %r
1017 }
1018
1019 define <2 x i8> @test_vector_ssub_add_nsw_no_ov_nonsplat2(<2 x i8> %a, <2 x i8> %b) {
1020 ; CHECK-LABEL: @test_vector_ssub_add_nsw_no_ov_nonsplat2(
1021 ; CHECK-NEXT:    [[AA:%.*]] = add nsw <2 x i8> [[A:%.*]], <i8 7, i8 8>
1022 ; CHECK-NEXT:    [[BB:%.*]] = and <2 x i8> [[B:%.*]], <i8 7, i8 7>
1023 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> [[AA]], <2 x i8> [[BB]])
1024 ; CHECK-NEXT:    ret <2 x i8> [[R]]
1025 ;
1026   %aa = add nsw <2 x i8> %a, <i8 7, i8 8>
1027   %bb = and <2 x i8> %b, <i8 7, i8 7>
1028   %r = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %aa, <2 x i8> %bb)
1029   ret <2 x i8> %r
1030 }
1031
1032 define <2 x i8> @test_vector_ssub_add_nsw_no_ov_nonsplat3(<2 x i8> %a, <2 x i8> %b) {
1033 ; CHECK-LABEL: @test_vector_ssub_add_nsw_no_ov_nonsplat3(
1034 ; CHECK-NEXT:    [[AA:%.*]] = add nsw <2 x i8> [[A:%.*]], <i8 7, i8 6>
1035 ; CHECK-NEXT:    [[BB:%.*]] = and <2 x i8> [[B:%.*]], <i8 7, i8 6>
1036 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> [[AA]], <2 x i8> [[BB]])
1037 ; CHECK-NEXT:    ret <2 x i8> [[R]]
1038 ;
1039   %aa = add nsw <2 x i8> %a, <i8 7, i8 6>
1040   %bb = and <2 x i8> %b, <i8 7, i8 6>
1041   %r = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %aa, <2 x i8> %bb)
1042   ret <2 x i8> %r
1043 }
1044
1045 ; Raw IR tests
1046
1047 define i32 @uadd_sat(i32 %x, i32 %y) {
1048 ; CHECK-LABEL: @uadd_sat(
1049 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[X:%.*]], i32 [[Y:%.*]])
1050 ; CHECK-NEXT:    ret i32 [[TMP1]]
1051 ;
1052   %notx = xor i32 %x, -1
1053   %a = add i32 %y, %x
1054   %c = icmp ult i32 %notx, %y
1055   %r = select i1 %c, i32 -1, i32 %a
1056   ret i32 %r
1057 }
1058
1059 define i32 @uadd_sat_commute_add(i32 %xp, i32 %y) {
1060 ; CHECK-LABEL: @uadd_sat_commute_add(
1061 ; CHECK-NEXT:    [[X:%.*]] = urem i32 42, [[XP:%.*]]
1062 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[X]], i32 [[Y:%.*]])
1063 ; CHECK-NEXT:    ret i32 [[TMP1]]
1064 ;
1065   %x = urem i32 42, %xp ; thwart complexity-based-canonicalization
1066   %notx = xor i32 %x, -1
1067   %a = add i32 %x, %y
1068   %c = icmp ult i32 %notx, %y
1069   %r = select i1 %c, i32 -1, i32 %a
1070   ret i32 %r
1071 }
1072
1073 define i32 @uadd_sat_ugt(i32 %x, i32 %yp) {
1074 ; CHECK-LABEL: @uadd_sat_ugt(
1075 ; CHECK-NEXT:    [[Y:%.*]] = sdiv i32 [[YP:%.*]], 2442
1076 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[X:%.*]], i32 [[Y]])
1077 ; CHECK-NEXT:    ret i32 [[TMP1]]
1078 ;
1079   %y = sdiv i32 %yp, 2442 ; thwart complexity-based-canonicalization
1080   %notx = xor i32 %x, -1
1081   %a = add i32 %y, %x
1082   %c = icmp ugt i32 %y, %notx
1083   %r = select i1 %c, i32 -1, i32 %a
1084   ret i32 %r
1085 }
1086
1087 define <2 x i32> @uadd_sat_ugt_commute_add(<2 x i32> %xp, <2 x i32> %yp) {
1088 ; CHECK-LABEL: @uadd_sat_ugt_commute_add(
1089 ; CHECK-NEXT:    [[Y:%.*]] = sdiv <2 x i32> [[YP:%.*]], <i32 2442, i32 4242>
1090 ; CHECK-NEXT:    [[X:%.*]] = srem <2 x i32> <i32 42, i32 43>, [[XP:%.*]]
1091 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @llvm.uadd.sat.v2i32(<2 x i32> [[X]], <2 x i32> [[Y]])
1092 ; CHECK-NEXT:    ret <2 x i32> [[TMP1]]
1093 ;
1094   %y = sdiv <2 x i32> %yp, <i32 2442, i32 4242> ; thwart complexity-based-canonicalization
1095   %x = srem <2 x i32> <i32 42, i32 43>, %xp     ; thwart complexity-based-canonicalization
1096   %notx = xor <2 x i32> %x, <i32 -1, i32 -1>
1097   %a = add <2 x i32> %x, %y
1098   %c = icmp ugt <2 x i32> %y, %notx
1099   %r = select <2 x i1> %c, <2 x i32> <i32 -1, i32 -1>, <2 x i32> %a
1100   ret <2 x i32> %r
1101 }
1102
1103 define i32 @uadd_sat_commute_select(i32 %x, i32 %yp) {
1104 ; CHECK-LABEL: @uadd_sat_commute_select(
1105 ; CHECK-NEXT:    [[Y:%.*]] = sdiv i32 [[YP:%.*]], 2442
1106 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[X:%.*]], i32 [[Y]])
1107 ; CHECK-NEXT:    ret i32 [[TMP1]]
1108 ;
1109   %y = sdiv i32 %yp, 2442 ; thwart complexity-based-canonicalization
1110   %notx = xor i32 %x, -1
1111   %a = add i32 %y, %x
1112   %c = icmp ult i32 %y, %notx
1113   %r = select i1 %c, i32 %a, i32 -1
1114   ret i32 %r
1115 }
1116
1117 define i32 @uadd_sat_commute_select_commute_add(i32 %xp, i32 %yp) {
1118 ; CHECK-LABEL: @uadd_sat_commute_select_commute_add(
1119 ; CHECK-NEXT:    [[X:%.*]] = urem i32 42, [[XP:%.*]]
1120 ; CHECK-NEXT:    [[Y:%.*]] = sdiv i32 [[YP:%.*]], 2442
1121 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[X]], i32 [[Y]])
1122 ; CHECK-NEXT:    ret i32 [[TMP1]]
1123 ;
1124   %x = urem i32 42, %xp ; thwart complexity-based-canonicalization
1125   %y = sdiv i32 %yp, 2442 ; thwart complexity-based-canonicalization
1126   %notx = xor i32 %x, -1
1127   %a = add i32 %x, %y
1128   %c = icmp ult i32 %y, %notx
1129   %r = select i1 %c, i32 %a, i32 -1
1130   ret i32 %r
1131 }
1132
1133 define <2 x i32> @uadd_sat_commute_select_ugt(<2 x i32> %x, <2 x i32> %y) {
1134 ; CHECK-LABEL: @uadd_sat_commute_select_ugt(
1135 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @llvm.uadd.sat.v2i32(<2 x i32> [[X:%.*]], <2 x i32> [[Y:%.*]])
1136 ; CHECK-NEXT:    ret <2 x i32> [[TMP1]]
1137 ;
1138   %notx = xor <2 x i32> %x, <i32 -1, i32 -1>
1139   %a = add <2 x i32> %y, %x
1140   %c = icmp ugt <2 x i32> %notx, %y
1141   %r = select <2 x i1> %c, <2 x i32> %a, <2 x i32> <i32 -1, i32 -1>
1142   ret <2 x i32> %r
1143 }
1144
1145 define i32 @uadd_sat_commute_select_ugt_commute_add(i32 %xp, i32 %y) {
1146 ; CHECK-LABEL: @uadd_sat_commute_select_ugt_commute_add(
1147 ; CHECK-NEXT:    [[X:%.*]] = srem i32 42, [[XP:%.*]]
1148 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[X]], i32 [[Y:%.*]])
1149 ; CHECK-NEXT:    ret i32 [[TMP1]]
1150 ;
1151   %x = srem i32 42, %xp   ; thwart complexity-based-canonicalization
1152   %notx = xor i32 %x, -1
1153   %a = add i32 %x, %y
1154   %c = icmp ugt i32 %notx, %y
1155   %r = select i1 %c, i32 %a, i32 -1
1156   ret i32 %r
1157 }
1158
1159 ; Negative test - make sure we have a -1 in the select.
1160
1161 define i32 @not_uadd_sat(i32 %x, i32 %y) {
1162 ; CHECK-LABEL: @not_uadd_sat(
1163 ; CHECK-NEXT:    [[A:%.*]] = add i32 [[X:%.*]], -2
1164 ; CHECK-NEXT:    [[C:%.*]] = icmp ugt i32 [[X]], 1
1165 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[C]], i32 [[A]], i32 [[Y:%.*]]
1166 ; CHECK-NEXT:    ret i32 [[R]]
1167 ;
1168   %a = add i32 %x, -2
1169   %c = icmp ugt i32 %x, 1
1170   %r = select i1 %c, i32 %a, i32 %y
1171   ret i32 %r
1172 }
1173
1174 ; Negative test - make sure the predicate is 'ult'.
1175
1176 define i32 @not_uadd_sat2(i32 %x, i32 %y) {
1177 ; CHECK-LABEL: @not_uadd_sat2(
1178 ; CHECK-NEXT:    [[A:%.*]] = add i32 [[X:%.*]], -2
1179 ; CHECK-NEXT:    [[C:%.*]] = icmp ugt i32 [[X]], 1
1180 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[C]], i32 [[A]], i32 -1
1181 ; CHECK-NEXT:    ret i32 [[R]]
1182 ;
1183   %a = add i32 %x, -2
1184   %c = icmp ugt i32 %x, 1
1185   %r = select i1 %c, i32 %a, i32 -1
1186   ret i32 %r
1187 }
1188
1189 ; The add may include a 'not' op rather than the cmp.
1190
1191 define i32 @uadd_sat_not(i32 %x, i32 %y) {
1192 ; CHECK-LABEL: @uadd_sat_not(
1193 ; CHECK-NEXT:    [[NOTX:%.*]] = xor i32 [[X:%.*]], -1
1194 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[NOTX]], i32 [[Y:%.*]])
1195 ; CHECK-NEXT:    ret i32 [[TMP1]]
1196 ;
1197   %notx = xor i32 %x, -1
1198   %a = add i32 %notx, %y
1199   %c = icmp ult i32 %x, %y
1200   %r = select i1 %c, i32 -1, i32 %a
1201   ret i32 %r
1202 }
1203
1204 define i32 @uadd_sat_not_commute_add(i32 %xp, i32 %yp) {
1205 ; CHECK-LABEL: @uadd_sat_not_commute_add(
1206 ; CHECK-NEXT:    [[X:%.*]] = srem i32 42, [[XP:%.*]]
1207 ; CHECK-NEXT:    [[Y:%.*]] = urem i32 42, [[YP:%.*]]
1208 ; CHECK-NEXT:    [[NOTX:%.*]] = xor i32 [[X]], -1
1209 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[Y]], i32 [[NOTX]])
1210 ; CHECK-NEXT:    ret i32 [[TMP1]]
1211 ;
1212   %x = srem i32 42, %xp ; thwart complexity-based-canonicalization
1213   %y = urem i32 42, %yp ; thwart complexity-based-canonicalization
1214   %notx = xor i32 %x, -1
1215   %a = add i32 %y, %notx
1216   %c = icmp ult i32 %x, %y
1217   %r = select i1 %c, i32 -1, i32 %a
1218   ret i32 %r
1219 }
1220
1221 define i32 @uadd_sat_not_ugt(i32 %x, i32 %y) {
1222 ; CHECK-LABEL: @uadd_sat_not_ugt(
1223 ; CHECK-NEXT:    [[NOTX:%.*]] = xor i32 [[X:%.*]], -1
1224 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[NOTX]], i32 [[Y:%.*]])
1225 ; CHECK-NEXT:    ret i32 [[TMP1]]
1226 ;
1227   %notx = xor i32 %x, -1
1228   %a = add i32 %notx, %y
1229   %c = icmp ugt i32 %y, %x
1230   %r = select i1 %c, i32 -1, i32 %a
1231   ret i32 %r
1232 }
1233
1234 define <2 x i32> @uadd_sat_not_ugt_commute_add(<2 x i32> %x, <2 x i32> %yp) {
1235 ; CHECK-LABEL: @uadd_sat_not_ugt_commute_add(
1236 ; CHECK-NEXT:    [[Y:%.*]] = sdiv <2 x i32> [[YP:%.*]], <i32 2442, i32 4242>
1237 ; CHECK-NEXT:    [[NOTX:%.*]] = xor <2 x i32> [[X:%.*]], <i32 -1, i32 -1>
1238 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @llvm.uadd.sat.v2i32(<2 x i32> [[Y]], <2 x i32> [[NOTX]])
1239 ; CHECK-NEXT:    ret <2 x i32> [[TMP1]]
1240 ;
1241   %y = sdiv <2 x i32> %yp, <i32 2442, i32 4242> ; thwart complexity-based-canonicalization
1242   %notx = xor <2 x i32> %x, <i32 -1, i32 -1>
1243   %a = add <2 x i32> %y, %notx
1244   %c = icmp ugt <2 x i32> %y, %x
1245   %r = select <2 x i1> %c, <2 x i32> <i32 -1, i32 -1>, <2 x i32> %a
1246   ret <2 x i32> %r
1247 }
1248
1249 define i32 @uadd_sat_not_commute_select(i32 %x, i32 %y) {
1250 ; CHECK-LABEL: @uadd_sat_not_commute_select(
1251 ; CHECK-NEXT:    [[NOTX:%.*]] = xor i32 [[X:%.*]], -1
1252 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[NOTX]], i32 [[Y:%.*]])
1253 ; CHECK-NEXT:    ret i32 [[TMP1]]
1254 ;
1255   %notx = xor i32 %x, -1
1256   %a = add i32 %notx, %y
1257   %c = icmp ult i32 %y, %x
1258   %r = select i1 %c, i32 %a, i32 -1
1259   ret i32 %r
1260 }
1261
1262 define i32 @uadd_sat_not_commute_select_commute_add(i32 %x, i32 %yp) {
1263 ; CHECK-LABEL: @uadd_sat_not_commute_select_commute_add(
1264 ; CHECK-NEXT:    [[Y:%.*]] = sdiv i32 42, [[YP:%.*]]
1265 ; CHECK-NEXT:    [[NOTX:%.*]] = xor i32 [[X:%.*]], -1
1266 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[Y]], i32 [[NOTX]])
1267 ; CHECK-NEXT:    ret i32 [[TMP1]]
1268 ;
1269   %y = sdiv i32 42, %yp ; thwart complexity-based-canonicalization
1270   %notx = xor i32 %x, -1
1271   %a = add i32 %y, %notx
1272   %c = icmp ult i32 %y, %x
1273   %r = select i1 %c, i32 %a, i32 -1
1274   ret i32 %r
1275 }
1276
1277 define <2 x i32> @uadd_sat_not_commute_select_ugt(<2 x i32> %xp, <2 x i32> %yp) {
1278 ; CHECK-LABEL: @uadd_sat_not_commute_select_ugt(
1279 ; CHECK-NEXT:    [[X:%.*]] = urem <2 x i32> <i32 42, i32 -42>, [[XP:%.*]]
1280 ; CHECK-NEXT:    [[Y:%.*]] = srem <2 x i32> <i32 12, i32 412>, [[YP:%.*]]
1281 ; CHECK-NEXT:    [[NOTX:%.*]] = xor <2 x i32> [[X]], <i32 -1, i32 -1>
1282 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @llvm.uadd.sat.v2i32(<2 x i32> [[Y]], <2 x i32> [[NOTX]])
1283 ; CHECK-NEXT:    ret <2 x i32> [[TMP1]]
1284 ;
1285   %x = urem <2 x i32> <i32 42, i32 -42>, %xp ; thwart complexity-based-canonicalization
1286   %y = srem <2 x i32> <i32 12, i32 412>, %yp ; thwart complexity-based-canonicalization
1287   %notx = xor <2 x i32> %x, <i32 -1, i32 -1>
1288   %a = add <2 x i32> %y, %notx
1289   %c = icmp ugt <2 x i32> %x, %y
1290   %r = select <2 x i1> %c, <2 x i32> %a, <2 x i32> <i32 -1, i32 -1>
1291   ret <2 x i32> %r
1292 }
1293
1294 define i32 @uadd_sat_not_commute_select_ugt_commute_add(i32 %x, i32 %y) {
1295 ; CHECK-LABEL: @uadd_sat_not_commute_select_ugt_commute_add(
1296 ; CHECK-NEXT:    [[NOTX:%.*]] = xor i32 [[X:%.*]], -1
1297 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[NOTX]], i32 [[Y:%.*]])
1298 ; CHECK-NEXT:    ret i32 [[TMP1]]
1299 ;
1300   %notx = xor i32 %x, -1
1301   %a = add i32 %notx, %y
1302   %c = icmp ugt i32 %x, %y
1303   %r = select i1 %c, i32 %a, i32 -1
1304   ret i32 %r
1305 }
1306
1307 define i32 @uadd_sat_constant(i32 %x) {
1308 ; CHECK-LABEL: @uadd_sat_constant(
1309 ; CHECK-NEXT:    [[A:%.*]] = add i32 [[X:%.*]], 42
1310 ; CHECK-NEXT:    [[C:%.*]] = icmp ugt i32 [[X]], -43
1311 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[C]], i32 -1, i32 [[A]]
1312 ; CHECK-NEXT:    ret i32 [[R]]
1313 ;
1314   %a = add i32 %x, 42
1315   %c = icmp ugt i32 %x, -43
1316   %r = select i1 %c, i32 -1, i32 %a
1317   ret i32 %r
1318 }
1319
1320 define i32 @uadd_sat_constant_commute(i32 %x) {
1321 ; CHECK-LABEL: @uadd_sat_constant_commute(
1322 ; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[X:%.*]], i32 42)
1323 ; CHECK-NEXT:    ret i32 [[TMP1]]
1324 ;
1325   %a = add i32 %x, 42
1326   %c = icmp ult i32 %x, -43
1327   %r = select i1 %c, i32 %a, i32 -1
1328   ret i32 %r
1329 }
1330
1331 define <4 x i32> @uadd_sat_constant_vec(<4 x i32> %x) {
1332 ; CHECK-LABEL: @uadd_sat_constant_vec(
1333 ; CHECK-NEXT:    [[A:%.*]] = add <4 x i32> [[X:%.*]], <i32 42, i32 42, i32 42, i32 42>
1334 ; CHECK-NEXT:    [[C:%.*]] = icmp ugt <4 x i32> [[X]], <i32 -43, i32 -43, i32 -43, i32 -43>
1335 ; CHECK-NEXT:    [[R:%.*]] = select <4 x i1> [[C]], <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, <4 x i32> [[A]]
1336 ; CHECK-NEXT:    ret <4 x i32> [[R]]
1337 ;
1338   %a = add <4 x i32> %x, <i32 42, i32 42, i32 42, i32 42>
1339   %c = icmp ugt <4 x i32> %x, <i32 -43, i32 -43, i32 -43, i32 -43>
1340   %r = select <4 x i1> %c, <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, <4 x i32> %a
1341   ret <4 x i32> %r
1342 }
1343
1344 define <4 x i32> @uadd_sat_constant_vec_commute(<4 x i32> %x) {
1345 ; CHECK-LABEL: @uadd_sat_constant_vec_commute(
1346 ; CHECK-NEXT:    [[TMP1:%.*]] = call <4 x i32> @llvm.uadd.sat.v4i32(<4 x i32> [[X:%.*]], <4 x i32> <i32 42, i32 42, i32 42, i32 42>)
1347 ; CHECK-NEXT:    ret <4 x i32> [[TMP1]]
1348 ;
1349   %a = add <4 x i32> %x, <i32 42, i32 42, i32 42, i32 42>
1350   %c = icmp ult <4 x i32> %x, <i32 -43, i32 -43, i32 -43, i32 -43>
1351   %r = select <4 x i1> %c, <4 x i32> %a, <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>
1352   ret <4 x i32> %r
1353 }
1354
1355 define <4 x i32> @uadd_sat_constant_vec_commute_undefs(<4 x i32> %x) {
1356 ; CHECK-LABEL: @uadd_sat_constant_vec_commute_undefs(
1357 ; CHECK-NEXT:    [[A:%.*]] = add <4 x i32> [[X:%.*]], <i32 42, i32 42, i32 42, i32 undef>
1358 ; CHECK-NEXT:    [[C:%.*]] = icmp ult <4 x i32> [[X]], <i32 -43, i32 -43, i32 undef, i32 -43>
1359 ; CHECK-NEXT:    [[R:%.*]] = select <4 x i1> [[C]], <4 x i32> [[A]], <4 x i32> <i32 -1, i32 undef, i32 -1, i32 -1>
1360 ; CHECK-NEXT:    ret <4 x i32> [[R]]
1361 ;
1362   %a = add <4 x i32> %x, <i32 42, i32 42, i32 42, i32 undef>
1363   %c = icmp ult <4 x i32> %x, <i32 -43, i32 -43, i32 undef, i32 -43>
1364   %r = select <4 x i1> %c, <4 x i32> %a, <4 x i32> <i32 -1, i32 undef, i32 -1, i32 -1>
1365   ret <4 x i32> %r
1366 }
1367
1368 declare i32 @get_i32()
1369 declare <2 x i8> @get_v2i8()
1370
1371 define i32 @unsigned_sat_variable_using_min_add(i32 %x) {
1372 ; CHECK-LABEL: @unsigned_sat_variable_using_min_add(
1373 ; CHECK-NEXT:    [[Y:%.*]] = call i32 @get_i32()
1374 ; CHECK-NEXT:    [[R:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[X:%.*]], i32 [[Y]])
1375 ; CHECK-NEXT:    ret i32 [[R]]
1376 ;
1377   %y = call i32 @get_i32() ; thwart complexity-based canonicalization
1378   %noty = xor i32 %y, -1
1379   %c = icmp ult i32 %x, %noty
1380   %s = select i1 %c, i32 %x, i32 %noty
1381   %r = add i32 %s, %y
1382   ret i32 %r
1383 }
1384
1385 define i32 @unsigned_sat_variable_using_min_commute_add(i32 %x) {
1386 ; CHECK-LABEL: @unsigned_sat_variable_using_min_commute_add(
1387 ; CHECK-NEXT:    [[Y:%.*]] = call i32 @get_i32()
1388 ; CHECK-NEXT:    [[R:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[X:%.*]], i32 [[Y]])
1389 ; CHECK-NEXT:    ret i32 [[R]]
1390 ;
1391   %y = call i32 @get_i32() ; thwart complexity-based canonicalization
1392   %noty = xor i32 %y, -1
1393   %c = icmp ult i32 %x, %noty
1394   %s = select i1 %c, i32 %x, i32 %noty
1395   %r = add i32 %y, %s
1396   ret i32 %r
1397 }
1398
1399 define <2 x i8> @unsigned_sat_variable_using_min_commute_select(<2 x i8> %x) {
1400 ; CHECK-LABEL: @unsigned_sat_variable_using_min_commute_select(
1401 ; CHECK-NEXT:    [[Y:%.*]] = call <2 x i8> @get_v2i8()
1402 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> [[X:%.*]], <2 x i8> [[Y]])
1403 ; CHECK-NEXT:    ret <2 x i8> [[R]]
1404 ;
1405   %y = call <2 x i8> @get_v2i8() ; thwart complexity-based canonicalization
1406   %noty = xor <2 x i8> %y, <i8 -1, i8 -1>
1407   %c = icmp ult <2 x i8> %noty, %x
1408   %s = select <2 x i1> %c, <2 x i8> %noty, <2 x i8> %x
1409   %r = add <2 x i8> %s, %y
1410   ret <2 x i8> %r
1411 }
1412
1413 define <2 x i8> @unsigned_sat_variable_using_min_commute_add_select(<2 x i8> %x) {
1414 ; CHECK-LABEL: @unsigned_sat_variable_using_min_commute_add_select(
1415 ; CHECK-NEXT:    [[Y:%.*]] = call <2 x i8> @get_v2i8()
1416 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> [[X:%.*]], <2 x i8> [[Y]])
1417 ; CHECK-NEXT:    ret <2 x i8> [[R]]
1418 ;
1419   %y = call <2 x i8> @get_v2i8() ; thwart complexity-based canonicalization
1420   %noty = xor <2 x i8> %y, <i8 -1, i8 -1>
1421   %c = icmp ult <2 x i8> %noty, %x
1422   %s = select <2 x i1> %c, <2 x i8> %noty, <2 x i8> %x
1423   %r = add <2 x i8> %y, %s
1424   ret <2 x i8> %r
1425 }
1426
1427 ; Negative test
1428
1429 define i32 @unsigned_sat_variable_using_wrong_min(i32 %x) {
1430 ; CHECK-LABEL: @unsigned_sat_variable_using_wrong_min(
1431 ; CHECK-NEXT:    [[Y:%.*]] = call i32 @get_i32()
1432 ; CHECK-NEXT:    [[NOTY:%.*]] = xor i32 [[Y]], -1
1433 ; CHECK-NEXT:    [[C:%.*]] = icmp sgt i32 [[NOTY]], [[X:%.*]]
1434 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i32 [[X]], i32 [[NOTY]]
1435 ; CHECK-NEXT:    [[R:%.*]] = add i32 [[Y]], [[S]]
1436 ; CHECK-NEXT:    ret i32 [[R]]
1437 ;
1438   %y = call i32 @get_i32() ; thwart complexity-based canonicalization
1439   %noty = xor i32 %y, -1
1440   %c = icmp slt i32 %x, %noty
1441   %s = select i1 %c, i32 %x, i32 %noty
1442   %r = add i32 %y, %s
1443   ret i32 %r
1444 }
1445
1446 ; Negative test
1447
1448 define i32 @unsigned_sat_variable_using_wrong_value(i32 %x, i32 %z) {
1449 ; CHECK-LABEL: @unsigned_sat_variable_using_wrong_value(
1450 ; CHECK-NEXT:    [[Y:%.*]] = call i32 @get_i32()
1451 ; CHECK-NEXT:    [[NOTY:%.*]] = xor i32 [[Y]], -1
1452 ; CHECK-NEXT:    [[C:%.*]] = icmp ugt i32 [[NOTY]], [[X:%.*]]
1453 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i32 [[X]], i32 [[NOTY]]
1454 ; CHECK-NEXT:    [[R:%.*]] = add i32 [[S]], [[Z:%.*]]
1455 ; CHECK-NEXT:    ret i32 [[R]]
1456 ;
1457   %y = call i32 @get_i32() ; thwart complexity-based canonicalization
1458   %noty = xor i32 %y, -1
1459   %c = icmp ult i32 %x, %noty
1460   %s = select i1 %c, i32 %x, i32 %noty
1461   %r = add i32 %z, %s
1462   ret i32 %r
1463 }
1464
1465 ; If we have a constant operand, there's no commutativity variation.
1466
1467 define i32 @unsigned_sat_constant_using_min(i32 %x) {
1468 ; CHECK-LABEL: @unsigned_sat_constant_using_min(
1469 ; CHECK-NEXT:    [[R:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[X:%.*]], i32 -43)
1470 ; CHECK-NEXT:    ret i32 [[R]]
1471 ;
1472   %c = icmp ult i32 %x, 42
1473   %s = select i1 %c, i32 %x, i32 42
1474   %r = add i32 %s, -43
1475   ret i32 %r
1476 }
1477
1478 define <2 x i32> @unsigned_sat_constant_using_min_splat(<2 x i32> %x) {
1479 ; CHECK-LABEL: @unsigned_sat_constant_using_min_splat(
1480 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i32> @llvm.uadd.sat.v2i32(<2 x i32> [[X:%.*]], <2 x i32> <i32 -15, i32 -15>)
1481 ; CHECK-NEXT:    ret <2 x i32> [[R]]
1482 ;
1483   %c = icmp ult <2 x i32> %x, <i32 14, i32 14>
1484   %s = select <2 x i1> %c, <2 x i32> %x, <2 x i32> <i32 14, i32 14>
1485   %r = add <2 x i32> %s, <i32 -15, i32 -15>
1486   ret <2 x i32> %r
1487 }
1488
1489 ; Negative test
1490
1491 define i32 @unsigned_sat_constant_using_min_wrong_constant(i32 %x) {
1492 ; CHECK-LABEL: @unsigned_sat_constant_using_min_wrong_constant(
1493 ; CHECK-NEXT:    [[C:%.*]] = icmp ult i32 [[X:%.*]], 42
1494 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i32 [[X]], i32 42
1495 ; CHECK-NEXT:    [[R:%.*]] = add nsw i32 [[S]], -42
1496 ; CHECK-NEXT:    ret i32 [[R]]
1497 ;
1498   %c = icmp ult i32 %x, 42
1499   %s = select i1 %c, i32 %x, i32 42
1500   %r = add i32 %s, -42
1501   ret i32 %r
1502 }