llvm/test/Transforms/InstCombine/shl-bo.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -instcombine -S | FileCheck %s
   3
   4 declare void @use(i8)
   5
   6 define i8 @lshr_add(i8 %a, i8 %y) {
   7 ; CHECK-LABEL: @lshr_add(
   8 ; CHECK-NEXT:    [[X:%.*]] = srem i8 [[A:%.*]], 42
   9 ; CHECK-NEXT:    [[B1:%.*]] = shl i8 [[X]], 5
  10 ; CHECK-NEXT:    [[R2:%.*]] = add i8 [[B1]], [[Y:%.*]]
  11 ; CHECK-NEXT:    [[L:%.*]] = and i8 [[R2]], -32
  12 ; CHECK-NEXT:    ret i8 [[L]]
  13 ;
  14   %x = srem i8 %a, 42 ; thwart complexity-based canonicalization
  15   %r = lshr i8 %y, 5
  16   %b = add i8 %r, %x
  17   %l = shl i8 %b, 5
  18   ret i8 %l
  19 }
  20
  21 define <2 x i8> @lshr_add_commute_splat(<2 x i8> %a, <2 x i8> %y) {
  22 ; CHECK-LABEL: @lshr_add_commute_splat(
  23 ; CHECK-NEXT:    [[X:%.*]] = srem <2 x i8> [[A:%.*]], <i8 42, i8 42>
  24 ; CHECK-NEXT:    [[B1:%.*]] = shl <2 x i8> [[X]], <i8 5, i8 5>
  25 ; CHECK-NEXT:    [[R2:%.*]] = add <2 x i8> [[B1]], [[Y:%.*]]
  26 ; CHECK-NEXT:    [[L:%.*]] = and <2 x i8> [[R2]], <i8 -32, i8 -32>
  27 ; CHECK-NEXT:    ret <2 x i8> [[L]]
  28 ;
  29   %x = srem <2 x i8> %a, <i8 42, i8 42> ; thwart complexity-based canonicalization
  30   %r = lshr <2 x i8> %y, <i8 5, i8 5>
  31   %b = add <2 x i8> %x, %r
  32   %l = shl <2 x i8> %b, <i8 5, i8 5>
  33   ret <2 x i8> %l
  34 }
  35
  36 define i8 @lshr_sub(i8 %a, i8 %y) {
  37 ; CHECK-LABEL: @lshr_sub(
  38 ; CHECK-NEXT:    [[X:%.*]] = srem i8 [[A:%.*]], 42
  39 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[Y:%.*]], 3
  40 ; CHECK-NEXT:    [[B:%.*]] = sub nsw i8 [[X]], [[R]]
  41 ; CHECK-NEXT:    [[L:%.*]] = shl i8 [[B]], 3
  42 ; CHECK-NEXT:    ret i8 [[L]]
  43 ;
  44   %x = srem i8 %a, 42 ; thwart complexity-based canonicalization
  45   %r = lshr i8 %y, 3
  46   %b = sub i8 %x, %r
  47   %l = shl i8 %b, 3
  48   ret i8 %l
  49 }
  50
  51 define <2 x i8> @lshr_sub_commute_splat(<2 x i8> %a, <2 x i8> %y) {
  52 ; CHECK-LABEL: @lshr_sub_commute_splat(
  53 ; CHECK-NEXT:    [[X:%.*]] = srem <2 x i8> [[A:%.*]], <i8 42, i8 42>
  54 ; CHECK-NEXT:    [[B1_NEG:%.*]] = mul <2 x i8> [[X]], <i8 -8, i8 -8>
  55 ; CHECK-NEXT:    [[R2:%.*]] = add <2 x i8> [[B1_NEG]], [[Y:%.*]]
  56 ; CHECK-NEXT:    [[L:%.*]] = and <2 x i8> [[R2]], <i8 -8, i8 -8>
  57 ; CHECK-NEXT:    ret <2 x i8> [[L]]
  58 ;
  59   %x = srem <2 x i8> %a, <i8 42, i8 42> ; thwart complexity-based canonicalization
  60   %r = lshr <2 x i8> %y, <i8 3, i8 3>
  61   %b = sub <2 x i8> %r, %x
  62   %l = shl <2 x i8> %b, <i8 3, i8 3>
  63   ret <2 x i8> %l
  64 }
  65
  66 define i8 @lshr_and(i8 %a, i8 %y) {
  67 ; CHECK-LABEL: @lshr_and(
  68 ; CHECK-NEXT:    [[X:%.*]] = srem i8 [[A:%.*]], 42
  69 ; CHECK-NEXT:    [[B1:%.*]] = shl i8 [[X]], 6
  70 ; CHECK-NEXT:    [[R2:%.*]] = and i8 [[B1]], [[Y:%.*]]
  71 ; CHECK-NEXT:    ret i8 [[R2]]
  72 ;
  73   %x = srem i8 %a, 42 ; thwart complexity-based canonicalization
  74   %r = lshr i8 %y, 6
  75   %b = and i8 %r, %x
  76   %l = shl i8 %b, 6
  77   ret i8 %l
  78 }
  79
  80 define <2 x i8> @lshr_and_commute_splat(<2 x i8> %a, <2 x i8> %y) {
  81 ; CHECK-LABEL: @lshr_and_commute_splat(
  82 ; CHECK-NEXT:    [[X:%.*]] = srem <2 x i8> [[A:%.*]], <i8 42, i8 42>
  83 ; CHECK-NEXT:    [[B1:%.*]] = shl <2 x i8> [[X]], <i8 6, i8 6>
  84 ; CHECK-NEXT:    [[R2:%.*]] = and <2 x i8> [[B1]], [[Y:%.*]]
  85 ; CHECK-NEXT:    ret <2 x i8> [[R2]]
  86 ;
  87   %x = srem <2 x i8> %a, <i8 42, i8 42> ; thwart complexity-based canonicalization
  88   %r = lshr <2 x i8> %y, <i8 6, i8 6>
  89   %b = and <2 x i8> %x, %r
  90   %l = shl <2 x i8> %b, <i8 6, i8 6>
  91   ret <2 x i8> %l
  92 }
  93
  94 define i8 @lshr_or(i8 %a, i8 %y) {
  95 ; CHECK-LABEL: @lshr_or(
  96 ; CHECK-NEXT:    [[X:%.*]] = srem i8 [[A:%.*]], 42
  97 ; CHECK-NEXT:    [[B1:%.*]] = shl i8 [[X]], 4
  98 ; CHECK-NEXT:    [[Y_MASKED:%.*]] = and i8 [[Y:%.*]], -16
  99 ; CHECK-NEXT:    [[L:%.*]] = or i8 [[B1]], [[Y_MASKED]]
 100 ; CHECK-NEXT:    ret i8 [[L]]
 101 ;
 102   %x = srem i8 %a, 42 ; thwart complexity-based canonicalization
 103   %r = lshr i8 %y, 4
 104   %b = or i8 %x, %r
 105   %l = shl i8 %b, 4
 106   ret i8 %l
 107 }
 108
 109 define <2 x i8> @lshr_or_commute_splat(<2 x i8> %a, <2 x i8> %y) {
 110 ; CHECK-LABEL: @lshr_or_commute_splat(
 111 ; CHECK-NEXT:    [[X:%.*]] = srem <2 x i8> [[A:%.*]], <i8 42, i8 42>
 112 ; CHECK-NEXT:    [[B1:%.*]] = shl <2 x i8> [[X]], <i8 4, i8 4>
 113 ; CHECK-NEXT:    [[Y_MASKED:%.*]] = and <2 x i8> [[Y:%.*]], <i8 -16, i8 -16>
 114 ; CHECK-NEXT:    [[L:%.*]] = or <2 x i8> [[B1]], [[Y_MASKED]]
 115 ; CHECK-NEXT:    ret <2 x i8> [[L]]
 116 ;
 117   %x = srem <2 x i8> %a, <i8 42, i8 42> ; thwart complexity-based canonicalization
 118   %r = lshr <2 x i8> %y, <i8 4, i8 4>
 119   %b = or <2 x i8> %r, %x
 120   %l = shl <2 x i8> %b, <i8 4, i8 4>
 121   ret <2 x i8> %l
 122 }
 123
 124 define i8 @lshr_xor(i8 %a, i8 %y) {
 125 ; CHECK-LABEL: @lshr_xor(
 126 ; CHECK-NEXT:    [[X:%.*]] = srem i8 [[A:%.*]], 42
 127 ; CHECK-NEXT:    [[B1:%.*]] = shl i8 [[X]], 3
 128 ; CHECK-NEXT:    [[Y_MASKED:%.*]] = and i8 [[Y:%.*]], -8
 129 ; CHECK-NEXT:    [[L:%.*]] = xor i8 [[B1]], [[Y_MASKED]]
 130 ; CHECK-NEXT:    ret i8 [[L]]
 131 ;
 132   %x = srem i8 %a, 42 ; thwart complexity-based canonicalization
 133   %r = lshr i8 %y, 3
 134   %b = xor i8 %r, %x
 135   %l = shl i8 %b, 3
 136   ret i8 %l
 137 }
 138
 139 define <2 x i8> @lshr_xor_commute_splat(<2 x i8> %a, <2 x i8> %y) {
 140 ; CHECK-LABEL: @lshr_xor_commute_splat(
 141 ; CHECK-NEXT:    [[X:%.*]] = srem <2 x i8> [[A:%.*]], <i8 42, i8 42>
 142 ; CHECK-NEXT:    [[B1:%.*]] = shl <2 x i8> [[X]], <i8 3, i8 3>
 143 ; CHECK-NEXT:    [[Y_MASKED:%.*]] = and <2 x i8> [[Y:%.*]], <i8 -8, i8 -8>
 144 ; CHECK-NEXT:    [[L:%.*]] = xor <2 x i8> [[B1]], [[Y_MASKED]]
 145 ; CHECK-NEXT:    ret <2 x i8> [[L]]
 146 ;
 147   %x = srem <2 x i8> %a, <i8 42, i8 42> ; thwart complexity-based canonicalization
 148   %r = lshr <2 x i8> %y, <i8 3, i8 3>
 149   %b = xor <2 x i8> %x, %r
 150   %l = shl <2 x i8> %b, <i8 3, i8 3>
 151   ret <2 x i8> %l
 152 }
 153
 154 define i8 @lshr_add_use1(i8 %x, i8 %y) {
 155 ; CHECK-LABEL: @lshr_add_use1(
 156 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[Y:%.*]], 5
 157 ; CHECK-NEXT:    call void @use(i8 [[R]])
 158 ; CHECK-NEXT:    [[B:%.*]] = add i8 [[R]], [[X:%.*]]
 159 ; CHECK-NEXT:    [[L:%.*]] = shl i8 [[B]], 5
 160 ; CHECK-NEXT:    ret i8 [[L]]
 161 ;
 162   %r = lshr i8 %y, 5
 163   call void @use(i8 %r)
 164   %b = add i8 %r, %x
 165   %l = shl i8 %b, 5
 166   ret i8 %l
 167 }
 168
 169 define i8 @lshr_add_use2(i8 %x, i8 %y) {
 170 ; CHECK-LABEL: @lshr_add_use2(
 171 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[Y:%.*]], 5
 172 ; CHECK-NEXT:    [[B:%.*]] = add i8 [[R]], [[X:%.*]]
 173 ; CHECK-NEXT:    call void @use(i8 [[B]])
 174 ; CHECK-NEXT:    [[L:%.*]] = shl i8 [[B]], 5
 175 ; CHECK-NEXT:    ret i8 [[L]]
 176 ;
 177   %r = lshr i8 %y, 5
 178   %b = add i8 %r, %x
 179   call void @use(i8 %b)
 180   %l = shl i8 %b, 5
 181   ret i8 %l
 182 }
 183
 184 define i8 @lshr_and_add(i8 %a, i8 %y)  {
 185 ; CHECK-LABEL: @lshr_and_add(
 186 ; CHECK-NEXT:    [[X:%.*]] = srem i8 [[A:%.*]], 42
 187 ; CHECK-NEXT:    [[B1:%.*]] = shl i8 [[X]], 3
 188 ; CHECK-NEXT:    [[Y_MASK:%.*]] = and i8 [[Y:%.*]], 96
 189 ; CHECK-NEXT:    [[L:%.*]] = add i8 [[Y_MASK]], [[B1]]
 190 ; CHECK-NEXT:    ret i8 [[L]]
 191 ;
 192   %x = srem i8 %a, 42 ; thwart complexity-based canonicalization
 193   %r = lshr i8 %y, 3
 194   %m = and i8 %r, 12
 195   %b = add i8 %x, %m
 196   %l = shl i8 %b, 3
 197   ret i8 %l
 198 }
 199
 200 define <2 x i8> @lshr_and_add_commute_splat(<2 x i8> %a, <2 x i8> %y)  {
 201 ; CHECK-LABEL: @lshr_and_add_commute_splat(
 202 ; CHECK-NEXT:    [[X:%.*]] = srem <2 x i8> [[A:%.*]], <i8 42, i8 42>
 203 ; CHECK-NEXT:    [[B1:%.*]] = shl <2 x i8> [[X]], <i8 3, i8 3>
 204 ; CHECK-NEXT:    [[Y_MASK:%.*]] = and <2 x i8> [[Y:%.*]], <i8 96, i8 96>
 205 ; CHECK-NEXT:    [[L:%.*]] = add <2 x i8> [[Y_MASK]], [[B1]]
 206 ; CHECK-NEXT:    ret <2 x i8> [[L]]
 207 ;
 208   %x = srem <2 x i8> %a, <i8 42, i8 42> ; thwart complexity-based canonicalization
 209   %r = lshr <2 x i8> %y, <i8 3, i8 3>
 210   %m = and <2 x i8> %r, <i8 12, i8 12>
 211   %b = add <2 x i8> %m, %x
 212   %l = shl <2 x i8> %b, <i8 3, i8 3>
 213   ret <2 x i8> %l
 214 }
 215
 216 define i8 @lshr_and_sub(i8 %a, i8 %y)  {
 217 ; CHECK-LABEL: @lshr_and_sub(
 218 ; CHECK-NEXT:    [[X:%.*]] = srem i8 [[A:%.*]], 42
 219 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[Y:%.*]], 2
 220 ; CHECK-NEXT:    [[M:%.*]] = and i8 [[R]], 13
 221 ; CHECK-NEXT:    [[B:%.*]] = sub nsw i8 [[X]], [[M]]
 222 ; CHECK-NEXT:    [[L:%.*]] = shl i8 [[B]], 2
 223 ; CHECK-NEXT:    ret i8 [[L]]
 224 ;
 225   %x = srem i8 %a, 42 ; thwart complexity-based canonicalization
 226   %r = lshr i8 %y, 2
 227   %m = and i8 %r, 13
 228   %b = sub i8 %x, %m
 229   %l = shl i8 %b, 2
 230   ret i8 %l
 231 }
 232
 233 define <2 x i8> @lshr_and_sub_commute_splat(<2 x i8> %a, <2 x i8> %y)  {
 234 ; CHECK-LABEL: @lshr_and_sub_commute_splat(
 235 ; CHECK-NEXT:    [[X:%.*]] = srem <2 x i8> [[A:%.*]], <i8 42, i8 42>
 236 ; CHECK-NEXT:    [[B1_NEG:%.*]] = mul <2 x i8> [[X]], <i8 -4, i8 -4>
 237 ; CHECK-NEXT:    [[Y_MASK:%.*]] = and <2 x i8> [[Y:%.*]], <i8 52, i8 52>
 238 ; CHECK-NEXT:    [[L:%.*]] = add <2 x i8> [[B1_NEG]], [[Y_MASK]]
 239 ; CHECK-NEXT:    ret <2 x i8> [[L]]
 240 ;
 241   %x = srem <2 x i8> %a, <i8 42, i8 42> ; thwart complexity-based canonicalization
 242   %r = lshr <2 x i8> %y, <i8 2, i8 2>
 243   %m = and <2 x i8> %r, <i8 13, i8 13>
 244   %b = sub <2 x i8> %m, %x
 245   %l = shl <2 x i8> %b, <i8 2, i8 2>
 246   ret <2 x i8> %l
 247 }
 248
 249 define i8 @lshr_and_and(i8 %a, i8 %y)  {
 250 ; CHECK-LABEL: @lshr_and_and(
 251 ; CHECK-NEXT:    [[X:%.*]] = srem i8 [[A:%.*]], 42
 252 ; CHECK-NEXT:    [[B1:%.*]] = shl i8 [[X]], 2
 253 ; CHECK-NEXT:    [[Y_MASK:%.*]] = and i8 [[Y:%.*]], 52
 254 ; CHECK-NEXT:    [[L:%.*]] = and i8 [[Y_MASK]], [[B1]]
 255 ; CHECK-NEXT:    ret i8 [[L]]
 256 ;
 257   %x = srem i8 %a, 42 ; thwart complexity-based canonicalization
 258   %r = lshr i8 %y, 2
 259   %m = and i8 %r, 13
 260   %b = and i8 %m, %x
 261   %l = shl i8 %b, 2
 262   ret i8 %l
 263 }
 264
 265 define <2 x i8> @lshr_and_and_commute_splat(<2 x i8> %a, <2 x i8> %y)  {
 266 ; CHECK-LABEL: @lshr_and_and_commute_splat(
 267 ; CHECK-NEXT:    [[X:%.*]] = srem <2 x i8> [[A:%.*]], <i8 42, i8 42>
 268 ; CHECK-NEXT:    [[B1:%.*]] = shl <2 x i8> [[X]], <i8 2, i8 2>
 269 ; CHECK-NEXT:    [[Y_MASK:%.*]] = and <2 x i8> [[Y:%.*]], <i8 52, i8 52>
 270 ; CHECK-NEXT:    [[L:%.*]] = and <2 x i8> [[Y_MASK]], [[B1]]
 271 ; CHECK-NEXT:    ret <2 x i8> [[L]]
 272 ;
 273   %x = srem <2 x i8> %a, <i8 42, i8 42> ; thwart complexity-based canonicalization
 274   %r = lshr <2 x i8> %y, <i8 2, i8 2>
 275   %m = and <2 x i8> %r, <i8 13, i8 13>
 276   %b = and <2 x i8> %x, %m
 277   %l = shl <2 x i8> %b, <i8 2, i8 2>
 278   ret <2 x i8> %l
 279 }
 280
 281 define i8 @lshr_and_or(i8 %a, i8 %y)  {
 282 ; CHECK-LABEL: @lshr_and_or(
 283 ; CHECK-NEXT:    [[X:%.*]] = srem i8 [[A:%.*]], 42
 284 ; CHECK-NEXT:    [[B1:%.*]] = shl i8 [[X]], 2
 285 ; CHECK-NEXT:    [[Y_MASK:%.*]] = and i8 [[Y:%.*]], 52
 286 ; CHECK-NEXT:    [[L:%.*]] = or i8 [[Y_MASK]], [[B1]]
 287 ; CHECK-NEXT:    ret i8 [[L]]
 288 ;
 289   %x = srem i8 %a, 42 ; thwart complexity-based canonicalization
 290   %r = lshr i8 %y, 2
 291   %m = and i8 %r, 13
 292   %b = or i8 %x, %m
 293   %l = shl i8 %b, 2
 294   ret i8 %l
 295 }
 296
 297 define <2 x i8> @lshr_and_or_commute_splat(<2 x i8> %a, <2 x i8> %y)  {
 298 ; CHECK-LABEL: @lshr_and_or_commute_splat(
 299 ; CHECK-NEXT:    [[X:%.*]] = srem <2 x i8> [[A:%.*]], <i8 42, i8 42>
 300 ; CHECK-NEXT:    [[B1:%.*]] = shl <2 x i8> [[X]], <i8 2, i8 2>
 301 ; CHECK-NEXT:    [[Y_MASK:%.*]] = and <2 x i8> [[Y:%.*]], <i8 52, i8 52>
 302 ; CHECK-NEXT:    [[L:%.*]] = or <2 x i8> [[Y_MASK]], [[B1]]
 303 ; CHECK-NEXT:    ret <2 x i8> [[L]]
 304 ;
 305   %x = srem <2 x i8> %a, <i8 42, i8 42> ; thwart complexity-based canonicalization
 306   %r = lshr <2 x i8> %y, <i8 2, i8 2>
 307   %m = and <2 x i8> %r, <i8 13, i8 13>
 308   %b = or <2 x i8> %m, %x
 309   %l = shl <2 x i8> %b, <i8 2, i8 2>
 310   ret <2 x i8> %l
 311 }
 312
 313 define i8 @lshr_and_xor(i8 %a, i8 %y)  {
 314 ; CHECK-LABEL: @lshr_and_xor(
 315 ; CHECK-NEXT:    [[X:%.*]] = srem i8 [[A:%.*]], 42
 316 ; CHECK-NEXT:    [[B1:%.*]] = shl i8 [[X]], 2
 317 ; CHECK-NEXT:    [[Y_MASK:%.*]] = and i8 [[Y:%.*]], 52
 318 ; CHECK-NEXT:    [[L:%.*]] = xor i8 [[Y_MASK]], [[B1]]
 319 ; CHECK-NEXT:    ret i8 [[L]]
 320 ;
 321   %x = srem i8 %a, 42 ; thwart complexity-based canonicalization
 322   %r = lshr i8 %y, 2
 323   %m = and i8 %r, 13
 324   %b = xor i8 %m, %x
 325   %l = shl i8 %b, 2
 326   ret i8 %l
 327 }
 328
 329 define <2 x i8> @lshr_and_xor_commute_splat(<2 x i8> %a, <2 x i8> %y)  {
 330 ; CHECK-LABEL: @lshr_and_xor_commute_splat(
 331 ; CHECK-NEXT:    [[X:%.*]] = srem <2 x i8> [[A:%.*]], <i8 42, i8 42>
 332 ; CHECK-NEXT:    [[B1:%.*]] = shl <2 x i8> [[X]], <i8 2, i8 2>
 333 ; CHECK-NEXT:    [[Y_MASK:%.*]] = and <2 x i8> [[Y:%.*]], <i8 52, i8 52>
 334 ; CHECK-NEXT:    [[L:%.*]] = xor <2 x i8> [[Y_MASK]], [[B1]]
 335 ; CHECK-NEXT:    ret <2 x i8> [[L]]
 336 ;
 337   %x = srem <2 x i8> %a, <i8 42, i8 42> ; thwart complexity-based canonicalization
 338   %r = lshr <2 x i8> %y, <i8 2, i8 2>
 339   %m = and <2 x i8> %r, <i8 13, i8 13>
 340   %b = xor <2 x i8> %x, %m
 341   %l = shl <2 x i8> %b, <i8 2, i8 2>
 342   ret <2 x i8> %l
 343 }
 344
 345 define i8 @lshr_and_add_use1(i8 %x, i8 %y)  {
 346 ; CHECK-LABEL: @lshr_and_add_use1(
 347 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[Y:%.*]], 3
 348 ; CHECK-NEXT:    call void @use(i8 [[R]])
 349 ; CHECK-NEXT:    [[M:%.*]] = and i8 [[R]], 12
 350 ; CHECK-NEXT:    [[B:%.*]] = add i8 [[M]], [[X:%.*]]
 351 ; CHECK-NEXT:    [[L:%.*]] = shl i8 [[B]], 3
 352 ; CHECK-NEXT:    ret i8 [[L]]
 353 ;
 354   %r = lshr i8 %y, 3
 355   call void @use(i8 %r)
 356   %m = and i8 %r, 12
 357   %b = add i8 %x, %m
 358   %l = shl i8 %b, 3
 359   ret i8 %l
 360 }
 361
 362 define i8 @lshr_and_add_use2(i8 %x, i8 %y)  {
 363 ; CHECK-LABEL: @lshr_and_add_use2(
 364 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[Y:%.*]], 3
 365 ; CHECK-NEXT:    [[M:%.*]] = and i8 [[R]], 12
 366 ; CHECK-NEXT:    call void @use(i8 [[M]])
 367 ; CHECK-NEXT:    [[B:%.*]] = add i8 [[M]], [[X:%.*]]
 368 ; CHECK-NEXT:    [[L:%.*]] = shl i8 [[B]], 3
 369 ; CHECK-NEXT:    ret i8 [[L]]
 370 ;
 371   %r = lshr i8 %y, 3
 372   %m = and i8 %r, 12
 373   call void @use(i8 %m)
 374   %b = add i8 %x, %m
 375   %l = shl i8 %b, 3
 376   ret i8 %l
 377 }
 378
 379 define i8 @lshr_and_add_use3(i8 %x, i8 %y)  {
 380 ; CHECK-LABEL: @lshr_and_add_use3(
 381 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[Y:%.*]], 3
 382 ; CHECK-NEXT:    [[M:%.*]] = and i8 [[R]], 12
 383 ; CHECK-NEXT:    [[B:%.*]] = add i8 [[M]], [[X:%.*]]
 384 ; CHECK-NEXT:    call void @use(i8 [[B]])
 385 ; CHECK-NEXT:    [[L:%.*]] = shl i8 [[B]], 3
 386 ; CHECK-NEXT:    ret i8 [[L]]
 387 ;
 388   %r = lshr i8 %y, 3
 389   %m = and i8 %r, 12
 390   %b = add i8 %x, %m
 391   call void @use(i8 %b)
 392   %l = shl i8 %b, 3
 393   ret i8 %l
 394 }
 395
 396 define i8 @lshr_and_add_use4(i8 %x, i8 %y)  {
 397 ; CHECK-LABEL: @lshr_and_add_use4(
 398 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[Y:%.*]], 3
 399 ; CHECK-NEXT:    call void @use(i8 [[R]])
 400 ; CHECK-NEXT:    [[M:%.*]] = and i8 [[R]], 12
 401 ; CHECK-NEXT:    call void @use(i8 [[M]])
 402 ; CHECK-NEXT:    [[B:%.*]] = add i8 [[M]], [[X:%.*]]
 403 ; CHECK-NEXT:    [[L:%.*]] = shl i8 [[B]], 3
 404 ; CHECK-NEXT:    ret i8 [[L]]
 405 ;
 406   %r = lshr i8 %y, 3
 407   call void @use(i8 %r)
 408   %m = and i8 %r, 12
 409   call void @use(i8 %m)
 410   %b = add i8 %x, %m
 411   %l = shl i8 %b, 3
 412   ret i8 %l
 413 }
 414
 415 define i8 @lshr_and_add_use5(i8 %x, i8 %y)  {
 416 ; CHECK-LABEL: @lshr_and_add_use5(
 417 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[Y:%.*]], 3
 418 ; CHECK-NEXT:    [[M:%.*]] = and i8 [[R]], 12
 419 ; CHECK-NEXT:    call void @use(i8 [[M]])
 420 ; CHECK-NEXT:    [[B:%.*]] = add i8 [[M]], [[X:%.*]]
 421 ; CHECK-NEXT:    call void @use(i8 [[B]])
 422 ; CHECK-NEXT:    [[L:%.*]] = shl i8 [[B]], 3
 423 ; CHECK-NEXT:    ret i8 [[L]]
 424 ;
 425   %r = lshr i8 %y, 3
 426   %m = and i8 %r, 12
 427   call void @use(i8 %m)
 428   %b = add i8 %x, %m
 429   call void @use(i8 %b)
 430   %l = shl i8 %b, 3
 431   ret i8 %l
 432 }
 433
 434 define i8 @lshr_and_add_use6(i8 %x, i8 %y)  {
 435 ; CHECK-LABEL: @lshr_and_add_use6(
 436 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[Y:%.*]], 3
 437 ; CHECK-NEXT:    call void @use(i8 [[R]])
 438 ; CHECK-NEXT:    [[M:%.*]] = and i8 [[R]], 12
 439 ; CHECK-NEXT:    call void @use(i8 [[M]])
 440 ; CHECK-NEXT:    [[B:%.*]] = add i8 [[M]], [[X:%.*]]
 441 ; CHECK-NEXT:    [[L:%.*]] = shl i8 [[B]], 3
 442 ; CHECK-NEXT:    ret i8 [[L]]
 443 ;
 444   %r = lshr i8 %y, 3
 445   call void @use(i8 %r)
 446   %m = and i8 %r, 12
 447   call void @use(i8 %m)
 448   %b = add i8 %x, %m
 449   %l = shl i8 %b, 3
 450   ret i8 %l
 451 }
 452
 453 define <2 x i8> @lshr_add_shl_v2i8_undef(<2 x i8> %x, <2 x i8> %y) {
 454 ; CHECK-LABEL: @lshr_add_shl_v2i8_undef(
 455 ; CHECK-NEXT:    [[A:%.*]] = lshr <2 x i8> [[Y:%.*]], <i8 5, i8 undef>
 456 ; CHECK-NEXT:    [[B:%.*]] = add <2 x i8> [[A]], [[X:%.*]]
 457 ; CHECK-NEXT:    [[C:%.*]] = shl <2 x i8> [[B]], <i8 undef, i8 5>
 458 ; CHECK-NEXT:    ret <2 x i8> [[C]]
 459 ;
 460   %a = lshr <2 x i8> %y, <i8 5, i8 undef>
 461   %b = add <2 x i8> %a, %x
 462   %c = shl <2 x i8> %b, <i8 undef, i8 5>
 463   ret <2 x i8> %c
 464 }
 465
 466 define <2 x i8> @lshr_add_shl_v2i8_nonuniform(<2 x i8> %x, <2 x i8> %y) {
 467 ; CHECK-LABEL: @lshr_add_shl_v2i8_nonuniform(
 468 ; CHECK-NEXT:    [[A:%.*]] = lshr <2 x i8> [[Y:%.*]], <i8 5, i8 6>
 469 ; CHECK-NEXT:    [[B:%.*]] = add <2 x i8> [[A]], [[X:%.*]]
 470 ; CHECK-NEXT:    [[C:%.*]] = shl <2 x i8> [[B]], <i8 5, i8 6>
 471 ; CHECK-NEXT:    ret <2 x i8> [[C]]
 472 ;
 473   %a = lshr <2 x i8> %y, <i8 5, i8 6>
 474   %b = add <2 x i8> %a, %x
 475   %c = shl <2 x i8> %b, <i8 5, i8 6>
 476   ret <2 x i8> %c
 477 }
 478
 479 define i32 @lshr_add_and_shl(i32 %x, i32 %y)  {
 480 ; CHECK-LABEL: @lshr_add_and_shl(
 481 ; CHECK-NEXT:    [[TMP1:%.*]] = shl i32 [[Y:%.*]], 5
 482 ; CHECK-NEXT:    [[X_MASK:%.*]] = and i32 [[X:%.*]], 4064
 483 ; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[X_MASK]], [[TMP1]]
 484 ; CHECK-NEXT:    ret i32 [[TMP2]]
 485 ;
 486   %1 = lshr i32 %x, 5
 487   %2 = and i32 %1, 127
 488   %3 = add i32 %y, %2
 489   %4 = shl i32 %3, 5
 490   ret i32 %4
 491 }
 492
 493 define <2 x i32> @lshr_add_and_shl_v2i32(<2 x i32> %x, <2 x i32> %y)  {
 494 ; CHECK-LABEL: @lshr_add_and_shl_v2i32(
 495 ; CHECK-NEXT:    [[TMP1:%.*]] = shl <2 x i32> [[Y:%.*]], <i32 5, i32 5>
 496 ; CHECK-NEXT:    [[X_MASK:%.*]] = and <2 x i32> [[X:%.*]], <i32 4064, i32 4064>
 497 ; CHECK-NEXT:    [[TMP2:%.*]] = add <2 x i32> [[X_MASK]], [[TMP1]]
 498 ; CHECK-NEXT:    ret <2 x i32> [[TMP2]]
 499 ;
 500   %1 = lshr <2 x i32> %x, <i32 5, i32 5>
 501   %2 = and <2 x i32> %1, <i32 127, i32 127>
 502   %3 = add <2 x i32> %y, %2
 503   %4 = shl <2 x i32> %3, <i32 5, i32 5>
 504   ret <2 x i32> %4
 505 }
 506
 507 define <2 x i32> @lshr_add_and_shl_v2i32_undef(<2 x i32> %x, <2 x i32> %y)  {
 508 ; CHECK-LABEL: @lshr_add_and_shl_v2i32_undef(
 509 ; CHECK-NEXT:    [[TMP1:%.*]] = lshr <2 x i32> [[X:%.*]], <i32 undef, i32 5>
 510 ; CHECK-NEXT:    [[TMP2:%.*]] = and <2 x i32> [[TMP1]], <i32 127, i32 127>
 511 ; CHECK-NEXT:    [[TMP3:%.*]] = add <2 x i32> [[TMP2]], [[Y:%.*]]
 512 ; CHECK-NEXT:    [[TMP4:%.*]] = shl <2 x i32> [[TMP3]], <i32 5, i32 undef>
 513 ; CHECK-NEXT:    ret <2 x i32> [[TMP4]]
 514 ;
 515   %1 = lshr <2 x i32> %x, <i32 undef, i32 5>
 516   %2 = and <2 x i32> %1, <i32 127, i32 127>
 517   %3 = add <2 x i32> %y, %2
 518   %4 = shl <2 x i32> %3, <i32 5, i32 undef>
 519   ret <2 x i32> %4
 520 }
 521
 522 define <2 x i32> @lshr_add_and_shl_v2i32_nonuniform(<2 x i32> %x, <2 x i32> %y)  {
 523 ; CHECK-LABEL: @lshr_add_and_shl_v2i32_nonuniform(
 524 ; CHECK-NEXT:    [[TMP1:%.*]] = lshr <2 x i32> [[X:%.*]], <i32 5, i32 6>
 525 ; CHECK-NEXT:    [[TMP2:%.*]] = and <2 x i32> [[TMP1]], <i32 127, i32 255>
 526 ; CHECK-NEXT:    [[TMP3:%.*]] = add <2 x i32> [[TMP2]], [[Y:%.*]]
 527 ; CHECK-NEXT:    [[TMP4:%.*]] = shl <2 x i32> [[TMP3]], <i32 5, i32 6>
 528 ; CHECK-NEXT:    ret <2 x i32> [[TMP4]]
 529 ;
 530   %1 = lshr <2 x i32> %x, <i32 5, i32 6>
 531   %2 = and <2 x i32> %1, <i32 127, i32 255>
 532   %3 = add <2 x i32> %y, %2
 533   %4 = shl <2 x i32> %3, <i32 5, i32 6>
 534   ret <2 x i32> %4
 535 }
 536
 537 define i32 @shl_add_and_lshr(i32 %x, i32 %y) {
 538 ; CHECK-LABEL: @shl_add_and_lshr(
 539 ; CHECK-NEXT:    [[C1:%.*]] = shl i32 [[Y:%.*]], 4
 540 ; CHECK-NEXT:    [[X_MASK:%.*]] = and i32 [[X:%.*]], 128
 541 ; CHECK-NEXT:    [[D:%.*]] = add i32 [[X_MASK]], [[C1]]
 542 ; CHECK-NEXT:    ret i32 [[D]]
 543 ;
 544   %a = lshr i32 %x, 4
 545   %b = and i32 %a, 8
 546   %c = add i32 %b, %y
 547   %d = shl i32 %c, 4
 548   ret i32 %d
 549 }
 550
 551 define <2 x i32> @shl_add_and_lshr_v2i32(<2 x i32> %x, <2 x i32> %y) {
 552 ; CHECK-LABEL: @shl_add_and_lshr_v2i32(
 553 ; CHECK-NEXT:    [[C1:%.*]] = shl <2 x i32> [[Y:%.*]], <i32 4, i32 4>
 554 ; CHECK-NEXT:    [[X_MASK:%.*]] = and <2 x i32> [[X:%.*]], <i32 128, i32 128>
 555 ; CHECK-NEXT:    [[D:%.*]] = add <2 x i32> [[X_MASK]], [[C1]]
 556 ; CHECK-NEXT:    ret <2 x i32> [[D]]
 557 ;
 558   %a = lshr <2 x i32> %x, <i32 4, i32 4>
 559   %b = and <2 x i32> %a, <i32 8, i32 8>
 560   %c = add <2 x i32> %b, %y
 561   %d = shl <2 x i32> %c, <i32 4, i32 4>
 562   ret <2 x i32> %d
 563 }
 564
 565 define <2 x i32> @shl_add_and_lshr_v2i32_undef(<2 x i32> %x, <2 x i32> %y) {
 566 ; CHECK-LABEL: @shl_add_and_lshr_v2i32_undef(
 567 ; CHECK-NEXT:    [[A:%.*]] = lshr <2 x i32> [[X:%.*]], <i32 4, i32 undef>
 568 ; CHECK-NEXT:    [[B:%.*]] = and <2 x i32> [[A]], <i32 8, i32 undef>
 569 ; CHECK-NEXT:    [[C:%.*]] = add <2 x i32> [[B]], [[Y:%.*]]
 570 ; CHECK-NEXT:    [[D:%.*]] = shl <2 x i32> [[C]], <i32 4, i32 undef>
 571 ; CHECK-NEXT:    ret <2 x i32> [[D]]
 572 ;
 573   %a = lshr <2 x i32> %x, <i32 4, i32 undef>
 574   %b = and <2 x i32> %a, <i32 8, i32 undef>
 575   %c = add <2 x i32> %b, %y
 576   %d = shl <2 x i32> %c, <i32 4, i32 undef>
 577   ret <2 x i32> %d
 578 }
 579
 580 define <2 x i32> @shl_add_and_lshr_v2i32_nonuniform(<2 x i32> %x, <2 x i32> %y) {
 581 ; CHECK-LABEL: @shl_add_and_lshr_v2i32_nonuniform(
 582 ; CHECK-NEXT:    [[A:%.*]] = lshr <2 x i32> [[X:%.*]], <i32 4, i32 5>
 583 ; CHECK-NEXT:    [[B:%.*]] = and <2 x i32> [[A]], <i32 8, i32 9>
 584 ; CHECK-NEXT:    [[C:%.*]] = add <2 x i32> [[B]], [[Y:%.*]]
 585 ; CHECK-NEXT:    [[D:%.*]] = shl <2 x i32> [[C]], <i32 4, i32 5>
 586 ; CHECK-NEXT:    ret <2 x i32> [[D]]
 587 ;
 588   %a = lshr <2 x i32> %x, <i32 4, i32 5>
 589   %b = and <2 x i32> %a, <i32 8, i32 9>
 590   %c = add <2 x i32> %b, %y
 591   %d = shl <2 x i32> %c, <i32 4, i32 5>
 592   ret <2 x i32> %d
 593 }
 594
 595 define <4 x i32> @test_FoldShiftByConstant_CreateSHL(<4 x i32> %in) {
 596 ; CHECK-LABEL: @test_FoldShiftByConstant_CreateSHL(
 597 ; CHECK-NEXT:    [[VSHL_N:%.*]] = mul <4 x i32> [[IN:%.*]], <i32 0, i32 -32, i32 0, i32 -32>
 598 ; CHECK-NEXT:    ret <4 x i32> [[VSHL_N]]
 599 ;
 600   %mul.i = mul <4 x i32> %in, <i32 0, i32 -1, i32 0, i32 -1>
 601   %vshl_n = shl <4 x i32> %mul.i, <i32 5, i32 5, i32 5, i32 5>
 602   ret <4 x i32> %vshl_n
 603 }
 604
 605 define <8 x i16> @test_FoldShiftByConstant_CreateSHL2(<8 x i16> %in) {
 606 ; CHECK-LABEL: @test_FoldShiftByConstant_CreateSHL2(
 607 ; CHECK-NEXT:    [[VSHL_N:%.*]] = mul <8 x i16> [[IN:%.*]], <i16 0, i16 -32, i16 0, i16 -32, i16 0, i16 -32, i16 0, i16 -32>
 608 ; CHECK-NEXT:    ret <8 x i16> [[VSHL_N]]
 609 ;
 610   %mul.i = mul <8 x i16> %in, <i16 0, i16 -1, i16 0, i16 -1, i16 0, i16 -1, i16 0, i16 -1>
 611   %vshl_n = shl <8 x i16> %mul.i, <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
 612   ret <8 x i16> %vshl_n
 613 }
 614
 615 define <16 x i8> @test_FoldShiftByConstant_CreateAnd(<16 x i8> %in0) {
 616 ; CHECK-LABEL: @test_FoldShiftByConstant_CreateAnd(
 617 ; CHECK-NEXT:    [[TMP1:%.*]] = mul <16 x i8> [[IN0:%.*]], <i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33>
 618 ; CHECK-NEXT:    [[VSHL_N:%.*]] = and <16 x i8> [[TMP1]], <i8 -32, i8 -32, i8 -32, i8 -32, i8 -32, i8 -32, i8 -32, i8 -32, i8 -32, i8 -32, i8 -32, i8 -32, i8 -32, i8 -32, i8 -32, i8 -32>
 619 ; CHECK-NEXT:    ret <16 x i8> [[VSHL_N]]
 620 ;
 621   %vsra_n = ashr <16 x i8> %in0, <i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5>
 622   %tmp = add <16 x i8> %in0, %vsra_n
 623   %vshl_n = shl <16 x i8> %tmp, <i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5>
 624   ret <16 x i8> %vshl_n
 625 }