test/CodeGen/Mips/msa/3r-a.ll

   1 ; Test the MSA intrinsics that are encoded with the 3R instruction format.
   2 ; There are lots of these so this covers those beginning with 'a'
   3
   4 ; RUN: llc -march=mips -mattr=+msa,+fp64 < %s | FileCheck %s
   5
   6 ; It should fail to compile without fp64.
   7 ; RUN: not llc -march=mips -mattr=+msa < %s 2>&1 | \
   8 ; RUN:    FileCheck -check-prefix=FP32ERROR %s
   9 ; FP32ERROR: LLVM ERROR: MSA requires a 64-bit FPU register file (FR=1 mode).
  10
  11 @llvm_mips_add_a_b_ARG1 = global <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, align 16
  12 @llvm_mips_add_a_b_ARG2 = global <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, align 16
  13 @llvm_mips_add_a_b_RES  = global <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, align 16
  14
  15 define void @llvm_mips_add_a_b_test() nounwind {
  16 entry:
  17   %0 = load <16 x i8>* @llvm_mips_add_a_b_ARG1
  18   %1 = load <16 x i8>* @llvm_mips_add_a_b_ARG2
  19   %2 = tail call <16 x i8> @llvm.mips.add.a.b(<16 x i8> %0, <16 x i8> %1)
  20   store <16 x i8> %2, <16 x i8>* @llvm_mips_add_a_b_RES
  21   ret void
  22 }
  23
  24 declare <16 x i8> @llvm.mips.add.a.b(<16 x i8>, <16 x i8>) nounwind
  25
  26 ; CHECK: llvm_mips_add_a_b_test:
  27 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_add_a_b_ARG1)
  28 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_add_a_b_ARG2)
  29 ; CHECK-DAG: ld.b [[WS:\$w[0-9]+]], 0([[R1]])
  30 ; CHECK-DAG: ld.b [[WT:\$w[0-9]+]], 0([[R2]])
  31 ; CHECK-DAG: add_a.b [[WD:\$w[0-9]+]], [[WS]], [[WT]]
  32 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_add_a_b_RES)
  33 ; CHECK-DAG: st.b [[WD]], 0([[R3]])
  34 ; CHECK: .size llvm_mips_add_a_b_test
  35 ;
  36 @llvm_mips_add_a_h_ARG1 = global <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>, align 16
  37 @llvm_mips_add_a_h_ARG2 = global <8 x i16> <i16 8, i16 9, i16 10, i16 11, i16 12, i16 13, i16 14, i16 15>, align 16
  38 @llvm_mips_add_a_h_RES  = global <8 x i16> <i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>, align 16
  39
  40 define void @llvm_mips_add_a_h_test() nounwind {
  41 entry:
  42   %0 = load <8 x i16>* @llvm_mips_add_a_h_ARG1
  43   %1 = load <8 x i16>* @llvm_mips_add_a_h_ARG2
  44   %2 = tail call <8 x i16> @llvm.mips.add.a.h(<8 x i16> %0, <8 x i16> %1)
  45   store <8 x i16> %2, <8 x i16>* @llvm_mips_add_a_h_RES
  46   ret void
  47 }
  48
  49 declare <8 x i16> @llvm.mips.add.a.h(<8 x i16>, <8 x i16>) nounwind
  50
  51 ; CHECK: llvm_mips_add_a_h_test:
  52 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_add_a_h_ARG1)
  53 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_add_a_h_ARG2)
  54 ; CHECK-DAG: ld.h [[WS:\$w[0-9]+]], 0([[R1]])
  55 ; CHECK-DAG: ld.h [[WT:\$w[0-9]+]], 0([[R2]])
  56 ; CHECK-DAG: add_a.h [[WD:\$w[0-9]+]], [[WS]], [[WT]]
  57 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_add_a_h_RES)
  58 ; CHECK-DAG: st.h [[WD]], 0([[R3]])
  59 ; CHECK: .size llvm_mips_add_a_h_test
  60 ;
  61 @llvm_mips_add_a_w_ARG1 = global <4 x i32> <i32 0, i32 1, i32 2, i32 3>, align 16
  62 @llvm_mips_add_a_w_ARG2 = global <4 x i32> <i32 4, i32 5, i32 6, i32 7>, align 16
  63 @llvm_mips_add_a_w_RES  = global <4 x i32> <i32 0, i32 0, i32 0, i32 0>, align 16
  64
  65 define void @llvm_mips_add_a_w_test() nounwind {
  66 entry:
  67   %0 = load <4 x i32>* @llvm_mips_add_a_w_ARG1
  68   %1 = load <4 x i32>* @llvm_mips_add_a_w_ARG2
  69   %2 = tail call <4 x i32> @llvm.mips.add.a.w(<4 x i32> %0, <4 x i32> %1)
  70   store <4 x i32> %2, <4 x i32>* @llvm_mips_add_a_w_RES
  71   ret void
  72 }
  73
  74 declare <4 x i32> @llvm.mips.add.a.w(<4 x i32>, <4 x i32>) nounwind
  75
  76 ; CHECK: llvm_mips_add_a_w_test:
  77 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_add_a_w_ARG1)
  78 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_add_a_w_ARG2)
  79 ; CHECK-DAG: ld.w [[WS:\$w[0-9]+]], 0([[R1]])
  80 ; CHECK-DAG: ld.w [[WT:\$w[0-9]+]], 0([[R2]])
  81 ; CHECK-DAG: add_a.w [[WD:\$w[0-9]+]], [[WS]], [[WT]]
  82 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_add_a_w_RES)
  83 ; CHECK-DAG: st.w [[WD]], 0([[R3]])
  84 ; CHECK: .size llvm_mips_add_a_w_test
  85 ;
  86 @llvm_mips_add_a_d_ARG1 = global <2 x i64> <i64 0, i64 1>, align 16
  87 @llvm_mips_add_a_d_ARG2 = global <2 x i64> <i64 2, i64 3>, align 16
  88 @llvm_mips_add_a_d_RES  = global <2 x i64> <i64 0, i64 0>, align 16
  89
  90 define void @llvm_mips_add_a_d_test() nounwind {
  91 entry:
  92   %0 = load <2 x i64>* @llvm_mips_add_a_d_ARG1
  93   %1 = load <2 x i64>* @llvm_mips_add_a_d_ARG2
  94   %2 = tail call <2 x i64> @llvm.mips.add.a.d(<2 x i64> %0, <2 x i64> %1)
  95   store <2 x i64> %2, <2 x i64>* @llvm_mips_add_a_d_RES
  96   ret void
  97 }
  98
  99 declare <2 x i64> @llvm.mips.add.a.d(<2 x i64>, <2 x i64>) nounwind
 100
 101 ; CHECK: llvm_mips_add_a_d_test:
 102 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_add_a_d_ARG1)
 103 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_add_a_d_ARG2)
 104 ; CHECK-DAG: ld.d [[WS:\$w[0-9]+]], 0([[R1]])
 105 ; CHECK-DAG: ld.d [[WT:\$w[0-9]+]], 0([[R2]])
 106 ; CHECK-DAG: add_a.d [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 107 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_add_a_d_RES)
 108 ; CHECK-DAG: st.d [[WD]], 0([[R3]])
 109 ; CHECK: .size llvm_mips_add_a_d_test
 110 ;
 111 @llvm_mips_adds_a_b_ARG1 = global <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, align 16
 112 @llvm_mips_adds_a_b_ARG2 = global <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, align 16
 113 @llvm_mips_adds_a_b_RES  = global <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, align 16
 114
 115 define void @llvm_mips_adds_a_b_test() nounwind {
 116 entry:
 117   %0 = load <16 x i8>* @llvm_mips_adds_a_b_ARG1
 118   %1 = load <16 x i8>* @llvm_mips_adds_a_b_ARG2
 119   %2 = tail call <16 x i8> @llvm.mips.adds.a.b(<16 x i8> %0, <16 x i8> %1)
 120   store <16 x i8> %2, <16 x i8>* @llvm_mips_adds_a_b_RES
 121   ret void
 122 }
 123
 124 declare <16 x i8> @llvm.mips.adds.a.b(<16 x i8>, <16 x i8>) nounwind
 125
 126 ; CHECK: llvm_mips_adds_a_b_test:
 127 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_adds_a_b_ARG1)
 128 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_adds_a_b_ARG2)
 129 ; CHECK-DAG: ld.b [[WS:\$w[0-9]+]], 0([[R1]])
 130 ; CHECK-DAG: ld.b [[WT:\$w[0-9]+]], 0([[R2]])
 131 ; CHECK-DAG: adds_a.b [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 132 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_adds_a_b_RES)
 133 ; CHECK-DAG: st.b [[WD]], 0([[R3]])
 134 ; CHECK: .size llvm_mips_adds_a_b_test
 135 ;
 136 @llvm_mips_adds_a_h_ARG1 = global <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>, align 16
 137 @llvm_mips_adds_a_h_ARG2 = global <8 x i16> <i16 8, i16 9, i16 10, i16 11, i16 12, i16 13, i16 14, i16 15>, align 16
 138 @llvm_mips_adds_a_h_RES  = global <8 x i16> <i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>, align 16
 139
 140 define void @llvm_mips_adds_a_h_test() nounwind {
 141 entry:
 142   %0 = load <8 x i16>* @llvm_mips_adds_a_h_ARG1
 143   %1 = load <8 x i16>* @llvm_mips_adds_a_h_ARG2
 144   %2 = tail call <8 x i16> @llvm.mips.adds.a.h(<8 x i16> %0, <8 x i16> %1)
 145   store <8 x i16> %2, <8 x i16>* @llvm_mips_adds_a_h_RES
 146   ret void
 147 }
 148
 149 declare <8 x i16> @llvm.mips.adds.a.h(<8 x i16>, <8 x i16>) nounwind
 150
 151 ; CHECK: llvm_mips_adds_a_h_test:
 152 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_adds_a_h_ARG1)
 153 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_adds_a_h_ARG2)
 154 ; CHECK-DAG: ld.h [[WS:\$w[0-9]+]], 0([[R1]])
 155 ; CHECK-DAG: ld.h [[WT:\$w[0-9]+]], 0([[R2]])
 156 ; CHECK-DAG: adds_a.h [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 157 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_adds_a_h_RES)
 158 ; CHECK-DAG: st.h [[WD]], 0([[R3]])
 159 ; CHECK: .size llvm_mips_adds_a_h_test
 160 ;
 161 @llvm_mips_adds_a_w_ARG1 = global <4 x i32> <i32 0, i32 1, i32 2, i32 3>, align 16
 162 @llvm_mips_adds_a_w_ARG2 = global <4 x i32> <i32 4, i32 5, i32 6, i32 7>, align 16
 163 @llvm_mips_adds_a_w_RES  = global <4 x i32> <i32 0, i32 0, i32 0, i32 0>, align 16
 164
 165 define void @llvm_mips_adds_a_w_test() nounwind {
 166 entry:
 167   %0 = load <4 x i32>* @llvm_mips_adds_a_w_ARG1
 168   %1 = load <4 x i32>* @llvm_mips_adds_a_w_ARG2
 169   %2 = tail call <4 x i32> @llvm.mips.adds.a.w(<4 x i32> %0, <4 x i32> %1)
 170   store <4 x i32> %2, <4 x i32>* @llvm_mips_adds_a_w_RES
 171   ret void
 172 }
 173
 174 declare <4 x i32> @llvm.mips.adds.a.w(<4 x i32>, <4 x i32>) nounwind
 175
 176 ; CHECK: llvm_mips_adds_a_w_test:
 177 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_adds_a_w_ARG1)
 178 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_adds_a_w_ARG2)
 179 ; CHECK-DAG: ld.w [[WS:\$w[0-9]+]], 0([[R1]])
 180 ; CHECK-DAG: ld.w [[WT:\$w[0-9]+]], 0([[R2]])
 181 ; CHECK-DAG: adds_a.w [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 182 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_adds_a_w_RES)
 183 ; CHECK-DAG: st.w [[WD]], 0([[R3]])
 184 ; CHECK: .size llvm_mips_adds_a_w_test
 185 ;
 186 @llvm_mips_adds_a_d_ARG1 = global <2 x i64> <i64 0, i64 1>, align 16
 187 @llvm_mips_adds_a_d_ARG2 = global <2 x i64> <i64 2, i64 3>, align 16
 188 @llvm_mips_adds_a_d_RES  = global <2 x i64> <i64 0, i64 0>, align 16
 189
 190 define void @llvm_mips_adds_a_d_test() nounwind {
 191 entry:
 192   %0 = load <2 x i64>* @llvm_mips_adds_a_d_ARG1
 193   %1 = load <2 x i64>* @llvm_mips_adds_a_d_ARG2
 194   %2 = tail call <2 x i64> @llvm.mips.adds.a.d(<2 x i64> %0, <2 x i64> %1)
 195   store <2 x i64> %2, <2 x i64>* @llvm_mips_adds_a_d_RES
 196   ret void
 197 }
 198
 199 declare <2 x i64> @llvm.mips.adds.a.d(<2 x i64>, <2 x i64>) nounwind
 200
 201 ; CHECK: llvm_mips_adds_a_d_test:
 202 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_adds_a_d_ARG1)
 203 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_adds_a_d_ARG2)
 204 ; CHECK-DAG: ld.d [[WS:\$w[0-9]+]], 0([[R1]])
 205 ; CHECK-DAG: ld.d [[WT:\$w[0-9]+]], 0([[R2]])
 206 ; CHECK-DAG: adds_a.d [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 207 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_adds_a_d_RES)
 208 ; CHECK-DAG: st.d [[WD]], 0([[R3]])
 209 ; CHECK: .size llvm_mips_adds_a_d_test
 210 ;
 211 @llvm_mips_adds_s_b_ARG1 = global <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, align 16
 212 @llvm_mips_adds_s_b_ARG2 = global <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, align 16
 213 @llvm_mips_adds_s_b_RES  = global <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, align 16
 214
 215 define void @llvm_mips_adds_s_b_test() nounwind {
 216 entry:
 217   %0 = load <16 x i8>* @llvm_mips_adds_s_b_ARG1
 218   %1 = load <16 x i8>* @llvm_mips_adds_s_b_ARG2
 219   %2 = tail call <16 x i8> @llvm.mips.adds.s.b(<16 x i8> %0, <16 x i8> %1)
 220   store <16 x i8> %2, <16 x i8>* @llvm_mips_adds_s_b_RES
 221   ret void
 222 }
 223
 224 declare <16 x i8> @llvm.mips.adds.s.b(<16 x i8>, <16 x i8>) nounwind
 225
 226 ; CHECK: llvm_mips_adds_s_b_test:
 227 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_adds_s_b_ARG1)
 228 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_adds_s_b_ARG2)
 229 ; CHECK-DAG: ld.b [[WS:\$w[0-9]+]], 0([[R1]])
 230 ; CHECK-DAG: ld.b [[WT:\$w[0-9]+]], 0([[R2]])
 231 ; CHECK-DAG: adds_s.b [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 232 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_adds_s_b_RES)
 233 ; CHECK-DAG: st.b [[WD]], 0([[R3]])
 234 ; CHECK: .size llvm_mips_adds_s_b_test
 235 ;
 236 @llvm_mips_adds_s_h_ARG1 = global <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>, align 16
 237 @llvm_mips_adds_s_h_ARG2 = global <8 x i16> <i16 8, i16 9, i16 10, i16 11, i16 12, i16 13, i16 14, i16 15>, align 16
 238 @llvm_mips_adds_s_h_RES  = global <8 x i16> <i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>, align 16
 239
 240 define void @llvm_mips_adds_s_h_test() nounwind {
 241 entry:
 242   %0 = load <8 x i16>* @llvm_mips_adds_s_h_ARG1
 243   %1 = load <8 x i16>* @llvm_mips_adds_s_h_ARG2
 244   %2 = tail call <8 x i16> @llvm.mips.adds.s.h(<8 x i16> %0, <8 x i16> %1)
 245   store <8 x i16> %2, <8 x i16>* @llvm_mips_adds_s_h_RES
 246   ret void
 247 }
 248
 249 declare <8 x i16> @llvm.mips.adds.s.h(<8 x i16>, <8 x i16>) nounwind
 250
 251 ; CHECK: llvm_mips_adds_s_h_test:
 252 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_adds_s_h_ARG1)
 253 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_adds_s_h_ARG2)
 254 ; CHECK-DAG: ld.h [[WS:\$w[0-9]+]], 0([[R1]])
 255 ; CHECK-DAG: ld.h [[WT:\$w[0-9]+]], 0([[R2]])
 256 ; CHECK-DAG: adds_s.h [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 257 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_adds_s_h_RES)
 258 ; CHECK-DAG: st.h [[WD]], 0([[R3]])
 259 ; CHECK: .size llvm_mips_adds_s_h_test
 260 ;
 261 @llvm_mips_adds_s_w_ARG1 = global <4 x i32> <i32 0, i32 1, i32 2, i32 3>, align 16
 262 @llvm_mips_adds_s_w_ARG2 = global <4 x i32> <i32 4, i32 5, i32 6, i32 7>, align 16
 263 @llvm_mips_adds_s_w_RES  = global <4 x i32> <i32 0, i32 0, i32 0, i32 0>, align 16
 264
 265 define void @llvm_mips_adds_s_w_test() nounwind {
 266 entry:
 267   %0 = load <4 x i32>* @llvm_mips_adds_s_w_ARG1
 268   %1 = load <4 x i32>* @llvm_mips_adds_s_w_ARG2
 269   %2 = tail call <4 x i32> @llvm.mips.adds.s.w(<4 x i32> %0, <4 x i32> %1)
 270   store <4 x i32> %2, <4 x i32>* @llvm_mips_adds_s_w_RES
 271   ret void
 272 }
 273
 274 declare <4 x i32> @llvm.mips.adds.s.w(<4 x i32>, <4 x i32>) nounwind
 275
 276 ; CHECK: llvm_mips_adds_s_w_test:
 277 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_adds_s_w_ARG1)
 278 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_adds_s_w_ARG2)
 279 ; CHECK-DAG: ld.w [[WS:\$w[0-9]+]], 0([[R1]])
 280 ; CHECK-DAG: ld.w [[WT:\$w[0-9]+]], 0([[R2]])
 281 ; CHECK-DAG: adds_s.w [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 282 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_adds_s_w_RES)
 283 ; CHECK-DAG: st.w [[WD]], 0([[R3]])
 284 ; CHECK: .size llvm_mips_adds_s_w_test
 285 ;
 286 @llvm_mips_adds_s_d_ARG1 = global <2 x i64> <i64 0, i64 1>, align 16
 287 @llvm_mips_adds_s_d_ARG2 = global <2 x i64> <i64 2, i64 3>, align 16
 288 @llvm_mips_adds_s_d_RES  = global <2 x i64> <i64 0, i64 0>, align 16
 289
 290 define void @llvm_mips_adds_s_d_test() nounwind {
 291 entry:
 292   %0 = load <2 x i64>* @llvm_mips_adds_s_d_ARG1
 293   %1 = load <2 x i64>* @llvm_mips_adds_s_d_ARG2
 294   %2 = tail call <2 x i64> @llvm.mips.adds.s.d(<2 x i64> %0, <2 x i64> %1)
 295   store <2 x i64> %2, <2 x i64>* @llvm_mips_adds_s_d_RES
 296   ret void
 297 }
 298
 299 declare <2 x i64> @llvm.mips.adds.s.d(<2 x i64>, <2 x i64>) nounwind
 300
 301 ; CHECK: llvm_mips_adds_s_d_test:
 302 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_adds_s_d_ARG1)
 303 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_adds_s_d_ARG2)
 304 ; CHECK-DAG: ld.d [[WS:\$w[0-9]+]], 0([[R1]])
 305 ; CHECK-DAG: ld.d [[WT:\$w[0-9]+]], 0([[R2]])
 306 ; CHECK-DAG: adds_s.d [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 307 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_adds_s_d_RES)
 308 ; CHECK-DAG: st.d [[WD]], 0([[R3]])
 309 ; CHECK: .size llvm_mips_adds_s_d_test
 310 ;
 311 @llvm_mips_adds_u_b_ARG1 = global <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, align 16
 312 @llvm_mips_adds_u_b_ARG2 = global <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, align 16
 313 @llvm_mips_adds_u_b_RES  = global <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, align 16
 314
 315 define void @llvm_mips_adds_u_b_test() nounwind {
 316 entry:
 317   %0 = load <16 x i8>* @llvm_mips_adds_u_b_ARG1
 318   %1 = load <16 x i8>* @llvm_mips_adds_u_b_ARG2
 319   %2 = tail call <16 x i8> @llvm.mips.adds.u.b(<16 x i8> %0, <16 x i8> %1)
 320   store <16 x i8> %2, <16 x i8>* @llvm_mips_adds_u_b_RES
 321   ret void
 322 }
 323
 324 declare <16 x i8> @llvm.mips.adds.u.b(<16 x i8>, <16 x i8>) nounwind
 325
 326 ; CHECK: llvm_mips_adds_u_b_test:
 327 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_adds_u_b_ARG1)
 328 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_adds_u_b_ARG2)
 329 ; CHECK-DAG: ld.b [[WS:\$w[0-9]+]], 0([[R1]])
 330 ; CHECK-DAG: ld.b [[WT:\$w[0-9]+]], 0([[R2]])
 331 ; CHECK-DAG: adds_u.b [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 332 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_adds_u_b_RES)
 333 ; CHECK-DAG: st.b [[WD]], 0([[R3]])
 334 ; CHECK: .size llvm_mips_adds_u_b_test
 335 ;
 336 @llvm_mips_adds_u_h_ARG1 = global <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>, align 16
 337 @llvm_mips_adds_u_h_ARG2 = global <8 x i16> <i16 8, i16 9, i16 10, i16 11, i16 12, i16 13, i16 14, i16 15>, align 16
 338 @llvm_mips_adds_u_h_RES  = global <8 x i16> <i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>, align 16
 339
 340 define void @llvm_mips_adds_u_h_test() nounwind {
 341 entry:
 342   %0 = load <8 x i16>* @llvm_mips_adds_u_h_ARG1
 343   %1 = load <8 x i16>* @llvm_mips_adds_u_h_ARG2
 344   %2 = tail call <8 x i16> @llvm.mips.adds.u.h(<8 x i16> %0, <8 x i16> %1)
 345   store <8 x i16> %2, <8 x i16>* @llvm_mips_adds_u_h_RES
 346   ret void
 347 }
 348
 349 declare <8 x i16> @llvm.mips.adds.u.h(<8 x i16>, <8 x i16>) nounwind
 350
 351 ; CHECK: llvm_mips_adds_u_h_test:
 352 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_adds_u_h_ARG1)
 353 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_adds_u_h_ARG2)
 354 ; CHECK-DAG: ld.h [[WS:\$w[0-9]+]], 0([[R1]])
 355 ; CHECK-DAG: ld.h [[WT:\$w[0-9]+]], 0([[R2]])
 356 ; CHECK-DAG: adds_u.h [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 357 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_adds_u_h_RES)
 358 ; CHECK-DAG: st.h [[WD]], 0([[R3]])
 359 ; CHECK: .size llvm_mips_adds_u_h_test
 360 ;
 361 @llvm_mips_adds_u_w_ARG1 = global <4 x i32> <i32 0, i32 1, i32 2, i32 3>, align 16
 362 @llvm_mips_adds_u_w_ARG2 = global <4 x i32> <i32 4, i32 5, i32 6, i32 7>, align 16
 363 @llvm_mips_adds_u_w_RES  = global <4 x i32> <i32 0, i32 0, i32 0, i32 0>, align 16
 364
 365 define void @llvm_mips_adds_u_w_test() nounwind {
 366 entry:
 367   %0 = load <4 x i32>* @llvm_mips_adds_u_w_ARG1
 368   %1 = load <4 x i32>* @llvm_mips_adds_u_w_ARG2
 369   %2 = tail call <4 x i32> @llvm.mips.adds.u.w(<4 x i32> %0, <4 x i32> %1)
 370   store <4 x i32> %2, <4 x i32>* @llvm_mips_adds_u_w_RES
 371   ret void
 372 }
 373
 374 declare <4 x i32> @llvm.mips.adds.u.w(<4 x i32>, <4 x i32>) nounwind
 375
 376 ; CHECK: llvm_mips_adds_u_w_test:
 377 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_adds_u_w_ARG1)
 378 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_adds_u_w_ARG2)
 379 ; CHECK-DAG: ld.w [[WS:\$w[0-9]+]], 0([[R1]])
 380 ; CHECK-DAG: ld.w [[WT:\$w[0-9]+]], 0([[R2]])
 381 ; CHECK-DAG: adds_u.w [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 382 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_adds_u_w_RES)
 383 ; CHECK-DAG: st.w [[WD]], 0([[R3]])
 384 ; CHECK: .size llvm_mips_adds_u_w_test
 385 ;
 386 @llvm_mips_adds_u_d_ARG1 = global <2 x i64> <i64 0, i64 1>, align 16
 387 @llvm_mips_adds_u_d_ARG2 = global <2 x i64> <i64 2, i64 3>, align 16
 388 @llvm_mips_adds_u_d_RES  = global <2 x i64> <i64 0, i64 0>, align 16
 389
 390 define void @llvm_mips_adds_u_d_test() nounwind {
 391 entry:
 392   %0 = load <2 x i64>* @llvm_mips_adds_u_d_ARG1
 393   %1 = load <2 x i64>* @llvm_mips_adds_u_d_ARG2
 394   %2 = tail call <2 x i64> @llvm.mips.adds.u.d(<2 x i64> %0, <2 x i64> %1)
 395   store <2 x i64> %2, <2 x i64>* @llvm_mips_adds_u_d_RES
 396   ret void
 397 }
 398
 399 declare <2 x i64> @llvm.mips.adds.u.d(<2 x i64>, <2 x i64>) nounwind
 400
 401 ; CHECK: llvm_mips_adds_u_d_test:
 402 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_adds_u_d_ARG1)
 403 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_adds_u_d_ARG2)
 404 ; CHECK-DAG: ld.d [[WS:\$w[0-9]+]], 0([[R1]])
 405 ; CHECK-DAG: ld.d [[WT:\$w[0-9]+]], 0([[R2]])
 406 ; CHECK-DAG: adds_u.d [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 407 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_adds_u_d_RES)
 408 ; CHECK-DAG: st.d [[WD]], 0([[R3]])
 409 ; CHECK: .size llvm_mips_adds_u_d_test
 410 ;
 411 @llvm_mips_addv_b_ARG1 = global <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, align 16
 412 @llvm_mips_addv_b_ARG2 = global <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, align 16
 413 @llvm_mips_addv_b_RES  = global <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, align 16
 414
 415 define void @llvm_mips_addv_b_test() nounwind {
 416 entry:
 417   %0 = load <16 x i8>* @llvm_mips_addv_b_ARG1
 418   %1 = load <16 x i8>* @llvm_mips_addv_b_ARG2
 419   %2 = tail call <16 x i8> @llvm.mips.addv.b(<16 x i8> %0, <16 x i8> %1)
 420   store <16 x i8> %2, <16 x i8>* @llvm_mips_addv_b_RES
 421   ret void
 422 }
 423
 424 declare <16 x i8> @llvm.mips.addv.b(<16 x i8>, <16 x i8>) nounwind
 425
 426 ; CHECK: llvm_mips_addv_b_test:
 427 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_addv_b_ARG1)
 428 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_addv_b_ARG2)
 429 ; CHECK-DAG: ld.b [[WS:\$w[0-9]+]], 0([[R1]])
 430 ; CHECK-DAG: ld.b [[WT:\$w[0-9]+]], 0([[R2]])
 431 ; CHECK-DAG: addv.b [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 432 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_addv_b_RES)
 433 ; CHECK-DAG: st.b [[WD]], 0([[R3]])
 434 ; CHECK: .size llvm_mips_addv_b_test
 435 ;
 436 @llvm_mips_addv_h_ARG1 = global <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>, align 16
 437 @llvm_mips_addv_h_ARG2 = global <8 x i16> <i16 8, i16 9, i16 10, i16 11, i16 12, i16 13, i16 14, i16 15>, align 16
 438 @llvm_mips_addv_h_RES  = global <8 x i16> <i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>, align 16
 439
 440 define void @llvm_mips_addv_h_test() nounwind {
 441 entry:
 442   %0 = load <8 x i16>* @llvm_mips_addv_h_ARG1
 443   %1 = load <8 x i16>* @llvm_mips_addv_h_ARG2
 444   %2 = tail call <8 x i16> @llvm.mips.addv.h(<8 x i16> %0, <8 x i16> %1)
 445   store <8 x i16> %2, <8 x i16>* @llvm_mips_addv_h_RES
 446   ret void
 447 }
 448
 449 declare <8 x i16> @llvm.mips.addv.h(<8 x i16>, <8 x i16>) nounwind
 450
 451 ; CHECK: llvm_mips_addv_h_test:
 452 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_addv_h_ARG1)
 453 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_addv_h_ARG2)
 454 ; CHECK-DAG: ld.h [[WS:\$w[0-9]+]], 0([[R1]])
 455 ; CHECK-DAG: ld.h [[WT:\$w[0-9]+]], 0([[R2]])
 456 ; CHECK-DAG: addv.h [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 457 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_addv_h_RES)
 458 ; CHECK-DAG: st.h [[WD]], 0([[R3]])
 459 ; CHECK: .size llvm_mips_addv_h_test
 460 ;
 461 @llvm_mips_addv_w_ARG1 = global <4 x i32> <i32 0, i32 1, i32 2, i32 3>, align 16
 462 @llvm_mips_addv_w_ARG2 = global <4 x i32> <i32 4, i32 5, i32 6, i32 7>, align 16
 463 @llvm_mips_addv_w_RES  = global <4 x i32> <i32 0, i32 0, i32 0, i32 0>, align 16
 464
 465 define void @llvm_mips_addv_w_test() nounwind {
 466 entry:
 467   %0 = load <4 x i32>* @llvm_mips_addv_w_ARG1
 468   %1 = load <4 x i32>* @llvm_mips_addv_w_ARG2
 469   %2 = tail call <4 x i32> @llvm.mips.addv.w(<4 x i32> %0, <4 x i32> %1)
 470   store <4 x i32> %2, <4 x i32>* @llvm_mips_addv_w_RES
 471   ret void
 472 }
 473
 474 declare <4 x i32> @llvm.mips.addv.w(<4 x i32>, <4 x i32>) nounwind
 475
 476 ; CHECK: llvm_mips_addv_w_test:
 477 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_addv_w_ARG1)
 478 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_addv_w_ARG2)
 479 ; CHECK-DAG: ld.w [[WS:\$w[0-9]+]], 0([[R1]])
 480 ; CHECK-DAG: ld.w [[WT:\$w[0-9]+]], 0([[R2]])
 481 ; CHECK-DAG: addv.w [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 482 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_addv_w_RES)
 483 ; CHECK-DAG: st.w [[WD]], 0([[R3]])
 484 ; CHECK: .size llvm_mips_addv_w_test
 485 ;
 486 @llvm_mips_addv_d_ARG1 = global <2 x i64> <i64 0, i64 1>, align 16
 487 @llvm_mips_addv_d_ARG2 = global <2 x i64> <i64 2, i64 3>, align 16
 488 @llvm_mips_addv_d_RES  = global <2 x i64> <i64 0, i64 0>, align 16
 489
 490 define void @llvm_mips_addv_d_test() nounwind {
 491 entry:
 492   %0 = load <2 x i64>* @llvm_mips_addv_d_ARG1
 493   %1 = load <2 x i64>* @llvm_mips_addv_d_ARG2
 494   %2 = tail call <2 x i64> @llvm.mips.addv.d(<2 x i64> %0, <2 x i64> %1)
 495   store <2 x i64> %2, <2 x i64>* @llvm_mips_addv_d_RES
 496   ret void
 497 }
 498
 499 declare <2 x i64> @llvm.mips.addv.d(<2 x i64>, <2 x i64>) nounwind
 500
 501 ; CHECK: llvm_mips_addv_d_test:
 502 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_addv_d_ARG1)
 503 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_addv_d_ARG2)
 504 ; CHECK-DAG: ld.d [[WS:\$w[0-9]+]], 0([[R1]])
 505 ; CHECK-DAG: ld.d [[WT:\$w[0-9]+]], 0([[R2]])
 506 ; CHECK-DAG: addv.d [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 507 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_addv_d_RES)
 508 ; CHECK-DAG: st.d [[WD]], 0([[R3]])
 509 ; CHECK: .size llvm_mips_addv_d_test
 510 ;
 511
 512 define void @addv_b_test() nounwind {
 513 entry:
 514   %0 = load <16 x i8>* @llvm_mips_addv_b_ARG1
 515   %1 = load <16 x i8>* @llvm_mips_addv_b_ARG2
 516   %2 = add <16 x i8> %0, %1
 517   store <16 x i8> %2, <16 x i8>* @llvm_mips_addv_b_RES
 518   ret void
 519 }
 520
 521 ; CHECK: addv_b_test:
 522 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_addv_b_ARG1)
 523 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_addv_b_ARG2)
 524 ; CHECK-DAG: ld.b [[WS:\$w[0-9]+]], 0([[R1]])
 525 ; CHECK-DAG: ld.b [[WT:\$w[0-9]+]], 0([[R2]])
 526 ; CHECK-DAG: addv.b [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 527 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_addv_b_RES)
 528 ; CHECK-DAG: st.b [[WD]], 0([[R3]])
 529 ; CHECK: .size addv_b_test
 530 ;
 531
 532 define void @addv_h_test() nounwind {
 533 entry:
 534   %0 = load <8 x i16>* @llvm_mips_addv_h_ARG1
 535   %1 = load <8 x i16>* @llvm_mips_addv_h_ARG2
 536   %2 = add <8 x i16> %0, %1
 537   store <8 x i16> %2, <8 x i16>* @llvm_mips_addv_h_RES
 538   ret void
 539 }
 540
 541 ; CHECK: addv_h_test:
 542 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_addv_h_ARG1)
 543 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_addv_h_ARG2)
 544 ; CHECK-DAG: ld.h [[WS:\$w[0-9]+]], 0([[R1]])
 545 ; CHECK-DAG: ld.h [[WT:\$w[0-9]+]], 0([[R2]])
 546 ; CHECK-DAG: addv.h [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 547 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_addv_h_RES)
 548 ; CHECK-DAG: st.h [[WD]], 0([[R3]])
 549 ; CHECK: .size addv_h_test
 550 ;
 551
 552 define void @addv_w_test() nounwind {
 553 entry:
 554   %0 = load <4 x i32>* @llvm_mips_addv_w_ARG1
 555   %1 = load <4 x i32>* @llvm_mips_addv_w_ARG2
 556   %2 = add <4 x i32> %0, %1
 557   store <4 x i32> %2, <4 x i32>* @llvm_mips_addv_w_RES
 558   ret void
 559 }
 560
 561 ; CHECK: addv_w_test:
 562 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_addv_w_ARG1)
 563 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_addv_w_ARG2)
 564 ; CHECK-DAG: ld.w [[WS:\$w[0-9]+]], 0([[R1]])
 565 ; CHECK-DAG: ld.w [[WT:\$w[0-9]+]], 0([[R2]])
 566 ; CHECK-DAG: addv.w [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 567 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_addv_w_RES)
 568 ; CHECK-DAG: st.w [[WD]], 0([[R3]])
 569 ; CHECK: .size addv_w_test
 570 ;
 571
 572 define void @addv_d_test() nounwind {
 573 entry:
 574   %0 = load <2 x i64>* @llvm_mips_addv_d_ARG1
 575   %1 = load <2 x i64>* @llvm_mips_addv_d_ARG2
 576   %2 = add <2 x i64> %0, %1
 577   store <2 x i64> %2, <2 x i64>* @llvm_mips_addv_d_RES
 578   ret void
 579 }
 580
 581 ; CHECK: addv_d_test:
 582 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_addv_d_ARG1)
 583 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_addv_d_ARG2)
 584 ; CHECK-DAG: ld.d [[WS:\$w[0-9]+]], 0([[R1]])
 585 ; CHECK-DAG: ld.d [[WT:\$w[0-9]+]], 0([[R2]])
 586 ; CHECK-DAG: addv.d [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 587 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_addv_d_RES)
 588 ; CHECK-DAG: st.d [[WD]], 0([[R3]])
 589 ; CHECK: .size addv_d_test
 590 ;
 591 @llvm_mips_asub_s_b_ARG1 = global <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, align 16
 592 @llvm_mips_asub_s_b_ARG2 = global <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, align 16
 593 @llvm_mips_asub_s_b_RES  = global <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, align 16
 594
 595 define void @llvm_mips_asub_s_b_test() nounwind {
 596 entry:
 597   %0 = load <16 x i8>* @llvm_mips_asub_s_b_ARG1
 598   %1 = load <16 x i8>* @llvm_mips_asub_s_b_ARG2
 599   %2 = tail call <16 x i8> @llvm.mips.asub.s.b(<16 x i8> %0, <16 x i8> %1)
 600   store <16 x i8> %2, <16 x i8>* @llvm_mips_asub_s_b_RES
 601   ret void
 602 }
 603
 604 declare <16 x i8> @llvm.mips.asub.s.b(<16 x i8>, <16 x i8>) nounwind
 605
 606 ; CHECK: llvm_mips_asub_s_b_test:
 607 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_asub_s_b_ARG1)
 608 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_asub_s_b_ARG2)
 609 ; CHECK-DAG: ld.b [[WS:\$w[0-9]+]], 0([[R1]])
 610 ; CHECK-DAG: ld.b [[WT:\$w[0-9]+]], 0([[R2]])
 611 ; CHECK-DAG: asub_s.b [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 612 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_asub_s_b_RES)
 613 ; CHECK-DAG: st.b [[WD]], 0([[R3]])
 614 ; CHECK: .size llvm_mips_asub_s_b_test
 615 ;
 616 @llvm_mips_asub_s_h_ARG1 = global <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>, align 16
 617 @llvm_mips_asub_s_h_ARG2 = global <8 x i16> <i16 8, i16 9, i16 10, i16 11, i16 12, i16 13, i16 14, i16 15>, align 16
 618 @llvm_mips_asub_s_h_RES  = global <8 x i16> <i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>, align 16
 619
 620 define void @llvm_mips_asub_s_h_test() nounwind {
 621 entry:
 622   %0 = load <8 x i16>* @llvm_mips_asub_s_h_ARG1
 623   %1 = load <8 x i16>* @llvm_mips_asub_s_h_ARG2
 624   %2 = tail call <8 x i16> @llvm.mips.asub.s.h(<8 x i16> %0, <8 x i16> %1)
 625   store <8 x i16> %2, <8 x i16>* @llvm_mips_asub_s_h_RES
 626   ret void
 627 }
 628
 629 declare <8 x i16> @llvm.mips.asub.s.h(<8 x i16>, <8 x i16>) nounwind
 630
 631 ; CHECK: llvm_mips_asub_s_h_test:
 632 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_asub_s_h_ARG1)
 633 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_asub_s_h_ARG2)
 634 ; CHECK-DAG: ld.h [[WS:\$w[0-9]+]], 0([[R1]])
 635 ; CHECK-DAG: ld.h [[WT:\$w[0-9]+]], 0([[R2]])
 636 ; CHECK-DAG: asub_s.h [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 637 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_asub_s_h_RES)
 638 ; CHECK-DAG: st.h [[WD]], 0([[R3]])
 639 ; CHECK: .size llvm_mips_asub_s_h_test
 640 ;
 641 @llvm_mips_asub_s_w_ARG1 = global <4 x i32> <i32 0, i32 1, i32 2, i32 3>, align 16
 642 @llvm_mips_asub_s_w_ARG2 = global <4 x i32> <i32 4, i32 5, i32 6, i32 7>, align 16
 643 @llvm_mips_asub_s_w_RES  = global <4 x i32> <i32 0, i32 0, i32 0, i32 0>, align 16
 644
 645 define void @llvm_mips_asub_s_w_test() nounwind {
 646 entry:
 647   %0 = load <4 x i32>* @llvm_mips_asub_s_w_ARG1
 648   %1 = load <4 x i32>* @llvm_mips_asub_s_w_ARG2
 649   %2 = tail call <4 x i32> @llvm.mips.asub.s.w(<4 x i32> %0, <4 x i32> %1)
 650   store <4 x i32> %2, <4 x i32>* @llvm_mips_asub_s_w_RES
 651   ret void
 652 }
 653
 654 declare <4 x i32> @llvm.mips.asub.s.w(<4 x i32>, <4 x i32>) nounwind
 655
 656 ; CHECK: llvm_mips_asub_s_w_test:
 657 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_asub_s_w_ARG1)
 658 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_asub_s_w_ARG2)
 659 ; CHECK-DAG: ld.w [[WS:\$w[0-9]+]], 0([[R1]])
 660 ; CHECK-DAG: ld.w [[WT:\$w[0-9]+]], 0([[R2]])
 661 ; CHECK-DAG: asub_s.w [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 662 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_asub_s_w_RES)
 663 ; CHECK-DAG: st.w [[WD]], 0([[R3]])
 664 ; CHECK: .size llvm_mips_asub_s_w_test
 665 ;
 666 @llvm_mips_asub_s_d_ARG1 = global <2 x i64> <i64 0, i64 1>, align 16
 667 @llvm_mips_asub_s_d_ARG2 = global <2 x i64> <i64 2, i64 3>, align 16
 668 @llvm_mips_asub_s_d_RES  = global <2 x i64> <i64 0, i64 0>, align 16
 669
 670 define void @llvm_mips_asub_s_d_test() nounwind {
 671 entry:
 672   %0 = load <2 x i64>* @llvm_mips_asub_s_d_ARG1
 673   %1 = load <2 x i64>* @llvm_mips_asub_s_d_ARG2
 674   %2 = tail call <2 x i64> @llvm.mips.asub.s.d(<2 x i64> %0, <2 x i64> %1)
 675   store <2 x i64> %2, <2 x i64>* @llvm_mips_asub_s_d_RES
 676   ret void
 677 }
 678
 679 declare <2 x i64> @llvm.mips.asub.s.d(<2 x i64>, <2 x i64>) nounwind
 680
 681 ; CHECK: llvm_mips_asub_s_d_test:
 682 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_asub_s_d_ARG1)
 683 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_asub_s_d_ARG2)
 684 ; CHECK-DAG: ld.d [[WS:\$w[0-9]+]], 0([[R1]])
 685 ; CHECK-DAG: ld.d [[WT:\$w[0-9]+]], 0([[R2]])
 686 ; CHECK-DAG: asub_s.d [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 687 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_asub_s_d_RES)
 688 ; CHECK-DAG: st.d [[WD]], 0([[R3]])
 689 ; CHECK: .size llvm_mips_asub_s_d_test
 690 ;
 691 @llvm_mips_asub_u_b_ARG1 = global <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, align 16
 692 @llvm_mips_asub_u_b_ARG2 = global <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, align 16
 693 @llvm_mips_asub_u_b_RES  = global <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, align 16
 694
 695 define void @llvm_mips_asub_u_b_test() nounwind {
 696 entry:
 697   %0 = load <16 x i8>* @llvm_mips_asub_u_b_ARG1
 698   %1 = load <16 x i8>* @llvm_mips_asub_u_b_ARG2
 699   %2 = tail call <16 x i8> @llvm.mips.asub.u.b(<16 x i8> %0, <16 x i8> %1)
 700   store <16 x i8> %2, <16 x i8>* @llvm_mips_asub_u_b_RES
 701   ret void
 702 }
 703
 704 declare <16 x i8> @llvm.mips.asub.u.b(<16 x i8>, <16 x i8>) nounwind
 705
 706 ; CHECK: llvm_mips_asub_u_b_test:
 707 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_asub_u_b_ARG1)
 708 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_asub_u_b_ARG2)
 709 ; CHECK-DAG: ld.b [[WS:\$w[0-9]+]], 0([[R1]])
 710 ; CHECK-DAG: ld.b [[WT:\$w[0-9]+]], 0([[R2]])
 711 ; CHECK-DAG: asub_u.b [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 712 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_asub_u_b_RES)
 713 ; CHECK-DAG: st.b [[WD]], 0([[R3]])
 714 ; CHECK: .size llvm_mips_asub_u_b_test
 715 ;
 716 @llvm_mips_asub_u_h_ARG1 = global <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>, align 16
 717 @llvm_mips_asub_u_h_ARG2 = global <8 x i16> <i16 8, i16 9, i16 10, i16 11, i16 12, i16 13, i16 14, i16 15>, align 16
 718 @llvm_mips_asub_u_h_RES  = global <8 x i16> <i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>, align 16
 719
 720 define void @llvm_mips_asub_u_h_test() nounwind {
 721 entry:
 722   %0 = load <8 x i16>* @llvm_mips_asub_u_h_ARG1
 723   %1 = load <8 x i16>* @llvm_mips_asub_u_h_ARG2
 724   %2 = tail call <8 x i16> @llvm.mips.asub.u.h(<8 x i16> %0, <8 x i16> %1)
 725   store <8 x i16> %2, <8 x i16>* @llvm_mips_asub_u_h_RES
 726   ret void
 727 }
 728
 729 declare <8 x i16> @llvm.mips.asub.u.h(<8 x i16>, <8 x i16>) nounwind
 730
 731 ; CHECK: llvm_mips_asub_u_h_test:
 732 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_asub_u_h_ARG1)
 733 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_asub_u_h_ARG2)
 734 ; CHECK-DAG: ld.h [[WS:\$w[0-9]+]], 0([[R1]])
 735 ; CHECK-DAG: ld.h [[WT:\$w[0-9]+]], 0([[R2]])
 736 ; CHECK-DAG: asub_u.h [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 737 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_asub_u_h_RES)
 738 ; CHECK-DAG: st.h [[WD]], 0([[R3]])
 739 ; CHECK: .size llvm_mips_asub_u_h_test
 740 ;
 741 @llvm_mips_asub_u_w_ARG1 = global <4 x i32> <i32 0, i32 1, i32 2, i32 3>, align 16
 742 @llvm_mips_asub_u_w_ARG2 = global <4 x i32> <i32 4, i32 5, i32 6, i32 7>, align 16
 743 @llvm_mips_asub_u_w_RES  = global <4 x i32> <i32 0, i32 0, i32 0, i32 0>, align 16
 744
 745 define void @llvm_mips_asub_u_w_test() nounwind {
 746 entry:
 747   %0 = load <4 x i32>* @llvm_mips_asub_u_w_ARG1
 748   %1 = load <4 x i32>* @llvm_mips_asub_u_w_ARG2
 749   %2 = tail call <4 x i32> @llvm.mips.asub.u.w(<4 x i32> %0, <4 x i32> %1)
 750   store <4 x i32> %2, <4 x i32>* @llvm_mips_asub_u_w_RES
 751   ret void
 752 }
 753
 754 declare <4 x i32> @llvm.mips.asub.u.w(<4 x i32>, <4 x i32>) nounwind
 755
 756 ; CHECK: llvm_mips_asub_u_w_test:
 757 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_asub_u_w_ARG1)
 758 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_asub_u_w_ARG2)
 759 ; CHECK-DAG: ld.w [[WS:\$w[0-9]+]], 0([[R1]])
 760 ; CHECK-DAG: ld.w [[WT:\$w[0-9]+]], 0([[R2]])
 761 ; CHECK-DAG: asub_u.w [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 762 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_asub_u_w_RES)
 763 ; CHECK-DAG: st.w [[WD]], 0([[R3]])
 764 ; CHECK: .size llvm_mips_asub_u_w_test
 765 ;
 766 @llvm_mips_asub_u_d_ARG1 = global <2 x i64> <i64 0, i64 1>, align 16
 767 @llvm_mips_asub_u_d_ARG2 = global <2 x i64> <i64 2, i64 3>, align 16
 768 @llvm_mips_asub_u_d_RES  = global <2 x i64> <i64 0, i64 0>, align 16
 769
 770 define void @llvm_mips_asub_u_d_test() nounwind {
 771 entry:
 772   %0 = load <2 x i64>* @llvm_mips_asub_u_d_ARG1
 773   %1 = load <2 x i64>* @llvm_mips_asub_u_d_ARG2
 774   %2 = tail call <2 x i64> @llvm.mips.asub.u.d(<2 x i64> %0, <2 x i64> %1)
 775   store <2 x i64> %2, <2 x i64>* @llvm_mips_asub_u_d_RES
 776   ret void
 777 }
 778
 779 declare <2 x i64> @llvm.mips.asub.u.d(<2 x i64>, <2 x i64>) nounwind
 780
 781 ; CHECK: llvm_mips_asub_u_d_test:
 782 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_asub_u_d_ARG1)
 783 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_asub_u_d_ARG2)
 784 ; CHECK-DAG: ld.d [[WS:\$w[0-9]+]], 0([[R1]])
 785 ; CHECK-DAG: ld.d [[WT:\$w[0-9]+]], 0([[R2]])
 786 ; CHECK-DAG: asub_u.d [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 787 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_asub_u_d_RES)
 788 ; CHECK-DAG: st.d [[WD]], 0([[R3]])
 789 ; CHECK: .size llvm_mips_asub_u_d_test
 790 ;
 791 @llvm_mips_ave_s_b_ARG1 = global <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, align 16
 792 @llvm_mips_ave_s_b_ARG2 = global <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, align 16
 793 @llvm_mips_ave_s_b_RES  = global <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, align 16
 794
 795 define void @llvm_mips_ave_s_b_test() nounwind {
 796 entry:
 797   %0 = load <16 x i8>* @llvm_mips_ave_s_b_ARG1
 798   %1 = load <16 x i8>* @llvm_mips_ave_s_b_ARG2
 799   %2 = tail call <16 x i8> @llvm.mips.ave.s.b(<16 x i8> %0, <16 x i8> %1)
 800   store <16 x i8> %2, <16 x i8>* @llvm_mips_ave_s_b_RES
 801   ret void
 802 }
 803
 804 declare <16 x i8> @llvm.mips.ave.s.b(<16 x i8>, <16 x i8>) nounwind
 805
 806 ; CHECK: llvm_mips_ave_s_b_test:
 807 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_ave_s_b_ARG1)
 808 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_ave_s_b_ARG2)
 809 ; CHECK-DAG: ld.b [[WS:\$w[0-9]+]], 0([[R1]])
 810 ; CHECK-DAG: ld.b [[WT:\$w[0-9]+]], 0([[R2]])
 811 ; CHECK-DAG: ave_s.b [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 812 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_ave_s_b_RES)
 813 ; CHECK-DAG: st.b [[WD]], 0([[R3]])
 814 ; CHECK: .size llvm_mips_ave_s_b_test
 815 ;
 816 @llvm_mips_ave_s_h_ARG1 = global <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>, align 16
 817 @llvm_mips_ave_s_h_ARG2 = global <8 x i16> <i16 8, i16 9, i16 10, i16 11, i16 12, i16 13, i16 14, i16 15>, align 16
 818 @llvm_mips_ave_s_h_RES  = global <8 x i16> <i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>, align 16
 819
 820 define void @llvm_mips_ave_s_h_test() nounwind {
 821 entry:
 822   %0 = load <8 x i16>* @llvm_mips_ave_s_h_ARG1
 823   %1 = load <8 x i16>* @llvm_mips_ave_s_h_ARG2
 824   %2 = tail call <8 x i16> @llvm.mips.ave.s.h(<8 x i16> %0, <8 x i16> %1)
 825   store <8 x i16> %2, <8 x i16>* @llvm_mips_ave_s_h_RES
 826   ret void
 827 }
 828
 829 declare <8 x i16> @llvm.mips.ave.s.h(<8 x i16>, <8 x i16>) nounwind
 830
 831 ; CHECK: llvm_mips_ave_s_h_test:
 832 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_ave_s_h_ARG1)
 833 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_ave_s_h_ARG2)
 834 ; CHECK-DAG: ld.h [[WS:\$w[0-9]+]], 0([[R1]])
 835 ; CHECK-DAG: ld.h [[WT:\$w[0-9]+]], 0([[R2]])
 836 ; CHECK-DAG: ave_s.h [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 837 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_ave_s_h_RES)
 838 ; CHECK-DAG: st.h [[WD]], 0([[R3]])
 839 ; CHECK: .size llvm_mips_ave_s_h_test
 840 ;
 841 @llvm_mips_ave_s_w_ARG1 = global <4 x i32> <i32 0, i32 1, i32 2, i32 3>, align 16
 842 @llvm_mips_ave_s_w_ARG2 = global <4 x i32> <i32 4, i32 5, i32 6, i32 7>, align 16
 843 @llvm_mips_ave_s_w_RES  = global <4 x i32> <i32 0, i32 0, i32 0, i32 0>, align 16
 844
 845 define void @llvm_mips_ave_s_w_test() nounwind {
 846 entry:
 847   %0 = load <4 x i32>* @llvm_mips_ave_s_w_ARG1
 848   %1 = load <4 x i32>* @llvm_mips_ave_s_w_ARG2
 849   %2 = tail call <4 x i32> @llvm.mips.ave.s.w(<4 x i32> %0, <4 x i32> %1)
 850   store <4 x i32> %2, <4 x i32>* @llvm_mips_ave_s_w_RES
 851   ret void
 852 }
 853
 854 declare <4 x i32> @llvm.mips.ave.s.w(<4 x i32>, <4 x i32>) nounwind
 855
 856 ; CHECK: llvm_mips_ave_s_w_test:
 857 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_ave_s_w_ARG1)
 858 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_ave_s_w_ARG2)
 859 ; CHECK-DAG: ld.w [[WS:\$w[0-9]+]], 0([[R1]])
 860 ; CHECK-DAG: ld.w [[WT:\$w[0-9]+]], 0([[R2]])
 861 ; CHECK-DAG: ave_s.w [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 862 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_ave_s_w_RES)
 863 ; CHECK-DAG: st.w [[WD]], 0([[R3]])
 864 ; CHECK: .size llvm_mips_ave_s_w_test
 865 ;
 866 @llvm_mips_ave_s_d_ARG1 = global <2 x i64> <i64 0, i64 1>, align 16
 867 @llvm_mips_ave_s_d_ARG2 = global <2 x i64> <i64 2, i64 3>, align 16
 868 @llvm_mips_ave_s_d_RES  = global <2 x i64> <i64 0, i64 0>, align 16
 869
 870 define void @llvm_mips_ave_s_d_test() nounwind {
 871 entry:
 872   %0 = load <2 x i64>* @llvm_mips_ave_s_d_ARG1
 873   %1 = load <2 x i64>* @llvm_mips_ave_s_d_ARG2
 874   %2 = tail call <2 x i64> @llvm.mips.ave.s.d(<2 x i64> %0, <2 x i64> %1)
 875   store <2 x i64> %2, <2 x i64>* @llvm_mips_ave_s_d_RES
 876   ret void
 877 }
 878
 879 declare <2 x i64> @llvm.mips.ave.s.d(<2 x i64>, <2 x i64>) nounwind
 880
 881 ; CHECK: llvm_mips_ave_s_d_test:
 882 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_ave_s_d_ARG1)
 883 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_ave_s_d_ARG2)
 884 ; CHECK-DAG: ld.d [[WS:\$w[0-9]+]], 0([[R1]])
 885 ; CHECK-DAG: ld.d [[WT:\$w[0-9]+]], 0([[R2]])
 886 ; CHECK-DAG: ave_s.d [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 887 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_ave_s_d_RES)
 888 ; CHECK-DAG: st.d [[WD]], 0([[R3]])
 889 ; CHECK: .size llvm_mips_ave_s_d_test
 890 ;
 891 @llvm_mips_ave_u_b_ARG1 = global <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, align 16
 892 @llvm_mips_ave_u_b_ARG2 = global <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, align 16
 893 @llvm_mips_ave_u_b_RES  = global <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, align 16
 894
 895 define void @llvm_mips_ave_u_b_test() nounwind {
 896 entry:
 897   %0 = load <16 x i8>* @llvm_mips_ave_u_b_ARG1
 898   %1 = load <16 x i8>* @llvm_mips_ave_u_b_ARG2
 899   %2 = tail call <16 x i8> @llvm.mips.ave.u.b(<16 x i8> %0, <16 x i8> %1)
 900   store <16 x i8> %2, <16 x i8>* @llvm_mips_ave_u_b_RES
 901   ret void
 902 }
 903
 904 declare <16 x i8> @llvm.mips.ave.u.b(<16 x i8>, <16 x i8>) nounwind
 905
 906 ; CHECK: llvm_mips_ave_u_b_test:
 907 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_ave_u_b_ARG1)
 908 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_ave_u_b_ARG2)
 909 ; CHECK-DAG: ld.b [[WS:\$w[0-9]+]], 0([[R1]])
 910 ; CHECK-DAG: ld.b [[WT:\$w[0-9]+]], 0([[R2]])
 911 ; CHECK-DAG: ave_u.b [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 912 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_ave_u_b_RES)
 913 ; CHECK-DAG: st.b [[WD]], 0([[R3]])
 914 ; CHECK: .size llvm_mips_ave_u_b_test
 915 ;
 916 @llvm_mips_ave_u_h_ARG1 = global <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>, align 16
 917 @llvm_mips_ave_u_h_ARG2 = global <8 x i16> <i16 8, i16 9, i16 10, i16 11, i16 12, i16 13, i16 14, i16 15>, align 16
 918 @llvm_mips_ave_u_h_RES  = global <8 x i16> <i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>, align 16
 919
 920 define void @llvm_mips_ave_u_h_test() nounwind {
 921 entry:
 922   %0 = load <8 x i16>* @llvm_mips_ave_u_h_ARG1
 923   %1 = load <8 x i16>* @llvm_mips_ave_u_h_ARG2
 924   %2 = tail call <8 x i16> @llvm.mips.ave.u.h(<8 x i16> %0, <8 x i16> %1)
 925   store <8 x i16> %2, <8 x i16>* @llvm_mips_ave_u_h_RES
 926   ret void
 927 }
 928
 929 declare <8 x i16> @llvm.mips.ave.u.h(<8 x i16>, <8 x i16>) nounwind
 930
 931 ; CHECK: llvm_mips_ave_u_h_test:
 932 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_ave_u_h_ARG1)
 933 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_ave_u_h_ARG2)
 934 ; CHECK-DAG: ld.h [[WS:\$w[0-9]+]], 0([[R1]])
 935 ; CHECK-DAG: ld.h [[WT:\$w[0-9]+]], 0([[R2]])
 936 ; CHECK-DAG: ave_u.h [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 937 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_ave_u_h_RES)
 938 ; CHECK-DAG: st.h [[WD]], 0([[R3]])
 939 ; CHECK: .size llvm_mips_ave_u_h_test
 940 ;
 941 @llvm_mips_ave_u_w_ARG1 = global <4 x i32> <i32 0, i32 1, i32 2, i32 3>, align 16
 942 @llvm_mips_ave_u_w_ARG2 = global <4 x i32> <i32 4, i32 5, i32 6, i32 7>, align 16
 943 @llvm_mips_ave_u_w_RES  = global <4 x i32> <i32 0, i32 0, i32 0, i32 0>, align 16
 944
 945 define void @llvm_mips_ave_u_w_test() nounwind {
 946 entry:
 947   %0 = load <4 x i32>* @llvm_mips_ave_u_w_ARG1
 948   %1 = load <4 x i32>* @llvm_mips_ave_u_w_ARG2
 949   %2 = tail call <4 x i32> @llvm.mips.ave.u.w(<4 x i32> %0, <4 x i32> %1)
 950   store <4 x i32> %2, <4 x i32>* @llvm_mips_ave_u_w_RES
 951   ret void
 952 }
 953
 954 declare <4 x i32> @llvm.mips.ave.u.w(<4 x i32>, <4 x i32>) nounwind
 955
 956 ; CHECK: llvm_mips_ave_u_w_test:
 957 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_ave_u_w_ARG1)
 958 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_ave_u_w_ARG2)
 959 ; CHECK-DAG: ld.w [[WS:\$w[0-9]+]], 0([[R1]])
 960 ; CHECK-DAG: ld.w [[WT:\$w[0-9]+]], 0([[R2]])
 961 ; CHECK-DAG: ave_u.w [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 962 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_ave_u_w_RES)
 963 ; CHECK-DAG: st.w [[WD]], 0([[R3]])
 964 ; CHECK: .size llvm_mips_ave_u_w_test
 965 ;
 966 @llvm_mips_ave_u_d_ARG1 = global <2 x i64> <i64 0, i64 1>, align 16
 967 @llvm_mips_ave_u_d_ARG2 = global <2 x i64> <i64 2, i64 3>, align 16
 968 @llvm_mips_ave_u_d_RES  = global <2 x i64> <i64 0, i64 0>, align 16
 969
 970 define void @llvm_mips_ave_u_d_test() nounwind {
 971 entry:
 972   %0 = load <2 x i64>* @llvm_mips_ave_u_d_ARG1
 973   %1 = load <2 x i64>* @llvm_mips_ave_u_d_ARG2
 974   %2 = tail call <2 x i64> @llvm.mips.ave.u.d(<2 x i64> %0, <2 x i64> %1)
 975   store <2 x i64> %2, <2 x i64>* @llvm_mips_ave_u_d_RES
 976   ret void
 977 }
 978
 979 declare <2 x i64> @llvm.mips.ave.u.d(<2 x i64>, <2 x i64>) nounwind
 980
 981 ; CHECK: llvm_mips_ave_u_d_test:
 982 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_ave_u_d_ARG1)
 983 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_ave_u_d_ARG2)
 984 ; CHECK-DAG: ld.d [[WS:\$w[0-9]+]], 0([[R1]])
 985 ; CHECK-DAG: ld.d [[WT:\$w[0-9]+]], 0([[R2]])
 986 ; CHECK-DAG: ave_u.d [[WD:\$w[0-9]+]], [[WS]], [[WT]]
 987 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_ave_u_d_RES)
 988 ; CHECK-DAG: st.d [[WD]], 0([[R3]])
 989 ; CHECK: .size llvm_mips_ave_u_d_test
 990 ;
 991 @llvm_mips_aver_s_b_ARG1 = global <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, align 16
 992 @llvm_mips_aver_s_b_ARG2 = global <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, align 16
 993 @llvm_mips_aver_s_b_RES  = global <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, align 16
 994
 995 define void @llvm_mips_aver_s_b_test() nounwind {
 996 entry:
 997   %0 = load <16 x i8>* @llvm_mips_aver_s_b_ARG1
 998   %1 = load <16 x i8>* @llvm_mips_aver_s_b_ARG2
 999   %2 = tail call <16 x i8> @llvm.mips.aver.s.b(<16 x i8> %0, <16 x i8> %1)
1000   store <16 x i8> %2, <16 x i8>* @llvm_mips_aver_s_b_RES
1001   ret void
1002 }
1003
1004 declare <16 x i8> @llvm.mips.aver.s.b(<16 x i8>, <16 x i8>) nounwind
1005
1006 ; CHECK: llvm_mips_aver_s_b_test:
1007 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_aver_s_b_ARG1)
1008 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_aver_s_b_ARG2)
1009 ; CHECK-DAG: ld.b [[WS:\$w[0-9]+]], 0([[R1]])
1010 ; CHECK-DAG: ld.b [[WT:\$w[0-9]+]], 0([[R2]])
1011 ; CHECK-DAG: aver_s.b [[WD:\$w[0-9]+]], [[WS]], [[WT]]
1012 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_aver_s_b_RES)
1013 ; CHECK-DAG: st.b [[WD]], 0([[R3]])
1014 ; CHECK: .size llvm_mips_aver_s_b_test
1015 ;
1016 @llvm_mips_aver_s_h_ARG1 = global <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>, align 16
1017 @llvm_mips_aver_s_h_ARG2 = global <8 x i16> <i16 8, i16 9, i16 10, i16 11, i16 12, i16 13, i16 14, i16 15>, align 16
1018 @llvm_mips_aver_s_h_RES  = global <8 x i16> <i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>, align 16
1019
1020 define void @llvm_mips_aver_s_h_test() nounwind {
1021 entry:
1022   %0 = load <8 x i16>* @llvm_mips_aver_s_h_ARG1
1023   %1 = load <8 x i16>* @llvm_mips_aver_s_h_ARG2
1024   %2 = tail call <8 x i16> @llvm.mips.aver.s.h(<8 x i16> %0, <8 x i16> %1)
1025   store <8 x i16> %2, <8 x i16>* @llvm_mips_aver_s_h_RES
1026   ret void
1027 }
1028
1029 declare <8 x i16> @llvm.mips.aver.s.h(<8 x i16>, <8 x i16>) nounwind
1030
1031 ; CHECK: llvm_mips_aver_s_h_test:
1032 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_aver_s_h_ARG1)
1033 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_aver_s_h_ARG2)
1034 ; CHECK-DAG: ld.h [[WS:\$w[0-9]+]], 0([[R1]])
1035 ; CHECK-DAG: ld.h [[WT:\$w[0-9]+]], 0([[R2]])
1036 ; CHECK-DAG: aver_s.h [[WD:\$w[0-9]+]], [[WS]], [[WT]]
1037 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_aver_s_h_RES)
1038 ; CHECK-DAG: st.h [[WD]], 0([[R3]])
1039 ; CHECK: .size llvm_mips_aver_s_h_test
1040 ;
1041 @llvm_mips_aver_s_w_ARG1 = global <4 x i32> <i32 0, i32 1, i32 2, i32 3>, align 16
1042 @llvm_mips_aver_s_w_ARG2 = global <4 x i32> <i32 4, i32 5, i32 6, i32 7>, align 16
1043 @llvm_mips_aver_s_w_RES  = global <4 x i32> <i32 0, i32 0, i32 0, i32 0>, align 16
1044
1045 define void @llvm_mips_aver_s_w_test() nounwind {
1046 entry:
1047   %0 = load <4 x i32>* @llvm_mips_aver_s_w_ARG1
1048   %1 = load <4 x i32>* @llvm_mips_aver_s_w_ARG2
1049   %2 = tail call <4 x i32> @llvm.mips.aver.s.w(<4 x i32> %0, <4 x i32> %1)
1050   store <4 x i32> %2, <4 x i32>* @llvm_mips_aver_s_w_RES
1051   ret void
1052 }
1053
1054 declare <4 x i32> @llvm.mips.aver.s.w(<4 x i32>, <4 x i32>) nounwind
1055
1056 ; CHECK: llvm_mips_aver_s_w_test:
1057 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_aver_s_w_ARG1)
1058 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_aver_s_w_ARG2)
1059 ; CHECK-DAG: ld.w [[WS:\$w[0-9]+]], 0([[R1]])
1060 ; CHECK-DAG: ld.w [[WT:\$w[0-9]+]], 0([[R2]])
1061 ; CHECK-DAG: aver_s.w [[WD:\$w[0-9]+]], [[WS]], [[WT]]
1062 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_aver_s_w_RES)
1063 ; CHECK-DAG: st.w [[WD]], 0([[R3]])
1064 ; CHECK: .size llvm_mips_aver_s_w_test
1065 ;
1066 @llvm_mips_aver_s_d_ARG1 = global <2 x i64> <i64 0, i64 1>, align 16
1067 @llvm_mips_aver_s_d_ARG2 = global <2 x i64> <i64 2, i64 3>, align 16
1068 @llvm_mips_aver_s_d_RES  = global <2 x i64> <i64 0, i64 0>, align 16
1069
1070 define void @llvm_mips_aver_s_d_test() nounwind {
1071 entry:
1072   %0 = load <2 x i64>* @llvm_mips_aver_s_d_ARG1
1073   %1 = load <2 x i64>* @llvm_mips_aver_s_d_ARG2
1074   %2 = tail call <2 x i64> @llvm.mips.aver.s.d(<2 x i64> %0, <2 x i64> %1)
1075   store <2 x i64> %2, <2 x i64>* @llvm_mips_aver_s_d_RES
1076   ret void
1077 }
1078
1079 declare <2 x i64> @llvm.mips.aver.s.d(<2 x i64>, <2 x i64>) nounwind
1080
1081 ; CHECK: llvm_mips_aver_s_d_test:
1082 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_aver_s_d_ARG1)
1083 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_aver_s_d_ARG2)
1084 ; CHECK-DAG: ld.d [[WS:\$w[0-9]+]], 0([[R1]])
1085 ; CHECK-DAG: ld.d [[WT:\$w[0-9]+]], 0([[R2]])
1086 ; CHECK-DAG: aver_s.d [[WD:\$w[0-9]+]], [[WS]], [[WT]]
1087 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_aver_s_d_RES)
1088 ; CHECK-DAG: st.d [[WD]], 0([[R3]])
1089 ; CHECK: .size llvm_mips_aver_s_d_test
1090 ;
1091 @llvm_mips_aver_u_b_ARG1 = global <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, align 16
1092 @llvm_mips_aver_u_b_ARG2 = global <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, align 16
1093 @llvm_mips_aver_u_b_RES  = global <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, align 16
1094
1095 define void @llvm_mips_aver_u_b_test() nounwind {
1096 entry:
1097   %0 = load <16 x i8>* @llvm_mips_aver_u_b_ARG1
1098   %1 = load <16 x i8>* @llvm_mips_aver_u_b_ARG2
1099   %2 = tail call <16 x i8> @llvm.mips.aver.u.b(<16 x i8> %0, <16 x i8> %1)
1100   store <16 x i8> %2, <16 x i8>* @llvm_mips_aver_u_b_RES
1101   ret void
1102 }
1103
1104 declare <16 x i8> @llvm.mips.aver.u.b(<16 x i8>, <16 x i8>) nounwind
1105
1106 ; CHECK: llvm_mips_aver_u_b_test:
1107 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_aver_u_b_ARG1)
1108 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_aver_u_b_ARG2)
1109 ; CHECK-DAG: ld.b [[WS:\$w[0-9]+]], 0([[R1]])
1110 ; CHECK-DAG: ld.b [[WT:\$w[0-9]+]], 0([[R2]])
1111 ; CHECK-DAG: aver_u.b [[WD:\$w[0-9]+]], [[WS]], [[WT]]
1112 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_aver_u_b_RES)
1113 ; CHECK-DAG: st.b [[WD]], 0([[R3]])
1114 ; CHECK: .size llvm_mips_aver_u_b_test
1115 ;
1116 @llvm_mips_aver_u_h_ARG1 = global <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>, align 16
1117 @llvm_mips_aver_u_h_ARG2 = global <8 x i16> <i16 8, i16 9, i16 10, i16 11, i16 12, i16 13, i16 14, i16 15>, align 16
1118 @llvm_mips_aver_u_h_RES  = global <8 x i16> <i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>, align 16
1119
1120 define void @llvm_mips_aver_u_h_test() nounwind {
1121 entry:
1122   %0 = load <8 x i16>* @llvm_mips_aver_u_h_ARG1
1123   %1 = load <8 x i16>* @llvm_mips_aver_u_h_ARG2
1124   %2 = tail call <8 x i16> @llvm.mips.aver.u.h(<8 x i16> %0, <8 x i16> %1)
1125   store <8 x i16> %2, <8 x i16>* @llvm_mips_aver_u_h_RES
1126   ret void
1127 }
1128
1129 declare <8 x i16> @llvm.mips.aver.u.h(<8 x i16>, <8 x i16>) nounwind
1130
1131 ; CHECK: llvm_mips_aver_u_h_test:
1132 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_aver_u_h_ARG1)
1133 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_aver_u_h_ARG2)
1134 ; CHECK-DAG: ld.h [[WS:\$w[0-9]+]], 0([[R1]])
1135 ; CHECK-DAG: ld.h [[WT:\$w[0-9]+]], 0([[R2]])
1136 ; CHECK-DAG: aver_u.h [[WD:\$w[0-9]+]], [[WS]], [[WT]]
1137 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_aver_u_h_RES)
1138 ; CHECK-DAG: st.h [[WD]], 0([[R3]])
1139 ; CHECK: .size llvm_mips_aver_u_h_test
1140 ;
1141 @llvm_mips_aver_u_w_ARG1 = global <4 x i32> <i32 0, i32 1, i32 2, i32 3>, align 16
1142 @llvm_mips_aver_u_w_ARG2 = global <4 x i32> <i32 4, i32 5, i32 6, i32 7>, align 16
1143 @llvm_mips_aver_u_w_RES  = global <4 x i32> <i32 0, i32 0, i32 0, i32 0>, align 16
1144
1145 define void @llvm_mips_aver_u_w_test() nounwind {
1146 entry:
1147   %0 = load <4 x i32>* @llvm_mips_aver_u_w_ARG1
1148   %1 = load <4 x i32>* @llvm_mips_aver_u_w_ARG2
1149   %2 = tail call <4 x i32> @llvm.mips.aver.u.w(<4 x i32> %0, <4 x i32> %1)
1150   store <4 x i32> %2, <4 x i32>* @llvm_mips_aver_u_w_RES
1151   ret void
1152 }
1153
1154 declare <4 x i32> @llvm.mips.aver.u.w(<4 x i32>, <4 x i32>) nounwind
1155
1156 ; CHECK: llvm_mips_aver_u_w_test:
1157 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_aver_u_w_ARG1)
1158 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_aver_u_w_ARG2)
1159 ; CHECK-DAG: ld.w [[WS:\$w[0-9]+]], 0([[R1]])
1160 ; CHECK-DAG: ld.w [[WT:\$w[0-9]+]], 0([[R2]])
1161 ; CHECK-DAG: aver_u.w [[WD:\$w[0-9]+]], [[WS]], [[WT]]
1162 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_aver_u_w_RES)
1163 ; CHECK-DAG: st.w [[WD]], 0([[R3]])
1164 ; CHECK: .size llvm_mips_aver_u_w_test
1165 ;
1166 @llvm_mips_aver_u_d_ARG1 = global <2 x i64> <i64 0, i64 1>, align 16
1167 @llvm_mips_aver_u_d_ARG2 = global <2 x i64> <i64 2, i64 3>, align 16
1168 @llvm_mips_aver_u_d_RES  = global <2 x i64> <i64 0, i64 0>, align 16
1169
1170 define void @llvm_mips_aver_u_d_test() nounwind {
1171 entry:
1172   %0 = load <2 x i64>* @llvm_mips_aver_u_d_ARG1
1173   %1 = load <2 x i64>* @llvm_mips_aver_u_d_ARG2
1174   %2 = tail call <2 x i64> @llvm.mips.aver.u.d(<2 x i64> %0, <2 x i64> %1)
1175   store <2 x i64> %2, <2 x i64>* @llvm_mips_aver_u_d_RES
1176   ret void
1177 }
1178
1179 declare <2 x i64> @llvm.mips.aver.u.d(<2 x i64>, <2 x i64>) nounwind
1180
1181 ; CHECK: llvm_mips_aver_u_d_test:
1182 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_aver_u_d_ARG1)
1183 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_aver_u_d_ARG2)
1184 ; CHECK-DAG: ld.d [[WS:\$w[0-9]+]], 0([[R1]])
1185 ; CHECK-DAG: ld.d [[WT:\$w[0-9]+]], 0([[R2]])
1186 ; CHECK-DAG: aver_u.d [[WD:\$w[0-9]+]], [[WS]], [[WT]]
1187 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_aver_u_d_RES)
1188 ; CHECK-DAG: st.d [[WD]], 0([[R3]])
1189 ; CHECK: .size llvm_mips_aver_u_d_test
1190 ;