CoCalc -- avx2intrin.h

GitHub Repository: emscripten-core/emscripten
Path: blob/main/system/include/compat/avx2intrin.h
⁶¹⁷¹ views
1
/*
2
 * Copyright 2024 The Emscripten Authors.  All rights reserved.
3
 * Emscripten is available under two separate licenses, the MIT license and the
4
 * University of Illinois/NCSA Open Source License.  Both these licenses can be
5
 * found in the LICENSE file.
6
 */
7

8
#ifndef __emscripten_immintrin_h__
9
#error "Never use <avx2intrin.h> directly; include <immintrin.h> instead."
10
#endif
11

12
#ifndef __emscripten_avx2intrin_h__
13
#define __emscripten_avx2intrin_h__
14

15
#ifndef __AVX2__
16
#error "AVX2 instruction set not enabled"
17
#endif
18

19
#define _mm256_mpsadbw_epu8(__A, __B, __imm)                                   \
20
  __extension__({                                                              \
21
    __m256i __a = (__A);                                                       \
22
    __m256i __b = (__B);                                                       \
23
    _mm256_set_m128i(_mm_mpsadbw_epu8(__a.v1, __b.v1, (__imm) >> 3),           \
24
                     _mm_mpsadbw_epu8(__a.v0, __b.v0, (__imm)));               \
25
  })
26

27
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
28
_mm256_abs_epi8(__m256i __a) {
29
  __m256i ret;
30
  ret.v0 = _mm_abs_epi8(__a.v0);
31
  ret.v1 = _mm_abs_epi8(__a.v1);
32
  return ret;
33
}
34

35
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
36
_mm256_abs_epi16(__m256i __a) {
37
  __m256i ret;
38
  ret.v0 = _mm_abs_epi16(__a.v0);
39
  ret.v1 = _mm_abs_epi16(__a.v1);
40
  return ret;
41
}
42

43
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
44
_mm256_abs_epi32(__m256i __a) {
45
  __m256i ret;
46
  ret.v0 = _mm_abs_epi32(__a.v0);
47
  ret.v1 = _mm_abs_epi32(__a.v1);
48
  return ret;
49
}
50

51
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
52
_mm256_packs_epi16(__m256i __a, __m256i __b) {
53
  __m256i ret;
54
  ret.v0 = _mm_packs_epi16(__a.v0, __b.v0);
55
  ret.v1 = _mm_packs_epi16(__a.v1, __b.v1);
56
  return ret;
57
}
58

59
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
60
_mm256_packs_epi32(__m256i __a, __m256i __b) {
61
  __m256i ret;
62
  ret.v0 = _mm_packs_epi32(__a.v0, __b.v0);
63
  ret.v1 = _mm_packs_epi32(__a.v1, __b.v1);
64
  return ret;
65
}
66

67
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
68
_mm256_packus_epi16(__m256i __a, __m256i __b) {
69
  __m256i ret;
70
  ret.v0 = _mm_packus_epi16(__a.v0, __b.v0);
71
  ret.v1 = _mm_packus_epi16(__a.v1, __b.v1);
72
  return ret;
73
}
74

75
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
76
_mm256_packus_epi32(__m256i __a, __m256i __b) {
77
  __m256i ret;
78
  ret.v0 = _mm_packus_epi32(__a.v0, __b.v0);
79
  ret.v1 = _mm_packus_epi32(__a.v1, __b.v1);
80
  return ret;
81
}
82

83
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
84
_mm256_add_epi8(__m256i __a, __m256i __b) {
85
  __m256i ret;
86
  ret.v0 = _mm_add_epi8(__a.v0, __b.v0);
87
  ret.v1 = _mm_add_epi8(__a.v1, __b.v1);
88
  return ret;
89
}
90

91
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
92
_mm256_add_epi16(__m256i __a, __m256i __b) {
93
  __m256i ret;
94
  ret.v0 = _mm_add_epi16(__a.v0, __b.v0);
95
  ret.v1 = _mm_add_epi16(__a.v1, __b.v1);
96
  return ret;
97
}
98

99
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
100
_mm256_add_epi32(__m256i __a, __m256i __b) {
101
  __m256i ret;
102
  ret.v0 = _mm_add_epi32(__a.v0, __b.v0);
103
  ret.v1 = _mm_add_epi32(__a.v1, __b.v1);
104
  return ret;
105
}
106

107
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
108
_mm256_add_epi64(__m256i __a, __m256i __b) {
109
  __m256i ret;
110
  ret.v0 = _mm_add_epi64(__a.v0, __b.v0);
111
  ret.v1 = _mm_add_epi64(__a.v1, __b.v1);
112
  return ret;
113
}
114

115
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
116
_mm256_adds_epi8(__m256i __a, __m256i __b) {
117
  __m256i ret;
118
  ret.v0 = _mm_adds_epi8(__a.v0, __b.v0);
119
  ret.v1 = _mm_adds_epi8(__a.v1, __b.v1);
120
  return ret;
121
}
122

123
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
124
_mm256_adds_epi16(__m256i __a, __m256i __b) {
125
  __m256i ret;
126
  ret.v0 = _mm_adds_epi16(__a.v0, __b.v0);
127
  ret.v1 = _mm_adds_epi16(__a.v1, __b.v1);
128
  return ret;
129
}
130

131
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
132
_mm256_adds_epu8(__m256i __a, __m256i __b) {
133
  __m256i ret;
134
  ret.v0 = _mm_adds_epu8(__a.v0, __b.v0);
135
  ret.v1 = _mm_adds_epu8(__a.v1, __b.v1);
136
  return ret;
137
}
138

139
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
140
_mm256_adds_epu16(__m256i __a, __m256i __b) {
141
  __m256i ret;
142
  ret.v0 = _mm_adds_epu16(__a.v0, __b.v0);
143
  ret.v1 = _mm_adds_epu16(__a.v1, __b.v1);
144
  return ret;
145
}
146

147
#define _mm256_alignr_epi8(__A, __B, __imm)                                    \
148
  __extension__({                                                              \
149
    __m256i __a = (__A);                                                       \
150
    __m256i __b = (__B);                                                       \
151
    _mm256_set_m128i(_mm_alignr_epi8(__a.v1, __b.v1, (__imm)),                 \
152
                     _mm_alignr_epi8(__a.v0, __b.v0, (__imm)));                \
153
  })
154

155
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
156
_mm256_and_si256(__m256i __a, __m256i __b) {
157
  __m256i ret;
158
  ret.v0 = _mm_and_si128(__a.v0, __b.v0);
159
  ret.v1 = _mm_and_si128(__a.v1, __b.v1);
160
  return ret;
161
}
162

163
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
164
_mm256_andnot_si256(__m256i __a, __m256i __b) {
165
  __m256i ret;
166
  ret.v0 = _mm_andnot_si128(__a.v0, __b.v0);
167
  ret.v1 = _mm_andnot_si128(__a.v1, __b.v1);
168
  return ret;
169
}
170

171
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
172
_mm256_avg_epu8(__m256i __a, __m256i __b) {
173
  __m256i ret;
174
  ret.v0 = _mm_avg_epu8(__a.v0, __b.v0);
175
  ret.v1 = _mm_avg_epu8(__a.v1, __b.v1);
176
  return ret;
177
}
178

179
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
180
_mm256_avg_epu16(__m256i __a, __m256i __b) {
181
  __m256i ret;
182
  ret.v0 = _mm_avg_epu16(__a.v0, __b.v0);
183
  ret.v1 = _mm_avg_epu16(__a.v1, __b.v1);
184
  return ret;
185
}
186

187
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
188
_mm256_blendv_epi8(__m256i __a, __m256i __b, __m256i __mask) {
189
  __m256i ret;
190
  ret.v0 = _mm_blendv_epi8(__a.v0, __b.v0, __mask.v0);
191
  ret.v1 = _mm_blendv_epi8(__a.v1, __b.v1, __mask.v1);
192
  return ret;
193
}
194

195
#define _mm256_blend_epi16(__A, __B, __imm)                                    \
196
  __extension__({                                                              \
197
    __m256i __a = (__A);                                                       \
198
    __m256i __b = (__B);                                                       \
199
    _mm256_set_m128i(_mm_blend_epi16(__a.v1, __b.v1, (__imm)),                 \
200
                     _mm_blend_epi16(__a.v0, __b.v0, (__imm)));                \
201
  })
202

203
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
204
_mm256_cmpeq_epi8(__m256i __a, __m256i __b) {
205
  __m256i ret;
206
  ret.v0 = _mm_cmpeq_epi8(__a.v0, __b.v0);
207
  ret.v1 = _mm_cmpeq_epi8(__a.v1, __b.v1);
208
  return ret;
209
}
210

211
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
212
_mm256_cmpeq_epi16(__m256i __a, __m256i __b) {
213
  __m256i ret;
214
  ret.v0 = _mm_cmpeq_epi16(__a.v0, __b.v0);
215
  ret.v1 = _mm_cmpeq_epi16(__a.v1, __b.v1);
216
  return ret;
217
}
218

219
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
220
_mm256_cmpeq_epi32(__m256i __a, __m256i __b) {
221
  __m256i ret;
222
  ret.v0 = _mm_cmpeq_epi32(__a.v0, __b.v0);
223
  ret.v1 = _mm_cmpeq_epi32(__a.v1, __b.v1);
224
  return ret;
225
}
226

227
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
228
_mm256_cmpeq_epi64(__m256i __a, __m256i __b) {
229
  __m256i ret;
230
  ret.v0 = _mm_cmpeq_epi64(__a.v0, __b.v0);
231
  ret.v1 = _mm_cmpeq_epi64(__a.v1, __b.v1);
232
  return ret;
233
}
234

235
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
236
_mm256_cmpgt_epi8(__m256i __a, __m256i __b) {
237
  __m256i ret;
238
  ret.v0 = _mm_cmpgt_epi8(__a.v0, __b.v0);
239
  ret.v1 = _mm_cmpgt_epi8(__a.v1, __b.v1);
240
  return ret;
241
}
242

243
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
244
_mm256_cmpgt_epi16(__m256i __a, __m256i __b) {
245
  __m256i ret;
246
  ret.v0 = _mm_cmpgt_epi16(__a.v0, __b.v0);
247
  ret.v1 = _mm_cmpgt_epi16(__a.v1, __b.v1);
248
  return ret;
249
}
250

251
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
252
_mm256_cmpgt_epi32(__m256i __a, __m256i __b) {
253
  __m256i ret;
254
  ret.v0 = _mm_cmpgt_epi32(__a.v0, __b.v0);
255
  ret.v1 = _mm_cmpgt_epi32(__a.v1, __b.v1);
256
  return ret;
257
}
258

259
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
260
_mm256_cmpgt_epi64(__m256i __a, __m256i __b) {
261
  __m256i ret;
262
  ret.v0 = _mm_cmpgt_epi64(__a.v0, __b.v0);
263
  ret.v1 = _mm_cmpgt_epi64(__a.v1, __b.v1);
264
  return ret;
265
}
266

267
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
268
_mm256_hadd_epi16(__m256i __a, __m256i __b) {
269
  __m256i ret;
270
  ret.v0 = _mm_hadd_epi16(__a.v0, __b.v0);
271
  ret.v1 = _mm_hadd_epi16(__a.v1, __b.v1);
272
  return ret;
273
}
274

275
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
276
_mm256_hadd_epi32(__m256i __a, __m256i __b) {
277
  __m256i ret;
278
  ret.v0 = _mm_hadd_epi32(__a.v0, __b.v0);
279
  ret.v1 = _mm_hadd_epi32(__a.v1, __b.v1);
280
  return ret;
281
}
282

283
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
284
_mm256_hadds_epi16(__m256i __a, __m256i __b) {
285
  __m256i ret;
286
  ret.v0 = _mm_hadds_epi16(__a.v0, __b.v0);
287
  ret.v1 = _mm_hadds_epi16(__a.v1, __b.v1);
288
  return ret;
289
}
290

291
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
292
_mm256_hsub_epi16(__m256i __a, __m256i __b) {
293
  __m256i ret;
294
  ret.v0 = _mm_hsub_epi16(__a.v0, __b.v0);
295
  ret.v1 = _mm_hsub_epi16(__a.v1, __b.v1);
296
  return ret;
297
}
298

299
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
300
_mm256_hsub_epi32(__m256i __a, __m256i __b) {
301
  __m256i ret;
302
  ret.v0 = _mm_hsub_epi32(__a.v0, __b.v0);
303
  ret.v1 = _mm_hsub_epi32(__a.v1, __b.v1);
304
  return ret;
305
}
306

307
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
308
_mm256_hsubs_epi16(__m256i __a, __m256i __b) {
309
  __m256i ret;
310
  ret.v0 = _mm_hsubs_epi16(__a.v0, __b.v0);
311
  ret.v1 = _mm_hsubs_epi16(__a.v1, __b.v1);
312
  return ret;
313
}
314

315
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
316
_mm256_maddubs_epi16(__m256i __a, __m256i __b) {
317
  __m256i ret;
318
  ret.v0 = _mm_maddubs_epi16(__a.v0, __b.v0);
319
  ret.v1 = _mm_maddubs_epi16(__a.v1, __b.v1);
320
  return ret;
321
}
322

323
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
324
_mm256_madd_epi16(__m256i __a, __m256i __b) {
325
  __m256i ret;
326
  ret.v0 = _mm_madd_epi16(__a.v0, __b.v0);
327
  ret.v1 = _mm_madd_epi16(__a.v1, __b.v1);
328
  return ret;
329
}
330

331
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
332
_mm256_max_epi8(__m256i __a, __m256i __b) {
333
  __m256i ret;
334
  ret.v0 = _mm_max_epi8(__a.v0, __b.v0);
335
  ret.v1 = _mm_max_epi8(__a.v1, __b.v1);
336
  return ret;
337
}
338

339
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
340
_mm256_max_epi16(__m256i __a, __m256i __b) {
341
  __m256i ret;
342
  ret.v0 = _mm_max_epi16(__a.v0, __b.v0);
343
  ret.v1 = _mm_max_epi16(__a.v1, __b.v1);
344
  return ret;
345
}
346

347
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
348
_mm256_max_epi32(__m256i __a, __m256i __b) {
349
  __m256i ret;
350
  ret.v0 = _mm_max_epi32(__a.v0, __b.v0);
351
  ret.v1 = _mm_max_epi32(__a.v1, __b.v1);
352
  return ret;
353
}
354

355
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
356
_mm256_max_epu8(__m256i __a, __m256i __b) {
357
  __m256i ret;
358
  ret.v0 = _mm_max_epu8(__a.v0, __b.v0);
359
  ret.v1 = _mm_max_epu8(__a.v1, __b.v1);
360
  return ret;
361
}
362

363
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
364
_mm256_max_epu16(__m256i __a, __m256i __b) {
365
  __m256i ret;
366
  ret.v0 = _mm_max_epu16(__a.v0, __b.v0);
367
  ret.v1 = _mm_max_epu16(__a.v1, __b.v1);
368
  return ret;
369
}
370

371
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
372
_mm256_max_epu32(__m256i __a, __m256i __b) {
373
  __m256i ret;
374
  ret.v0 = _mm_max_epu32(__a.v0, __b.v0);
375
  ret.v1 = _mm_max_epu32(__a.v1, __b.v1);
376
  return ret;
377
}
378

379
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
380
_mm256_min_epi8(__m256i __a, __m256i __b) {
381
  __m256i ret;
382
  ret.v0 = _mm_min_epi8(__a.v0, __b.v0);
383
  ret.v1 = _mm_min_epi8(__a.v1, __b.v1);
384
  return ret;
385
}
386

387
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
388
_mm256_min_epi16(__m256i __a, __m256i __b) {
389
  __m256i ret;
390
  ret.v0 = _mm_min_epi16(__a.v0, __b.v0);
391
  ret.v1 = _mm_min_epi16(__a.v1, __b.v1);
392
  return ret;
393
}
394

395
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
396
_mm256_min_epi32(__m256i __a, __m256i __b) {
397
  __m256i ret;
398
  ret.v0 = _mm_min_epi32(__a.v0, __b.v0);
399
  ret.v1 = _mm_min_epi32(__a.v1, __b.v1);
400
  return ret;
401
}
402

403
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
404
_mm256_min_epu8(__m256i __a, __m256i __b) {
405
  __m256i ret;
406
  ret.v0 = _mm_min_epu8(__a.v0, __b.v0);
407
  ret.v1 = _mm_min_epu8(__a.v1, __b.v1);
408
  return ret;
409
}
410

411
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
412
_mm256_min_epu16(__m256i __a, __m256i __b) {
413
  __m256i ret;
414
  ret.v0 = _mm_min_epu16(__a.v0, __b.v0);
415
  ret.v1 = _mm_min_epu16(__a.v1, __b.v1);
416
  return ret;
417
}
418

419
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
420
_mm256_min_epu32(__m256i __a, __m256i __b) {
421
  __m256i ret;
422
  ret.v0 = _mm_min_epu32(__a.v0, __b.v0);
423
  ret.v1 = _mm_min_epu32(__a.v1, __b.v1);
424
  return ret;
425
}
426

427
static __inline__ int __attribute__((__always_inline__, __nodebug__))
428
_mm256_movemask_epi8(__m256i __a) {
429
  return (_mm_movemask_epi8(__a.v1) << 16) | _mm_movemask_epi8(__a.v0);
430
}
431

432
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
433
_mm256_cvtepi8_epi16(__m128i __a) {
434
  __m256i ret;
435
  ret.v0 = _mm_cvtepi8_epi16(__a);
436
  ret.v1 = _mm_cvtepi8_epi16(_mm_shuffle_epi32(__a, 0x4E));
437
  return ret;
438
}
439

440
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
441
_mm256_cvtepi8_epi32(__m128i __a) {
442
  __m256i ret;
443
  ret.v0 = _mm_cvtepi8_epi32(__a);
444
  ret.v1 = _mm_cvtepi8_epi32(_mm_shuffle_epi32(__a, 0xE1));
445
  return ret;
446
}
447

448
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
449
_mm256_cvtepi8_epi64(__m128i __a) {
450
  __m256i ret;
451
  ret.v0 = _mm_cvtepi8_epi64(__a);
452
  ret.v1 = _mm_cvtepi8_epi64(_mm_srli_epi32(__a, 16));
453
  return ret;
454
}
455

456
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
457
_mm256_cvtepi16_epi32(__m128i __a) {
458
  __m256i ret;
459
  ret.v0 = _mm_cvtepi16_epi32(__a);
460
  ret.v1 = _mm_cvtepi16_epi32(_mm_shuffle_epi32(__a, 0x4E));
461
  return ret;
462
}
463

464
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
465
_mm256_cvtepi16_epi64(__m128i __a) {
466
  __m256i ret;
467
  ret.v0 = _mm_cvtepi16_epi64(__a);
468
  ret.v1 = _mm_cvtepi16_epi64(_mm_shuffle_epi32(__a, 0xE1));
469
  return ret;
470
}
471

472
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
473
_mm256_cvtepi32_epi64(__m128i __a) {
474
  __m256i ret;
475
  ret.v0 = _mm_cvtepi32_epi64(__a);
476
  ret.v1 = _mm_cvtepi32_epi64(_mm_shuffle_epi32(__a, 0x4E));
477
  return ret;
478
}
479

480
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
481
_mm256_cvtepu8_epi16(__m128i __a) {
482
  __m256i ret;
483
  ret.v0 = _mm_cvtepu8_epi16(__a);
484
  ret.v1 = _mm_cvtepu8_epi16(_mm_shuffle_epi32(__a, 0x4E));
485
  return ret;
486
}
487

488
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
489
_mm256_cvtepu8_epi32(__m128i __a) {
490
  __m256i ret;
491
  ret.v0 = _mm_cvtepu8_epi32(__a);
492
  ret.v1 = _mm_cvtepu8_epi32(_mm_shuffle_epi32(__a, 0xE1));
493
  return ret;
494
}
495

496
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
497
_mm256_cvtepu8_epi64(__m128i __a) {
498
  __m256i ret;
499
  ret.v0 = _mm_cvtepu8_epi64(__a);
500
  ret.v1 = _mm_cvtepu8_epi64(_mm_srli_epi32(__a, 16));
501
  return ret;
502
}
503

504
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
505
_mm256_cvtepu16_epi32(__m128i __a) {
506
  __m256i ret;
507
  ret.v0 = _mm_cvtepu16_epi32(__a);
508
  ret.v1 = _mm_cvtepu16_epi32(_mm_shuffle_epi32(__a, 0x4E));
509
  return ret;
510
}
511

512
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
513
_mm256_cvtepu16_epi64(__m128i __a) {
514
  __m256i ret;
515
  ret.v0 = _mm_cvtepu16_epi64(__a);
516
  ret.v1 = _mm_cvtepu16_epi64(_mm_shuffle_epi32(__a, 0xE1));
517
  return ret;
518
}
519

520
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
521
_mm256_cvtepu32_epi64(__m128i __a) {
522
  __m256i ret;
523
  ret.v0 = _mm_cvtepu32_epi64(__a);
524
  ret.v1 = _mm_cvtepu32_epi64(_mm_shuffle_epi32(__a, 0x4E));
525
  return ret;
526
}
527

528
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
529
_mm256_mul_epi32(__m256i __a, __m256i __b) {
530
  __m256i ret;
531
  ret.v0 = _mm_mul_epi32(__a.v0, __b.v0);
532
  ret.v1 = _mm_mul_epi32(__a.v1, __b.v1);
533
  return ret;
534
}
535

536
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
537
_mm256_mulhrs_epi16(__m256i __a, __m256i __b) {
538
  __m256i ret;
539
  ret.v0 = _mm_mulhrs_epi16(__a.v0, __b.v0);
540
  ret.v1 = _mm_mulhrs_epi16(__a.v1, __b.v1);
541
  return ret;
542
}
543

544
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
545
_mm256_mulhi_epu16(__m256i __a, __m256i __b) {
546
  __m256i ret;
547
  ret.v0 = _mm_mulhi_epu16(__a.v0, __b.v0);
548
  ret.v1 = _mm_mulhi_epu16(__a.v1, __b.v1);
549
  return ret;
550
}
551

552
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
553
_mm256_mulhi_epi16(__m256i __a, __m256i __b) {
554
  __m256i ret;
555
  ret.v0 = _mm_mulhi_epi16(__a.v0, __b.v0);
556
  ret.v1 = _mm_mulhi_epi16(__a.v1, __b.v1);
557
  return ret;
558
}
559

560
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
561
_mm256_mullo_epi16(__m256i __a, __m256i __b) {
562
  __m256i ret;
563
  ret.v0 = _mm_mullo_epi16(__a.v0, __b.v0);
564
  ret.v1 = _mm_mullo_epi16(__a.v1, __b.v1);
565
  return ret;
566
}
567

568
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
569
_mm256_mullo_epi32(__m256i __a, __m256i __b) {
570
  __m256i ret;
571
  ret.v0 = _mm_mullo_epi32(__a.v0, __b.v0);
572
  ret.v1 = _mm_mullo_epi32(__a.v1, __b.v1);
573
  return ret;
574
}
575

576
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
577
_mm256_mul_epu32(__m256i __a, __m256i __b) {
578
  __m256i ret;
579
  ret.v0 = _mm_mul_epu32(__a.v0, __b.v0);
580
  ret.v1 = _mm_mul_epu32(__a.v1, __b.v1);
581
  return ret;
582
}
583

584
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
585
_mm256_or_si256(__m256i __a, __m256i __b) {
586
  __m256i ret;
587
  ret.v0 = _mm_or_si128(__a.v0, __b.v0);
588
  ret.v1 = _mm_or_si128(__a.v1, __b.v1);
589
  return ret;
590
}
591

592
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
593
_mm256_sad_epu8(__m256i __a, __m256i __b) {
594
  __m256i ret;
595
  ret.v0 = _mm_sad_epu8(__a.v0, __b.v0);
596
  ret.v1 = _mm_sad_epu8(__a.v1, __b.v1);
597
  return ret;
598
}
599

600
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
601
_mm256_shuffle_epi8(__m256i __a, __m256i __b) {
602
  __m256i ret;
603
  ret.v0 = _mm_shuffle_epi8(__a.v0, __b.v0);
604
  ret.v1 = _mm_shuffle_epi8(__a.v1, __b.v1);
605
  return ret;
606
}
607

608
#define _mm256_shuffle_epi32(__A, __imm)                                       \
609
  __extension__({                                                              \
610
    __m256i __a = (__A);                                                       \
611
    _mm256_set_m128i(_mm_shuffle_epi32(__a.v1, (__imm)),                       \
612
                     _mm_shuffle_epi32(__a.v0, (__imm)));                      \
613
  })
614

615
#define _mm256_shufflehi_epi16(__A, __imm)                                     \
616
  __extension__({                                                              \
617
    __m256i __a = (__A);                                                       \
618
    _mm256_set_m128i(_mm_shufflehi_epi16(__a.v1, (__imm)),                     \
619
                     _mm_shufflehi_epi16(__a.v0, (__imm)));                    \
620
  })
621

622
#define _mm256_shufflelo_epi16(__A, __imm)                                     \
623
  __extension__({                                                              \
624
    __m256i __a = (__A);                                                       \
625
    _mm256_set_m128i(_mm_shufflelo_epi16(__a.v1, (__imm)),                     \
626
                     _mm_shufflelo_epi16(__a.v0, (__imm)));                    \
627
  })
628

629
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
630
_mm256_sign_epi8(__m256i __a, __m256i __b) {
631
  __m256i ret;
632
  ret.v0 = _mm_sign_epi8(__a.v0, __b.v0);
633
  ret.v1 = _mm_sign_epi8(__a.v1, __b.v1);
634
  return ret;
635
}
636

637
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
638
_mm256_sign_epi16(__m256i __a, __m256i __b) {
639
  __m256i ret;
640
  ret.v0 = _mm_sign_epi16(__a.v0, __b.v0);
641
  ret.v1 = _mm_sign_epi16(__a.v1, __b.v1);
642
  return ret;
643
}
644

645
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
646
_mm256_sign_epi32(__m256i __a, __m256i __b) {
647
  __m256i ret;
648
  ret.v0 = _mm_sign_epi32(__a.v0, __b.v0);
649
  ret.v1 = _mm_sign_epi32(__a.v1, __b.v1);
650
  return ret;
651
}
652

653
#define _mm256_slli_si256(__A, __imm)                                          \
654
  __extension__({                                                              \
655
    __m256i __a = (__A);                                                       \
656
    _mm256_set_m128i(_mm_slli_si128(__a.v1, (__imm)),                          \
657
                     _mm_slli_si128(__a.v0, (__imm)));                         \
658
  })
659

660
#define _mm256_bslli_epi128(__A, __imm) _mm256_slli_si256(__A, __imm)
661

662
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
663
_mm256_slli_epi16(__m256i __a, int __count) {
664
  __m256i ret;
665
  ret.v0 = _mm_slli_epi16(__a.v0, __count);
666
  ret.v1 = _mm_slli_epi16(__a.v1, __count);
667
  return ret;
668
}
669

670
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
671
_mm256_sll_epi16(__m256i __a, __m128i __count) {
672
  __m256i ret;
673
  ret.v0 = _mm_sll_epi16(__a.v0, __count);
674
  ret.v1 = _mm_sll_epi16(__a.v1, __count);
675
  return ret;
676
}
677

678
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
679
_mm256_slli_epi32(__m256i __a, int __count) {
680
  __m256i ret;
681
  ret.v0 = _mm_slli_epi32(__a.v0, __count);
682
  ret.v1 = _mm_slli_epi32(__a.v1, __count);
683
  return ret;
684
}
685

686
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
687
_mm256_sll_epi32(__m256i __a, __m128i __count) {
688
  __m256i ret;
689
  ret.v0 = _mm_sll_epi32(__a.v0, __count);
690
  ret.v1 = _mm_sll_epi32(__a.v1, __count);
691
  return ret;
692
}
693

694
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
695
_mm256_slli_epi64(__m256i __a, int __count) {
696
  __m256i ret;
697
  ret.v0 = _mm_slli_epi64(__a.v0, __count);
698
  ret.v1 = _mm_slli_epi64(__a.v1, __count);
699
  return ret;
700
}
701

702
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
703
_mm256_sll_epi64(__m256i __a, __m128i __count) {
704
  __m256i ret;
705
  ret.v0 = _mm_sll_epi64(__a.v0, __count);
706
  ret.v1 = _mm_sll_epi64(__a.v1, __count);
707
  return ret;
708
}
709

710
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
711
_mm256_srai_epi16(__m256i __a, int __count) {
712
  __m256i ret;
713
  ret.v0 = _mm_srai_epi16(__a.v0, __count);
714
  ret.v1 = _mm_srai_epi16(__a.v1, __count);
715
  return ret;
716
}
717

718
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
719
_mm256_sra_epi16(__m256i __a, __m128i __count) {
720
  __m256i ret;
721
  ret.v0 = _mm_sra_epi16(__a.v0, __count);
722
  ret.v1 = _mm_sra_epi16(__a.v1, __count);
723
  return ret;
724
}
725

726
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
727
_mm256_srai_epi32(__m256i __a, int __count) {
728
  __m256i ret;
729
  ret.v0 = _mm_srai_epi32(__a.v0, __count);
730
  ret.v1 = _mm_srai_epi32(__a.v1, __count);
731
  return ret;
732
}
733

734
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
735
_mm256_sra_epi32(__m256i __a, __m128i __count) {
736
  __m256i ret;
737
  ret.v0 = _mm_sra_epi32(__a.v0, __count);
738
  ret.v1 = _mm_sra_epi32(__a.v1, __count);
739
  return ret;
740
}
741

742
#define _mm256_srli_si256(__A, __imm)                                          \
743
  __extension__({                                                              \
744
    __m256i __a = (__A);                                                       \
745
    _mm256_set_m128i(_mm_srli_si128(__a.v1, (__imm)),                          \
746
                     _mm_srli_si128(__a.v0, (__imm)));                         \
747
  })
748

749
#define _mm256_bsrli_epi128(a, imm) _mm256_srli_si256(a, imm)
750

751
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
752
_mm256_srli_epi16(__m256i __a, int __count) {
753
  __m256i ret;
754
  ret.v0 = _mm_srli_epi16(__a.v0, __count);
755
  ret.v1 = _mm_srli_epi16(__a.v1, __count);
756
  return ret;
757
}
758

759
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
760
_mm256_srl_epi16(__m256i __a, __m128i __count) {
761
  __m256i ret;
762
  ret.v0 = _mm_srl_epi16(__a.v0, __count);
763
  ret.v1 = _mm_srl_epi16(__a.v1, __count);
764
  return ret;
765
}
766

767
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
768
_mm256_srli_epi32(__m256i __a, int __count) {
769
  __m256i ret;
770
  ret.v0 = _mm_srli_epi32(__a.v0, __count);
771
  ret.v1 = _mm_srli_epi32(__a.v1, __count);
772
  return ret;
773
}
774

775
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
776
_mm256_srl_epi32(__m256i __a, __m128i __count) {
777
  __m256i ret;
778
  ret.v0 = _mm_srl_epi32(__a.v0, __count);
779
  ret.v1 = _mm_srl_epi32(__a.v1, __count);
780
  return ret;
781
}
782

783
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
784
_mm256_srli_epi64(__m256i __a, int __count) {
785
  __m256i ret;
786
  ret.v0 = _mm_srli_epi64(__a.v0, __count);
787
  ret.v1 = _mm_srli_epi64(__a.v1, __count);
788
  return ret;
789
}
790

791
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
792
_mm256_srl_epi64(__m256i __a, __m128i __count) {
793
  __m256i ret;
794
  ret.v0 = _mm_srl_epi64(__a.v0, __count);
795
  ret.v1 = _mm_srl_epi64(__a.v1, __count);
796
  return ret;
797
}
798

799
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
800
_mm256_sub_epi8(__m256i __a, __m256i __b) {
801
  __m256i ret;
802
  ret.v0 = _mm_sub_epi8(__a.v0, __b.v0);
803
  ret.v1 = _mm_sub_epi8(__a.v1, __b.v1);
804
  return ret;
805
}
806

807
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
808
_mm256_sub_epi16(__m256i __a, __m256i __b) {
809
  __m256i ret;
810
  ret.v0 = _mm_sub_epi16(__a.v0, __b.v0);
811
  ret.v1 = _mm_sub_epi16(__a.v1, __b.v1);
812
  return ret;
813
}
814

815
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
816
_mm256_sub_epi32(__m256i __a, __m256i __b) {
817
  __m256i ret;
818
  ret.v0 = _mm_sub_epi32(__a.v0, __b.v0);
819
  ret.v1 = _mm_sub_epi32(__a.v1, __b.v1);
820
  return ret;
821
}
822

823
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
824
_mm256_sub_epi64(__m256i __a, __m256i __b) {
825
  __m256i ret;
826
  ret.v0 = _mm_sub_epi64(__a.v0, __b.v0);
827
  ret.v1 = _mm_sub_epi64(__a.v1, __b.v1);
828
  return ret;
829
}
830

831
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
832
_mm256_subs_epi8(__m256i __a, __m256i __b) {
833
  __m256i ret;
834
  ret.v0 = _mm_subs_epi8(__a.v0, __b.v0);
835
  ret.v1 = _mm_subs_epi8(__a.v1, __b.v1);
836
  return ret;
837
}
838

839
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
840
_mm256_subs_epi16(__m256i __a, __m256i __b) {
841
  __m256i ret;
842
  ret.v0 = _mm_subs_epi16(__a.v0, __b.v0);
843
  ret.v1 = _mm_subs_epi16(__a.v1, __b.v1);
844
  return ret;
845
}
846

847
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
848
_mm256_subs_epu8(__m256i __a, __m256i __b) {
849
  __m256i ret;
850
  ret.v0 = _mm_subs_epu8(__a.v0, __b.v0);
851
  ret.v1 = _mm_subs_epu8(__a.v1, __b.v1);
852
  return ret;
853
}
854

855
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
856
_mm256_subs_epu16(__m256i __a, __m256i __b) {
857
  __m256i ret;
858
  ret.v0 = _mm_subs_epu16(__a.v0, __b.v0);
859
  ret.v1 = _mm_subs_epu16(__a.v1, __b.v1);
860
  return ret;
861
}
862

863
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
864
_mm256_unpackhi_epi8(__m256i __a, __m256i __b) {
865
  __m256i ret;
866
  ret.v0 = _mm_unpackhi_epi8(__a.v0, __b.v0);
867
  ret.v1 = _mm_unpackhi_epi8(__a.v1, __b.v1);
868
  return ret;
869
}
870

871
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
872
_mm256_unpackhi_epi16(__m256i __a, __m256i __b) {
873
  __m256i ret;
874
  ret.v0 = _mm_unpackhi_epi16(__a.v0, __b.v0);
875
  ret.v1 = _mm_unpackhi_epi16(__a.v1, __b.v1);
876
  return ret;
877
}
878

879
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
880
_mm256_unpackhi_epi32(__m256i __a, __m256i __b) {
881
  __m256i ret;
882
  ret.v0 = _mm_unpackhi_epi32(__a.v0, __b.v0);
883
  ret.v1 = _mm_unpackhi_epi32(__a.v1, __b.v1);
884
  return ret;
885
}
886

887
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
888
_mm256_unpackhi_epi64(__m256i __a, __m256i __b) {
889
  __m256i ret;
890
  ret.v0 = _mm_unpackhi_epi64(__a.v0, __b.v0);
891
  ret.v1 = _mm_unpackhi_epi64(__a.v1, __b.v1);
892
  return ret;
893
}
894

895
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
896
_mm256_unpacklo_epi8(__m256i __a, __m256i __b) {
897
  __m256i ret;
898
  ret.v0 = _mm_unpacklo_epi8(__a.v0, __b.v0);
899
  ret.v1 = _mm_unpacklo_epi8(__a.v1, __b.v1);
900
  return ret;
901
}
902

903
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
904
_mm256_unpacklo_epi16(__m256i __a, __m256i __b) {
905
  __m256i ret;
906
  ret.v0 = _mm_unpacklo_epi16(__a.v0, __b.v0);
907
  ret.v1 = _mm_unpacklo_epi16(__a.v1, __b.v1);
908
  return ret;
909
}
910

911
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
912
_mm256_unpacklo_epi32(__m256i __a, __m256i __b) {
913
  __m256i ret;
914
  ret.v0 = _mm_unpacklo_epi32(__a.v0, __b.v0);
915
  ret.v1 = _mm_unpacklo_epi32(__a.v1, __b.v1);
916
  return ret;
917
}
918

919
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
920
_mm256_unpacklo_epi64(__m256i __a, __m256i __b) {
921
  __m256i ret;
922
  ret.v0 = _mm_unpacklo_epi64(__a.v0, __b.v0);
923
  ret.v1 = _mm_unpacklo_epi64(__a.v1, __b.v1);
924
  return ret;
925
}
926

927
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
928
_mm256_xor_si256(__m256i __a, __m256i __b) {
929
  __m256i ret;
930
  ret.v0 = _mm_xor_si128(__a.v0, __b.v0);
931
  ret.v1 = _mm_xor_si128(__a.v1, __b.v1);
932
  return ret;
933
}
934

935
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
936
_mm256_stream_load_si256(const void* __V) {
937
  __m256i ret;
938
  ret.v0 = _mm_stream_load_si128((const __m128i*)__V);
939
  ret.v1 = _mm_stream_load_si128((const __m128i*)(((const uint8_t*)__V) + 16));
940
  return ret;
941
}
942

943
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
944
_mm_broadcastss_ps(__m128 __a) {
945
  return (__m128)wasm_i32x4_shuffle(__a, __a, 0, 0, 0, 0);
946
}
947

948
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
949
_mm_broadcastsd_pd(__m128d __a) {
950
  return (__m128d)wasm_i64x2_shuffle(__a, __a, 0, 0);
951
}
952

953
static __inline__ __m256 __attribute__((__always_inline__, __nodebug__))
954
_mm256_broadcastss_ps(__m128 __a) {
955
  __m256 ret;
956
  ret.v1 = ret.v0 = _mm_broadcastss_ps(__a);
957
  return ret;
958
}
959

960
static __inline__ __m256d __attribute__((__always_inline__, __nodebug__))
961
_mm256_broadcastsd_pd(__m128d __a) {
962
  __m256d ret;
963
  ret.v1 = ret.v0 = _mm_broadcastsd_pd(__a);
964
  return ret;
965
}
966

967
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
968
_mm256_broadcastsi128_si256(__m128i __a) {
969
  __m256i ret;
970
  ret.v1 = ret.v0 = __a;
971
  return ret;
972
}
973

974
#define _mm_broadcastsi128_si256(X) _mm256_broadcastsi128_si256(X)
975

976
#define _mm_blend_epi32(__a, __b, __imm8)                                      \
977
  __extension__({                                                              \
978
    (__m128i) __builtin_shufflevector((__i32x4)(__m128i)(__a),                 \
979
                                      (__i32x4)(__m128i)(__b),                 \
980
                                      (((__imm8) & 0x01) ? 4 : 0),             \
981
                                      (((__imm8) & 0x02) ? 5 : 1),             \
982
                                      (((__imm8) & 0x04) ? 6 : 2),             \
983
                                      (((__imm8) & 0x08) ? 7 : 3));            \
984
  })
985

986
#define _mm256_blend_epi32(__A, __B, __imm)                                    \
987
  __extension__({                                                              \
988
    __m256i __a = (__A);                                                       \
989
    __m256i __b = (__B);                                                       \
990
    _mm256_set_m128i(_mm_blend_epi32(__a.v1, __b.v1, (__imm) >> 4),            \
991
                     _mm_blend_epi32(__a.v0, __b.v0, (__imm)));                \
992
  })
993

994
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
995
_mm_broadcastb_epi8(__m128i __a) {
996
  return (__m128i)wasm_i8x16_shuffle(
997
    __a, __a, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
998
}
999

1000
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
1001
_mm_broadcastw_epi16(__m128i __a) {
1002
  return (__m128i)wasm_i16x8_shuffle(__a, __a, 0, 0, 0, 0, 0, 0, 0, 0);
1003
}
1004

1005
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
1006
_mm_broadcastd_epi32(__m128i __a) {
1007
  return (__m128i)wasm_i32x4_shuffle(__a, __a, 0, 0, 0, 0);
1008
}
1009

1010
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
1011
_mm_broadcastq_epi64(__m128i __a) {
1012
  return (__m128i)wasm_i64x2_shuffle(__a, __a, 0, 0);
1013
}
1014

1015
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
1016
_mm256_broadcastb_epi8(__m128i __a) {
1017
  __m256i ret;
1018
  ret.v1 = ret.v0 = _mm_broadcastb_epi8(__a);
1019
  return ret;
1020
}
1021

1022
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
1023
_mm256_broadcastw_epi16(__m128i __a) {
1024
  __m256i ret;
1025
  ret.v1 = ret.v0 = _mm_broadcastw_epi16(__a);
1026
  return ret;
1027
}
1028

1029
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
1030
_mm256_broadcastd_epi32(__m128i __a) {
1031
  __m256i ret;
1032
  ret.v1 = ret.v0 = _mm_broadcastd_epi32(__a);
1033
  return ret;
1034
}
1035

1036
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
1037
_mm256_broadcastq_epi64(__m128i __a) {
1038
  __m256i ret;
1039
  ret.v1 = ret.v0 = _mm_broadcastq_epi64(__a);
1040
  return ret;
1041
}
1042

1043
static __inline__ __m256i
1044
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1045
  _mm256_permutevar8x32_epi32(__m256i __a, __m256i __b) {
1046
  __m256i ret;
1047
  int index[8];
1048
  int lane[8];
1049
  for (int i = 0; i < 4; i++) {
1050
    index[i] = ((__i32x4)__b.v0)[i] & 7;
1051
    index[i + 4] = ((__i32x4)__b.v1)[i] & 7;
1052
  }
1053

1054
  for (int j = 0; j < 8; j++) {
1055
    lane[j] = index[j] < 4 ? ((__i32x4)(__a.v0))[index[j]]
1056
                           : ((__i32x4)(__a.v1))[index[j] - 4];
1057
  }
1058

1059
  ret.v0 = (__m128i)wasm_i32x4_make(lane[0], lane[1], lane[2], lane[3]);
1060
  ret.v1 = (__m128i)wasm_i32x4_make(lane[4], lane[5], lane[6], lane[7]);
1061
  return ret;
1062
}
1063

1064
#define _mm256_permute4x64_pd(__A, __imm)                                      \
1065
  __extension__({                                                              \
1066
    __m256d __a = (__A);                                                       \
1067
    _mm256_set_m128d(                                                          \
1068
      (__m128d)wasm_i64x2_shuffle(                                             \
1069
        __a.v0, __a.v1, (((__imm) >> 4) & 3), (((__imm) >> 6) & 3)),           \
1070
      (__m128d)wasm_i64x2_shuffle(                                             \
1071
        __a.v0, __a.v1, ((__imm) & 3), (((__imm) >> 2) & 3)));                 \
1072
  })
1073

1074
static __inline__ __m256
1075
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1076
  _mm256_permutevar8x32_ps(__m256 __a, __m256i __b) {
1077
  __m256 ret;
1078
  int index[8];
1079
  float lane[8];
1080
  for (int i = 0; i < 4; i++) {
1081
    index[i] = ((__i32x4)__b.v0)[i] & 7;
1082
    index[i + 4] = ((__i32x4)__b.v1)[i] & 7;
1083
  }
1084
  for (int j = 0; j < 8; j++) {
1085
    lane[j] = index[j] < 4 ? ((__f32x4)(__a.v0))[index[j]]
1086
                           : ((__f32x4)(__a.v1))[index[j] - 4];
1087
  }
1088
  ret.v0 = (__m128)wasm_f32x4_make(lane[0], lane[1], lane[2], lane[3]);
1089
  ret.v1 = (__m128)wasm_f32x4_make(lane[4], lane[5], lane[6], lane[7]);
1090
  return ret;
1091
}
1092

1093
#define _mm256_permute4x64_epi64(__A, __imm)                                   \
1094
  __extension__({                                                              \
1095
    __m256i __a = (__A);                                                       \
1096
    _mm256_set_m128i(                                                          \
1097
      wasm_i64x2_shuffle(                                                      \
1098
        __a.v0, __a.v1, (((__imm) >> 4) & 3), (((__imm) >> 6) & 3)),           \
1099
      wasm_i64x2_shuffle(                                                      \
1100
        __a.v0, __a.v1, ((__imm) & 3), (((__imm) >> 2) & 3)));                 \
1101
  })
1102

1103
static __inline__ __m256i
1104
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1105
  _mm256_permute2x128_si256(__m256i __a, __m256i __b, const int imm8) {
1106
  __m256i ret;
1107
  ret.v0 = __avx_select4i(__a, __b, imm8);
1108
  ret.v1 = __avx_select4i(__a, __b, imm8 >> 4);
1109
  return ret;
1110
}
1111

1112
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
1113
_mm256_extracti128_si256(__m256i __a, const int imm8) {
1114
  if (imm8 & 0x1) {
1115
    return __a.v1;
1116
  } else {
1117
    return __a.v0;
1118
  }
1119
}
1120

1121
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
1122
_mm256_inserti128_si256(__m256i __a, __m128i __b, const int imm8) {
1123
  __m256i ret = __a;
1124
  if (imm8 & 0x1) {
1125
    ret.v1 = __b;
1126
  } else {
1127
    ret.v0 = __b;
1128
  }
1129
  return ret;
1130
}
1131

1132
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
1133
_mm_maskload_epi32(int32_t const* __p, __m128i __m) {
1134
  int32_t lane[4];
1135
  for (size_t i = 0; i < 4; i++) {
1136
    uint32_t mask = ((__i32x4)__m)[i];
1137
    lane[i] = ((mask >> 31) & 0x1) ? __p[i] : 0;
1138
  }
1139
  return (__m128i)wasm_i32x4_make(lane[0], lane[1], lane[2], lane[3]);
1140
}
1141

1142
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
1143
_mm_maskload_epi64(int64_t const* __p, __m128i __m) {
1144
  int64_t lane[2];
1145
  for (size_t i = 0; i < 2; i++) {
1146
    uint64_t mask = ((__i64x2)__m)[i];
1147
    lane[i] = ((mask >> 63) & 0x1) ? __p[i] : 0;
1148
  }
1149
  return (__m128i)wasm_i64x2_make(lane[0], lane[1]);
1150
}
1151

1152
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
1153
_mm256_maskload_epi32(int const* __p, __m256i __m) {
1154
  __m256i ret;
1155
  ret.v0 = _mm_maskload_epi32(__p, __m.v0);
1156
  ret.v1 = _mm_maskload_epi32(((int32_t*)__p) + 4, __m.v1);
1157
  return ret;
1158
}
1159

1160
static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
1161
_mm256_maskload_epi64(long long const* __p, __m256i __m) {
1162
  __m256i ret;
1163
  ret.v0 = _mm_maskload_epi64(__p, __m.v0);
1164
  ret.v1 = _mm_maskload_epi64(((int64_t*)__p) + 2, __m.v1);
1165
  return ret;
1166
}
1167

1168
static __inline__ void
1169
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1170
  _mm_maskstore_epi32(int* __p, __m128i __m, __m128i __a) {
1171
  if ((wasm_i32x4_extract_lane(__m, 0) & 0x80000000ull) != 0)
1172
    __p[0] = wasm_i32x4_extract_lane((v128_t)__a, 0);
1173
  if ((wasm_i32x4_extract_lane(__m, 1) & 0x80000000ull) != 0)
1174
    __p[1] = wasm_i32x4_extract_lane((v128_t)__a, 1);
1175
  if ((wasm_i32x4_extract_lane(__m, 2) & 0x80000000ull) != 0)
1176
    __p[2] = wasm_i32x4_extract_lane((v128_t)__a, 2);
1177
  if ((wasm_i32x4_extract_lane(__m, 3) & 0x80000000ull) != 0)
1178
    __p[3] = wasm_i32x4_extract_lane((v128_t)__a, 3);
1179
}
1180

1181
static __inline__ void
1182
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1183
  _mm_maskstore_epi64(long long* __p, __m128i __m, __m128i __a) {
1184
  if ((wasm_i64x2_extract_lane(__m, 0) & 0x8000000000000000ull) != 0)
1185
    __p[0] = wasm_i64x2_extract_lane((v128_t)__a, 0);
1186
  if ((wasm_i64x2_extract_lane(__m, 1) & 0x8000000000000000ull) != 0)
1187
    __p[1] = wasm_i64x2_extract_lane((v128_t)__a, 1);
1188
}
1189

1190
static __inline__ void __attribute__((__always_inline__, __nodebug__))
1191
_mm256_maskstore_epi32(int* __p, __m256i __m, __m256i __a) {
1192
  _mm_maskstore_epi32(__p, __m.v0, __a.v0);
1193
  _mm_maskstore_epi32(((int32_t*)__p) + 4, __m.v1, __a.v1);
1194
}
1195

1196
static __inline__ void __attribute__((__always_inline__, __nodebug__))
1197
_mm256_maskstore_epi64(long long* __p, __m256i __m, __m256i __a) {
1198
  _mm_maskstore_epi64(__p, __m.v0, __a.v0);
1199
  _mm_maskstore_epi64(((int64_t*)__p) + 2, __m.v1, __a.v1);
1200
}
1201

1202
static __inline__ __m128i
1203
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1204
  _mm_sllv_epi32(__m128i __a, __m128i __count) {
1205
  int32_t lane[4];
1206
  for (size_t i = 0; i < 4; i++) {
1207
    uint32_t shift = ((__u32x4)__count)[i];
1208
    lane[i] = shift < 32 ? ((__u32x4)__a)[i] << shift : 0;
1209
  }
1210
  return (__m128i)wasm_i32x4_make(lane[0], lane[1], lane[2], lane[3]);
1211
}
1212

1213
static __inline__ __m256i
1214
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1215
  _mm256_sllv_epi32(__m256i __a, __m256i __count) {
1216
  __m256i ret;
1217
  ret.v0 = _mm_sllv_epi32(__a.v0, __count.v0);
1218
  ret.v1 = _mm_sllv_epi32(__a.v1, __count.v1);
1219
  return ret;
1220
}
1221

1222
static __inline__ __m128i
1223
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1224
  _mm_sllv_epi64(__m128i __a, __m128i __count) {
1225

1226
  int64_t lane[2];
1227
  for (size_t i = 0; i < 2; i++) {
1228
    uint64_t shift = (uint64_t)((__u64x2)__count)[i];
1229
    lane[i] = shift < 64 ? ((__u64x2)__a)[i] << shift : 0;
1230
  }
1231
  return (__m128i)wasm_i64x2_make(lane[0], lane[1]);
1232
}
1233

1234
static __inline__ __m256i
1235
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1236
  _mm256_sllv_epi64(__m256i __a, __m256i __count) {
1237
  __m256i ret;
1238
  ret.v0 = _mm_sllv_epi64(__a.v0, __count.v0);
1239
  ret.v1 = _mm_sllv_epi64(__a.v1, __count.v1);
1240
  return ret;
1241
}
1242

1243
static __inline__ __m128i
1244
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1245
  _mm_srav_epi32(__m128i __a, __m128i __count) {
1246
  int32_t lane[4];
1247
  for (size_t i = 0; i < 4; i++) {
1248
    uint32_t shift = ((__u32x4)__count)[i];
1249
    shift = shift < 31 ? shift : 31;
1250
    lane[i] = ((__i32x4)__a)[i] >> shift;
1251
  }
1252
  return (__m128i)wasm_i32x4_make(lane[0], lane[1], lane[2], lane[3]);
1253
}
1254

1255
static __inline__ __m256i
1256
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1257
  _mm256_srav_epi32(__m256i __a, __m256i __count) {
1258
  __m256i ret;
1259
  ret.v0 = _mm_srav_epi32(__a.v0, __count.v0);
1260
  ret.v1 = _mm_srav_epi32(__a.v1, __count.v1);
1261
  return ret;
1262
}
1263

1264
static __inline__ __m128i
1265
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1266
  _mm_srlv_epi32(__m128i __a, __m128i __count) {
1267
  int32_t lane[4];
1268
  for (size_t i = 0; i < 4; i++) {
1269
    uint32_t shift = ((__u32x4)__count)[i];
1270
    lane[i] = shift < 32 ? ((__u32x4)__a)[i] >> shift : 0;
1271
  }
1272
  return (__m128i)wasm_i32x4_make(lane[0], lane[1], lane[2], lane[3]);
1273
}
1274

1275
static __inline__ __m256i
1276
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1277
  _mm256_srlv_epi32(__m256i __a, __m256i __count) {
1278
  __m256i ret;
1279
  ret.v0 = _mm_srlv_epi32(__a.v0, __count.v0);
1280
  ret.v1 = _mm_srlv_epi32(__a.v1, __count.v1);
1281
  return ret;
1282
}
1283

1284
static __inline__ __m128i
1285
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1286
  _mm_srlv_epi64(__m128i __a, __m128i __count) {
1287
  int64_t lane[2];
1288
  for (size_t i = 0; i < 2; i++) {
1289
    uint64_t shift = ((__u64x2)__count)[i];
1290
    lane[i] = shift < 64 ? ((__u64x2)__a)[i] >> shift : 0;
1291
  }
1292
  return (__m128i)wasm_i64x2_make(lane[0], lane[1]);
1293
}
1294

1295
static __inline__ __m256i
1296
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1297
  _mm256_srlv_epi64(__m256i __a, __m256i __count) {
1298
  __m256i ret;
1299
  ret.v0 = _mm_srlv_epi64(__a.v0, __count.v0);
1300
  ret.v1 = _mm_srlv_epi64(__a.v1, __count.v1);
1301
  return ret;
1302
}
1303

1304
static __inline__ __m128d
1305
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1306
  _mm_mask_i32gather_pd(__m128d src,
1307
                        const double* base_addr,
1308
                        __m128i vindex,
1309
                        __m128d mask,
1310
                        const int scale) {
1311
  double lane[2];
1312
  for (size_t i = 0; i < 2; i++) {
1313
    if ((((__i64x2)mask)[i] >> 63) & 0x1) {
1314
      double* addr =
1315
        (double*)((uint8_t*)base_addr + (int64_t)(((__i32x4)vindex)[i]) *
1316
                                          (uint64_t)((uint32_t)scale));
1317
      lane[i] = *addr;
1318
    } else {
1319
      lane[i] = ((__f64x2)src)[i];
1320
    }
1321
  }
1322
  return (__m128d)wasm_f64x2_make(lane[0], lane[1]);
1323
}
1324

1325
static __inline__ __m256d
1326
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1327
  _mm256_mask_i32gather_pd(__m256d src,
1328
                           const double* base_addr,
1329
                           __m128i vindex,
1330
                           __m256d mask,
1331
                           const int scale) {
1332
  __m256d ret;
1333
  ret.v0 = _mm_mask_i32gather_pd(src.v0, base_addr, vindex, mask.v0, scale);
1334
  __m128i vindex1 = (__m128i)wasm_i32x4_shuffle(vindex, vindex, 2, 3, 0, 1);
1335
  ret.v1 = _mm_mask_i32gather_pd(src.v1, base_addr, vindex1, mask.v1, scale);
1336
  return ret;
1337
}
1338

1339
static __inline__ __m128d
1340
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1341
  _mm_mask_i64gather_pd(__m128d src,
1342
                        const double* base_addr,
1343
                        __m128i vindex,
1344
                        __m128d mask,
1345
                        const int scale) {
1346
  double lane[2];
1347
  for (size_t i = 0; i < 2; i++) {
1348
    if ((((__i64x2)mask)[i] >> 63) & 0x1) {
1349
      double* addr =
1350
        (double*)((uint8_t*)base_addr +
1351
                  ((__i64x2)vindex)[i] * (uint64_t)((uint32_t)scale));
1352
      lane[i] = *addr;
1353
    } else {
1354
      lane[i] = ((__f64x2)src)[i];
1355
    }
1356
  }
1357
  return (__m128d)wasm_f64x2_make(lane[0], lane[1]);
1358
}
1359

1360
static __inline__ __m256d
1361
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1362
  _mm256_mask_i64gather_pd(__m256d src,
1363
                           const double* base_addr,
1364
                           __m256i vindex,
1365
                           __m256d mask,
1366
                           const int scale) {
1367
  __m256d ret;
1368
  ret.v0 = _mm_mask_i64gather_pd(src.v0, base_addr, vindex.v0, mask.v0, scale);
1369
  ret.v1 = _mm_mask_i64gather_pd(src.v1, base_addr, vindex.v1, mask.v1, scale);
1370
  return ret;
1371
}
1372

1373
static __inline__ __m128
1374
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1375
  _mm_mask_i32gather_ps(__m128 src,
1376
                        const float* base_addr,
1377
                        __m128i vindex,
1378
                        __m128 mask,
1379
                        const int scale) {
1380
  float lane[4];
1381
  for (size_t i = 0; i < 4; i++) {
1382
    if ((((__i32x4)mask)[i] >> 31) & 0x1) {
1383
      float* addr =
1384
        (float*)((uint8_t*)base_addr +
1385
                 (int64_t)(((__i32x4)vindex)[i]) * (uint64_t)((uint32_t)scale));
1386
      lane[i] = *addr;
1387
    } else {
1388
      lane[i] = ((__f32x4)src)[i];
1389
    }
1390
  }
1391
  return (__m128)wasm_f32x4_make(lane[0], lane[1], lane[2], lane[3]);
1392
}
1393

1394
static __inline__ __m256
1395
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1396
  _mm256_mask_i32gather_ps(__m256 src,
1397
                           const float* base_addr,
1398
                           __m256i vindex,
1399
                           __m256 mask,
1400
                           const int scale) {
1401
  __m256 ret;
1402
  ret.v0 = _mm_mask_i32gather_ps(src.v0, base_addr, vindex.v0, mask.v0, scale);
1403
  ret.v1 = _mm_mask_i32gather_ps(src.v1, base_addr, vindex.v1, mask.v1, scale);
1404
  return ret;
1405
}
1406

1407
static __inline__ __m128
1408
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1409
  _mm_mask_i64gather_ps(__m128 src,
1410
                        const float* base_addr,
1411
                        __m128i vindex,
1412
                        __m128 mask,
1413
                        const int scale) {
1414
  float lane[2];
1415
  for (size_t i = 0; i < 2; i++) {
1416
    if ((((__i32x4)mask)[i] >> 31) & 0x1) {
1417
      float* addr =
1418
        (float*)((uint8_t*)base_addr +
1419
                 ((__i64x2)vindex)[i] * (uint64_t)((uint32_t)scale));
1420
      lane[i] = *addr;
1421
    } else {
1422
      lane[i] = ((__f32x4)src)[i];
1423
    }
1424
  }
1425
  return (__m128)wasm_f32x4_make(lane[0], lane[1], 0, 0);
1426
}
1427

1428
static __inline__ __m128
1429
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1430
  _mm256_mask_i64gather_ps(__m128 src,
1431
                           const float* base_addr,
1432
                           __m256i vindex,
1433
                           __m128 mask,
1434
                           const int scale) {
1435
  float lane[4];
1436
  __m128i current_vindex;
1437
  for (size_t i = 0; i < 4; i++) {
1438
    current_vindex = i < 2 ? vindex.v0 : vindex.v1;
1439
    if ((((__i32x4)mask)[i] >> 31) & 0x1) {
1440
      float* addr =
1441
        (float*)((uint8_t*)base_addr + ((__i64x2)current_vindex)[i & 1] *
1442
                                         (uint64_t)((uint32_t)scale));
1443
      lane[i] = *addr;
1444
    } else {
1445
      lane[i] = ((__f32x4)src)[i];
1446
    }
1447
  }
1448
  return (__m128)wasm_f32x4_make(lane[0], lane[1], lane[2], lane[3]);
1449
}
1450

1451
static __inline__ __m128i
1452
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1453
  _mm_mask_i32gather_epi32(__m128i src,
1454
                           const int* base_addr,
1455
                           __m128i vindex,
1456
                           __m128i mask,
1457
                           const int scale) {
1458
  int32_t lane[4];
1459
  for (size_t i = 0; i < 4; i++) {
1460
    if ((((__i32x4)mask)[i] >> 31) & 0x1) {
1461
      int32_t* addr =
1462
        (int32_t*)((uint8_t*)base_addr + (int64_t)(((__i32x4)vindex)[i]) *
1463
                                           (uint64_t)((uint32_t)scale));
1464
      lane[i] = *addr;
1465
    } else {
1466
      lane[i] = ((__i32x4)src)[i];
1467
    }
1468
  }
1469
  return (__m128i)wasm_i32x4_make(lane[0], lane[1], lane[2], lane[3]);
1470
}
1471

1472
static __inline__ __m256i
1473
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1474
  _mm256_mask_i32gather_epi32(__m256i src,
1475
                              const int* base_addr,
1476
                              __m256i vindex,
1477
                              __m256i mask,
1478
                              const int scale) {
1479
  __m256i ret;
1480
  ret.v0 =
1481
    _mm_mask_i32gather_epi32(src.v0, base_addr, vindex.v0, mask.v0, scale);
1482
  ret.v1 =
1483
    _mm_mask_i32gather_epi32(src.v1, base_addr, vindex.v1, mask.v1, scale);
1484
  return ret;
1485
}
1486

1487
static __inline__ __m128i
1488
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1489
  _mm_mask_i64gather_epi32(__m128i src,
1490
                           const int* base_addr,
1491
                           __m128i vindex,
1492
                           __m128i mask,
1493
                           const int scale) {
1494
  int32_t lane[2];
1495
  for (size_t i = 0; i < 2; i++) {
1496
    if ((((__i32x4)mask)[i] >> 31) & 0x1) {
1497
      int32_t* addr =
1498
        (int32_t*)((uint8_t*)base_addr +
1499
                   ((__i64x2)vindex)[i] * (uint64_t)((uint32_t)scale));
1500
      lane[i] = *addr;
1501
    } else {
1502
      lane[i] = ((__i32x4)src)[i];
1503
    }
1504
  }
1505
  return (__m128i)wasm_i32x4_make(lane[0], lane[1], 0, 0);
1506
}
1507

1508
static __inline__ __m128i
1509
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1510
  _mm256_mask_i64gather_epi32(__m128i src,
1511
                              const int* base_addr,
1512
                              __m256i vindex,
1513
                              __m128i mask,
1514
                              const int scale) {
1515
  int32_t lane[4];
1516
  __m128i current_vindex;
1517
  for (size_t i = 0; i < 4; i++) {
1518
    current_vindex = i < 2 ? vindex.v0 : vindex.v1;
1519
    if ((((__i32x4)mask)[i] >> 31) & 0x1) {
1520
      int32_t* addr =
1521
        (int32_t*)((uint8_t*)base_addr + ((__i64x2)current_vindex)[i & 1] *
1522
                                           (uint64_t)((uint32_t)scale));
1523
      lane[i] = *addr;
1524
    } else {
1525
      lane[i] = ((__i32x4)src)[i];
1526
    }
1527
  }
1528
  return (__m128i)wasm_i32x4_make(lane[0], lane[1], lane[2], lane[3]);
1529
}
1530

1531
static __inline__ __m128i
1532
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1533
  _mm_mask_i32gather_epi64(__m128i src,
1534
                           const long long* base_addr,
1535
                           __m128i vindex,
1536
                           __m128i mask,
1537
                           const int scale) {
1538
  int64_t lane[2];
1539
  for (size_t i = 0; i < 2; i++) {
1540
    if ((((__i64x2)mask)[i] >> 63) & 0x1) {
1541
      int64_t* addr =
1542
        (int64_t*)((uint8_t*)base_addr + (int64_t)(((__i32x4)vindex)[i]) *
1543
                                           (uint64_t)((uint32_t)scale));
1544
      lane[i] = *addr;
1545
    } else {
1546
      lane[i] = ((__i64x2)src)[i];
1547
    }
1548
  }
1549
  return (__m128i)wasm_i64x2_make(lane[0], lane[1]);
1550
}
1551

1552
static __inline__ __m256i
1553
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1554
  _mm256_mask_i32gather_epi64(__m256i src,
1555
                              const long long* base_addr,
1556
                              __m128i vindex,
1557
                              __m256i mask,
1558
                              const int scale) {
1559
  __m256i ret;
1560
  ret.v0 = _mm_mask_i32gather_epi64(src.v0, base_addr, vindex, mask.v0, scale);
1561
  __m128i vindex1 = (__m128i)wasm_i32x4_shuffle(vindex, vindex, 2, 3, 0, 1);
1562
  ret.v1 = _mm_mask_i32gather_epi64(src.v1, base_addr, vindex1, mask.v1, scale);
1563
  return ret;
1564
}
1565

1566
static __inline__ __m128i
1567
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1568
  _mm_mask_i64gather_epi64(__m128i src,
1569
                           const long long* base_addr,
1570
                           __m128i vindex,
1571
                           __m128i mask,
1572
                           const int scale) {
1573
  int64_t lane[2];
1574
  for (size_t i = 0; i < 2; i++) {
1575
    if ((((__i64x2)mask)[i] >> 63) & 0x1) {
1576
      int64_t* addr =
1577
        (int64_t*)((uint8_t*)base_addr +
1578
                   ((__i64x2)vindex)[i] * (uint64_t)((uint32_t)scale));
1579
      lane[i] = *addr;
1580
    } else {
1581
      lane[i] = ((__i64x2)src)[i];
1582
    }
1583
  }
1584
  return (__m128i)wasm_i64x2_make(lane[0], lane[1]);
1585
}
1586

1587
static __inline__ __m256i
1588
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1589
  _mm256_mask_i64gather_epi64(__m256i src,
1590
                              const long long* base_addr,
1591
                              __m256i vindex,
1592
                              __m256i mask,
1593
                              const int scale) {
1594
  __m256i ret;
1595
  ret.v0 =
1596
    _mm_mask_i64gather_epi64(src.v0, base_addr, vindex.v0, mask.v0, scale);
1597
  ret.v1 =
1598
    _mm_mask_i64gather_epi64(src.v1, base_addr, vindex.v1, mask.v1, scale);
1599
  return ret;
1600
}
1601

1602
static __inline__ __m128d
1603
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1604
  _mm_i32gather_pd(const double* base_addr, __m128i vindex, const int scale) {
1605
  double* lane[2];
1606
  for (size_t i = 0; i < 2; i++) {
1607
    lane[i] = (double*)((uint8_t*)base_addr + (int64_t)(((__i32x4)vindex)[i]) *
1608
                                                (uint64_t)((uint32_t)scale));
1609
  }
1610
  return (__m128d)wasm_f64x2_make(*lane[0], *lane[1]);
1611
}
1612

1613
static __inline__ __m256d
1614
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1615
  _mm256_i32gather_pd(const double* base_addr,
1616
                      __m128i vindex,
1617
                      const int scale) {
1618
  __m256d ret;
1619
  double* lane[4];
1620
  for (size_t i = 0; i < 4; i++) {
1621
    lane[i] = (double*)((uint8_t*)base_addr + (int64_t)(((__i32x4)vindex)[i]) *
1622
                                                (uint64_t)((uint32_t)scale));
1623
  }
1624
  ret.v0 = (__m128d)wasm_f64x2_make(*lane[0], *lane[1]);
1625
  ret.v1 = (__m128d)wasm_f64x2_make(*lane[2], *lane[3]);
1626
  return ret;
1627
}
1628

1629
static __inline__ __m128d
1630
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1631
  _mm_i64gather_pd(const double* base_addr, __m128i vindex, const int scale) {
1632
  double* lane[2];
1633
  for (size_t i = 0; i < 2; i++) {
1634
    lane[i] = (double*)((uint8_t*)base_addr +
1635
                        ((__i64x2)vindex)[i] * (uint64_t)((uint32_t)scale));
1636
  }
1637
  return (__m128d)wasm_f64x2_make(*lane[0], *lane[1]);
1638
}
1639

1640
static __inline__ __m256d
1641
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1642
  _mm256_i64gather_pd(const double* base_addr,
1643
                      __m256i vindex,
1644
                      const int scale) {
1645
  __m256d ret;
1646
  ret.v0 = _mm_i64gather_pd(base_addr, vindex.v0, scale);
1647
  ret.v1 = _mm_i64gather_pd(base_addr, vindex.v1, scale);
1648
  return ret;
1649
}
1650

1651
static __inline__ __m128
1652
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1653
  _mm_i32gather_ps(const float* base_addr, __m128i vindex, const int scale) {
1654
  float* lane[4];
1655
  for (size_t i = 0; i < 4; i++) {
1656
    lane[i] = (float*)((uint8_t*)base_addr + (int64_t)(((__i32x4)vindex)[i]) *
1657
                                               (uint64_t)((uint32_t)scale));
1658
  }
1659
  return (__m128)wasm_f32x4_make(*lane[0], *lane[1], *lane[2], *lane[3]);
1660
}
1661

1662
static __inline__ __m256
1663
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1664
  _mm256_i32gather_ps(const float* base_addr, __m256i vindex, const int scale) {
1665
  __m256 ret;
1666
  ret.v0 = _mm_i32gather_ps(base_addr, vindex.v0, scale);
1667
  ret.v1 = _mm_i32gather_ps(base_addr, vindex.v1, scale);
1668
  return ret;
1669
}
1670

1671
static __inline__ __m128
1672
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1673
  _mm_i64gather_ps(const float* base_addr, __m128i vindex, const int scale) {
1674
  float* lane[2];
1675
  for (size_t i = 0; i < 2; i++) {
1676
    lane[i] = (float*)((uint8_t*)base_addr +
1677
                       ((__i64x2)vindex)[i] * (uint64_t)((uint32_t)scale));
1678
  }
1679
  return (__m128)wasm_f32x4_make(*lane[0], *lane[1], 0, 0);
1680
}
1681

1682
static __inline__ __m128
1683
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1684
  _mm256_i64gather_ps(const float* base_addr, __m256i vindex, const int scale) {
1685
  float* lane[4];
1686
  __m128i current_vindex;
1687
  for (size_t i = 0; i < 4; i++) {
1688
    current_vindex = i < 2 ? vindex.v0 : vindex.v1;
1689
    lane[i] = (float*)((uint8_t*)base_addr + ((__i64x2)current_vindex)[i & 1] *
1690
                                               (uint64_t)((uint32_t)scale));
1691
  }
1692
  return (__m128)wasm_f32x4_make(*lane[0], *lane[1], *lane[2], *lane[3]);
1693
}
1694

1695
static __inline__ __m128i
1696
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1697
  _mm_i32gather_epi32(const int* base_addr, __m128i vindex, const int scale) {
1698
  int32_t* lane[4];
1699
  for (size_t i = 0; i < 4; i++) {
1700
    lane[i] = (int32_t*)((uint8_t*)base_addr + (int64_t)(((__i32x4)vindex)[i]) *
1701
                                                 (uint64_t)((uint32_t)scale));
1702
  }
1703
  return (__m128i)wasm_i32x4_make(*lane[0], *lane[1], *lane[2], *lane[3]);
1704
}
1705

1706
static __inline__ __m256i
1707
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1708
  _mm256_i32gather_epi32(const int* base_addr,
1709
                         __m256i vindex,
1710
                         const int scale) {
1711
  __m256i ret;
1712
  ret.v0 = _mm_i32gather_epi32(base_addr, vindex.v0, scale);
1713
  ret.v1 = _mm_i32gather_epi32(base_addr, vindex.v1, scale);
1714
  return ret;
1715
}
1716

1717
static __inline__ __m128i
1718
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1719
  _mm_i64gather_epi32(const int* base_addr, __m128i vindex, const int scale) {
1720
  int32_t* lane[2];
1721
  for (size_t i = 0; i < 2; i++) {
1722
    lane[i] = (int32_t*)((uint8_t*)base_addr +
1723
                         ((__i64x2)vindex)[i] * (uint64_t)((uint32_t)scale));
1724
  }
1725
  return (__m128i)wasm_i32x4_make(*lane[0], *lane[1], 0, 0);
1726
}
1727

1728
static __inline__ __m128i
1729
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1730
  _mm256_i64gather_epi32(const int* base_addr,
1731
                         __m256i vindex,
1732
                         const int scale) {
1733
  int32_t* lane[4];
1734
  __m128i current_vindex;
1735
  for (size_t i = 0; i < 4; i++) {
1736
    current_vindex = i < 2 ? vindex.v0 : vindex.v1;
1737
    lane[i] =
1738
      (int32_t*)((uint8_t*)base_addr + ((__i64x2)current_vindex)[i & 1] *
1739
                                         (uint64_t)((uint32_t)scale));
1740
  }
1741
  return (__m128i)wasm_i32x4_make(*lane[0], *lane[1], *lane[2], *lane[3]);
1742
}
1743

1744
static __inline__ __m128i
1745
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1746
  _mm_i32gather_epi64(const long long* base_addr,
1747
                      __m128i vindex,
1748
                      const int scale) {
1749
  int64_t* lane[2];
1750
  for (size_t i = 0; i < 2; i++) {
1751
    lane[i] = (int64_t*)((uint8_t*)base_addr + (int64_t)(((__i32x4)vindex)[i]) *
1752
                                                 (uint64_t)((uint32_t)scale));
1753
  }
1754
  return (__m128i)wasm_i64x2_make(*lane[0], *lane[1]);
1755
}
1756

1757
static __inline__ __m256i
1758
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1759
  _mm256_i32gather_epi64(const long long* base_addr,
1760
                         __m128i vindex,
1761
                         const int scale) {
1762

1763
  __m256i ret;
1764
  int64_t* lane[4];
1765
  for (size_t i = 0; i < 4; i++) {
1766
    lane[i] = (int64_t*)((uint8_t*)base_addr + (int64_t)(((__i32x4)vindex)[i]) *
1767
                                                 (uint64_t)((uint32_t)scale));
1768
  }
1769
  ret.v0 = (__m128i)wasm_i64x2_make(*lane[0], *lane[1]);
1770
  ret.v1 = (__m128i)wasm_i64x2_make(*lane[2], *lane[3]);
1771
  return ret;
1772
}
1773

1774
static __inline__ __m128i
1775
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1776
  _mm_i64gather_epi64(const long long* base_addr,
1777
                      __m128i vindex,
1778
                      const int scale) {
1779
  int64_t* lane[2];
1780
  for (size_t i = 0; i < 2; i++) {
1781
    lane[i] = (int64_t*)((uint8_t*)base_addr +
1782
                         ((__i64x2)vindex)[i] * (uint64_t)((uint32_t)scale));
1783
  }
1784
  return (__m128i)wasm_i64x2_make(*lane[0], *lane[1]);
1785
}
1786

1787
static __inline__ __m256i
1788
  __attribute__((__always_inline__, __nodebug__, DIAGNOSE_SLOW))
1789
  _mm256_i64gather_epi64(const long long* base_addr,
1790
                         __m256i vindex,
1791
                         const int scale) {
1792
  __m256i ret;
1793
  ret.v0 = _mm_i64gather_epi64(base_addr, vindex.v0, scale);
1794
  ret.v1 = _mm_i64gather_epi64(base_addr, vindex.v1, scale);
1795
  return ret;
1796
}
1797

1798
#endif /* __emscripten_avx2intrin_h__ */
1799

1800
Product

Resources

Company
