test/CodeGen/Mips/msa/arithmetic.ll

   1 ; RUN: llc -march=mips -mattr=+msa,+fp64 < %s | FileCheck %s
   2
   3 define void @add_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
   4   ; CHECK: add_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 = add <16 x i8> %1, %2
  11   ; CHECK-DAG: addv.b [[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 add_v16i8
  17 }
  18
  19 define void @add_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
  20   ; CHECK: add_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 = add <8 x i16> %1, %2
  27   ; CHECK-DAG: addv.h [[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 add_v8i16
  33 }
  34
  35 define void @add_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
  36   ; CHECK: add_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 = add <4 x i32> %1, %2
  43   ; CHECK-DAG: addv.w [[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 add_v4i32
  49 }
  50
  51 define void @add_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
  52   ; CHECK: add_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 = add <2 x i64> %1, %2
  59   ; CHECK-DAG: addv.d [[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 add_v2i64
  65 }
  66
  67 define void @add_v16i8_i(<16 x i8>* %c, <16 x i8>* %a) nounwind {
  68   ; CHECK: add_v16i8_i:
  69
  70   %1 = load <16 x i8>* %a
  71   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
  72   %2 = add <16 x i8> %1, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1,
  73                           i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
  74   ; CHECK-DAG: addvi.b [[R3:\$w[0-9]+]], [[R1]], 1
  75   store <16 x i8> %2, <16 x i8>* %c
  76   ; CHECK-DAG: st.b [[R3]], 0($4)
  77
  78   ret void
  79   ; CHECK: .size add_v16i8_i
  80 }
  81
  82 define void @add_v8i16_i(<8 x i16>* %c, <8 x i16>* %a) nounwind {
  83   ; CHECK: add_v8i16_i:
  84
  85   %1 = load <8 x i16>* %a
  86   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
  87   %2 = add <8 x i16> %1, <i16 1, i16 1, i16 1, i16 1,
  88                           i16 1, i16 1, i16 1, i16 1>
  89   ; CHECK-DAG: addvi.h [[R3:\$w[0-9]+]], [[R1]], 1
  90   store <8 x i16> %2, <8 x i16>* %c
  91   ; CHECK-DAG: st.h [[R3]], 0($4)
  92
  93   ret void
  94   ; CHECK: .size add_v8i16_i
  95 }
  96
  97 define void @add_v4i32_i(<4 x i32>* %c, <4 x i32>* %a) nounwind {
  98   ; CHECK: add_v4i32_i:
  99
 100   %1 = load <4 x i32>* %a
 101   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 102   %2 = add <4 x i32> %1, <i32 1, i32 1, i32 1, i32 1>
 103   ; CHECK-DAG: addvi.w [[R3:\$w[0-9]+]], [[R1]], 1
 104   store <4 x i32> %2, <4 x i32>* %c
 105   ; CHECK-DAG: st.w [[R3]], 0($4)
 106
 107   ret void
 108   ; CHECK: .size add_v4i32_i
 109 }
 110
 111 define void @add_v2i64_i(<2 x i64>* %c, <2 x i64>* %a) nounwind {
 112   ; CHECK: add_v2i64_i:
 113
 114   %1 = load <2 x i64>* %a
 115   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 116   %2 = add <2 x i64> %1, <i64 1, i64 1>
 117   ; CHECK-DAG: addvi.d [[R3:\$w[0-9]+]], [[R1]], 1
 118   store <2 x i64> %2, <2 x i64>* %c
 119   ; CHECK-DAG: st.d [[R3]], 0($4)
 120
 121   ret void
 122   ; CHECK: .size add_v2i64_i
 123 }
 124
 125 define void @sub_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 126   ; CHECK: sub_v16i8:
 127
 128   %1 = load <16 x i8>* %a
 129   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 130   %2 = load <16 x i8>* %b
 131   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 132   %3 = sub <16 x i8> %1, %2
 133   ; CHECK-DAG: subv.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 134   store <16 x i8> %3, <16 x i8>* %c
 135   ; CHECK-DAG: st.b [[R3]], 0($4)
 136
 137   ret void
 138   ; CHECK: .size sub_v16i8
 139 }
 140
 141 define void @sub_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 142   ; CHECK: sub_v8i16:
 143
 144   %1 = load <8 x i16>* %a
 145   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 146   %2 = load <8 x i16>* %b
 147   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 148   %3 = sub <8 x i16> %1, %2
 149   ; CHECK-DAG: subv.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 150   store <8 x i16> %3, <8 x i16>* %c
 151   ; CHECK-DAG: st.h [[R3]], 0($4)
 152
 153   ret void
 154   ; CHECK: .size sub_v8i16
 155 }
 156
 157 define void @sub_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 158   ; CHECK: sub_v4i32:
 159
 160   %1 = load <4 x i32>* %a
 161   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 162   %2 = load <4 x i32>* %b
 163   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 164   %3 = sub <4 x i32> %1, %2
 165   ; CHECK-DAG: subv.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 166   store <4 x i32> %3, <4 x i32>* %c
 167   ; CHECK-DAG: st.w [[R3]], 0($4)
 168
 169   ret void
 170   ; CHECK: .size sub_v4i32
 171 }
 172
 173 define void @sub_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 174   ; CHECK: sub_v2i64:
 175
 176   %1 = load <2 x i64>* %a
 177   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 178   %2 = load <2 x i64>* %b
 179   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 180   %3 = sub <2 x i64> %1, %2
 181   ; CHECK-DAG: subv.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 182   store <2 x i64> %3, <2 x i64>* %c
 183   ; CHECK-DAG: st.d [[R3]], 0($4)
 184
 185   ret void
 186   ; CHECK: .size sub_v2i64
 187 }
 188
 189 define void @sub_v16i8_i(<16 x i8>* %c, <16 x i8>* %a) nounwind {
 190   ; CHECK: sub_v16i8_i:
 191
 192   %1 = load <16 x i8>* %a
 193   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 194   %2 = sub <16 x i8> %1, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1,
 195                           i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
 196   ; CHECK-DAG: subvi.b [[R3:\$w[0-9]+]], [[R1]], 1
 197   store <16 x i8> %2, <16 x i8>* %c
 198   ; CHECK-DAG: st.b [[R3]], 0($4)
 199
 200   ret void
 201   ; CHECK: .size sub_v16i8_i
 202 }
 203
 204 define void @sub_v8i16_i(<8 x i16>* %c, <8 x i16>* %a) nounwind {
 205   ; CHECK: sub_v8i16_i:
 206
 207   %1 = load <8 x i16>* %a
 208   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 209   %2 = sub <8 x i16> %1, <i16 1, i16 1, i16 1, i16 1,
 210                           i16 1, i16 1, i16 1, i16 1>
 211   ; CHECK-DAG: subvi.h [[R3:\$w[0-9]+]], [[R1]], 1
 212   store <8 x i16> %2, <8 x i16>* %c
 213   ; CHECK-DAG: st.h [[R3]], 0($4)
 214
 215   ret void
 216   ; CHECK: .size sub_v8i16_i
 217 }
 218
 219 define void @sub_v4i32_i(<4 x i32>* %c, <4 x i32>* %a) nounwind {
 220   ; CHECK: sub_v4i32_i:
 221
 222   %1 = load <4 x i32>* %a
 223   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 224   %2 = sub <4 x i32> %1, <i32 1, i32 1, i32 1, i32 1>
 225   ; CHECK-DAG: subvi.w [[R3:\$w[0-9]+]], [[R1]], 1
 226   store <4 x i32> %2, <4 x i32>* %c
 227   ; CHECK-DAG: st.w [[R3]], 0($4)
 228
 229   ret void
 230   ; CHECK: .size sub_v4i32_i
 231 }
 232
 233 define void @sub_v2i64_i(<2 x i64>* %c, <2 x i64>* %a) nounwind {
 234   ; CHECK: sub_v2i64_i:
 235
 236   %1 = load <2 x i64>* %a
 237   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 238   %2 = sub <2 x i64> %1, <i64 1, i64 1>
 239   ; CHECK-DAG: subvi.d [[R3:\$w[0-9]+]], [[R1]], 1
 240   store <2 x i64> %2, <2 x i64>* %c
 241   ; CHECK-DAG: st.d [[R3]], 0($4)
 242
 243   ret void
 244   ; CHECK: .size sub_v2i64_i
 245 }
 246
 247 define void @mul_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 248   ; CHECK: mul_v16i8:
 249
 250   %1 = load <16 x i8>* %a
 251   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 252   %2 = load <16 x i8>* %b
 253   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 254   %3 = mul <16 x i8> %1, %2
 255   ; CHECK-DAG: mulv.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 256   store <16 x i8> %3, <16 x i8>* %c
 257   ; CHECK-DAG: st.b [[R3]], 0($4)
 258
 259   ret void
 260   ; CHECK: .size mul_v16i8
 261 }
 262
 263 define void @mul_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 264   ; CHECK: mul_v8i16:
 265
 266   %1 = load <8 x i16>* %a
 267   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 268   %2 = load <8 x i16>* %b
 269   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 270   %3 = mul <8 x i16> %1, %2
 271   ; CHECK-DAG: mulv.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 272   store <8 x i16> %3, <8 x i16>* %c
 273   ; CHECK-DAG: st.h [[R3]], 0($4)
 274
 275   ret void
 276   ; CHECK: .size mul_v8i16
 277 }
 278
 279 define void @mul_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 280   ; CHECK: mul_v4i32:
 281
 282   %1 = load <4 x i32>* %a
 283   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 284   %2 = load <4 x i32>* %b
 285   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 286   %3 = mul <4 x i32> %1, %2
 287   ; CHECK-DAG: mulv.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 288   store <4 x i32> %3, <4 x i32>* %c
 289   ; CHECK-DAG: st.w [[R3]], 0($4)
 290
 291   ret void
 292   ; CHECK: .size mul_v4i32
 293 }
 294
 295 define void @mul_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 296   ; CHECK: mul_v2i64:
 297
 298   %1 = load <2 x i64>* %a
 299   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 300   %2 = load <2 x i64>* %b
 301   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 302   %3 = mul <2 x i64> %1, %2
 303   ; CHECK-DAG: mulv.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 304   store <2 x i64> %3, <2 x i64>* %c
 305   ; CHECK-DAG: st.d [[R3]], 0($4)
 306
 307   ret void
 308   ; CHECK: .size mul_v2i64
 309 }
 310
 311 define void @div_s_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 312   ; CHECK: div_s_v16i8:
 313
 314   %1 = load <16 x i8>* %a
 315   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 316   %2 = load <16 x i8>* %b
 317   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 318   %3 = sdiv <16 x i8> %1, %2
 319   ; CHECK-DAG: div_s.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 320   store <16 x i8> %3, <16 x i8>* %c
 321   ; CHECK-DAG: st.b [[R3]], 0($4)
 322
 323   ret void
 324   ; CHECK: .size div_s_v16i8
 325 }
 326
 327 define void @div_s_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 328   ; CHECK: div_s_v8i16:
 329
 330   %1 = load <8 x i16>* %a
 331   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 332   %2 = load <8 x i16>* %b
 333   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 334   %3 = sdiv <8 x i16> %1, %2
 335   ; CHECK-DAG: div_s.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 336   store <8 x i16> %3, <8 x i16>* %c
 337   ; CHECK-DAG: st.h [[R3]], 0($4)
 338
 339   ret void
 340   ; CHECK: .size div_s_v8i16
 341 }
 342
 343 define void @div_s_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 344   ; CHECK: div_s_v4i32:
 345
 346   %1 = load <4 x i32>* %a
 347   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 348   %2 = load <4 x i32>* %b
 349   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 350   %3 = sdiv <4 x i32> %1, %2
 351   ; CHECK-DAG: div_s.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 352   store <4 x i32> %3, <4 x i32>* %c
 353   ; CHECK-DAG: st.w [[R3]], 0($4)
 354
 355   ret void
 356   ; CHECK: .size div_s_v4i32
 357 }
 358
 359 define void @div_s_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 360   ; CHECK: div_s_v2i64:
 361
 362   %1 = load <2 x i64>* %a
 363   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 364   %2 = load <2 x i64>* %b
 365   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 366   %3 = sdiv <2 x i64> %1, %2
 367   ; CHECK-DAG: div_s.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 368   store <2 x i64> %3, <2 x i64>* %c
 369   ; CHECK-DAG: st.d [[R3]], 0($4)
 370
 371   ret void
 372   ; CHECK: .size div_s_v2i64
 373 }
 374
 375 define void @div_u_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 376   ; CHECK: div_u_v16i8:
 377
 378   %1 = load <16 x i8>* %a
 379   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 380   %2 = load <16 x i8>* %b
 381   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 382   %3 = udiv <16 x i8> %1, %2
 383   ; CHECK-DAG: div_u.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 384   store <16 x i8> %3, <16 x i8>* %c
 385   ; CHECK-DAG: st.b [[R3]], 0($4)
 386
 387   ret void
 388   ; CHECK: .size div_u_v16i8
 389 }
 390
 391 define void @div_u_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 392   ; CHECK: div_u_v8i16:
 393
 394   %1 = load <8 x i16>* %a
 395   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 396   %2 = load <8 x i16>* %b
 397   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 398   %3 = udiv <8 x i16> %1, %2
 399   ; CHECK-DAG: div_u.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 400   store <8 x i16> %3, <8 x i16>* %c
 401   ; CHECK-DAG: st.h [[R3]], 0($4)
 402
 403   ret void
 404   ; CHECK: .size div_u_v8i16
 405 }
 406
 407 define void @div_u_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 408   ; CHECK: div_u_v4i32:
 409
 410   %1 = load <4 x i32>* %a
 411   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 412   %2 = load <4 x i32>* %b
 413   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 414   %3 = udiv <4 x i32> %1, %2
 415   ; CHECK-DAG: div_u.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 416   store <4 x i32> %3, <4 x i32>* %c
 417   ; CHECK-DAG: st.w [[R3]], 0($4)
 418
 419   ret void
 420   ; CHECK: .size div_u_v4i32
 421 }
 422
 423 define void @div_u_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 424   ; CHECK: div_u_v2i64:
 425
 426   %1 = load <2 x i64>* %a
 427   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 428   %2 = load <2 x i64>* %b
 429   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 430   %3 = udiv <2 x i64> %1, %2
 431   ; CHECK-DAG: div_u.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 432   store <2 x i64> %3, <2 x i64>* %c
 433   ; CHECK-DAG: st.d [[R3]], 0($4)
 434
 435   ret void
 436   ; CHECK: .size div_u_v2i64
 437 }
 438
 439 define void @mod_s_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 440   ; CHECK: mod_s_v16i8:
 441
 442   %1 = load <16 x i8>* %a
 443   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 444   %2 = load <16 x i8>* %b
 445   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 446   %3 = srem <16 x i8> %1, %2
 447   ; CHECK-DAG: mod_s.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 448   store <16 x i8> %3, <16 x i8>* %c
 449   ; CHECK-DAG: st.b [[R3]], 0($4)
 450
 451   ret void
 452   ; CHECK: .size mod_s_v16i8
 453 }
 454
 455 define void @mod_s_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 456   ; CHECK: mod_s_v8i16:
 457
 458   %1 = load <8 x i16>* %a
 459   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 460   %2 = load <8 x i16>* %b
 461   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 462   %3 = srem <8 x i16> %1, %2
 463   ; CHECK-DAG: mod_s.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 464   store <8 x i16> %3, <8 x i16>* %c
 465   ; CHECK-DAG: st.h [[R3]], 0($4)
 466
 467   ret void
 468   ; CHECK: .size mod_s_v8i16
 469 }
 470
 471 define void @mod_s_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 472   ; CHECK: mod_s_v4i32:
 473
 474   %1 = load <4 x i32>* %a
 475   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 476   %2 = load <4 x i32>* %b
 477   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 478   %3 = srem <4 x i32> %1, %2
 479   ; CHECK-DAG: mod_s.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 480   store <4 x i32> %3, <4 x i32>* %c
 481   ; CHECK-DAG: st.w [[R3]], 0($4)
 482
 483   ret void
 484   ; CHECK: .size mod_s_v4i32
 485 }
 486
 487 define void @mod_s_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 488   ; CHECK: mod_s_v2i64:
 489
 490   %1 = load <2 x i64>* %a
 491   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 492   %2 = load <2 x i64>* %b
 493   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 494   %3 = srem <2 x i64> %1, %2
 495   ; CHECK-DAG: mod_s.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 496   store <2 x i64> %3, <2 x i64>* %c
 497   ; CHECK-DAG: st.d [[R3]], 0($4)
 498
 499   ret void
 500   ; CHECK: .size mod_s_v2i64
 501 }
 502
 503 define void @mod_u_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 504   ; CHECK: mod_u_v16i8:
 505
 506   %1 = load <16 x i8>* %a
 507   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 508   %2 = load <16 x i8>* %b
 509   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 510   %3 = urem <16 x i8> %1, %2
 511   ; CHECK-DAG: mod_u.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 512   store <16 x i8> %3, <16 x i8>* %c
 513   ; CHECK-DAG: st.b [[R3]], 0($4)
 514
 515   ret void
 516   ; CHECK: .size mod_u_v16i8
 517 }
 518
 519 define void @mod_u_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 520   ; CHECK: mod_u_v8i16:
 521
 522   %1 = load <8 x i16>* %a
 523   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 524   %2 = load <8 x i16>* %b
 525   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 526   %3 = urem <8 x i16> %1, %2
 527   ; CHECK-DAG: mod_u.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 528   store <8 x i16> %3, <8 x i16>* %c
 529   ; CHECK-DAG: st.h [[R3]], 0($4)
 530
 531   ret void
 532   ; CHECK: .size mod_u_v8i16
 533 }
 534
 535 define void @mod_u_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 536   ; CHECK: mod_u_v4i32:
 537
 538   %1 = load <4 x i32>* %a
 539   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 540   %2 = load <4 x i32>* %b
 541   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 542   %3 = urem <4 x i32> %1, %2
 543   ; CHECK-DAG: mod_u.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 544   store <4 x i32> %3, <4 x i32>* %c
 545   ; CHECK-DAG: st.w [[R3]], 0($4)
 546
 547   ret void
 548   ; CHECK: .size mod_u_v4i32
 549 }
 550
 551 define void @mod_u_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 552   ; CHECK: mod_u_v2i64:
 553
 554   %1 = load <2 x i64>* %a
 555   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 556   %2 = load <2 x i64>* %b
 557   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 558   %3 = urem <2 x i64> %1, %2
 559   ; CHECK-DAG: mod_u.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 560   store <2 x i64> %3, <2 x i64>* %c
 561   ; CHECK-DAG: st.d [[R3]], 0($4)
 562
 563   ret void
 564   ; CHECK: .size mod_u_v2i64
 565 }