test/CodeGen/Mips/msa/bitwise.ll

   1 ; RUN: llc -march=mips -mattr=+msa < %s | FileCheck %s
   2
   3 define void @and_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
   4   ; CHECK: and_v16i8:
   5
   6   %1 = load <16 x i8>* %a
   7   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
   8   %2 = load <16 x i8>* %b
   9   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
  10   %3 = and <16 x i8> %1, %2
  11   ; CHECK-DAG: and.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
  12   store <16 x i8> %3, <16 x i8>* %c
  13   ; CHECK-DAG: st.b [[R3]], 0($4)
  14
  15   ret void
  16   ; CHECK: .size and_v16i8
  17 }
  18
  19 define void @and_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
  20   ; CHECK: and_v8i16:
  21
  22   %1 = load <8 x i16>* %a
  23   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
  24   %2 = load <8 x i16>* %b
  25   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
  26   %3 = and <8 x i16> %1, %2
  27   ; CHECK-DAG: and.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
  28   store <8 x i16> %3, <8 x i16>* %c
  29   ; CHECK-DAG: st.h [[R3]], 0($4)
  30
  31   ret void
  32   ; CHECK: .size and_v8i16
  33 }
  34
  35 define void @and_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
  36   ; CHECK: and_v4i32:
  37
  38   %1 = load <4 x i32>* %a
  39   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
  40   %2 = load <4 x i32>* %b
  41   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
  42   %3 = and <4 x i32> %1, %2
  43   ; CHECK-DAG: and.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
  44   store <4 x i32> %3, <4 x i32>* %c
  45   ; CHECK-DAG: st.w [[R3]], 0($4)
  46
  47   ret void
  48   ; CHECK: .size and_v4i32
  49 }
  50
  51 define void @and_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
  52   ; CHECK: and_v2i64:
  53
  54   %1 = load <2 x i64>* %a
  55   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
  56   %2 = load <2 x i64>* %b
  57   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
  58   %3 = and <2 x i64> %1, %2
  59   ; CHECK-DAG: and.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
  60   store <2 x i64> %3, <2 x i64>* %c
  61   ; CHECK-DAG: st.d [[R3]], 0($4)
  62
  63   ret void
  64   ; CHECK: .size and_v2i64
  65 }
  66
  67 define void @or_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
  68   ; CHECK: or_v16i8:
  69
  70   %1 = load <16 x i8>* %a
  71   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
  72   %2 = load <16 x i8>* %b
  73   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
  74   %3 = or <16 x i8> %1, %2
  75   ; CHECK-DAG: or.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
  76   store <16 x i8> %3, <16 x i8>* %c
  77   ; CHECK-DAG: st.b [[R3]], 0($4)
  78
  79   ret void
  80   ; CHECK: .size or_v16i8
  81 }
  82
  83 define void @or_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
  84   ; CHECK: or_v8i16:
  85
  86   %1 = load <8 x i16>* %a
  87   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
  88   %2 = load <8 x i16>* %b
  89   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
  90   %3 = or <8 x i16> %1, %2
  91   ; CHECK-DAG: or.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
  92   store <8 x i16> %3, <8 x i16>* %c
  93   ; CHECK-DAG: st.h [[R3]], 0($4)
  94
  95   ret void
  96   ; CHECK: .size or_v8i16
  97 }
  98
  99 define void @or_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 100   ; CHECK: or_v4i32:
 101
 102   %1 = load <4 x i32>* %a
 103   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 104   %2 = load <4 x i32>* %b
 105   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 106   %3 = or <4 x i32> %1, %2
 107   ; CHECK-DAG: or.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 108   store <4 x i32> %3, <4 x i32>* %c
 109   ; CHECK-DAG: st.w [[R3]], 0($4)
 110
 111   ret void
 112   ; CHECK: .size or_v4i32
 113 }
 114
 115 define void @or_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 116   ; CHECK: or_v2i64:
 117
 118   %1 = load <2 x i64>* %a
 119   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 120   %2 = load <2 x i64>* %b
 121   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 122   %3 = or <2 x i64> %1, %2
 123   ; CHECK-DAG: or.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 124   store <2 x i64> %3, <2 x i64>* %c
 125   ; CHECK-DAG: st.d [[R3]], 0($4)
 126
 127   ret void
 128   ; CHECK: .size or_v2i64
 129 }
 130
 131 define void @nor_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 132   ; CHECK: nor_v16i8:
 133
 134   %1 = load <16 x i8>* %a
 135   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 136   %2 = load <16 x i8>* %b
 137   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 138   %3 = or <16 x i8> %1, %2
 139   %4 = xor <16 x i8> %3, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 140   ; CHECK-DAG: nor.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 141   store <16 x i8> %4, <16 x i8>* %c
 142   ; CHECK-DAG: st.b [[R3]], 0($4)
 143
 144   ret void
 145   ; CHECK: .size nor_v16i8
 146 }
 147
 148 define void @nor_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 149   ; CHECK: nor_v8i16:
 150
 151   %1 = load <8 x i16>* %a
 152   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 153   %2 = load <8 x i16>* %b
 154   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 155   %3 = or <8 x i16> %1, %2
 156   %4 = xor <8 x i16> %3, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
 157   ; CHECK-DAG: nor.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 158   store <8 x i16> %4, <8 x i16>* %c
 159   ; CHECK-DAG: st.h [[R3]], 0($4)
 160
 161   ret void
 162   ; CHECK: .size nor_v8i16
 163 }
 164
 165 define void @nor_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 166   ; CHECK: nor_v4i32:
 167
 168   %1 = load <4 x i32>* %a
 169   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 170   %2 = load <4 x i32>* %b
 171   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 172   %3 = or <4 x i32> %1, %2
 173   %4 = xor <4 x i32> %3, <i32 -1, i32 -1, i32 -1, i32 -1>
 174   ; CHECK-DAG: nor.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 175   store <4 x i32> %4, <4 x i32>* %c
 176   ; CHECK-DAG: st.w [[R3]], 0($4)
 177
 178   ret void
 179   ; CHECK: .size nor_v4i32
 180 }
 181
 182 define void @nor_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 183   ; CHECK: nor_v2i64:
 184
 185   %1 = load <2 x i64>* %a
 186   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 187   %2 = load <2 x i64>* %b
 188   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 189   %3 = or <2 x i64> %1, %2
 190   %4 = xor <2 x i64> %3, <i64 -1, i64 -1>
 191   ; CHECK-DAG: nor.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 192   store <2 x i64> %4, <2 x i64>* %c
 193   ; CHECK-DAG: st.d [[R3]], 0($4)
 194
 195   ret void
 196   ; CHECK: .size nor_v2i64
 197 }
 198
 199 define void @xor_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 200   ; CHECK: xor_v16i8:
 201
 202   %1 = load <16 x i8>* %a
 203   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 204   %2 = load <16 x i8>* %b
 205   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 206   %3 = xor <16 x i8> %1, %2
 207   ; CHECK-DAG: xor.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 208   store <16 x i8> %3, <16 x i8>* %c
 209   ; CHECK-DAG: st.b [[R3]], 0($4)
 210
 211   ret void
 212   ; CHECK: .size xor_v16i8
 213 }
 214
 215 define void @xor_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 216   ; CHECK: xor_v8i16:
 217
 218   %1 = load <8 x i16>* %a
 219   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 220   %2 = load <8 x i16>* %b
 221   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 222   %3 = xor <8 x i16> %1, %2
 223   ; CHECK-DAG: xor.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 224   store <8 x i16> %3, <8 x i16>* %c
 225   ; CHECK-DAG: st.h [[R3]], 0($4)
 226
 227   ret void
 228   ; CHECK: .size xor_v8i16
 229 }
 230
 231 define void @xor_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 232   ; CHECK: xor_v4i32:
 233
 234   %1 = load <4 x i32>* %a
 235   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 236   %2 = load <4 x i32>* %b
 237   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 238   %3 = xor <4 x i32> %1, %2
 239   ; CHECK-DAG: xor.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 240   store <4 x i32> %3, <4 x i32>* %c
 241   ; CHECK-DAG: st.w [[R3]], 0($4)
 242
 243   ret void
 244   ; CHECK: .size xor_v4i32
 245 }
 246
 247 define void @xor_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 248   ; CHECK: xor_v2i64:
 249
 250   %1 = load <2 x i64>* %a
 251   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 252   %2 = load <2 x i64>* %b
 253   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 254   %3 = xor <2 x i64> %1, %2
 255   ; CHECK-DAG: xor.v [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 256   store <2 x i64> %3, <2 x i64>* %c
 257   ; CHECK-DAG: st.d [[R3]], 0($4)
 258
 259   ret void
 260   ; CHECK: .size xor_v2i64
 261 }
 262
 263 define void @sll_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 264   ; CHECK: sll_v16i8:
 265
 266   %1 = load <16 x i8>* %a
 267   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 268   %2 = load <16 x i8>* %b
 269   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 270   %3 = shl <16 x i8> %1, %2
 271   ; CHECK-DAG: sll.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 272   store <16 x i8> %3, <16 x i8>* %c
 273   ; CHECK-DAG: st.b [[R3]], 0($4)
 274
 275   ret void
 276   ; CHECK: .size sll_v16i8
 277 }
 278
 279 define void @sll_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 280   ; CHECK: sll_v8i16:
 281
 282   %1 = load <8 x i16>* %a
 283   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 284   %2 = load <8 x i16>* %b
 285   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 286   %3 = shl <8 x i16> %1, %2
 287   ; CHECK-DAG: sll.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 288   store <8 x i16> %3, <8 x i16>* %c
 289   ; CHECK-DAG: st.h [[R3]], 0($4)
 290
 291   ret void
 292   ; CHECK: .size sll_v8i16
 293 }
 294
 295 define void @sll_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 296   ; CHECK: sll_v4i32:
 297
 298   %1 = load <4 x i32>* %a
 299   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 300   %2 = load <4 x i32>* %b
 301   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 302   %3 = shl <4 x i32> %1, %2
 303   ; CHECK-DAG: sll.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 304   store <4 x i32> %3, <4 x i32>* %c
 305   ; CHECK-DAG: st.w [[R3]], 0($4)
 306
 307   ret void
 308   ; CHECK: .size sll_v4i32
 309 }
 310
 311 define void @sll_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 312   ; CHECK: sll_v2i64:
 313
 314   %1 = load <2 x i64>* %a
 315   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 316   %2 = load <2 x i64>* %b
 317   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 318   %3 = shl <2 x i64> %1, %2
 319   ; CHECK-DAG: sll.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 320   store <2 x i64> %3, <2 x i64>* %c
 321   ; CHECK-DAG: st.d [[R3]], 0($4)
 322
 323   ret void
 324   ; CHECK: .size sll_v2i64
 325 }
 326
 327 define void @sra_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 328   ; CHECK: sra_v16i8:
 329
 330   %1 = load <16 x i8>* %a
 331   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 332   %2 = load <16 x i8>* %b
 333   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 334   %3 = ashr <16 x i8> %1, %2
 335   ; CHECK-DAG: sra.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 336   store <16 x i8> %3, <16 x i8>* %c
 337   ; CHECK-DAG: st.b [[R3]], 0($4)
 338
 339   ret void
 340   ; CHECK: .size sra_v16i8
 341 }
 342
 343 define void @sra_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 344   ; CHECK: sra_v8i16:
 345
 346   %1 = load <8 x i16>* %a
 347   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 348   %2 = load <8 x i16>* %b
 349   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 350   %3 = ashr <8 x i16> %1, %2
 351   ; CHECK-DAG: sra.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 352   store <8 x i16> %3, <8 x i16>* %c
 353   ; CHECK-DAG: st.h [[R3]], 0($4)
 354
 355   ret void
 356   ; CHECK: .size sra_v8i16
 357 }
 358
 359 define void @sra_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 360   ; CHECK: sra_v4i32:
 361
 362   %1 = load <4 x i32>* %a
 363   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 364   %2 = load <4 x i32>* %b
 365   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 366   %3 = ashr <4 x i32> %1, %2
 367   ; CHECK-DAG: sra.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 368   store <4 x i32> %3, <4 x i32>* %c
 369   ; CHECK-DAG: st.w [[R3]], 0($4)
 370
 371   ret void
 372   ; CHECK: .size sra_v4i32
 373 }
 374
 375 define void @sra_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 376   ; CHECK: sra_v2i64:
 377
 378   %1 = load <2 x i64>* %a
 379   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 380   %2 = load <2 x i64>* %b
 381   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 382   %3 = ashr <2 x i64> %1, %2
 383   ; CHECK-DAG: sra.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 384   store <2 x i64> %3, <2 x i64>* %c
 385   ; CHECK-DAG: st.d [[R3]], 0($4)
 386
 387   ret void
 388   ; CHECK: .size sra_v2i64
 389 }
 390
 391 define void @srl_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 392   ; CHECK: srl_v16i8:
 393
 394   %1 = load <16 x i8>* %a
 395   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 396   %2 = load <16 x i8>* %b
 397   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 398   %3 = lshr <16 x i8> %1, %2
 399   ; CHECK-DAG: srl.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 400   store <16 x i8> %3, <16 x i8>* %c
 401   ; CHECK-DAG: st.b [[R3]], 0($4)
 402
 403   ret void
 404   ; CHECK: .size srl_v16i8
 405 }
 406
 407 define void @srl_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 408   ; CHECK: srl_v8i16:
 409
 410   %1 = load <8 x i16>* %a
 411   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 412   %2 = load <8 x i16>* %b
 413   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 414   %3 = lshr <8 x i16> %1, %2
 415   ; CHECK-DAG: srl.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 416   store <8 x i16> %3, <8 x i16>* %c
 417   ; CHECK-DAG: st.h [[R3]], 0($4)
 418
 419   ret void
 420   ; CHECK: .size srl_v8i16
 421 }
 422
 423 define void @srl_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 424   ; CHECK: srl_v4i32:
 425
 426   %1 = load <4 x i32>* %a
 427   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 428   %2 = load <4 x i32>* %b
 429   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 430   %3 = lshr <4 x i32> %1, %2
 431   ; CHECK-DAG: srl.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 432   store <4 x i32> %3, <4 x i32>* %c
 433   ; CHECK-DAG: st.w [[R3]], 0($4)
 434
 435   ret void
 436   ; CHECK: .size srl_v4i32
 437 }
 438
 439 define void @srl_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 440   ; CHECK: srl_v2i64:
 441
 442   %1 = load <2 x i64>* %a
 443   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 444   %2 = load <2 x i64>* %b
 445   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 446   %3 = lshr <2 x i64> %1, %2
 447   ; CHECK-DAG: srl.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 448   store <2 x i64> %3, <2 x i64>* %c
 449   ; CHECK-DAG: st.d [[R3]], 0($4)
 450
 451   ret void
 452   ; CHECK: .size srl_v2i64
 453 }
 454
 455 define void @ctpop_v16i8(<16 x i8>* %c, <16 x i8>* %a) nounwind {
 456   ; CHECK: ctpop_v16i8:
 457
 458   %1 = load <16 x i8>* %a
 459   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 460   %2 = tail call <16 x i8> @llvm.ctpop.v16i8 (<16 x i8> %1)
 461   ; CHECK-DAG: pcnt.b [[R3:\$w[0-9]+]], [[R1]]
 462   store <16 x i8> %2, <16 x i8>* %c
 463   ; CHECK-DAG: st.b [[R3]], 0($4)
 464
 465   ret void
 466   ; CHECK: .size ctpop_v16i8
 467 }
 468
 469 define void @ctpop_v8i16(<8 x i16>* %c, <8 x i16>* %a) nounwind {
 470   ; CHECK: ctpop_v8i16:
 471
 472   %1 = load <8 x i16>* %a
 473   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 474   %2 = tail call <8 x i16> @llvm.ctpop.v8i16 (<8 x i16> %1)
 475   ; CHECK-DAG: pcnt.h [[R3:\$w[0-9]+]], [[R1]]
 476   store <8 x i16> %2, <8 x i16>* %c
 477   ; CHECK-DAG: st.h [[R3]], 0($4)
 478
 479   ret void
 480   ; CHECK: .size ctpop_v8i16
 481 }
 482
 483 define void @ctpop_v4i32(<4 x i32>* %c, <4 x i32>* %a) nounwind {
 484   ; CHECK: ctpop_v4i32:
 485
 486   %1 = load <4 x i32>* %a
 487   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 488   %2 = tail call <4 x i32> @llvm.ctpop.v4i32 (<4 x i32> %1)
 489   ; CHECK-DAG: pcnt.w [[R3:\$w[0-9]+]], [[R1]]
 490   store <4 x i32> %2, <4 x i32>* %c
 491   ; CHECK-DAG: st.w [[R3]], 0($4)
 492
 493   ret void
 494   ; CHECK: .size ctpop_v4i32
 495 }
 496
 497 define void @ctpop_v2i64(<2 x i64>* %c, <2 x i64>* %a) nounwind {
 498   ; CHECK: ctpop_v2i64:
 499
 500   %1 = load <2 x i64>* %a
 501   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 502   %2 = tail call <2 x i64> @llvm.ctpop.v2i64 (<2 x i64> %1)
 503   ; CHECK-DAG: pcnt.d [[R3:\$w[0-9]+]], [[R1]]
 504   store <2 x i64> %2, <2 x i64>* %c
 505   ; CHECK-DAG: st.d [[R3]], 0($4)
 506
 507   ret void
 508   ; CHECK: .size ctpop_v2i64
 509 }
 510
 511 define void @ctlz_v16i8(<16 x i8>* %c, <16 x i8>* %a) nounwind {
 512   ; CHECK: ctlz_v16i8:
 513
 514   %1 = load <16 x i8>* %a
 515   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 516   %2 = tail call <16 x i8> @llvm.ctlz.v16i8 (<16 x i8> %1)
 517   ; CHECK-DAG: nlzc.b [[R3:\$w[0-9]+]], [[R1]]
 518   store <16 x i8> %2, <16 x i8>* %c
 519   ; CHECK-DAG: st.b [[R3]], 0($4)
 520
 521   ret void
 522   ; CHECK: .size ctlz_v16i8
 523 }
 524
 525 define void @ctlz_v8i16(<8 x i16>* %c, <8 x i16>* %a) nounwind {
 526   ; CHECK: ctlz_v8i16:
 527
 528   %1 = load <8 x i16>* %a
 529   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 530   %2 = tail call <8 x i16> @llvm.ctlz.v8i16 (<8 x i16> %1)
 531   ; CHECK-DAG: nlzc.h [[R3:\$w[0-9]+]], [[R1]]
 532   store <8 x i16> %2, <8 x i16>* %c
 533   ; CHECK-DAG: st.h [[R3]], 0($4)
 534
 535   ret void
 536   ; CHECK: .size ctlz_v8i16
 537 }
 538
 539 define void @ctlz_v4i32(<4 x i32>* %c, <4 x i32>* %a) nounwind {
 540   ; CHECK: ctlz_v4i32:
 541
 542   %1 = load <4 x i32>* %a
 543   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 544   %2 = tail call <4 x i32> @llvm.ctlz.v4i32 (<4 x i32> %1)
 545   ; CHECK-DAG: nlzc.w [[R3:\$w[0-9]+]], [[R1]]
 546   store <4 x i32> %2, <4 x i32>* %c
 547   ; CHECK-DAG: st.w [[R3]], 0($4)
 548
 549   ret void
 550   ; CHECK: .size ctlz_v4i32
 551 }
 552
 553 define void @ctlz_v2i64(<2 x i64>* %c, <2 x i64>* %a) nounwind {
 554   ; CHECK: ctlz_v2i64:
 555
 556   %1 = load <2 x i64>* %a
 557   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 558   %2 = tail call <2 x i64> @llvm.ctlz.v2i64 (<2 x i64> %1)
 559   ; CHECK-DAG: nlzc.d [[R3:\$w[0-9]+]], [[R1]]
 560   store <2 x i64> %2, <2 x i64>* %c
 561   ; CHECK-DAG: st.d [[R3]], 0($4)
 562
 563   ret void
 564   ; CHECK: .size ctlz_v2i64
 565 }
 566
 567 declare <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %val)
 568 declare <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %val)
 569 declare <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %val)
 570 declare <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %val)
 571 declare <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %val)
 572 declare <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %val)
 573 declare <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %val)
 574 declare <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %val)