cross-project-tests/intrinsic-header-tests/wasm_simd128.c

   1 // REQUIRES: webassembly-registered-target
   2 // expected-no-diagnostics
   3
   4 // RUN: %clang %s -O2 -S -o - -target wasm32-unknown-unknown \
   5 // RUN: -msimd128 -mrelaxed-simd -mfp16 -Wcast-qual -Werror | FileCheck %s
   6
   7 #include <wasm_simd128.h>
   8
   9 // CHECK-LABEL: test_v128_load:
  10 // CHECK: v128.load 0:p2align=0{{$}}
  11 v128_t test_v128_load(const void *mem) { return wasm_v128_load(mem); }
  12
  13 // CHECK-LABEL: test_v128_load8_splat:
  14 // CHECK: v128.load8_splat 0{{$}}
  15 v128_t test_v128_load8_splat(const void *mem) {
  16   return wasm_v128_load8_splat(mem);
  17 }
  18
  19 // CHECK-LABEL: test_v128_load16_splat:
  20 // CHECK: v128.load16_splat 0:p2align=0{{$}}
  21 v128_t test_v128_load16_splat(const void *mem) {
  22   return wasm_v128_load16_splat(mem);
  23 }
  24
  25 // CHECK-LABEL: test_v128_load32_splat:
  26 // CHECK: v128.load32_splat 0:p2align=0{{$}}
  27 v128_t test_v128_load32_splat(const void *mem) {
  28   return wasm_v128_load32_splat(mem);
  29 }
  30
  31 // CHECK-LABEL: test_v128_load64_splat:
  32 // CHECK: v128.load64_splat 0:p2align=0{{$}}
  33 v128_t test_v128_load64_splat(const void *mem) {
  34   return wasm_v128_load64_splat(mem);
  35 }
  36
  37 // CHECK-LABEL: test_i16x8_load8x8:
  38 // CHECK: i16x8.load8x8_s 0:p2align=0{{$}}
  39 v128_t test_i16x8_load8x8(const void *mem) { return wasm_i16x8_load8x8(mem); }
  40
  41 // CHECK-LABEL: test_u16x8_load8x8:
  42 // CHECK: i16x8.load8x8_u 0:p2align=0{{$}}
  43 v128_t test_u16x8_load8x8(const void *mem) { return wasm_u16x8_load8x8(mem); }
  44
  45 // CHECK-LABEL: test_i32x4_load16x4:
  46 // CHECK: i32x4.load16x4_s 0:p2align=0{{$}}
  47 v128_t test_i32x4_load16x4(const void *mem) { return wasm_i32x4_load16x4(mem); }
  48
  49 // CHECK-LABEL: test_u32x4_load16x4:
  50 // CHECK: i32x4.load16x4_u 0:p2align=0{{$}}
  51 v128_t test_u32x4_load16x4(const void *mem) { return wasm_u32x4_load16x4(mem); }
  52
  53 // CHECK-LABEL: test_i64x2_load32x2:
  54 // CHECK: i64x2.load32x2_s 0:p2align=0{{$}}
  55 v128_t test_i64x2_load32x2(const void *mem) { return wasm_i64x2_load32x2(mem); }
  56
  57 // CHECK-LABEL: test_u64x2_load32x2:
  58 // CHECK: i64x2.load32x2_u 0:p2align=0{{$}}
  59 v128_t test_u64x2_load32x2(const void *mem) { return wasm_u64x2_load32x2(mem); }
  60
  61 // CHECK-LABEL: test_v128_load32_zero:
  62 // CHECK: v128.load32_zero 0:p2align=0{{$}}
  63 v128_t test_v128_load32_zero(const void *mem) {
  64   return wasm_v128_load32_zero(mem);
  65 }
  66
  67 // CHECK-LABEL: test_v128_load64_zero:
  68 // CHECK: v128.load64_zero 0:p2align=0{{$}}
  69 v128_t test_v128_load64_zero(const void *mem) {
  70   return wasm_v128_load64_zero(mem);
  71 }
  72
  73 // CHECK-LABEL: test_v128_load8_lane:
  74 // CHECK: v128.load8_lane 0, 15{{$}}
  75 v128_t test_v128_load8_lane(uint8_t *ptr, v128_t vec) {
  76   return wasm_v128_load8_lane(ptr, vec, 15);
  77 }
  78
  79 // CHECK-LABEL: test_v128_load16_lane:
  80 // CHECK: v128.load16_lane 0:p2align=0, 7{{$}}
  81 v128_t test_v128_load16_lane(uint16_t *ptr, v128_t vec) {
  82   return wasm_v128_load16_lane(ptr, vec, 7);
  83 }
  84
  85 // CHECK-LABEL: test_v128_load32_lane:
  86 // CHECK: v128.load32_lane 0:p2align=0, 3{{$}}
  87 v128_t test_v128_load32_lane(uint32_t *ptr, v128_t vec) {
  88   return wasm_v128_load32_lane(ptr, vec, 3);
  89 }
  90
  91 // CHECK-LABEL: test_v128_load64_lane:
  92 // CHECK: v128.load64_lane 0:p2align=0, 1{{$}}
  93 v128_t test_v128_load64_lane(uint64_t *ptr, v128_t vec) {
  94   return wasm_v128_load64_lane(ptr, vec, 1);
  95 }
  96
  97 // CHECK-LABEL: test_v128_store:
  98 // CHECK: v128.store 0:p2align=0{{$}}
  99 void test_v128_store(void *mem, v128_t a) { return wasm_v128_store(mem, a); }
 100
 101 // CHECK-LABEL: test_v128_store8_lane:
 102 // CHECK: v128.store8_lane 0, 15{{$}}
 103 void test_v128_store8_lane(uint8_t *ptr, v128_t vec) {
 104   return wasm_v128_store8_lane(ptr, vec, 15);
 105 }
 106
 107 // CHECK-LABEL: test_v128_store16_lane:
 108 // CHECK: v128.store16_lane 0:p2align=0, 7{{$}}
 109 void test_v128_store16_lane(uint16_t *ptr, v128_t vec) {
 110   return wasm_v128_store16_lane(ptr, vec, 7);
 111 }
 112
 113 // CHECK-LABEL: test_v128_store32_lane:
 114 // CHECK: v128.store32_lane 0:p2align=0, 3{{$}}
 115 void test_v128_store32_lane(uint32_t *ptr, v128_t vec) {
 116   return wasm_v128_store32_lane(ptr, vec, 3);
 117 }
 118
 119 // CHECK-LABEL: test_v128_store64_lane:
 120 // CHECK: v128.store64_lane 0:p2align=0, 1{{$}}
 121 void test_v128_store64_lane(uint64_t *ptr, v128_t vec) {
 122   return wasm_v128_store64_lane(ptr, vec, 1);
 123 }
 124
 125 // CHECK-LABEL: test_i8x16_make:
 126 // CHECK:      local.get 0{{$}}
 127 // CHECK-NEXT: i8x16.splat{{$}}
 128 // CHECK-NEXT: local.get 1{{$}}
 129 // CHECK-NEXT: i8x16.replace_lane 1{{$}}
 130 // CHECK-NEXT: local.get 2{{$}}
 131 // CHECK-NEXT: i8x16.replace_lane 2{{$}}
 132 // CHECK-NEXT: local.get 3{{$}}
 133 // CHECK-NEXT: i8x16.replace_lane 3{{$}}
 134 // CHECK-NEXT: local.get 4{{$}}
 135 // CHECK-NEXT: i8x16.replace_lane 4{{$}}
 136 // CHECK-NEXT: local.get 5{{$}}
 137 // CHECK-NEXT: i8x16.replace_lane 5{{$}}
 138 // CHECK-NEXT: local.get 6{{$}}
 139 // CHECK-NEXT: i8x16.replace_lane 6{{$}}
 140 // CHECK-NEXT: local.get 7{{$}}
 141 // CHECK-NEXT: i8x16.replace_lane 7{{$}}
 142 // CHECK-NEXT: local.get 8{{$}}
 143 // CHECK-NEXT: i8x16.replace_lane 8{{$}}
 144 // CHECK-NEXT: local.get 9{{$}}
 145 // CHECK-NEXT: i8x16.replace_lane 9{{$}}
 146 // CHECK-NEXT: local.get 10{{$}}
 147 // CHECK-NEXT: i8x16.replace_lane 10{{$}}
 148 // CHECK-NEXT: local.get 11{{$}}
 149 // CHECK-NEXT: i8x16.replace_lane 11{{$}}
 150 // CHECK-NEXT: local.get 12{{$}}
 151 // CHECK-NEXT: i8x16.replace_lane 12{{$}}
 152 // CHECK-NEXT: local.get 13{{$}}
 153 // CHECK-NEXT: i8x16.replace_lane 13{{$}}
 154 // CHECK-NEXT: local.get 14{{$}}
 155 // CHECK-NEXT: i8x16.replace_lane 14{{$}}
 156 // CHECK-NEXT: local.get 15{{$}}
 157 // CHECK-NEXT: i8x16.replace_lane 15{{$}}
 158 v128_t test_i8x16_make(int8_t c0, int8_t c1, int8_t c2, int8_t c3, int8_t c4,
 159                        int8_t c5, int8_t c6, int8_t c7, int8_t c8, int8_t c9,
 160                        int8_t c10, int8_t c11, int8_t c12, int8_t c13,
 161                        int8_t c14, int8_t c15) {
 162   return wasm_i8x16_make(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12,
 163                          c13, c14, c15);
 164 }
 165
 166 // CHECK-LABEL: test_i16x8_make:
 167 // CHECK:      local.get 0{{$}}
 168 // CHECK-NEXT: i16x8.splat{{$}}
 169 // CHECK-NEXT: local.get 1{{$}}
 170 // CHECK-NEXT: i16x8.replace_lane 1{{$}}
 171 // CHECK-NEXT: local.get 2{{$}}
 172 // CHECK-NEXT: i16x8.replace_lane 2{{$}}
 173 // CHECK-NEXT: local.get 3{{$}}
 174 // CHECK-NEXT: i16x8.replace_lane 3{{$}}
 175 // CHECK-NEXT: local.get 4{{$}}
 176 // CHECK-NEXT: i16x8.replace_lane 4{{$}}
 177 // CHECK-NEXT: local.get 5{{$}}
 178 // CHECK-NEXT: i16x8.replace_lane 5{{$}}
 179 // CHECK-NEXT: local.get 6{{$}}
 180 // CHECK-NEXT: i16x8.replace_lane 6{{$}}
 181 // CHECK-NEXT: local.get 7{{$}}
 182 // CHECK-NEXT: i16x8.replace_lane 7{{$}}
 183 v128_t test_i16x8_make(int16_t c0, int16_t c1, int16_t c2, int16_t c3,
 184                        int16_t c4, int16_t c5, int16_t c6, int16_t c7) {
 185   return wasm_i16x8_make(c0, c1, c2, c3, c4, c5, c6, c7);
 186 }
 187
 188 // CHECK-LABEL: test_i32x4_make:
 189 // CHECK:      local.get 0{{$}}
 190 // CHECK-NEXT: i32x4.splat{{$}}
 191 // CHECK-NEXT: local.get 1{{$}}
 192 // CHECK-NEXT: i32x4.replace_lane 1{{$}}
 193 // CHECK-NEXT: local.get 2{{$}}
 194 // CHECK-NEXT: i32x4.replace_lane 2{{$}}
 195 // CHECK-NEXT: local.get 3{{$}}
 196 // CHECK-NEXT: i32x4.replace_lane 3{{$}}
 197 v128_t test_i32x4_make(int32_t c0, int32_t c1, int32_t c2, int32_t c3) {
 198   return wasm_i32x4_make(c0, c1, c2, c3);
 199 }
 200
 201 // CHECK-LABEL: test_i64x2_make:
 202 // CHECK:      local.get 0{{$}}
 203 // CHECK-NEXT: i64x2.splat{{$}}
 204 // CHECK-NEXT: local.get 1{{$}}
 205 // CHECK-NEXT: i64x2.replace_lane 1{{$}}
 206 v128_t test_i64x2_make(int64_t c0, int64_t c1) {
 207   return wasm_i64x2_make(c0, c1);
 208 }
 209
 210 // CHECK-LABEL: test_f32x4_make:
 211 // CHECK:      local.get 0{{$}}
 212 // CHECK-NEXT: f32x4.splat{{$}}
 213 // CHECK-NEXT: local.get 1{{$}}
 214 // CHECK-NEXT: f32x4.replace_lane 1{{$}}
 215 // CHECK-NEXT: local.get 2{{$}}
 216 // CHECK-NEXT: f32x4.replace_lane 2{{$}}
 217 // CHECK-NEXT: local.get 3{{$}}
 218 // CHECK-NEXT: f32x4.replace_lane 3{{$}}
 219 v128_t test_f32x4_make(float c0, float c1, float c2, float c3) {
 220   return wasm_f32x4_make(c0, c1, c2, c3);
 221 }
 222
 223 // CHECK-LABEL: test_f64x2_make:
 224 // CHECK:      local.get 0{{$}}
 225 // CHECK-NEXT: f64x2.splat{{$}}
 226 // CHECK-NEXT: local.get 1{{$}}
 227 // CHECK-NEXT: f64x2.replace_lane 1{{$}}
 228 v128_t test_f64x2_make(double c0, double c1) { return wasm_f64x2_make(c0, c1); }
 229
 230 // CHECK-LABEL: test_i8x16_const:
 231 // CHECK: v128.const 50462976, 117835012, 185207048, 252579084{{$}}
 232 v128_t test_i8x16_const() {
 233   return wasm_i8x16_const(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
 234 }
 235
 236 // CHECK-LABEL: test_i16x8_const:
 237 // CHECK: v128.const 65536, 196610, 327684, 458758{{$}}
 238 v128_t test_i16x8_const() { return wasm_i16x8_const(0, 1, 2, 3, 4, 5, 6, 7); }
 239
 240 // CHECK-LABEL: test_i32x4_const:
 241 // CHECK: v128.const 0, 1, 2, 3{{$}}
 242 v128_t test_i32x4_const() { return wasm_i32x4_const(0, 1, 2, 3); }
 243
 244 // CHECK-LABEL: test_i64x2_const:
 245 // CHECK: v128.const 0, 0, 1, 0{{$}}
 246 v128_t test_i64x2_const() { return wasm_i64x2_const(0, 1); }
 247
 248 // CHECK-LABEL: test_f32x4_const:
 249 // CHECK: v128.const 0, 1065353216, 1073741824, 1077936128{{$}}
 250 v128_t test_f32x4_const() { return wasm_f32x4_const(0, 1, 2, 3); }
 251
 252 // CHECK-LABEL: test_f64x2_const:
 253 // CHECK: v128.const 0, 0, 0, 1072693248{{$}}
 254 v128_t test_f64x2_const() { return wasm_f64x2_const(0, 1); }
 255
 256 // CHECK-LABEL: test_i8x16_splat:
 257 // CHECK: i8x16.splat{{$}}
 258 v128_t test_i8x16_splat(int8_t a) { return wasm_i8x16_splat(a); }
 259
 260 // CHECK-LABEL: test_i8x16_extract_lane:
 261 // CHECK: i8x16.extract_lane_s 15{{$}}
 262 int8_t test_i8x16_extract_lane(v128_t a) {
 263   return wasm_i8x16_extract_lane(a, 15);
 264 }
 265
 266 // CHECK-LABEL: test_u8x16_extract_lane:
 267 // CHECK: i8x16.extract_lane_u 15{{$}}
 268 uint8_t test_u8x16_extract_lane(v128_t a) {
 269   return wasm_u8x16_extract_lane(a, 15);
 270 }
 271
 272 // CHECK-LABEL: test_i8x16_replace_lane:
 273 // CHECK: i8x16.replace_lane 15{{$}}
 274 v128_t test_i8x16_replace_lane(v128_t a, int8_t b) {
 275   return wasm_i8x16_replace_lane(a, 15, b);
 276 }
 277
 278 // CHECK-LABEL: test_i16x8_splat:
 279 // CHECK: i16x8.splat{{$}}
 280 v128_t test_i16x8_splat(int16_t a) { return wasm_i16x8_splat(a); }
 281
 282 // CHECK-LABEL: test_i16x8_extract_lane:
 283 // CHECK: i16x8.extract_lane_s 7{{$}}
 284 int16_t test_i16x8_extract_lane(v128_t a) {
 285   return wasm_i16x8_extract_lane(a, 7);
 286 }
 287
 288 // CHECK-LABEL: test_u16x8_extract_lane:
 289 // CHECK: i16x8.extract_lane_u 7{{$}}
 290 uint16_t test_u16x8_extract_lane(v128_t a) {
 291   return wasm_u16x8_extract_lane(a, 7);
 292 }
 293
 294 // CHECK-LABEL: test_i16x8_replace_lane:
 295 // CHECK: i16x8.replace_lane 7{{$}}
 296 v128_t test_i16x8_replace_lane(v128_t a, int16_t b) {
 297   return wasm_i16x8_replace_lane(a, 7, b);
 298 }
 299
 300 // CHECK-LABEL: test_i32x4_splat:
 301 // CHECK: i32x4.splat{{$}}
 302 v128_t test_i32x4_splat(int32_t a) { return wasm_i32x4_splat(a); }
 303
 304 // CHECK-LABEL: test_i32x4_extract_lane:
 305 // CHECK: i32x4.extract_lane 3{{$}}
 306 int32_t test_i32x4_extract_lane(v128_t a) {
 307   return wasm_i32x4_extract_lane(a, 3);
 308 }
 309
 310 // CHECK-LABEL: test_i32x4_replace_lane:
 311 // CHECK: i32x4.replace_lane 3{{$}}
 312 v128_t test_i32x4_replace_lane(v128_t a, int32_t b) {
 313   return wasm_i32x4_replace_lane(a, 3, b);
 314 }
 315
 316 // CHECK-LABEL: test_i64x2_splat:
 317 // CHECK: i64x2.splat{{$}}
 318 v128_t test_i64x2_splat(int64_t a) { return wasm_i64x2_splat(a); }
 319
 320 // CHECK-LABEL: test_i64x2_extract_lane:
 321 // CHECK: i64x2.extract_lane 1{{$}}
 322 int64_t test_i64x2_extract_lane(v128_t a) {
 323   return wasm_i64x2_extract_lane(a, 1);
 324 }
 325
 326 // CHECK-LABEL: test_i64x2_replace_lane:
 327 // CHECK: i64x2.replace_lane 1{{$}}
 328 v128_t test_i64x2_replace_lane(v128_t a, int64_t b) {
 329   return wasm_i64x2_replace_lane(a, 1, b);
 330 }
 331
 332 // CHECK-LABEL: test_f32x4_splat:
 333 // CHECK: f32x4.splat{{$}}
 334 v128_t test_f32x4_splat(float a) { return wasm_f32x4_splat(a); }
 335
 336 // CHECK-LABEL: test_f32x4_extract_lane:
 337 // CHECK: f32x4.extract_lane 3{{$}}
 338 float test_f32x4_extract_lane(v128_t a) {
 339   return wasm_f32x4_extract_lane(a, 3);
 340 }
 341
 342 // CHECK-LABEL: test_f32x4_replace_lane:
 343 // CHECK: f32x4.replace_lane 3{{$}}
 344 v128_t test_f32x4_replace_lane(v128_t a, float b) {
 345   return wasm_f32x4_replace_lane(a, 3, b);
 346 }
 347
 348 // CHECK-LABEL: test_f64x2_splat:
 349 // CHECK: f64x2.splat{{$}}
 350 v128_t test_f64x2_splat(double a) { return wasm_f64x2_splat(a); }
 351
 352 // CHECK-LABEL: test_f64x2_extract_lane:
 353 // CHECK: f64x2.extract_lane 1{{$}}
 354 double test_f64x2_extract_lane(v128_t a) {
 355   return wasm_f64x2_extract_lane(a, 1);
 356 }
 357
 358 // CHECK-LABEL: test_f64x2_replace_lane:
 359 // CHECK: f64x2.replace_lane 1{{$}}
 360 v128_t test_f64x2_replace_lane(v128_t a, double b) {
 361   return wasm_f64x2_replace_lane(a, 1, b);
 362 }
 363
 364 // CHECK-LABEL: test_i8x16_eq:
 365 // CHECK: i8x16.eq{{$}}
 366 v128_t test_i8x16_eq(v128_t a, v128_t b) { return wasm_i8x16_eq(a, b); }
 367
 368 // CHECK-LABEL: test_i8x16_ne:
 369 // CHECK: i8x16.ne{{$}}
 370 v128_t test_i8x16_ne(v128_t a, v128_t b) { return wasm_i8x16_ne(a, b); }
 371
 372 // CHECK-LABEL: test_i8x16_lt:
 373 // CHECK: i8x16.lt_s{{$}}
 374 v128_t test_i8x16_lt(v128_t a, v128_t b) { return wasm_i8x16_lt(a, b); }
 375
 376 // CHECK-LABEL: test_u8x16_lt:
 377 // CHECK: i8x16.lt_u{{$}}
 378 v128_t test_u8x16_lt(v128_t a, v128_t b) { return wasm_u8x16_lt(a, b); }
 379
 380 // CHECK-LABEL: test_i8x16_gt:
 381 // CHECK: i8x16.gt_s{{$}}
 382 v128_t test_i8x16_gt(v128_t a, v128_t b) { return wasm_i8x16_gt(a, b); }
 383
 384 // CHECK-LABEL: test_u8x16_gt:
 385 // CHECK: i8x16.gt_u{{$}}
 386 v128_t test_u8x16_gt(v128_t a, v128_t b) { return wasm_u8x16_gt(a, b); }
 387
 388 // CHECK-LABEL: test_i8x16_le:
 389 // CHECK: i8x16.le_s{{$}}
 390 v128_t test_i8x16_le(v128_t a, v128_t b) { return wasm_i8x16_le(a, b); }
 391
 392 // CHECK-LABEL: test_u8x16_le:
 393 // CHECK: i8x16.le_u{{$}}
 394 v128_t test_u8x16_le(v128_t a, v128_t b) { return wasm_u8x16_le(a, b); }
 395
 396 // CHECK-LABEL: test_i8x16_ge:
 397 // CHECK: i8x16.ge_s{{$}}
 398 v128_t test_i8x16_ge(v128_t a, v128_t b) { return wasm_i8x16_ge(a, b); }
 399
 400 // CHECK-LABEL: test_u8x16_ge:
 401 // CHECK: i8x16.ge_u{{$}}
 402 v128_t test_u8x16_ge(v128_t a, v128_t b) { return wasm_u8x16_ge(a, b); }
 403
 404 // CHECK-LABEL: test_i16x8_eq:
 405 // CHECK: i16x8.eq{{$}}
 406 v128_t test_i16x8_eq(v128_t a, v128_t b) { return wasm_i16x8_eq(a, b); }
 407
 408 // CHECK-LABEL: test_i16x8_ne:
 409 // CHECK: i16x8.ne{{$}}
 410 v128_t test_i16x8_ne(v128_t a, v128_t b) { return wasm_i16x8_ne(a, b); }
 411
 412 // CHECK-LABEL: test_i16x8_lt:
 413 // CHECK: i16x8.lt_s{{$}}
 414 v128_t test_i16x8_lt(v128_t a, v128_t b) { return wasm_i16x8_lt(a, b); }
 415
 416 // CHECK-LABEL: test_u16x8_lt:
 417 // CHECK: i16x8.lt_u{{$}}
 418 v128_t test_u16x8_lt(v128_t a, v128_t b) { return wasm_u16x8_lt(a, b); }
 419
 420 // CHECK-LABEL: test_i16x8_gt:
 421 // CHECK: i16x8.gt_s{{$}}
 422 v128_t test_i16x8_gt(v128_t a, v128_t b) { return wasm_i16x8_gt(a, b); }
 423
 424 // CHECK-LABEL: test_u16x8_gt:
 425 // CHECK: i16x8.gt_u{{$}}
 426 v128_t test_u16x8_gt(v128_t a, v128_t b) { return wasm_u16x8_gt(a, b); }
 427
 428 // CHECK-LABEL: test_i16x8_le:
 429 // CHECK: i16x8.le_s{{$}}
 430 v128_t test_i16x8_le(v128_t a, v128_t b) { return wasm_i16x8_le(a, b); }
 431
 432 // CHECK-LABEL: test_u16x8_le:
 433 // CHECK: i16x8.le_u{{$}}
 434 v128_t test_u16x8_le(v128_t a, v128_t b) { return wasm_u16x8_le(a, b); }
 435
 436 // CHECK-LABEL: test_i16x8_ge:
 437 // CHECK: i16x8.ge_s{{$}}
 438 v128_t test_i16x8_ge(v128_t a, v128_t b) { return wasm_i16x8_ge(a, b); }
 439
 440 // CHECK-LABEL: test_u16x8_ge:
 441 // CHECK: i16x8.ge_u{{$}}
 442 v128_t test_u16x8_ge(v128_t a, v128_t b) { return wasm_u16x8_ge(a, b); }
 443
 444 // CHECK-LABEL: test_i32x4_eq:
 445 // CHECK: i32x4.eq{{$}}
 446 v128_t test_i32x4_eq(v128_t a, v128_t b) { return wasm_i32x4_eq(a, b); }
 447
 448 // CHECK-LABEL: test_i32x4_ne:
 449 // CHECK: i32x4.ne{{$}}
 450 v128_t test_i32x4_ne(v128_t a, v128_t b) { return wasm_i32x4_ne(a, b); }
 451
 452 // CHECK-LABEL: test_i32x4_lt:
 453 // CHECK: i32x4.lt_s{{$}}
 454 v128_t test_i32x4_lt(v128_t a, v128_t b) { return wasm_i32x4_lt(a, b); }
 455
 456 // CHECK-LABEL: test_u32x4_lt:
 457 // CHECK: i32x4.lt_u{{$}}
 458 v128_t test_u32x4_lt(v128_t a, v128_t b) { return wasm_u32x4_lt(a, b); }
 459
 460 // CHECK-LABEL: test_i32x4_gt:
 461 // CHECK: i32x4.gt_s{{$}}
 462 v128_t test_i32x4_gt(v128_t a, v128_t b) { return wasm_i32x4_gt(a, b); }
 463
 464 // CHECK-LABEL: test_u32x4_gt:
 465 // CHECK: i32x4.gt_u{{$}}
 466 v128_t test_u32x4_gt(v128_t a, v128_t b) { return wasm_u32x4_gt(a, b); }
 467
 468 // CHECK-LABEL: test_i32x4_le:
 469 // CHECK: i32x4.le_s{{$}}
 470 v128_t test_i32x4_le(v128_t a, v128_t b) { return wasm_i32x4_le(a, b); }
 471
 472 // CHECK-LABEL: test_u32x4_le:
 473 // CHECK: i32x4.le_u{{$}}
 474 v128_t test_u32x4_le(v128_t a, v128_t b) { return wasm_u32x4_le(a, b); }
 475
 476 // CHECK-LABEL: test_i32x4_ge:
 477 // CHECK: i32x4.ge_s{{$}}
 478 v128_t test_i32x4_ge(v128_t a, v128_t b) { return wasm_i32x4_ge(a, b); }
 479
 480 // CHECK-LABEL: test_u32x4_ge:
 481 // CHECK: i32x4.ge_u{{$}}
 482 v128_t test_u32x4_ge(v128_t a, v128_t b) { return wasm_u32x4_ge(a, b); }
 483
 484 // CHECK-LABEL: test_i64x2_eq:
 485 // CHECK: i64x2.eq{{$}}
 486 v128_t test_i64x2_eq(v128_t a, v128_t b) { return wasm_i64x2_eq(a, b); }
 487
 488 // CHECK-LABEL: test_i64x2_ne:
 489 // CHECK: i64x2.ne{{$}}
 490 v128_t test_i64x2_ne(v128_t a, v128_t b) { return wasm_i64x2_ne(a, b); }
 491
 492 // CHECK-LABEL: test_i64x2_lt:
 493 // CHECK: i64x2.lt_s{{$}}
 494 v128_t test_i64x2_lt(v128_t a, v128_t b) { return wasm_i64x2_lt(a, b); }
 495
 496 // CHECK-LABEL: test_i64x2_gt:
 497 // CHECK: i64x2.gt_s{{$}}
 498 v128_t test_i64x2_gt(v128_t a, v128_t b) { return wasm_i64x2_gt(a, b); }
 499
 500 // CHECK-LABEL: test_i64x2_le:
 501 // CHECK: i64x2.le_s{{$}}
 502 v128_t test_i64x2_le(v128_t a, v128_t b) { return wasm_i64x2_le(a, b); }
 503
 504 // CHECK-LABEL: test_i64x2_ge:
 505 // CHECK: i64x2.ge_s{{$}}
 506 v128_t test_i64x2_ge(v128_t a, v128_t b) { return wasm_i64x2_ge(a, b); }
 507
 508 // CHECK-LABEL: test_f32x4_eq:
 509 // CHECK: f32x4.eq{{$}}
 510 v128_t test_f32x4_eq(v128_t a, v128_t b) { return wasm_f32x4_eq(a, b); }
 511
 512 // CHECK-LABEL: test_f32x4_ne:
 513 // CHECK: f32x4.ne{{$}}
 514 v128_t test_f32x4_ne(v128_t a, v128_t b) { return wasm_f32x4_ne(a, b); }
 515
 516 // CHECK-LABEL: test_f32x4_lt:
 517 // CHECK: f32x4.lt{{$}}
 518 v128_t test_f32x4_lt(v128_t a, v128_t b) { return wasm_f32x4_lt(a, b); }
 519
 520 // CHECK-LABEL: test_f32x4_gt:
 521 // CHECK: f32x4.gt{{$}}
 522 v128_t test_f32x4_gt(v128_t a, v128_t b) { return wasm_f32x4_gt(a, b); }
 523
 524 // CHECK-LABEL: test_f32x4_le:
 525 // CHECK: f32x4.le{{$}}
 526 v128_t test_f32x4_le(v128_t a, v128_t b) { return wasm_f32x4_le(a, b); }
 527
 528 // CHECK-LABEL: test_f32x4_ge:
 529 // CHECK: f32x4.ge{{$}}
 530 v128_t test_f32x4_ge(v128_t a, v128_t b) { return wasm_f32x4_ge(a, b); }
 531
 532 // CHECK-LABEL: test_f64x2_eq:
 533 // CHECK: f64x2.eq{{$}}
 534 v128_t test_f64x2_eq(v128_t a, v128_t b) { return wasm_f64x2_eq(a, b); }
 535
 536 // CHECK-LABEL: test_f64x2_ne:
 537 // CHECK: f64x2.ne{{$}}
 538 v128_t test_f64x2_ne(v128_t a, v128_t b) { return wasm_f64x2_ne(a, b); }
 539
 540 // CHECK-LABEL: test_f64x2_lt:
 541 // CHECK: f64x2.lt{{$}}
 542 v128_t test_f64x2_lt(v128_t a, v128_t b) { return wasm_f64x2_lt(a, b); }
 543
 544 // CHECK-LABEL: test_f64x2_gt:
 545 // CHECK: f64x2.gt{{$}}
 546 v128_t test_f64x2_gt(v128_t a, v128_t b) { return wasm_f64x2_gt(a, b); }
 547
 548 // CHECK-LABEL: test_f64x2_le:
 549 // CHECK: f64x2.le{{$}}
 550 v128_t test_f64x2_le(v128_t a, v128_t b) { return wasm_f64x2_le(a, b); }
 551
 552 // CHECK-LABEL: test_f64x2_ge:
 553 // CHECK: f64x2.ge{{$}}
 554 v128_t test_f64x2_ge(v128_t a, v128_t b) { return wasm_f64x2_ge(a, b); }
 555
 556 // CHECK-LABEL: test_v128_not:
 557 // CHECK: v128.not{{$}}
 558 v128_t test_v128_not(v128_t a) { return wasm_v128_not(a); }
 559
 560 // CHECK-LABEL: test_v128_and:
 561 // CHECK: v128.and{{$}}
 562 v128_t test_v128_and(v128_t a, v128_t b) { return wasm_v128_and(a, b); }
 563
 564 // CHECK-LABEL: test_v128_or:
 565 // CHECK: v128.or{{$}}
 566 v128_t test_v128_or(v128_t a, v128_t b) { return wasm_v128_or(a, b); }
 567
 568 // CHECK-LABEL: test_v128_xor:
 569 // CHECK: v128.xor{{$}}
 570 v128_t test_v128_xor(v128_t a, v128_t b) { return wasm_v128_xor(a, b); }
 571
 572 // CHECK-LABEL: test_v128_andnot:
 573 // CHECK: v128.andnot{{$}}
 574 v128_t test_v128_andnot(v128_t a, v128_t b) { return wasm_v128_andnot(a, b); }
 575
 576 // CHECK-LABEL: test_v128_any_true:
 577 // CHECK: v128.any_true{{$}}
 578 bool test_v128_any_true(v128_t a) { return wasm_v128_any_true(a); }
 579
 580 // CHECK-LABEL: test_v128_bitselect:
 581 // CHECK: v128.bitselect{{$}}
 582 v128_t test_v128_bitselect(v128_t a, v128_t b, v128_t mask) {
 583   return wasm_v128_bitselect(a, b, mask);
 584 }
 585
 586 // CHECK-LABEL: test_i8x16_abs:
 587 // CHECK: i8x16.abs{{$}}
 588 v128_t test_i8x16_abs(v128_t a) { return wasm_i8x16_abs(a); }
 589
 590 // CHECK-LABEL: test_i8x16_neg:
 591 // CHECK: i8x16.neg{{$}}
 592 v128_t test_i8x16_neg(v128_t a) { return wasm_i8x16_neg(a); }
 593
 594 // CHECK-LABEL: test_i8x16_all_true:
 595 // CHECK: i8x16.all_true{{$}}
 596 bool test_i8x16_all_true(v128_t a) { return wasm_i8x16_all_true(a); }
 597
 598 // CHECK-LABEL: test_i8x16_bitmask:
 599 // CHECK: i8x16.bitmask{{$}}
 600 int32_t test_i8x16_bitmask(v128_t a) { return wasm_i8x16_bitmask(a); }
 601
 602 // CHECK-LABEL: test_i8x16_popcnt:
 603 // CHECK: i8x16.popcnt{{$}}
 604 v128_t test_i8x16_popcnt(v128_t a) { return wasm_i8x16_popcnt(a); }
 605
 606 // CHECK-LABEL: test_i8x16_shl:
 607 // CHECK: i8x16.shl{{$}}
 608 v128_t test_i8x16_shl(v128_t a, int32_t b) { return wasm_i8x16_shl(a, b); }
 609
 610 // CHECK-LABEL: test_i8x16_shr:
 611 // CHECK: i8x16.shr_s{{$}}
 612 v128_t test_i8x16_shr(v128_t a, int32_t b) { return wasm_i8x16_shr(a, b); }
 613
 614 // CHECK-LABEL: test_u8x16_shr:
 615 // CHECK: i8x16.shr_u{{$}}
 616 v128_t test_u8x16_shr(v128_t a, int32_t b) { return wasm_u8x16_shr(a, b); }
 617
 618 // CHECK-LABEL: test_i8x16_add:
 619 // CHECK: i8x16.add{{$}}
 620 v128_t test_i8x16_add(v128_t a, v128_t b) { return wasm_i8x16_add(a, b); }
 621
 622 // CHECK-LABEL: test_i8x16_add_sat:
 623 // CHECK: i8x16.add_sat_s{{$}}
 624 v128_t test_i8x16_add_sat(v128_t a, v128_t b) {
 625   return wasm_i8x16_add_sat(a, b);
 626 }
 627
 628 // CHECK-LABEL: test_u8x16_add_sat:
 629 // CHECK: i8x16.add_sat_u{{$}}
 630 v128_t test_u8x16_add_sat(v128_t a, v128_t b) {
 631   return wasm_u8x16_add_sat(a, b);
 632 }
 633
 634 // CHECK-LABEL: test_i8x16_sub:
 635 // CHECK: i8x16.sub{{$}}
 636 v128_t test_i8x16_sub(v128_t a, v128_t b) { return wasm_i8x16_sub(a, b); }
 637
 638 // CHECK-LABEL: test_i8x16_sub_sat:
 639 // CHECK: i8x16.sub_sat_s{{$}}
 640 v128_t test_i8x16_sub_sat(v128_t a, v128_t b) {
 641   return wasm_i8x16_sub_sat(a, b);
 642 }
 643
 644 // CHECK-LABEL: test_u8x16_sub_sat:
 645 // CHECK: i8x16.sub_sat_u{{$}}
 646 v128_t test_u8x16_sub_sat(v128_t a, v128_t b) {
 647   return wasm_u8x16_sub_sat(a, b);
 648 }
 649
 650 // CHECK-LABEL: test_i8x16_min:
 651 // CHECK: i8x16.min_s{{$}}
 652 v128_t test_i8x16_min(v128_t a, v128_t b) { return wasm_i8x16_min(a, b); }
 653
 654 // CHECK-LABEL: test_u8x16_min:
 655 // CHECK: i8x16.min_u{{$}}
 656 v128_t test_u8x16_min(v128_t a, v128_t b) { return wasm_u8x16_min(a, b); }
 657
 658 // CHECK-LABEL: test_i8x16_max:
 659 // CHECK: i8x16.max_s{{$}}
 660 v128_t test_i8x16_max(v128_t a, v128_t b) { return wasm_i8x16_max(a, b); }
 661
 662 // CHECK-LABEL: test_u8x16_max:
 663 // CHECK: i8x16.max_u{{$}}
 664 v128_t test_u8x16_max(v128_t a, v128_t b) { return wasm_u8x16_max(a, b); }
 665
 666 // CHECK-LABEL: test_u8x16_avgr:
 667 // CHECK: i8x16.avgr_u{{$}}
 668 v128_t test_u8x16_avgr(v128_t a, v128_t b) { return wasm_u8x16_avgr(a, b); }
 669
 670 // CHECK-LABEL: test_i16x8_abs:
 671 // CHECK: i16x8.abs{{$}}
 672 v128_t test_i16x8_abs(v128_t a) { return wasm_i16x8_abs(a); }
 673
 674 // CHECK-LABEL: test_i16x8_neg:
 675 // CHECK: i16x8.neg{{$}}
 676 v128_t test_i16x8_neg(v128_t a) { return wasm_i16x8_neg(a); }
 677
 678 // CHECK-LABEL: test_i16x8_all_true:
 679 // CHECK: i16x8.all_true{{$}}
 680 bool test_i16x8_all_true(v128_t a) { return wasm_i16x8_all_true(a); }
 681
 682 // CHECK-LABEL: test_i16x8_bitmask:
 683 // CHECK: i16x8.bitmask{{$}}
 684 int32_t test_i16x8_bitmask(v128_t a) { return wasm_i16x8_bitmask(a); }
 685
 686 // CHECK-LABEL: test_i16x8_shl:
 687 // CHECK: i16x8.shl{{$}}
 688 v128_t test_i16x8_shl(v128_t a, int32_t b) { return wasm_i16x8_shl(a, b); }
 689
 690 // CHECK-LABEL: test_i16x8_shr:
 691 // CHECK: i16x8.shr_s{{$}}
 692 v128_t test_i16x8_shr(v128_t a, int32_t b) { return wasm_i16x8_shr(a, b); }
 693
 694 // CHECK-LABEL: test_u16x8_shr:
 695 // CHECK: i16x8.shr_u{{$}}
 696 v128_t test_u16x8_shr(v128_t a, int32_t b) { return wasm_u16x8_shr(a, b); }
 697
 698 // CHECK-LABEL: test_i16x8_add:
 699 // CHECK: i16x8.add{{$}}
 700 v128_t test_i16x8_add(v128_t a, v128_t b) { return wasm_i16x8_add(a, b); }
 701
 702 // CHECK-LABEL: test_i16x8_add_sat:
 703 // CHECK: i16x8.add_sat_s{{$}}
 704 v128_t test_i16x8_add_sat(v128_t a, v128_t b) {
 705   return wasm_i16x8_add_sat(a, b);
 706 }
 707
 708 // CHECK-LABEL: test_u16x8_add_sat:
 709 // CHECK: i16x8.add_sat_u{{$}}
 710 v128_t test_u16x8_add_sat(v128_t a, v128_t b) {
 711   return wasm_u16x8_add_sat(a, b);
 712 }
 713
 714 // CHECK-LABEL: test_i16x8_sub:
 715 // CHECK: i16x8.sub{{$}}
 716 v128_t test_i16x8_sub(v128_t a, v128_t b) { return wasm_i16x8_sub(a, b); }
 717
 718 // CHECK-LABEL: test_i16x8_sub_sat:
 719 // CHECK: i16x8.sub_sat_s{{$}}
 720 v128_t test_i16x8_sub_sat(v128_t a, v128_t b) {
 721   return wasm_i16x8_sub_sat(a, b);
 722 }
 723
 724 // CHECK-LABEL: test_u16x8_sub_sat:
 725 // CHECK: i16x8.sub_sat_u{{$}}
 726 v128_t test_u16x8_sub_sat(v128_t a, v128_t b) {
 727   return wasm_u16x8_sub_sat(a, b);
 728 }
 729
 730 // CHECK-LABEL: test_i16x8_mul:
 731 // CHECK: i16x8.mul{{$}}
 732 v128_t test_i16x8_mul(v128_t a, v128_t b) { return wasm_i16x8_mul(a, b); }
 733
 734 // CHECK-LABEL: test_i16x8_min:
 735 // CHECK: i16x8.min_s{{$}}
 736 v128_t test_i16x8_min(v128_t a, v128_t b) { return wasm_i16x8_min(a, b); }
 737
 738 // CHECK-LABEL: test_u16x8_min:
 739 // CHECK: i16x8.min_u{{$}}
 740 v128_t test_u16x8_min(v128_t a, v128_t b) { return wasm_u16x8_min(a, b); }
 741
 742 // CHECK-LABEL: test_i16x8_max:
 743 // CHECK: i16x8.max_s{{$}}
 744 v128_t test_i16x8_max(v128_t a, v128_t b) { return wasm_i16x8_max(a, b); }
 745
 746 // CHECK-LABEL: test_u16x8_max:
 747 // CHECK: i16x8.max_u{{$}}
 748 v128_t test_u16x8_max(v128_t a, v128_t b) { return wasm_u16x8_max(a, b); }
 749
 750 // CHECK-LABEL: test_u16x8_avgr:
 751 // CHECK: i16x8.avgr_u{{$}}
 752 v128_t test_u16x8_avgr(v128_t a, v128_t b) { return wasm_u16x8_avgr(a, b); }
 753
 754 // CHECK-LABEL: test_i32x4_abs:
 755 // CHECK: i32x4.abs{{$}}
 756 v128_t test_i32x4_abs(v128_t a) { return wasm_i32x4_abs(a); }
 757
 758 // CHECK-LABEL: test_i32x4_neg:
 759 // CHECK: i32x4.neg{{$}}
 760 v128_t test_i32x4_neg(v128_t a) { return wasm_i32x4_neg(a); }
 761
 762 // CHECK-LABEL: test_i32x4_all_true:
 763 // CHECK: i32x4.all_true{{$}}
 764 bool test_i32x4_all_true(v128_t a) { return wasm_i32x4_all_true(a); }
 765
 766 // CHECK-LABEL: test_i32x4_bitmask:
 767 // CHECK: i32x4.bitmask{{$}}
 768 int32_t test_i32x4_bitmask(v128_t a) { return wasm_i32x4_bitmask(a); }
 769
 770 // CHECK-LABEL: test_i32x4_shl:
 771 // CHECK: i32x4.shl{{$}}
 772 v128_t test_i32x4_shl(v128_t a, int32_t b) { return wasm_i32x4_shl(a, b); }
 773
 774 // CHECK-LABEL: test_i32x4_shr:
 775 // CHECK: i32x4.shr_s{{$}}
 776 v128_t test_i32x4_shr(v128_t a, int32_t b) { return wasm_i32x4_shr(a, b); }
 777
 778 // CHECK-LABEL: test_u32x4_shr:
 779 // CHECK: i32x4.shr_u{{$}}
 780 v128_t test_u32x4_shr(v128_t a, int32_t b) { return wasm_u32x4_shr(a, b); }
 781
 782 // CHECK-LABEL: test_i32x4_add:
 783 // CHECK: i32x4.add{{$}}
 784 v128_t test_i32x4_add(v128_t a, v128_t b) { return wasm_i32x4_add(a, b); }
 785
 786 // CHECK-LABEL: test_i32x4_sub:
 787 // CHECK: i32x4.sub{{$}}
 788 v128_t test_i32x4_sub(v128_t a, v128_t b) { return wasm_i32x4_sub(a, b); }
 789
 790 // CHECK-LABEL: test_i32x4_mul:
 791 // CHECK: i32x4.mul{{$}}
 792 v128_t test_i32x4_mul(v128_t a, v128_t b) { return wasm_i32x4_mul(a, b); }
 793
 794 // CHECK-LABEL: test_i32x4_min:
 795 // CHECK: i32x4.min_s{{$}}
 796 v128_t test_i32x4_min(v128_t a, v128_t b) { return wasm_i32x4_min(a, b); }
 797
 798 // CHECK-LABEL: test_u32x4_min:
 799 // CHECK: i32x4.min_u{{$}}
 800 v128_t test_u32x4_min(v128_t a, v128_t b) { return wasm_u32x4_min(a, b); }
 801
 802 // CHECK-LABEL: test_i32x4_max:
 803 // CHECK: i32x4.max_s{{$}}
 804 v128_t test_i32x4_max(v128_t a, v128_t b) { return wasm_i32x4_max(a, b); }
 805
 806 // CHECK-LABEL: test_u32x4_max:
 807 // CHECK: i32x4.max_u{{$}}
 808 v128_t test_u32x4_max(v128_t a, v128_t b) { return wasm_u32x4_max(a, b); }
 809
 810 // CHECK-LABEL: test_i32x4_dot_i16x8:
 811 // CHECK: i32x4.dot_i16x8_s{{$}}
 812 v128_t test_i32x4_dot_i16x8(v128_t a, v128_t b) {
 813   return wasm_i32x4_dot_i16x8(a, b);
 814 }
 815
 816 // CHECK-LABEL: test_i64x2_abs:
 817 // CHECK: i64x2.abs{{$}}
 818 v128_t test_i64x2_abs(v128_t a) { return wasm_i64x2_abs(a); }
 819
 820 // CHECK-LABEL: test_i64x2_neg:
 821 // CHECK: i64x2.neg{{$}}
 822 v128_t test_i64x2_neg(v128_t a) { return wasm_i64x2_neg(a); }
 823
 824 // CHECK-LABEL: test_i64x2_all_true:
 825 // CHECK: i64x2.all_true{{$}}
 826 bool test_i64x2_all_true(v128_t a) { return wasm_i64x2_all_true(a); }
 827
 828 // CHECK-LABEL: test_i64x2_bitmask:
 829 // CHECK: i64x2.bitmask{{$}}
 830 int32_t test_i64x2_bitmask(v128_t a) { return wasm_i64x2_bitmask(a); }
 831
 832 // CHECK-LABEL: test_i64x2_shl:
 833 // CHECK: i64x2.shl{{$}}
 834 v128_t test_i64x2_shl(v128_t a, int32_t b) { return wasm_i64x2_shl(a, b); }
 835
 836 // CHECK-LABEL: test_i64x2_shr:
 837 // CHECK: i64x2.shr_s{{$}}
 838 v128_t test_i64x2_shr(v128_t a, int32_t b) { return wasm_i64x2_shr(a, b); }
 839
 840 // CHECK-LABEL: test_u64x2_shr:
 841 // CHECK: i64x2.shr_u{{$}}
 842 v128_t test_u64x2_shr(v128_t a, int32_t b) { return wasm_u64x2_shr(a, b); }
 843
 844 // CHECK-LABEL: test_i64x2_add:
 845 // CHECK: i64x2.add{{$}}
 846 v128_t test_i64x2_add(v128_t a, v128_t b) { return wasm_i64x2_add(a, b); }
 847
 848 // CHECK-LABEL: test_i64x2_sub:
 849 // CHECK: i64x2.sub{{$}}
 850 v128_t test_i64x2_sub(v128_t a, v128_t b) { return wasm_i64x2_sub(a, b); }
 851
 852 // CHECK-LABEL: test_i64x2_mul:
 853 // CHECK: i64x2.mul{{$}}
 854 v128_t test_i64x2_mul(v128_t a, v128_t b) { return wasm_i64x2_mul(a, b); }
 855
 856 // CHECK-LABEL: test_f32x4_abs:
 857 // CHECK: f32x4.abs{{$}}
 858 v128_t test_f32x4_abs(v128_t a) { return wasm_f32x4_abs(a); }
 859
 860 // CHECK-LABEL: test_f32x4_neg:
 861 // CHECK: f32x4.neg{{$}}
 862 v128_t test_f32x4_neg(v128_t a) { return wasm_f32x4_neg(a); }
 863
 864 // CHECK-LABEL: test_f32x4_sqrt:
 865 // CHECK: f32x4.sqrt{{$}}
 866 v128_t test_f32x4_sqrt(v128_t a) { return wasm_f32x4_sqrt(a); }
 867
 868 // CHECK-LABEL: test_f32x4_ceil:
 869 // CHECK: f32x4.ceil{{$}}
 870 v128_t test_f32x4_ceil(v128_t a) { return wasm_f32x4_ceil(a); }
 871
 872 // CHECK-LABEL: test_f32x4_floor:
 873 // CHECK: f32x4.floor{{$}}
 874 v128_t test_f32x4_floor(v128_t a) { return wasm_f32x4_floor(a); }
 875
 876 // CHECK-LABEL: test_f32x4_trunc:
 877 // CHECK: f32x4.trunc{{$}}
 878 v128_t test_f32x4_trunc(v128_t a) { return wasm_f32x4_trunc(a); }
 879
 880 // CHECK-LABEL: test_f32x4_nearest:
 881 // CHECK: f32x4.nearest{{$}}
 882 v128_t test_f32x4_nearest(v128_t a) { return wasm_f32x4_nearest(a); }
 883
 884 // CHECK-LABEL: test_f32x4_add:
 885 // CHECK: f32x4.add{{$}}
 886 v128_t test_f32x4_add(v128_t a, v128_t b) { return wasm_f32x4_add(a, b); }
 887
 888 // CHECK-LABEL: test_f32x4_sub:
 889 // CHECK: f32x4.sub{{$}}
 890 v128_t test_f32x4_sub(v128_t a, v128_t b) { return wasm_f32x4_sub(a, b); }
 891
 892 // CHECK-LABEL: test_f32x4_mul:
 893 // CHECK: f32x4.mul{{$}}
 894 v128_t test_f32x4_mul(v128_t a, v128_t b) { return wasm_f32x4_mul(a, b); }
 895
 896 // CHECK-LABEL: test_f32x4_div:
 897 // CHECK: f32x4.div{{$}}
 898 v128_t test_f32x4_div(v128_t a, v128_t b) { return wasm_f32x4_div(a, b); }
 899
 900 // CHECK-LABEL: test_f32x4_min:
 901 // CHECK: f32x4.min{{$}}
 902 v128_t test_f32x4_min(v128_t a, v128_t b) { return wasm_f32x4_min(a, b); }
 903
 904 // CHECK-LABEL: test_f32x4_max:
 905 // CHECK: f32x4.max{{$}}
 906 v128_t test_f32x4_max(v128_t a, v128_t b) { return wasm_f32x4_max(a, b); }
 907
 908 // CHECK-LABEL: test_f32x4_pmin:
 909 // CHECK: f32x4.pmin{{$}}
 910 v128_t test_f32x4_pmin(v128_t a, v128_t b) { return wasm_f32x4_pmin(a, b); }
 911
 912 // CHECK-LABEL: test_f32x4_pmax:
 913 // CHECK: f32x4.pmax{{$}}
 914 v128_t test_f32x4_pmax(v128_t a, v128_t b) { return wasm_f32x4_pmax(a, b); }
 915
 916 // CHECK-LABEL: test_f64x2_abs:
 917 // CHECK: f64x2.abs{{$}}
 918 v128_t test_f64x2_abs(v128_t a) { return wasm_f64x2_abs(a); }
 919
 920 // CHECK-LABEL: test_f64x2_neg:
 921 // CHECK: f64x2.neg{{$}}
 922 v128_t test_f64x2_neg(v128_t a) { return wasm_f64x2_neg(a); }
 923
 924 // CHECK-LABEL: test_f64x2_sqrt:
 925 // CHECK: f64x2.sqrt{{$}}
 926 v128_t test_f64x2_sqrt(v128_t a) { return wasm_f64x2_sqrt(a); }
 927
 928 // CHECK-LABEL: test_f64x2_ceil:
 929 // CHECK: f64x2.ceil{{$}}
 930 v128_t test_f64x2_ceil(v128_t a) { return wasm_f64x2_ceil(a); }
 931
 932 // CHECK-LABEL: test_f64x2_floor:
 933 // CHECK: f64x2.floor{{$}}
 934 v128_t test_f64x2_floor(v128_t a) { return wasm_f64x2_floor(a); }
 935
 936 // CHECK-LABEL: test_f64x2_trunc:
 937 // CHECK: f64x2.trunc{{$}}
 938 v128_t test_f64x2_trunc(v128_t a) { return wasm_f64x2_trunc(a); }
 939
 940 // CHECK-LABEL: test_f64x2_nearest:
 941 // CHECK: f64x2.nearest{{$}}
 942 v128_t test_f64x2_nearest(v128_t a) { return wasm_f64x2_nearest(a); }
 943
 944 // CHECK-LABEL: test_f64x2_add:
 945 // CHECK: f64x2.add{{$}}
 946 v128_t test_f64x2_add(v128_t a, v128_t b) { return wasm_f64x2_add(a, b); }
 947
 948 // CHECK-LABEL: test_f64x2_sub:
 949 // CHECK: f64x2.sub{{$}}
 950 v128_t test_f64x2_sub(v128_t a, v128_t b) { return wasm_f64x2_sub(a, b); }
 951
 952 // CHECK-LABEL: test_f64x2_mul:
 953 // CHECK: f64x2.mul{{$}}
 954 v128_t test_f64x2_mul(v128_t a, v128_t b) { return wasm_f64x2_mul(a, b); }
 955
 956 // CHECK-LABEL: test_f64x2_div:
 957 // CHECK: f64x2.div{{$}}
 958 v128_t test_f64x2_div(v128_t a, v128_t b) { return wasm_f64x2_div(a, b); }
 959
 960 // CHECK-LABEL: test_f64x2_min:
 961 // CHECK: f64x2.min{{$}}
 962 v128_t test_f64x2_min(v128_t a, v128_t b) { return wasm_f64x2_min(a, b); }
 963
 964 // CHECK-LABEL: test_f64x2_max:
 965 // CHECK: f64x2.max{{$}}
 966 v128_t test_f64x2_max(v128_t a, v128_t b) { return wasm_f64x2_max(a, b); }
 967
 968 // CHECK-LABEL: test_f64x2_pmin:
 969 // CHECK: f64x2.pmin{{$}}
 970 v128_t test_f64x2_pmin(v128_t a, v128_t b) { return wasm_f64x2_pmin(a, b); }
 971
 972 // CHECK-LABEL: test_f64x2_pmax:
 973 // CHECK: f64x2.pmax{{$}}
 974 v128_t test_f64x2_pmax(v128_t a, v128_t b) { return wasm_f64x2_pmax(a, b); }
 975
 976 // CHECK-LABEL: test_i32x4_trunc_sat_f32x4:
 977 // CHECK: i32x4.trunc_sat_f32x4_s{{$}}
 978 v128_t test_i32x4_trunc_sat_f32x4(v128_t a) {
 979   return wasm_i32x4_trunc_sat_f32x4(a);
 980 }
 981
 982 // CHECK-LABEL: test_u32x4_trunc_sat_f32x4:
 983 // CHECK: i32x4.trunc_sat_f32x4_u{{$}}
 984 v128_t test_u32x4_trunc_sat_f32x4(v128_t a) {
 985   return wasm_u32x4_trunc_sat_f32x4(a);
 986 }
 987
 988 // CHECK-LABEL: test_f32x4_convert_i32x4:
 989 // CHECK: f32x4.convert_i32x4_s{{$}}
 990 v128_t test_f32x4_convert_i32x4(v128_t a) {
 991   return wasm_f32x4_convert_i32x4(a);
 992 }
 993
 994 // CHECK-LABEL: test_f32x4_convert_u32x4:
 995 // CHECK: f32x4.convert_i32x4_u{{$}}
 996 v128_t test_f32x4_convert_u32x4(v128_t a) {
 997   return wasm_f32x4_convert_u32x4(a);
 998 }
 999
1000 // CHECK-LABEL: test_f64x2_convert_low_i32x4:
1001 // CHECK: f64x2.convert_low_i32x4_s{{$}}
1002 v128_t test_f64x2_convert_low_i32x4(v128_t a) {
1003   return wasm_f64x2_convert_low_i32x4(a);
1004 }
1005
1006 // CHECK-LABEL: test_f64x2_convert_low_u32x4:
1007 // CHECK: f64x2.convert_low_i32x4_u{{$}}
1008 v128_t test_f64x2_convert_low_u32x4(v128_t a) {
1009   return wasm_f64x2_convert_low_u32x4(a);
1010 }
1011
1012 // CHECK-LABEL: test_i32x4_trunc_sat_f64x2_zero:
1013 // CHECK: i32x4.trunc_sat_f64x2_s_zero{{$}}
1014 v128_t test_i32x4_trunc_sat_f64x2_zero(v128_t a) {
1015   return wasm_i32x4_trunc_sat_f64x2_zero(a);
1016 }
1017
1018 // CHECK-LABEL: test_u32x4_trunc_sat_f64x2_zero:
1019 // CHECK: i32x4.trunc_sat_f64x2_u_zero{{$}}
1020 v128_t test_u32x4_trunc_sat_f64x2_zero(v128_t a) {
1021   return wasm_u32x4_trunc_sat_f64x2_zero(a);
1022 }
1023
1024 // CHECK-LABEL: test_f32x4_demote_f64x2_zero:
1025 // CHECK: f32x4.demote_f64x2_zero{{$}}
1026 v128_t test_f32x4_demote_f64x2_zero(v128_t a) {
1027   return wasm_f32x4_demote_f64x2_zero(a);
1028 }
1029
1030 // CHECK-LABEL: test_f64x2_promote_low_f32x4:
1031 // CHECK: f64x2.promote_low_f32x4{{$}}
1032 v128_t test_f64x2_promote_low_f32x4(v128_t a) {
1033   return wasm_f64x2_promote_low_f32x4(a);
1034 }
1035
1036 // CHECK-LABEL: test_i8x16_shuffle:
1037 // CHECK: i8x16.shuffle 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
1038 // 0{{$}}
1039 v128_t test_i8x16_shuffle(v128_t a, v128_t b) {
1040   return wasm_i8x16_shuffle(a, b, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3,
1041                             2, 1, 0);
1042 }
1043
1044 // CHECK-LABEL: test_i16x8_shuffle:
1045 // CHECK: i8x16.shuffle 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0,
1046 // 1{{$}}
1047 v128_t test_i16x8_shuffle(v128_t a, v128_t b) {
1048   return wasm_i16x8_shuffle(a, b, 7, 6, 5, 4, 3, 2, 1, 0);
1049 }
1050
1051 // CHECK-LABEL: test_i32x4_shuffle:
1052 // CHECK: i8x16.shuffle 12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2,
1053 // 3{{$}}
1054 v128_t test_i32x4_shuffle(v128_t a, v128_t b) {
1055   return wasm_i32x4_shuffle(a, b, 3, 2, 1, 0);
1056 }
1057
1058 // CHECK-LABEL: test_i64x2_shuffle:
1059 // CHECK: i8x16.shuffle 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6,
1060 // 7{{$}}
1061 v128_t test_i64x2_shuffle(v128_t a, v128_t b) {
1062   return wasm_i64x2_shuffle(a, b, 1, 0);
1063 }
1064
1065 // CHECK-LABEL: test_i8x16_swizzle:
1066 // CHECK: i8x16.swizzle{{$}}
1067 v128_t test_i8x16_swizzle(v128_t a, v128_t b) {
1068   return wasm_i8x16_swizzle(a, b);
1069 }
1070
1071 // CHECK-LABEL: test_i8x16_narrow_i16x8:
1072 // CHECK: i8x16.narrow_i16x8_s{{$}}
1073 v128_t test_i8x16_narrow_i16x8(v128_t a, v128_t b) {
1074   return wasm_i8x16_narrow_i16x8(a, b);
1075 }
1076
1077 // CHECK-LABEL: test_u8x16_narrow_i16x8:
1078 // CHECK: i8x16.narrow_i16x8_u{{$}}
1079 v128_t test_u8x16_narrow_i16x8(v128_t a, v128_t b) {
1080   return wasm_u8x16_narrow_i16x8(a, b);
1081 }
1082
1083 // CHECK-LABEL: test_i16x8_narrow_i32x4:
1084 // CHECK: i16x8.narrow_i32x4_s{{$}}
1085 v128_t test_i16x8_narrow_i32x4(v128_t a, v128_t b) {
1086   return wasm_i16x8_narrow_i32x4(a, b);
1087 }
1088
1089 // CHECK-LABEL: test_u16x8_narrow_i32x4:
1090 // CHECK: i16x8.narrow_i32x4_u{{$}}
1091 v128_t test_u16x8_narrow_i32x4(v128_t a, v128_t b) {
1092   return wasm_u16x8_narrow_i32x4(a, b);
1093 }
1094
1095 // CHECK-LABEL: test_i16x8_extend_low_i8x16:
1096 // CHECK: i16x8.extend_low_i8x16_s{{$}}
1097 v128_t test_i16x8_extend_low_i8x16(v128_t a) {
1098   return wasm_i16x8_extend_low_i8x16(a);
1099 }
1100
1101 // CHECK-LABEL: test_i16x8_extend_high_i8x16:
1102 // CHECK: i16x8.extend_high_i8x16_s{{$}}
1103 v128_t test_i16x8_extend_high_i8x16(v128_t a) {
1104   return wasm_i16x8_extend_high_i8x16(a);
1105 }
1106
1107 // CHECK-LABEL: test_u16x8_extend_low_u8x16:
1108 // CHECK: i16x8.extend_low_i8x16_u{{$}}
1109 v128_t test_u16x8_extend_low_u8x16(v128_t a) {
1110   return wasm_u16x8_extend_low_u8x16(a);
1111 }
1112
1113 // CHECK-LABEL: test_u16x8_extend_high_u8x16:
1114 // CHECK: i16x8.extend_high_i8x16_u{{$}}
1115 v128_t test_u16x8_extend_high_u8x16(v128_t a) {
1116   return wasm_u16x8_extend_high_u8x16(a);
1117 }
1118
1119 // CHECK-LABEL: test_i32x4_extend_low_i16x8:
1120 // CHECK: i32x4.extend_low_i16x8_s{{$}}
1121 v128_t test_i32x4_extend_low_i16x8(v128_t a) {
1122   return wasm_i32x4_extend_low_i16x8(a);
1123 }
1124
1125 // CHECK-LABEL: test_i32x4_extend_high_i16x8:
1126 // CHECK: i32x4.extend_high_i16x8_s{{$}}
1127 v128_t test_i32x4_extend_high_i16x8(v128_t a) {
1128   return wasm_i32x4_extend_high_i16x8(a);
1129 }
1130
1131 // CHECK-LABEL: test_u32x4_extend_low_u16x8:
1132 // CHECK: i32x4.extend_low_i16x8_u{{$}}
1133 v128_t test_u32x4_extend_low_u16x8(v128_t a) {
1134   return wasm_u32x4_extend_low_u16x8(a);
1135 }
1136
1137 // CHECK-LABEL: test_u32x4_extend_high_u16x8:
1138 // CHECK: i32x4.extend_high_i16x8_u{{$}}
1139 v128_t test_u32x4_extend_high_u16x8(v128_t a) {
1140   return wasm_u32x4_extend_high_u16x8(a);
1141 }
1142
1143 // CHECK-LABEL: test_i64x2_extend_low_i32x4:
1144 // CHECK: i64x2.extend_low_i32x4_s{{$}}
1145 v128_t test_i64x2_extend_low_i32x4(v128_t a) {
1146   return wasm_i64x2_extend_low_i32x4(a);
1147 }
1148
1149 // CHECK-LABEL: test_i64x2_extend_high_i32x4:
1150 // CHECK: i64x2.extend_high_i32x4_s{{$}}
1151 v128_t test_i64x2_extend_high_i32x4(v128_t a) {
1152   return wasm_i64x2_extend_high_i32x4(a);
1153 }
1154
1155 // CHECK-LABEL: test_u64x2_extend_low_u32x4:
1156 // CHECK: i64x2.extend_low_i32x4_u{{$}}
1157 v128_t test_u64x2_extend_low_u32x4(v128_t a) {
1158   return wasm_u64x2_extend_low_u32x4(a);
1159 }
1160
1161 // CHECK-LABEL: test_u64x2_extend_high_u32x4:
1162 // CHECK: i64x2.extend_high_i32x4_u{{$}}
1163 v128_t test_u64x2_extend_high_u32x4(v128_t a) {
1164   return wasm_u64x2_extend_high_u32x4(a);
1165 }
1166
1167 // CHECK-LABEL: test_i16x8_extadd_pairwise_i8x16:
1168 // CHECK: i16x8.extadd_pairwise_i8x16_s{{$}}
1169 v128_t test_i16x8_extadd_pairwise_i8x16(v128_t a) {
1170   return wasm_i16x8_extadd_pairwise_i8x16(a);
1171 }
1172
1173 // CHECK-LABEL: test_u16x8_extadd_pairwise_u8x16:
1174 // CHECK: i16x8.extadd_pairwise_i8x16_u{{$}}
1175 v128_t test_u16x8_extadd_pairwise_u8x16(v128_t a) {
1176   return wasm_u16x8_extadd_pairwise_u8x16(a);
1177 }
1178
1179 // CHECK-LABEL: test_i32x4_extadd_pairwise_i16x8:
1180 // CHECK: i32x4.extadd_pairwise_i16x8_s{{$}}
1181 v128_t test_i32x4_extadd_pairwise_i16x8(v128_t a) {
1182   return wasm_i32x4_extadd_pairwise_i16x8(a);
1183 }
1184
1185 // CHECK-LABEL: test_u32x4_extadd_pairwise_u16x8:
1186 // CHECK: i32x4.extadd_pairwise_i16x8_u{{$}}
1187 v128_t test_u32x4_extadd_pairwise_u16x8(v128_t a) {
1188   return wasm_u32x4_extadd_pairwise_u16x8(a);
1189 }
1190
1191 // CHECK-LABEL: test_i16x8_extmul_low_i8x16:
1192 // CHECK: i16x8.extmul_low_i8x16_s{{$}}
1193 v128_t test_i16x8_extmul_low_i8x16(v128_t a, v128_t b) {
1194   return wasm_i16x8_extmul_low_i8x16(a, b);
1195 }
1196
1197 // CHECK-LABEL: test_i16x8_extmul_high_i8x16:
1198 // CHECK: i16x8.extmul_high_i8x16_s{{$}}
1199 v128_t test_i16x8_extmul_high_i8x16(v128_t a, v128_t b) {
1200   return wasm_i16x8_extmul_high_i8x16(a, b);
1201 }
1202
1203 // CHECK-LABEL: test_u16x8_extmul_low_u8x16:
1204 // CHECK: i16x8.extmul_low_i8x16_u{{$}}
1205 v128_t test_u16x8_extmul_low_u8x16(v128_t a, v128_t b) {
1206   return wasm_u16x8_extmul_low_u8x16(a, b);
1207 }
1208
1209 // CHECK-LABEL: test_u16x8_extmul_high_u8x16:
1210 // CHECK: i16x8.extmul_high_i8x16_u{{$}}
1211 v128_t test_u16x8_extmul_high_u8x16(v128_t a, v128_t b) {
1212   return wasm_u16x8_extmul_high_u8x16(a, b);
1213 }
1214
1215 // CHECK-LABEL: test_i32x4_extmul_low_i16x8:
1216 // CHECK: i32x4.extmul_low_i16x8_s{{$}}
1217 v128_t test_i32x4_extmul_low_i16x8(v128_t a, v128_t b) {
1218   return wasm_i32x4_extmul_low_i16x8(a, b);
1219 }
1220
1221 // CHECK-LABEL: test_i32x4_extmul_high_i16x8:
1222 // CHECK: i32x4.extmul_high_i16x8_s{{$}}
1223 v128_t test_i32x4_extmul_high_i16x8(v128_t a, v128_t b) {
1224   return wasm_i32x4_extmul_high_i16x8(a, b);
1225 }
1226
1227 // CHECK-LABEL: test_u32x4_extmul_low_u16x8:
1228 // CHECK: i32x4.extmul_low_i16x8_u{{$}}
1229 v128_t test_u32x4_extmul_low_u16x8(v128_t a, v128_t b) {
1230   return wasm_u32x4_extmul_low_u16x8(a, b);
1231 }
1232
1233 // CHECK-LABEL: test_u32x4_extmul_high_u16x8:
1234 // CHECK: i32x4.extmul_high_i16x8_u{{$}}
1235 v128_t test_u32x4_extmul_high_u16x8(v128_t a, v128_t b) {
1236   return wasm_u32x4_extmul_high_u16x8(a, b);
1237 }
1238
1239 // CHECK-LABEL: test_i64x2_extmul_low_i32x4:
1240 // CHECK: i64x2.extmul_low_i32x4_s{{$}}
1241 v128_t test_i64x2_extmul_low_i32x4(v128_t a, v128_t b) {
1242   return wasm_i64x2_extmul_low_i32x4(a, b);
1243 }
1244
1245 // CHECK-LABEL: test_i64x2_extmul_high_i32x4:
1246 // CHECK: i64x2.extmul_high_i32x4_s{{$}}
1247 v128_t test_i64x2_extmul_high_i32x4(v128_t a, v128_t b) {
1248   return wasm_i64x2_extmul_high_i32x4(a, b);
1249 }
1250
1251 // CHECK-LABEL: test_u64x2_extmul_low_u32x4:
1252 // CHECK: i64x2.extmul_low_i32x4_u{{$}}
1253 v128_t test_u64x2_extmul_low_u32x4(v128_t a, v128_t b) {
1254   return wasm_u64x2_extmul_low_u32x4(a, b);
1255 }
1256
1257 // CHECK-LABEL: test_u64x2_extmul_high_u32x4:
1258 // CHECK: i64x2.extmul_high_i32x4_u{{$}}
1259 v128_t test_u64x2_extmul_high_u32x4(v128_t a, v128_t b) {
1260   return wasm_u64x2_extmul_high_u32x4(a, b);
1261 }
1262
1263 // CHECK-LABEL: test_i16x8_q15mulr_sat:
1264 // CHECK: i16x8.q15mulr_sat_s{{$}}
1265 v128_t test_i16x8_q15mulr_sat(v128_t a, v128_t b) {
1266   return wasm_i16x8_q15mulr_sat(a, b);
1267 }
1268
1269 // CHECK-LABEL: test_f32x4_relaxed_madd:
1270 // CHECK: f32x4.relaxed_madd{{$}}
1271 v128_t test_f32x4_relaxed_madd(v128_t a, v128_t b, v128_t c) {
1272   return wasm_f32x4_relaxed_madd(a, b, c);
1273 }
1274
1275 // CHECK-LABEL: test_f32x4_relaxed_nmadd:
1276 // CHECK: f32x4.relaxed_nmadd{{$}}
1277 v128_t test_f32x4_relaxed_nmadd(v128_t a, v128_t b, v128_t c) {
1278   return wasm_f32x4_relaxed_nmadd(a, b, c);
1279 }
1280
1281 // CHECK-LABEL: test_f64x2_relaxed_madd:
1282 // CHECK: f64x2.relaxed_madd{{$}}
1283 v128_t test_f64x2_relaxed_madd(v128_t a, v128_t b, v128_t c) {
1284   return wasm_f64x2_relaxed_madd(a, b, c);
1285 }
1286
1287 // CHECK-LABEL: test_f64x2_relaxed_nmadd:
1288 // CHECK: f64x2.relaxed_nmadd{{$}}
1289 v128_t test_f64x2_relaxed_nmadd(v128_t a, v128_t b, v128_t c) {
1290   return wasm_f64x2_relaxed_nmadd(a, b, c);
1291 }
1292
1293 // CHECK-LABEL: test_i8x16_relaxed_laneselect:
1294 // CHECK: i8x16.relaxed_laneselect{{$}}
1295 v128_t test_i8x16_relaxed_laneselect(v128_t a, v128_t b, v128_t m) {
1296   return wasm_i8x16_relaxed_laneselect(a, b, m);
1297 }
1298
1299 // CHECK-LABEL: test_i16x8_relaxed_laneselect:
1300 // CHECK: i16x8.relaxed_laneselect{{$}}
1301 v128_t test_i16x8_relaxed_laneselect(v128_t a, v128_t b, v128_t m) {
1302   return wasm_i16x8_relaxed_laneselect(a, b, m);
1303 }
1304
1305 // CHECK-LABEL: test_i32x4_relaxed_laneselect:
1306 // CHECK: i32x4.relaxed_laneselect{{$}}
1307 v128_t test_i32x4_relaxed_laneselect(v128_t a, v128_t b, v128_t m) {
1308   return wasm_i32x4_relaxed_laneselect(a, b, m);
1309 }
1310
1311 // CHECK-LABEL: test_i64x2_relaxed_laneselect:
1312 // CHECK: i64x2.relaxed_laneselect{{$}}
1313 v128_t test_i64x2_relaxed_laneselect(v128_t a, v128_t b, v128_t m) {
1314   return wasm_i64x2_relaxed_laneselect(a, b, m);
1315 }
1316
1317 // CHECK-LABEL: test_i8x16_relaxed_swizzle:
1318 // CHECK: i8x16.relaxed_swizzle{{$}}
1319 v128_t test_i8x16_relaxed_swizzle(v128_t a, v128_t s) {
1320   return wasm_i8x16_relaxed_swizzle(a, s);
1321 }
1322
1323 // CHECK-LABEL: test_f32x4_relaxed_min:
1324 // CHECK: f32x4.relaxed_min{{$}}
1325 v128_t test_f32x4_relaxed_min(v128_t a, v128_t b) {
1326   return wasm_f32x4_relaxed_min(a, b);
1327 }
1328
1329 // CHECK-LABEL: test_f32x4_relaxed_max:
1330 // CHECK: f32x4.relaxed_max{{$}}
1331 v128_t test_f32x4_relaxed_max(v128_t a, v128_t b) {
1332   return wasm_f32x4_relaxed_max(a, b);
1333 }
1334
1335 // CHECK-LABEL: test_f64x2_relaxed_min:
1336 // CHECK: f64x2.relaxed_min{{$}}
1337 v128_t test_f64x2_relaxed_min(v128_t a, v128_t b) {
1338   return wasm_f64x2_relaxed_min(a, b);
1339 }
1340
1341 // CHECK-LABEL: test_f64x2_relaxed_max:
1342 // CHECK: f64x2.relaxed_max
1343 v128_t test_f64x2_relaxed_max(v128_t a, v128_t b) {
1344   return wasm_f64x2_relaxed_max(a, b);
1345 }
1346
1347 // CHECK-LABEL: test_i32x4_relaxed_trunc_f32x4:
1348 // CHECK: i32x4.relaxed_trunc_f32x4_s{{$}}
1349 v128_t test_i32x4_relaxed_trunc_f32x4(v128_t a) {
1350   return wasm_i32x4_relaxed_trunc_f32x4(a);
1351 }
1352
1353 // CHECK-LABEL: test_u32x4_relaxed_trunc_f32x4:
1354 // CHECK: i32x4.relaxed_trunc_f32x4_u{{$}}
1355 v128_t test_u32x4_relaxed_trunc_f32x4(v128_t a) {
1356   return wasm_u32x4_relaxed_trunc_f32x4(a);
1357 }
1358
1359 // CHECK-LABEL: test_i32x4_relaxed_trunc_f64x2_zero:
1360 // CHECK: i32x4.relaxed_trunc_f64x2_s_zero{{$}}
1361 v128_t test_i32x4_relaxed_trunc_f64x2_zero(v128_t a) {
1362   return wasm_i32x4_relaxed_trunc_f64x2_zero(a);
1363 }
1364
1365 // CHECK-LABEL: test_u32x4_relaxed_trunc_f64x2_zero:
1366 // CHECK: i32x4.relaxed_trunc_f64x2_u_zero{{$}}
1367 v128_t test_u32x4_relaxed_trunc_f64x2_zero(v128_t a) {
1368   return wasm_u32x4_relaxed_trunc_f64x2_zero(a);
1369 }
1370
1371 // CHECK-LABEL: test_i16x8_relaxed_q15mulr:
1372 // CHECK: i16x8.relaxed_q15mulr_s{{$}}
1373 v128_t test_i16x8_relaxed_q15mulr(v128_t a, v128_t b) {
1374   return wasm_i16x8_relaxed_q15mulr(a, b);
1375 }
1376
1377 // CHECK-LABEL: test_i16x8_relaxed_dot_i8x16_i7x16:
1378 // CHECK: i16x8.relaxed_dot_i8x16_i7x16_s{{$}}
1379 v128_t test_i16x8_relaxed_dot_i8x16_i7x16(v128_t a, v128_t b) {
1380   return wasm_i16x8_relaxed_dot_i8x16_i7x16(a, b);
1381 }
1382
1383 // CHECK-LABEL: test_i32x4_relaxed_dot_i8x16_i7x16_add:
1384 // CHECK: i32x4.relaxed_dot_i8x16_i7x16_add_s{{$}}
1385 v128_t test_i32x4_relaxed_dot_i8x16_i7x16_add(v128_t a, v128_t b, v128_t c) {
1386   return wasm_i32x4_relaxed_dot_i8x16_i7x16_add(a, b, c);
1387 }
1388
1389 // CHECK-LABEL: test_f16x8_splat:
1390 // CHECK: f16x8.splat{{$}}
1391 v128_t test_f16x8_splat(float a) { return wasm_f16x8_splat(a); }
1392
1393 // CHECK-LABEL: test_f16x8_extract_lane:
1394 // CHECK: f16x8.extract_lane 7{{$}}
1395 int16_t test_f16x8_extract_lane(v128_t a) {
1396   return wasm_f16x8_extract_lane(a, 7);
1397 }
1398
1399 // CHECK-LABEL: test_f16x8_replace_lane:
1400 // CHECK: f16x8.replace_lane 7{{$}}
1401 v128_t test_f16x8_replace_lane(v128_t a, float b) {
1402   return wasm_f16x8_replace_lane(a, 7, b);
1403 }
1404
1405 // CHECK-LABEL: test_f16x8_abs:
1406 // CHECK: f16x8.abs{{$}}
1407 v128_t test_f16x8_abs(v128_t a) { return wasm_f16x8_abs(a); }
1408
1409 // CHECK-LABEL: test_f16x8_neg:
1410 // CHECK: f16x8.neg{{$}}
1411 v128_t test_f16x8_neg(v128_t a) { return wasm_f16x8_neg(a); }
1412
1413 // CHECK-LABEL: test_f16x8_sqrt:
1414 // CHECK: f16x8.sqrt{{$}}
1415 v128_t test_f16x8_sqrt(v128_t a) { return wasm_f16x8_sqrt(a); }
1416
1417 // CHECK-LABEL: test_f16x8_ceil:
1418 // CHECK: f16x8.ceil{{$}}
1419 v128_t test_f16x8_ceil(v128_t a) { return wasm_f16x8_ceil(a); }
1420
1421 // CHECK-LABEL: test_f16x8_floor:
1422 // CHECK: f16x8.floor{{$}}
1423 v128_t test_f16x8_floor(v128_t a) { return wasm_f16x8_floor(a); }
1424
1425 // CHECK-LABEL: test_f16x8_trunc:
1426 // CHECK: f16x8.trunc{{$}}
1427 v128_t test_f16x8_trunc(v128_t a) { return wasm_f16x8_trunc(a); }
1428
1429 // CHECK-LABEL: test_f16x8_nearest:
1430 // CHECK: f16x8.nearest{{$}}
1431 v128_t test_f16x8_nearest(v128_t a) { return wasm_f16x8_nearest(a); }
1432
1433 // CHECK-LABEL: test_f16x8_add:
1434 // CHECK: f16x8.add{{$}}
1435 v128_t test_f16x8_add(v128_t a, v128_t b) { return wasm_f16x8_add(a, b); }
1436
1437 // CHECK-LABEL: test_f16x8_sub:
1438 // CHECK: f16x8.sub{{$}}
1439 v128_t test_f16x8_sub(v128_t a, v128_t b) { return wasm_f16x8_sub(a, b); }
1440
1441 // CHECK-LABEL: test_f16x8_mul:
1442 // CHECK: f16x8.mul{{$}}
1443 v128_t test_f16x8_mul(v128_t a, v128_t b) { return wasm_f16x8_mul(a, b); }
1444
1445 // CHECK-LABEL: test_f16x8_div:
1446 // CHECK: f16x8.div{{$}}
1447 v128_t test_f16x8_div(v128_t a, v128_t b) { return wasm_f16x8_div(a, b); }
1448
1449 // CHECK-LABEL: test_f16x8_min:
1450 // CHECK: f16x8.min{{$}}
1451 v128_t test_f16x8_min(v128_t a, v128_t b) { return wasm_f16x8_min(a, b); }
1452
1453 // CHECK-LABEL: test_f16x8_max:
1454 // CHECK: f16x8.max{{$}}
1455 v128_t test_f16x8_max(v128_t a, v128_t b) { return wasm_f16x8_max(a, b); }
1456
1457 // CHECK-LABEL: test_f16x8_pmin:
1458 // CHECK: f16x8.pmin{{$}}
1459 v128_t test_f16x8_pmin(v128_t a, v128_t b) { return wasm_f16x8_pmin(a, b); }
1460
1461 // CHECK-LABEL: test_f16x8_pmax:
1462 // CHECK: f16x8.pmax{{$}}
1463 v128_t test_f16x8_pmax(v128_t a, v128_t b) { return wasm_f16x8_pmax(a, b); }
1464
1465 // CHECK-LABEL: test_f16x8_eq:
1466 // CHECK: f16x8.eq{{$}}
1467 v128_t test_f16x8_eq(v128_t a, v128_t b) { return wasm_f16x8_eq(a, b); }
1468
1469 // CHECK-LABEL: test_f16x8_ne:
1470 // CHECK: f16x8.ne{{$}}
1471 v128_t test_f16x8_ne(v128_t a, v128_t b) { return wasm_f16x8_ne(a, b); }
1472
1473 // CHECK-LABEL: test_f16x8_lt:
1474 // CHECK: f16x8.lt{{$}}
1475 v128_t test_f16x8_lt(v128_t a, v128_t b) { return wasm_f16x8_lt(a, b); }
1476
1477 // CHECK-LABEL: test_f16x8_gt:
1478 // CHECK: f16x8.gt{{$}}
1479 v128_t test_f16x8_gt(v128_t a, v128_t b) { return wasm_f16x8_gt(a, b); }
1480
1481 // CHECK-LABEL: test_f16x8_le:
1482 // CHECK: f16x8.le{{$}}
1483 v128_t test_f16x8_le(v128_t a, v128_t b) { return wasm_f16x8_le(a, b); }
1484
1485 // CHECK-LABEL: test_f16x8_ge:
1486 // CHECK: f16x8.ge{{$}}
1487 v128_t test_f16x8_ge(v128_t a, v128_t b) { return wasm_f16x8_ge(a, b); }
1488
1489 // CHECK-LABEL: test_i16x8_trunc_sat_f16x8:
1490 // CHECK: i16x8.trunc_sat_f16x8_s{{$}}
1491 v128_t test_i16x8_trunc_sat_f16x8(v128_t a) {
1492   return wasm_i16x8_trunc_sat_f16x8(a);
1493 }
1494
1495 // CHECK-LABEL: test_u16x8_trunc_sat_f16x8:
1496 // CHECK: i16x8.trunc_sat_f16x8_u{{$}}
1497 v128_t test_u16x8_trunc_sat_f16x8(v128_t a) {
1498   return wasm_u16x8_trunc_sat_f16x8(a);
1499 }
1500
1501 // CHECK-LABEL: test_f16x8_convert_i16x8:
1502 // CHECK: f16x8.convert_i16x8_s{{$}}
1503 v128_t test_f16x8_convert_i16x8(v128_t a) {
1504   return wasm_f16x8_convert_i16x8(a);
1505 }
1506
1507 // CHECK-LABEL: test_f16x8_convert_u16x8:
1508 // CHECK: f16x8.convert_i16x8_u{{$}}
1509 v128_t test_f16x8_convert_u16x8(v128_t a) {
1510   return wasm_f16x8_convert_u16x8(a);
1511 }
1512
1513 // CHECK-LABEL: test_f16x8_relaxed_madd:
1514 // CHECK: f16x8.relaxed_madd{{$}}
1515 v128_t test_f16x8_relaxed_madd(v128_t a, v128_t b, v128_t c) {
1516   return wasm_f16x8_relaxed_madd(a, b, c);
1517 }
1518
1519 // CHECK-LABEL: test_f16x8_relaxed_nmadd:
1520 // CHECK: f16x8.relaxed_nmadd{{$}}
1521 v128_t test_f16x8_relaxed_nmadd(v128_t a, v128_t b, v128_t c) {
1522   return wasm_f16x8_relaxed_nmadd(a, b, c);
1523 }