CoCalc -- insn-x86-dat-src.c

GitHub Repository: torvalds/linux
Path: blob/master/tools/perf/arch/x86/tests/insn-x86-dat-src.c
²⁶²⁹² views
1
// SPDX-License-Identifier: GPL-2.0
2
/*
3
 * This file contains instructions for testing by the test titled:
4
 *
5
 *         "Test x86 instruction decoder - new instructions"
6
 *
7
 * Note that the 'Expecting' comment lines are consumed by the
8
 * gen-insn-x86-dat.awk script and have the format:
9
 *
10
 *         Expecting: <op> <branch> <rel>
11
 *
12
 * If this file is changed, remember to run the gen-insn-x86-dat.sh
13
 * script and commit the result.
14
 *
15
 * Refer to insn-x86.c for more details.
16
 */
17

18
int main(void)
19
{
20
	/* Following line is a marker for the awk script - do not change */
21
	asm volatile("rdtsc"); /* Start here */
22

23
	/* Test fix for vcvtph2ps in x86-opcode-map.txt */
24

25
	asm volatile("vcvtph2ps %xmm3,%ymm5");
26

27
#ifdef __x86_64__
28

29
	/* AVX-512: Instructions with the same op codes as Mask Instructions  */
30

31
	asm volatile("cmovno %rax,%rbx");
32
	asm volatile("cmovno 0x12345678(%rax),%rcx");
33
	asm volatile("cmovno 0x12345678(%rax),%cx");
34

35
	asm volatile("cmove  %rax,%rbx");
36
	asm volatile("cmove 0x12345678(%rax),%rcx");
37
	asm volatile("cmove 0x12345678(%rax),%cx");
38

39
	asm volatile("seto    0x12345678(%rax)");
40
	asm volatile("setno   0x12345678(%rax)");
41
	asm volatile("setb    0x12345678(%rax)");
42
	asm volatile("setc    0x12345678(%rax)");
43
	asm volatile("setnae  0x12345678(%rax)");
44
	asm volatile("setae   0x12345678(%rax)");
45
	asm volatile("setnb   0x12345678(%rax)");
46
	asm volatile("setnc   0x12345678(%rax)");
47
	asm volatile("sets    0x12345678(%rax)");
48
	asm volatile("setns   0x12345678(%rax)");
49

50
	/* AVX-512: Mask Instructions */
51

52
	asm volatile("kandw  %k7,%k6,%k5");
53
	asm volatile("kandq  %k7,%k6,%k5");
54
	asm volatile("kandb  %k7,%k6,%k5");
55
	asm volatile("kandd  %k7,%k6,%k5");
56

57
	asm volatile("kandnw  %k7,%k6,%k5");
58
	asm volatile("kandnq  %k7,%k6,%k5");
59
	asm volatile("kandnb  %k7,%k6,%k5");
60
	asm volatile("kandnd  %k7,%k6,%k5");
61

62
	asm volatile("knotw  %k7,%k6");
63
	asm volatile("knotq  %k7,%k6");
64
	asm volatile("knotb  %k7,%k6");
65
	asm volatile("knotd  %k7,%k6");
66

67
	asm volatile("korw  %k7,%k6,%k5");
68
	asm volatile("korq  %k7,%k6,%k5");
69
	asm volatile("korb  %k7,%k6,%k5");
70
	asm volatile("kord  %k7,%k6,%k5");
71

72
	asm volatile("kxnorw  %k7,%k6,%k5");
73
	asm volatile("kxnorq  %k7,%k6,%k5");
74
	asm volatile("kxnorb  %k7,%k6,%k5");
75
	asm volatile("kxnord  %k7,%k6,%k5");
76

77
	asm volatile("kxorw  %k7,%k6,%k5");
78
	asm volatile("kxorq  %k7,%k6,%k5");
79
	asm volatile("kxorb  %k7,%k6,%k5");
80
	asm volatile("kxord  %k7,%k6,%k5");
81

82
	asm volatile("kaddw  %k7,%k6,%k5");
83
	asm volatile("kaddq  %k7,%k6,%k5");
84
	asm volatile("kaddb  %k7,%k6,%k5");
85
	asm volatile("kaddd  %k7,%k6,%k5");
86

87
	asm volatile("kunpckbw %k7,%k6,%k5");
88
	asm volatile("kunpckwd %k7,%k6,%k5");
89
	asm volatile("kunpckdq %k7,%k6,%k5");
90

91
	asm volatile("kmovw  %k6,%k5");
92
	asm volatile("kmovw  (%rcx),%k5");
93
	asm volatile("kmovw  0x123(%rax,%r14,8),%k5");
94
	asm volatile("kmovw  %k5,(%rcx)");
95
	asm volatile("kmovw  %k5,0x123(%rax,%r14,8)");
96
	asm volatile("kmovw  %eax,%k5");
97
	asm volatile("kmovw  %ebp,%k5");
98
	asm volatile("kmovw  %r13d,%k5");
99
	asm volatile("kmovw  %k5,%eax");
100
	asm volatile("kmovw  %k5,%ebp");
101
	asm volatile("kmovw  %k5,%r13d");
102

103
	asm volatile("kmovq  %k6,%k5");
104
	asm volatile("kmovq  (%rcx),%k5");
105
	asm volatile("kmovq  0x123(%rax,%r14,8),%k5");
106
	asm volatile("kmovq  %k5,(%rcx)");
107
	asm volatile("kmovq  %k5,0x123(%rax,%r14,8)");
108
	asm volatile("kmovq  %rax,%k5");
109
	asm volatile("kmovq  %rbp,%k5");
110
	asm volatile("kmovq  %r13,%k5");
111
	asm volatile("kmovq  %k5,%rax");
112
	asm volatile("kmovq  %k5,%rbp");
113
	asm volatile("kmovq  %k5,%r13");
114

115
	asm volatile("kmovb  %k6,%k5");
116
	asm volatile("kmovb  (%rcx),%k5");
117
	asm volatile("kmovb  0x123(%rax,%r14,8),%k5");
118
	asm volatile("kmovb  %k5,(%rcx)");
119
	asm volatile("kmovb  %k5,0x123(%rax,%r14,8)");
120
	asm volatile("kmovb  %eax,%k5");
121
	asm volatile("kmovb  %ebp,%k5");
122
	asm volatile("kmovb  %r13d,%k5");
123
	asm volatile("kmovb  %k5,%eax");
124
	asm volatile("kmovb  %k5,%ebp");
125
	asm volatile("kmovb  %k5,%r13d");
126

127
	asm volatile("kmovd  %k6,%k5");
128
	asm volatile("kmovd  (%rcx),%k5");
129
	asm volatile("kmovd  0x123(%rax,%r14,8),%k5");
130
	asm volatile("kmovd  %k5,(%rcx)");
131
	asm volatile("kmovd  %k5,0x123(%rax,%r14,8)");
132
	asm volatile("kmovd  %eax,%k5");
133
	asm volatile("kmovd  %ebp,%k5");
134
	asm volatile("kmovd  %r13d,%k5");
135
	asm volatile("kmovd  %k5,%eax");
136
	asm volatile("kmovd  %k5,%ebp");
137
	asm volatile("kmovd %k5,%r13d");
138

139
	asm volatile("kortestw %k6,%k5");
140
	asm volatile("kortestq %k6,%k5");
141
	asm volatile("kortestb %k6,%k5");
142
	asm volatile("kortestd %k6,%k5");
143

144
	asm volatile("ktestw %k6,%k5");
145
	asm volatile("ktestq %k6,%k5");
146
	asm volatile("ktestb %k6,%k5");
147
	asm volatile("ktestd %k6,%k5");
148

149
	asm volatile("kshiftrw $0x12,%k6,%k5");
150
	asm volatile("kshiftrq $0x5b,%k6,%k5");
151
	asm volatile("kshiftlw $0x12,%k6,%k5");
152
	asm volatile("kshiftlq $0x5b,%k6,%k5");
153

154
	/* AVX-512: Op code 0f 5b */
155
	asm volatile("vcvtdq2ps %xmm5,%xmm6");
156
	asm volatile("vcvtqq2ps %zmm29,%ymm6{%k7}");
157
	asm volatile("vcvtps2dq %xmm5,%xmm6");
158
	asm volatile("vcvttps2dq %xmm5,%xmm6");
159

160
	/* AVX-512: Op code 0f 6f */
161

162
	asm volatile("movq   %mm0,%mm4");
163
	asm volatile("vmovdqa %ymm4,%ymm6");
164
	asm volatile("vmovdqa32 %zmm25,%zmm26");
165
	asm volatile("vmovdqa64 %zmm25,%zmm26");
166
	asm volatile("vmovdqu %ymm4,%ymm6");
167
	asm volatile("vmovdqu32 %zmm29,%zmm30");
168
	asm volatile("vmovdqu64 %zmm25,%zmm26");
169
	asm volatile("vmovdqu8 %zmm29,%zmm30");
170
	asm volatile("vmovdqu16 %zmm25,%zmm26");
171

172
	/* AVX-512: Op code 0f 78 */
173

174
	asm volatile("vmread %rax,%rbx");
175
	asm volatile("vcvttps2udq %zmm25,%zmm26");
176
	asm volatile("vcvttpd2udq %zmm29,%ymm6{%k7}");
177
	asm volatile("vcvttsd2usi %xmm6,%rax");
178
	asm volatile("vcvttss2usi %xmm6,%rax");
179
	asm volatile("vcvttps2uqq %ymm5,%zmm26{%k7}");
180
	asm volatile("vcvttpd2uqq %zmm29,%zmm30");
181

182
	/* AVX-512: Op code 0f 79 */
183

184
	asm volatile("vmwrite %rax,%rbx");
185
	asm volatile("vcvtps2udq %zmm25,%zmm26");
186
	asm volatile("vcvtpd2udq %zmm29,%ymm6{%k7}");
187
	asm volatile("vcvtsd2usi %xmm6,%rax");
188
	asm volatile("vcvtss2usi %xmm6,%rax");
189
	asm volatile("vcvtps2uqq %ymm5,%zmm26{%k7}");
190
	asm volatile("vcvtpd2uqq %zmm29,%zmm30");
191

192
	/* AVX-512: Op code 0f 7a */
193

194
	asm volatile("vcvtudq2pd %ymm5,%zmm29{%k7}");
195
	asm volatile("vcvtuqq2pd %zmm25,%zmm26");
196
	asm volatile("vcvtudq2ps %zmm29,%zmm30");
197
	asm volatile("vcvtuqq2ps %zmm25,%ymm26{%k7}");
198
	asm volatile("vcvttps2qq %ymm25,%zmm26{%k7}");
199
	asm volatile("vcvttpd2qq %zmm29,%zmm30");
200

201
	/* AVX-512: Op code 0f 7b */
202

203
	asm volatile("vcvtusi2sd %eax,%xmm5,%xmm6");
204
	asm volatile("vcvtusi2ss %eax,%xmm5,%xmm6");
205
	asm volatile("vcvtps2qq %ymm5,%zmm26{%k7}");
206
	asm volatile("vcvtpd2qq %zmm29,%zmm30");
207

208
	/* AVX-512: Op code 0f 7f */
209

210
	asm volatile("movq.s  %mm0,%mm4");
211
	asm volatile("vmovdqa %ymm8,%ymm6");
212
	asm volatile("vmovdqa32.s %zmm25,%zmm26");
213
	asm volatile("vmovdqa64.s %zmm25,%zmm26");
214
	asm volatile("vmovdqu %ymm8,%ymm6");
215
	asm volatile("vmovdqu32.s %zmm25,%zmm26");
216
	asm volatile("vmovdqu64.s %zmm25,%zmm26");
217
	asm volatile("vmovdqu8.s %zmm30,(%rcx)");
218
	asm volatile("vmovdqu16.s %zmm25,%zmm26");
219

220
	/* AVX-512: Op code 0f db */
221

222
	asm volatile("pand  %mm1,%mm2");
223
	asm volatile("pand  %xmm1,%xmm2");
224
	asm volatile("vpand  %ymm4,%ymm6,%ymm2");
225
	asm volatile("vpandd %zmm24,%zmm25,%zmm26");
226
	asm volatile("vpandq %zmm24,%zmm25,%zmm26");
227

228
	/* AVX-512: Op code 0f df */
229

230
	asm volatile("pandn  %mm1,%mm2");
231
	asm volatile("pandn  %xmm1,%xmm2");
232
	asm volatile("vpandn %ymm4,%ymm6,%ymm2");
233
	asm volatile("vpandnd %zmm24,%zmm25,%zmm26");
234
	asm volatile("vpandnq %zmm24,%zmm25,%zmm26");
235

236
	/* AVX-512: Op code 0f e6 */
237

238
	asm volatile("vcvttpd2dq %xmm1,%xmm2");
239
	asm volatile("vcvtdq2pd %xmm5,%xmm6");
240
	asm volatile("vcvtdq2pd %ymm5,%zmm26{%k7}");
241
	asm volatile("vcvtqq2pd %zmm25,%zmm26");
242
	asm volatile("vcvtpd2dq %xmm1,%xmm2");
243

244
	/* AVX-512: Op code 0f eb */
245

246
	asm volatile("por   %mm4,%mm6");
247
	asm volatile("vpor   %ymm4,%ymm6,%ymm2");
248
	asm volatile("vpord  %zmm24,%zmm25,%zmm26");
249
	asm volatile("vporq  %zmm24,%zmm25,%zmm26");
250

251
	/* AVX-512: Op code 0f ef */
252

253
	asm volatile("pxor   %mm4,%mm6");
254
	asm volatile("vpxor  %ymm4,%ymm6,%ymm2");
255
	asm volatile("vpxord %zmm24,%zmm25,%zmm26");
256
	asm volatile("vpxorq %zmm24,%zmm25,%zmm26");
257

258
	/* AVX-512: Op code 0f 38 10 */
259

260
	asm volatile("pblendvb %xmm1,%xmm0");
261
	asm volatile("vpsrlvw %zmm27,%zmm28,%zmm29");
262
	asm volatile("vpmovuswb %zmm28,%ymm6{%k7}");
263

264
	/* AVX-512: Op code 0f 38 11 */
265

266
	asm volatile("vpmovusdb %zmm28,%xmm6{%k7}");
267
	asm volatile("vpsravw %zmm27,%zmm28,%zmm29");
268

269
	/* AVX-512: Op code 0f 38 12 */
270

271
	asm volatile("vpmovusqb %zmm27,%xmm6{%k7}");
272
	asm volatile("vpsllvw %zmm27,%zmm28,%zmm29");
273

274
	/* AVX-512: Op code 0f 38 13 */
275

276
	asm volatile("vcvtph2ps %xmm3,%ymm5");
277
	asm volatile("vcvtph2ps %ymm5,%zmm27{%k7}");
278
	asm volatile("vpmovusdw %zmm27,%ymm6{%k7}");
279

280
	/* AVX-512: Op code 0f 38 14 */
281

282
	asm volatile("blendvps %xmm1,%xmm0");
283
	asm volatile("vpmovusqw %zmm27,%xmm6{%k7}");
284
	asm volatile("vprorvd %zmm27,%zmm28,%zmm29");
285
	asm volatile("vprorvq %zmm27,%zmm28,%zmm29");
286

287
	/* AVX-512: Op code 0f 38 15 */
288

289
	asm volatile("blendvpd %xmm1,%xmm0");
290
	asm volatile("vpmovusqd %zmm27,%ymm6{%k7}");
291
	asm volatile("vprolvd %zmm27,%zmm28,%zmm29");
292
	asm volatile("vprolvq %zmm27,%zmm28,%zmm29");
293

294
	/* AVX-512: Op code 0f 38 16 */
295

296
	asm volatile("vpermps %ymm4,%ymm6,%ymm2");
297
	asm volatile("vpermps %ymm24,%ymm26,%ymm22{%k7}");
298
	asm volatile("vpermpd %ymm24,%ymm26,%ymm22{%k7}");
299

300
	/* AVX-512: Op code 0f 38 19 */
301

302
	asm volatile("vbroadcastsd %xmm4,%ymm6");
303
	asm volatile("vbroadcastf32x2 %xmm27,%zmm26");
304

305
	/* AVX-512: Op code 0f 38 1a */
306

307
	asm volatile("vbroadcastf128 (%rcx),%ymm4");
308
	asm volatile("vbroadcastf32x4 (%rcx),%zmm26");
309
	asm volatile("vbroadcastf64x2 (%rcx),%zmm26");
310

311
	/* AVX-512: Op code 0f 38 1b */
312

313
	asm volatile("vbroadcastf32x8 (%rcx),%zmm27");
314
	asm volatile("vbroadcastf64x4 (%rcx),%zmm26");
315

316
	/* AVX-512: Op code 0f 38 1f */
317

318
	asm volatile("vpabsq %zmm27,%zmm28");
319

320
	/* AVX-512: Op code 0f 38 20 */
321

322
	asm volatile("vpmovsxbw %xmm4,%xmm5");
323
	asm volatile("vpmovswb %zmm27,%ymm6{%k7}");
324

325
	/* AVX-512: Op code 0f 38 21 */
326

327
	asm volatile("vpmovsxbd %xmm4,%ymm6");
328
	asm volatile("vpmovsdb %zmm27,%xmm6{%k7}");
329

330
	/* AVX-512: Op code 0f 38 22 */
331

332
	asm volatile("vpmovsxbq %xmm4,%ymm4");
333
	asm volatile("vpmovsqb %zmm27,%xmm6{%k7}");
334

335
	/* AVX-512: Op code 0f 38 23 */
336

337
	asm volatile("vpmovsxwd %xmm4,%ymm4");
338
	asm volatile("vpmovsdw %zmm27,%ymm6{%k7}");
339

340
	/* AVX-512: Op code 0f 38 24 */
341

342
	asm volatile("vpmovsxwq %xmm4,%ymm6");
343
	asm volatile("vpmovsqw %zmm27,%xmm6{%k7}");
344

345
	/* AVX-512: Op code 0f 38 25 */
346

347
	asm volatile("vpmovsxdq %xmm4,%ymm4");
348
	asm volatile("vpmovsqd %zmm27,%ymm6{%k7}");
349

350
	/* AVX-512: Op code 0f 38 26 */
351

352
	asm volatile("vptestmb %zmm27,%zmm28,%k5");
353
	asm volatile("vptestmw %zmm27,%zmm28,%k5");
354
	asm volatile("vptestnmb %zmm26,%zmm27,%k5");
355
	asm volatile("vptestnmw %zmm26,%zmm27,%k5");
356

357
	/* AVX-512: Op code 0f 38 27 */
358

359
	asm volatile("vptestmd %zmm27,%zmm28,%k5");
360
	asm volatile("vptestmq %zmm27,%zmm28,%k5");
361
	asm volatile("vptestnmd %zmm26,%zmm27,%k5");
362
	asm volatile("vptestnmq %zmm26,%zmm27,%k5");
363

364
	/* AVX-512: Op code 0f 38 28 */
365

366
	asm volatile("vpmuldq %ymm4,%ymm6,%ymm2");
367
	asm volatile("vpmovm2b %k5,%zmm28");
368
	asm volatile("vpmovm2w %k5,%zmm28");
369

370
	/* AVX-512: Op code 0f 38 29 */
371

372
	asm volatile("vpcmpeqq %ymm4,%ymm6,%ymm2");
373
	asm volatile("vpmovb2m %zmm28,%k5");
374
	asm volatile("vpmovw2m %zmm28,%k5");
375

376
	/* AVX-512: Op code 0f 38 2a */
377

378
	asm volatile("vmovntdqa (%rcx),%ymm4");
379
	asm volatile("vpbroadcastmb2q %k6,%zmm30");
380

381
	/* AVX-512: Op code 0f 38 2c */
382

383
	asm volatile("vmaskmovps (%rcx),%ymm4,%ymm6");
384
	asm volatile("vscalefps %zmm24,%zmm25,%zmm26");
385
	asm volatile("vscalefpd %zmm24,%zmm25,%zmm26");
386

387
	/* AVX-512: Op code 0f 38 2d */
388

389
	asm volatile("vmaskmovpd (%rcx),%ymm4,%ymm6");
390
	asm volatile("vscalefss %xmm24,%xmm25,%xmm26{%k7}");
391
	asm volatile("vscalefsd %xmm24,%xmm25,%xmm26{%k7}");
392

393
	/* AVX-512: Op code 0f 38 30 */
394

395
	asm volatile("vpmovzxbw %xmm4,%ymm4");
396
	asm volatile("vpmovwb %zmm27,%ymm6{%k7}");
397

398
	/* AVX-512: Op code 0f 38 31 */
399

400
	asm volatile("vpmovzxbd %xmm4,%ymm6");
401
	asm volatile("vpmovdb %zmm27,%xmm6{%k7}");
402

403
	/* AVX-512: Op code 0f 38 32 */
404

405
	asm volatile("vpmovzxbq %xmm4,%ymm4");
406
	asm volatile("vpmovqb %zmm27,%xmm6{%k7}");
407

408
	/* AVX-512: Op code 0f 38 33 */
409

410
	asm volatile("vpmovzxwd %xmm4,%ymm4");
411
	asm volatile("vpmovdw %zmm27,%ymm6{%k7}");
412

413
	/* AVX-512: Op code 0f 38 34 */
414

415
	asm volatile("vpmovzxwq %xmm4,%ymm6");
416
	asm volatile("vpmovqw %zmm27,%xmm6{%k7}");
417

418
	/* AVX-512: Op code 0f 38 35 */
419

420
	asm volatile("vpmovzxdq %xmm4,%ymm4");
421
	asm volatile("vpmovqd %zmm27,%ymm6{%k7}");
422

423
	/* AVX-512: Op code 0f 38 38 */
424

425
	asm volatile("vpermd %ymm4,%ymm6,%ymm2");
426
	asm volatile("vpermd %ymm24,%ymm26,%ymm22{%k7}");
427
	asm volatile("vpermq %ymm24,%ymm26,%ymm22{%k7}");
428

429
	/* AVX-512: Op code 0f 38 38 */
430

431
	asm volatile("vpminsb %ymm4,%ymm6,%ymm2");
432
	asm volatile("vpmovm2d %k5,%zmm28");
433
	asm volatile("vpmovm2q %k5,%zmm28");
434

435
	/* AVX-512: Op code 0f 38 39 */
436

437
	asm volatile("vpminsd %xmm1,%xmm2,%xmm3");
438
	asm volatile("vpminsd %zmm24,%zmm25,%zmm26");
439
	asm volatile("vpminsq %zmm24,%zmm25,%zmm26");
440
	asm volatile("vpmovd2m %zmm28,%k5");
441
	asm volatile("vpmovq2m %zmm28,%k5");
442

443
	/* AVX-512: Op code 0f 38 3a */
444

445
	asm volatile("vpminuw %ymm4,%ymm6,%ymm2");
446
	asm volatile("vpbroadcastmw2d %k6,%zmm28");
447

448
	/* AVX-512: Op code 0f 38 3b */
449

450
	asm volatile("vpminud %ymm4,%ymm6,%ymm2");
451
	asm volatile("vpminud %zmm24,%zmm25,%zmm26");
452
	asm volatile("vpminuq %zmm24,%zmm25,%zmm26");
453

454
	/* AVX-512: Op code 0f 38 3d */
455

456
	asm volatile("vpmaxsd %ymm4,%ymm6,%ymm2");
457
	asm volatile("vpmaxsd %zmm24,%zmm25,%zmm26");
458
	asm volatile("vpmaxsq %zmm24,%zmm25,%zmm26");
459

460
	/* AVX-512: Op code 0f 38 3f */
461

462
	asm volatile("vpmaxud %ymm4,%ymm6,%ymm2");
463
	asm volatile("vpmaxud %zmm24,%zmm25,%zmm26");
464
	asm volatile("vpmaxuq %zmm24,%zmm25,%zmm26");
465

466
	/* AVX-512: Op code 0f 38 42 */
467

468
	asm volatile("vpmulld %ymm4,%ymm6,%ymm2");
469
	asm volatile("vpmulld %zmm24,%zmm25,%zmm26");
470
	asm volatile("vpmullq %zmm24,%zmm25,%zmm26");
471

472
	/* AVX-512: Op code 0f 38 42 */
473

474
	asm volatile("vgetexpps %zmm25,%zmm26");
475
	asm volatile("vgetexppd %zmm27,%zmm28");
476

477
	/* AVX-512: Op code 0f 38 43 */
478

479
	asm volatile("vgetexpss %xmm24,%xmm25,%xmm26{%k7}");
480
	asm volatile("vgetexpsd %xmm28,%xmm29,%xmm30{%k7}");
481

482
	/* AVX-512: Op code 0f 38 44 */
483

484
	asm volatile("vplzcntd %zmm27,%zmm28");
485
	asm volatile("vplzcntq %zmm27,%zmm28");
486

487
	/* AVX-512: Op code 0f 38 46 */
488

489
	asm volatile("vpsravd %ymm4,%ymm6,%ymm2");
490
	asm volatile("vpsravd %zmm24,%zmm25,%zmm26");
491
	asm volatile("vpsravq %zmm24,%zmm25,%zmm26");
492

493
	/* AVX-512: Op code 0f 38 4c */
494

495
	asm volatile("vrcp14ps %zmm25,%zmm26");
496
	asm volatile("vrcp14pd %zmm27,%zmm28");
497

498
	/* AVX-512: Op code 0f 38 4d */
499

500
	asm volatile("vrcp14ss %xmm24,%xmm25,%xmm26{%k7}");
501
	asm volatile("vrcp14sd %xmm24,%xmm25,%xmm26{%k7}");
502

503
	/* AVX-512: Op code 0f 38 4e */
504

505
	asm volatile("vrsqrt14ps %zmm25,%zmm26");
506
	asm volatile("vrsqrt14pd %zmm27,%zmm28");
507

508
	/* AVX-512: Op code 0f 38 4f */
509

510
	asm volatile("vrsqrt14ss %xmm24,%xmm25,%xmm26{%k7}");
511
	asm volatile("vrsqrt14sd %xmm24,%xmm25,%xmm26{%k7}");
512

513
	/* AVX-512: Op code 0f 38 50 */
514

515
	asm volatile("vpdpbusd %xmm1, %xmm2, %xmm3");
516
	asm volatile("vpdpbusd %ymm1, %ymm2, %ymm3");
517
	asm volatile("vpdpbusd %zmm1, %zmm2, %zmm3");
518
	asm volatile("vpdpbusd 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
519
	asm volatile("vpdpbusd 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
520

521
	/* AVX-512: Op code 0f 38 51 */
522

523
	asm volatile("vpdpbusds %xmm1, %xmm2, %xmm3");
524
	asm volatile("vpdpbusds %ymm1, %ymm2, %ymm3");
525
	asm volatile("vpdpbusds %zmm1, %zmm2, %zmm3");
526
	asm volatile("vpdpbusds 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
527
	asm volatile("vpdpbusds 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
528

529
	/* AVX-512: Op code 0f 38 52 */
530

531
	asm volatile("vdpbf16ps %xmm1, %xmm2, %xmm3");
532
	asm volatile("vdpbf16ps %ymm1, %ymm2, %ymm3");
533
	asm volatile("vdpbf16ps %zmm1, %zmm2, %zmm3");
534
	asm volatile("vdpbf16ps 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
535
	asm volatile("vdpbf16ps 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
536

537
	asm volatile("vpdpwssd %xmm1, %xmm2, %xmm3");
538
	asm volatile("vpdpwssd %ymm1, %ymm2, %ymm3");
539
	asm volatile("vpdpwssd %zmm1, %zmm2, %zmm3");
540
	asm volatile("vpdpwssd 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
541
	asm volatile("vpdpwssd 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
542

543
	asm volatile("vp4dpwssd (%rax), %zmm0, %zmm4");
544
	asm volatile("vp4dpwssd (%eax), %zmm0, %zmm4");
545
	asm volatile("vp4dpwssd 0x12345678(%rax,%rcx,8),%zmm0,%zmm4");
546
	asm volatile("vp4dpwssd 0x12345678(%eax,%ecx,8),%zmm0,%zmm4");
547

548
	/* AVX-512: Op code 0f 38 53 */
549

550
	asm volatile("vpdpwssds %xmm1, %xmm2, %xmm3");
551
	asm volatile("vpdpwssds %ymm1, %ymm2, %ymm3");
552
	asm volatile("vpdpwssds %zmm1, %zmm2, %zmm3");
553
	asm volatile("vpdpwssds 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
554
	asm volatile("vpdpwssds 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
555

556
	asm volatile("vp4dpwssds (%rax), %zmm0, %zmm4");
557
	asm volatile("vp4dpwssds (%eax), %zmm0, %zmm4");
558
	asm volatile("vp4dpwssds 0x12345678(%rax,%rcx,8),%zmm0,%zmm4");
559
	asm volatile("vp4dpwssds 0x12345678(%eax,%ecx,8),%zmm0,%zmm4");
560

561
	/* AVX-512: Op code 0f 38 54 */
562

563
	asm volatile("vpopcntb %xmm1, %xmm2");
564
	asm volatile("vpopcntb %ymm1, %ymm2");
565
	asm volatile("vpopcntb %zmm1, %zmm2");
566
	asm volatile("vpopcntb 0x12345678(%rax,%rcx,8),%zmm2");
567
	asm volatile("vpopcntb 0x12345678(%eax,%ecx,8),%zmm2");
568

569
	asm volatile("vpopcntw %xmm1, %xmm2");
570
	asm volatile("vpopcntw %ymm1, %ymm2");
571
	asm volatile("vpopcntw %zmm1, %zmm2");
572
	asm volatile("vpopcntw 0x12345678(%rax,%rcx,8),%zmm2");
573
	asm volatile("vpopcntw 0x12345678(%eax,%ecx,8),%zmm2");
574

575
	/* AVX-512: Op code 0f 38 55 */
576

577
	asm volatile("vpopcntd %xmm1, %xmm2");
578
	asm volatile("vpopcntd %ymm1, %ymm2");
579
	asm volatile("vpopcntd %zmm1, %zmm2");
580
	asm volatile("vpopcntd 0x12345678(%rax,%rcx,8),%zmm2");
581
	asm volatile("vpopcntd 0x12345678(%eax,%ecx,8),%zmm2");
582

583
	asm volatile("vpopcntq %xmm1, %xmm2");
584
	asm volatile("vpopcntq %ymm1, %ymm2");
585
	asm volatile("vpopcntq %zmm1, %zmm2");
586
	asm volatile("vpopcntq 0x12345678(%rax,%rcx,8),%zmm2");
587
	asm volatile("vpopcntq 0x12345678(%eax,%ecx,8),%zmm2");
588

589
	/* AVX-512: Op code 0f 38 59 */
590

591
	asm volatile("vpbroadcastq %xmm4,%xmm6");
592
	asm volatile("vbroadcasti32x2 %xmm27,%zmm26");
593

594
	/* AVX-512: Op code 0f 38 5a */
595

596
	asm volatile("vbroadcasti128 (%rcx),%ymm4");
597
	asm volatile("vbroadcasti32x4 (%rcx),%zmm26");
598
	asm volatile("vbroadcasti64x2 (%rcx),%zmm26");
599

600
	/* AVX-512: Op code 0f 38 5b */
601

602
	asm volatile("vbroadcasti32x8 (%rcx),%zmm28");
603
	asm volatile("vbroadcasti64x4 (%rcx),%zmm26");
604

605
	/* AVX-512: Op code 0f 38 62 */
606

607
	asm volatile("vpexpandb %xmm1, %xmm2");
608
	asm volatile("vpexpandb %ymm1, %ymm2");
609
	asm volatile("vpexpandb %zmm1, %zmm2");
610
	asm volatile("vpexpandb 0x12345678(%rax,%rcx,8),%zmm2");
611
	asm volatile("vpexpandb 0x12345678(%eax,%ecx,8),%zmm2");
612

613
	asm volatile("vpexpandw %xmm1, %xmm2");
614
	asm volatile("vpexpandw %ymm1, %ymm2");
615
	asm volatile("vpexpandw %zmm1, %zmm2");
616
	asm volatile("vpexpandw 0x12345678(%rax,%rcx,8),%zmm2");
617
	asm volatile("vpexpandw 0x12345678(%eax,%ecx,8),%zmm2");
618

619
	/* AVX-512: Op code 0f 38 63 */
620

621
	asm volatile("vpcompressb %xmm1, %xmm2");
622
	asm volatile("vpcompressb %ymm1, %ymm2");
623
	asm volatile("vpcompressb %zmm1, %zmm2");
624
	asm volatile("vpcompressb %zmm2,0x12345678(%rax,%rcx,8)");
625
	asm volatile("vpcompressb %zmm2,0x12345678(%eax,%ecx,8)");
626

627
	asm volatile("vpcompressw %xmm1, %xmm2");
628
	asm volatile("vpcompressw %ymm1, %ymm2");
629
	asm volatile("vpcompressw %zmm1, %zmm2");
630
	asm volatile("vpcompressw %zmm2,0x12345678(%rax,%rcx,8)");
631
	asm volatile("vpcompressw %zmm2,0x12345678(%eax,%ecx,8)");
632

633
	/* AVX-512: Op code 0f 38 64 */
634

635
	asm volatile("vpblendmd %zmm26,%zmm27,%zmm28");
636
	asm volatile("vpblendmq %zmm26,%zmm27,%zmm28");
637

638
	/* AVX-512: Op code 0f 38 65 */
639

640
	asm volatile("vblendmps %zmm24,%zmm25,%zmm26");
641
	asm volatile("vblendmpd %zmm26,%zmm27,%zmm28");
642

643
	/* AVX-512: Op code 0f 38 66 */
644

645
	asm volatile("vpblendmb %zmm26,%zmm27,%zmm28");
646
	asm volatile("vpblendmw %zmm26,%zmm27,%zmm28");
647

648
	/* AVX-512: Op code 0f 38 68 */
649

650
	asm volatile("vp2intersectd %xmm1, %xmm2, %k3");
651
	asm volatile("vp2intersectd %ymm1, %ymm2, %k3");
652
	asm volatile("vp2intersectd %zmm1, %zmm2, %k3");
653
	asm volatile("vp2intersectd 0x12345678(%rax,%rcx,8),%zmm2,%k3");
654
	asm volatile("vp2intersectd 0x12345678(%eax,%ecx,8),%zmm2,%k3");
655

656
	asm volatile("vp2intersectq %xmm1, %xmm2, %k3");
657
	asm volatile("vp2intersectq %ymm1, %ymm2, %k3");
658
	asm volatile("vp2intersectq %zmm1, %zmm2, %k3");
659
	asm volatile("vp2intersectq 0x12345678(%rax,%rcx,8),%zmm2,%k3");
660
	asm volatile("vp2intersectq 0x12345678(%eax,%ecx,8),%zmm2,%k3");
661

662
	/* AVX-512: Op code 0f 38 70 */
663

664
	asm volatile("vpshldvw %xmm1, %xmm2, %xmm3");
665
	asm volatile("vpshldvw %ymm1, %ymm2, %ymm3");
666
	asm volatile("vpshldvw %zmm1, %zmm2, %zmm3");
667
	asm volatile("vpshldvw 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
668
	asm volatile("vpshldvw 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
669

670
	/* AVX-512: Op code 0f 38 71 */
671

672
	asm volatile("vpshldvd %xmm1, %xmm2, %xmm3");
673
	asm volatile("vpshldvd %ymm1, %ymm2, %ymm3");
674
	asm volatile("vpshldvd %zmm1, %zmm2, %zmm3");
675
	asm volatile("vpshldvd 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
676
	asm volatile("vpshldvd 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
677

678
	asm volatile("vpshldvq %xmm1, %xmm2, %xmm3");
679
	asm volatile("vpshldvq %ymm1, %ymm2, %ymm3");
680
	asm volatile("vpshldvq %zmm1, %zmm2, %zmm3");
681
	asm volatile("vpshldvq 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
682
	asm volatile("vpshldvq 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
683

684
	/* AVX-512: Op code 0f 38 72 */
685

686
	asm volatile("vcvtne2ps2bf16 %xmm1, %xmm2, %xmm3");
687
	asm volatile("vcvtne2ps2bf16 %ymm1, %ymm2, %ymm3");
688
	asm volatile("vcvtne2ps2bf16 %zmm1, %zmm2, %zmm3");
689
	asm volatile("vcvtne2ps2bf16 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
690
	asm volatile("vcvtne2ps2bf16 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
691

692
	asm volatile("vcvtneps2bf16 %xmm1, %xmm2");
693
	asm volatile("vcvtneps2bf16 %ymm1, %xmm2");
694
	asm volatile("vcvtneps2bf16 %zmm1, %ymm2");
695
	asm volatile("vcvtneps2bf16 0x12345678(%rax,%rcx,8),%ymm2");
696
	asm volatile("vcvtneps2bf16 0x12345678(%eax,%ecx,8),%ymm2");
697

698
	asm volatile("vpshrdvw %xmm1, %xmm2, %xmm3");
699
	asm volatile("vpshrdvw %ymm1, %ymm2, %ymm3");
700
	asm volatile("vpshrdvw %zmm1, %zmm2, %zmm3");
701
	asm volatile("vpshrdvw 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
702
	asm volatile("vpshrdvw 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
703

704
	/* AVX-512: Op code 0f 38 73 */
705

706
	asm volatile("vpshrdvd %xmm1, %xmm2, %xmm3");
707
	asm volatile("vpshrdvd %ymm1, %ymm2, %ymm3");
708
	asm volatile("vpshrdvd %zmm1, %zmm2, %zmm3");
709
	asm volatile("vpshrdvd 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
710
	asm volatile("vpshrdvd 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
711

712
	asm volatile("vpshrdvq %xmm1, %xmm2, %xmm3");
713
	asm volatile("vpshrdvq %ymm1, %ymm2, %ymm3");
714
	asm volatile("vpshrdvq %zmm1, %zmm2, %zmm3");
715
	asm volatile("vpshrdvq 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
716
	asm volatile("vpshrdvq 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
717

718
	/* AVX-512: Op code 0f 38 75 */
719

720
	asm volatile("vpermi2b %zmm24,%zmm25,%zmm26");
721
	asm volatile("vpermi2w %zmm26,%zmm27,%zmm28");
722

723
	/* AVX-512: Op code 0f 38 76 */
724

725
	asm volatile("vpermi2d %zmm26,%zmm27,%zmm28");
726
	asm volatile("vpermi2q %zmm26,%zmm27,%zmm28");
727

728
	/* AVX-512: Op code 0f 38 77 */
729

730
	asm volatile("vpermi2ps %zmm26,%zmm27,%zmm28");
731
	asm volatile("vpermi2pd %zmm26,%zmm27,%zmm28");
732

733
	/* AVX-512: Op code 0f 38 7a */
734

735
	asm volatile("vpbroadcastb %eax,%xmm30");
736

737
	/* AVX-512: Op code 0f 38 7b */
738

739
	asm volatile("vpbroadcastw %eax,%xmm30");
740

741
	/* AVX-512: Op code 0f 38 7c */
742

743
	asm volatile("vpbroadcastd %eax,%xmm30");
744
	asm volatile("vpbroadcastq %rax,%zmm30");
745

746
	/* AVX-512: Op code 0f 38 7d */
747

748
	asm volatile("vpermt2b %zmm26,%zmm27,%zmm28");
749
	asm volatile("vpermt2w %zmm26,%zmm27,%zmm28");
750

751
	/* AVX-512: Op code 0f 38 7e */
752

753
	asm volatile("vpermt2d %zmm26,%zmm27,%zmm28");
754
	asm volatile("vpermt2q %zmm26,%zmm27,%zmm28");
755

756
	/* AVX-512: Op code 0f 38 7f */
757

758
	asm volatile("vpermt2ps %zmm26,%zmm27,%zmm28");
759
	asm volatile("vpermt2pd %zmm26,%zmm27,%zmm28");
760

761
	/* AVX-512: Op code 0f 38 83 */
762

763
	asm volatile("vpmultishiftqb %zmm26,%zmm27,%zmm28");
764

765
	/* AVX-512: Op code 0f 38 88 */
766

767
	asm volatile("vexpandps (%rcx),%zmm26");
768
	asm volatile("vexpandpd (%rcx),%zmm28");
769

770
	/* AVX-512: Op code 0f 38 89 */
771

772
	asm volatile("vpexpandd (%rcx),%zmm28");
773
	asm volatile("vpexpandq (%rcx),%zmm26");
774

775
	/* AVX-512: Op code 0f 38 8a */
776

777
	asm volatile("vcompressps %zmm28,(%rcx)");
778
	asm volatile("vcompresspd %zmm28,(%rcx)");
779

780
	/* AVX-512: Op code 0f 38 8b */
781

782
	asm volatile("vpcompressd %zmm28,(%rcx)");
783
	asm volatile("vpcompressq %zmm26,(%rcx)");
784

785
	/* AVX-512: Op code 0f 38 8d */
786

787
	asm volatile("vpermb %zmm26,%zmm27,%zmm28");
788
	asm volatile("vpermw %zmm26,%zmm27,%zmm28");
789

790
	/* AVX-512: Op code 0f 38 8f */
791

792
	asm volatile("vpshufbitqmb %xmm1, %xmm2, %k3");
793
	asm volatile("vpshufbitqmb %ymm1, %ymm2, %k3");
794
	asm volatile("vpshufbitqmb %zmm1, %zmm2, %k3");
795
	asm volatile("vpshufbitqmb 0x12345678(%rax,%rcx,8),%zmm2,%k3");
796
	asm volatile("vpshufbitqmb 0x12345678(%eax,%ecx,8),%zmm2,%k3");
797

798
	/* AVX-512: Op code 0f 38 90 */
799

800
	asm volatile("vpgatherdd %xmm2,0x02(%rbp,%xmm7,2),%xmm1");
801
	asm volatile("vpgatherdq %xmm2,0x04(%rbp,%xmm7,2),%xmm1");
802
	asm volatile("vpgatherdd 0x7b(%rbp,%zmm27,8),%zmm26{%k1}");
803
	asm volatile("vpgatherdq 0x7b(%rbp,%ymm27,8),%zmm26{%k1}");
804

805
	/* AVX-512: Op code 0f 38 91 */
806

807
	asm volatile("vpgatherqd %xmm2,0x02(%rbp,%xmm7,2),%xmm1");
808
	asm volatile("vpgatherqq %xmm2,0x02(%rbp,%xmm7,2),%xmm1");
809
	asm volatile("vpgatherqd 0x7b(%rbp,%zmm27,8),%ymm26{%k1}");
810
	asm volatile("vpgatherqq 0x7b(%rbp,%zmm27,8),%zmm26{%k1}");
811

812
	/* AVX-512: Op code 0f 38 9a */
813

814
	asm volatile("vfmsub132ps %xmm1, %xmm2, %xmm3");
815
	asm volatile("vfmsub132ps %ymm1, %ymm2, %ymm3");
816
	asm volatile("vfmsub132ps %zmm1, %zmm2, %zmm3");
817
	asm volatile("vfmsub132ps 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
818
	asm volatile("vfmsub132ps 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
819

820
	asm volatile("vfmsub132pd %xmm1, %xmm2, %xmm3");
821
	asm volatile("vfmsub132pd %ymm1, %ymm2, %ymm3");
822
	asm volatile("vfmsub132pd %zmm1, %zmm2, %zmm3");
823
	asm volatile("vfmsub132pd 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
824
	asm volatile("vfmsub132pd 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
825

826
	asm volatile("v4fmaddps (%rax), %zmm0, %zmm4");
827
	asm volatile("v4fmaddps (%eax), %zmm0, %zmm4");
828
	asm volatile("v4fmaddps 0x12345678(%rax,%rcx,8),%zmm0,%zmm4");
829
	asm volatile("v4fmaddps 0x12345678(%eax,%ecx,8),%zmm0,%zmm4");
830

831
	/* AVX-512: Op code 0f 38 9b */
832

833
	asm volatile("vfmsub132ss %xmm1, %xmm2, %xmm3");
834
	asm volatile("vfmsub132ss 0x12345678(%rax,%rcx,8),%xmm2,%xmm3");
835
	asm volatile("vfmsub132ss 0x12345678(%eax,%ecx,8),%xmm2,%xmm3");
836

837
	asm volatile("vfmsub132sd %xmm1, %xmm2, %xmm3");
838
	asm volatile("vfmsub132sd 0x12345678(%rax,%rcx,8),%xmm2,%xmm3");
839
	asm volatile("vfmsub132sd 0x12345678(%eax,%ecx,8),%xmm2,%xmm3");
840

841
	asm volatile("v4fmaddss (%rax), %xmm0, %xmm4");
842
	asm volatile("v4fmaddss (%eax), %xmm0, %xmm4");
843
	asm volatile("v4fmaddss 0x12345678(%rax,%rcx,8),%xmm0,%xmm4");
844
	asm volatile("v4fmaddss 0x12345678(%eax,%ecx,8),%xmm0,%xmm4");
845

846
	/* AVX-512: Op code 0f 38 a0 */
847

848
	asm volatile("vpscatterdd %zmm28,0x7b(%rbp,%zmm29,8){%k1}");
849
	asm volatile("vpscatterdq %zmm26,0x7b(%rbp,%ymm27,8){%k1}");
850

851
	/* AVX-512: Op code 0f 38 a1 */
852

853
	asm volatile("vpscatterqd %ymm6,0x7b(%rbp,%zmm29,8){%k1}");
854
	asm volatile("vpscatterqq %ymm6,0x7b(%rbp,%ymm27,8){%k1}");
855

856
	/* AVX-512: Op code 0f 38 a2 */
857

858
	asm volatile("vscatterdps %zmm28,0x7b(%rbp,%zmm29,8){%k1}");
859
	asm volatile("vscatterdpd %zmm28,0x7b(%rbp,%ymm27,8){%k1}");
860

861
	/* AVX-512: Op code 0f 38 a3 */
862

863
	asm volatile("vscatterqps %ymm6,0x7b(%rbp,%zmm29,8){%k1}");
864
	asm volatile("vscatterqpd %zmm28,0x7b(%rbp,%zmm29,8){%k1}");
865

866
	/* AVX-512: Op code 0f 38 aa */
867

868
	asm volatile("vfmsub213ps %xmm1, %xmm2, %xmm3");
869
	asm volatile("vfmsub213ps %ymm1, %ymm2, %ymm3");
870
	asm volatile("vfmsub213ps %zmm1, %zmm2, %zmm3");
871
	asm volatile("vfmsub213ps 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
872
	asm volatile("vfmsub213ps 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
873

874
	asm volatile("vfmsub213pd %xmm1, %xmm2, %xmm3");
875
	asm volatile("vfmsub213pd %ymm1, %ymm2, %ymm3");
876
	asm volatile("vfmsub213pd %zmm1, %zmm2, %zmm3");
877
	asm volatile("vfmsub213pd 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
878
	asm volatile("vfmsub213pd 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
879

880
	asm volatile("v4fnmaddps (%rax), %zmm0, %zmm4");
881
	asm volatile("v4fnmaddps (%eax), %zmm0, %zmm4");
882
	asm volatile("v4fnmaddps 0x12345678(%rax,%rcx,8),%zmm0,%zmm4");
883
	asm volatile("v4fnmaddps 0x12345678(%eax,%ecx,8),%zmm0,%zmm4");
884

885
	/* AVX-512: Op code 0f 38 ab */
886

887
	asm volatile("vfmsub213ss %xmm1, %xmm2, %xmm3");
888
	asm volatile("vfmsub213ss 0x12345678(%rax,%rcx,8),%xmm2,%xmm3");
889
	asm volatile("vfmsub213ss 0x12345678(%eax,%ecx,8),%xmm2,%xmm3");
890

891
	asm volatile("vfmsub213sd %xmm1, %xmm2, %xmm3");
892
	asm volatile("vfmsub213sd 0x12345678(%rax,%rcx,8),%xmm2,%xmm3");
893
	asm volatile("vfmsub213sd 0x12345678(%eax,%ecx,8),%xmm2,%xmm3");
894

895
	asm volatile("v4fnmaddss (%rax), %xmm0, %xmm4");
896
	asm volatile("v4fnmaddss (%eax), %xmm0, %xmm4");
897
	asm volatile("v4fnmaddss 0x12345678(%rax,%rcx,8),%xmm0,%xmm4");
898
	asm volatile("v4fnmaddss 0x12345678(%eax,%ecx,8),%xmm0,%xmm4");
899

900
	/* AVX-512: Op code 0f 38 b4 */
901

902
	asm volatile("vpmadd52luq %zmm26,%zmm27,%zmm28");
903

904
	/* AVX-512: Op code 0f 38 b5 */
905

906
	asm volatile("vpmadd52huq %zmm26,%zmm27,%zmm28");
907

908
	/* AVX-512: Op code 0f 38 c4 */
909

910
	asm volatile("vpconflictd %zmm26,%zmm27");
911
	asm volatile("vpconflictq %zmm26,%zmm27");
912

913
	/* AVX-512: Op code 0f 38 c8 */
914

915
	asm volatile("vexp2ps %zmm29,%zmm30");
916
	asm volatile("vexp2pd %zmm26,%zmm27");
917

918
	/* AVX-512: Op code 0f 38 ca */
919

920
	asm volatile("vrcp28ps %zmm29,%zmm30");
921
	asm volatile("vrcp28pd %zmm26,%zmm27");
922

923
	/* AVX-512: Op code 0f 38 cb */
924

925
	asm volatile("vrcp28ss %xmm28,%xmm29,%xmm30{%k7}");
926
	asm volatile("vrcp28sd %xmm25,%xmm26,%xmm27{%k7}");
927

928
	/* AVX-512: Op code 0f 38 cc */
929

930
	asm volatile("vrsqrt28ps %zmm29,%zmm30");
931
	asm volatile("vrsqrt28pd %zmm26,%zmm27");
932

933
	/* AVX-512: Op code 0f 38 cd */
934

935
	asm volatile("vrsqrt28ss %xmm28,%xmm29,%xmm30{%k7}");
936
	asm volatile("vrsqrt28sd %xmm25,%xmm26,%xmm27{%k7}");
937

938
	/* AVX-512: Op code 0f 38 cf */
939

940
	asm volatile("gf2p8mulb %xmm1, %xmm3");
941
	asm volatile("gf2p8mulb 0x12345678(%rax,%rcx,8),%xmm3");
942
	asm volatile("gf2p8mulb 0x12345678(%eax,%ecx,8),%xmm3");
943

944
	asm volatile("vgf2p8mulb %xmm1, %xmm2, %xmm3");
945
	asm volatile("vgf2p8mulb %ymm1, %ymm2, %ymm3");
946
	asm volatile("vgf2p8mulb %zmm1, %zmm2, %zmm3");
947
	asm volatile("vgf2p8mulb 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
948
	asm volatile("vgf2p8mulb 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
949

950
	/* AVX-512: Op code 0f 38 dc */
951

952
	asm volatile("vaesenc %xmm1, %xmm2, %xmm3");
953
	asm volatile("vaesenc %ymm1, %ymm2, %ymm3");
954
	asm volatile("vaesenc %zmm1, %zmm2, %zmm3");
955
	asm volatile("vaesenc 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
956
	asm volatile("vaesenc 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
957

958
	/* AVX-512: Op code 0f 38 dd */
959

960
	asm volatile("vaesenclast %xmm1, %xmm2, %xmm3");
961
	asm volatile("vaesenclast %ymm1, %ymm2, %ymm3");
962
	asm volatile("vaesenclast %zmm1, %zmm2, %zmm3");
963
	asm volatile("vaesenclast 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
964
	asm volatile("vaesenclast 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
965

966
	/* AVX-512: Op code 0f 38 de */
967

968
	asm volatile("vaesdec %xmm1, %xmm2, %xmm3");
969
	asm volatile("vaesdec %ymm1, %ymm2, %ymm3");
970
	asm volatile("vaesdec %zmm1, %zmm2, %zmm3");
971
	asm volatile("vaesdec 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
972
	asm volatile("vaesdec 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
973

974
	/* AVX-512: Op code 0f 38 df */
975

976
	asm volatile("vaesdeclast %xmm1, %xmm2, %xmm3");
977
	asm volatile("vaesdeclast %ymm1, %ymm2, %ymm3");
978
	asm volatile("vaesdeclast %zmm1, %zmm2, %zmm3");
979
	asm volatile("vaesdeclast 0x12345678(%rax,%rcx,8),%zmm2,%zmm3");
980
	asm volatile("vaesdeclast 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
981

982
	/* AVX-512: Op code 0f 3a 03 */
983

984
	asm volatile("valignd $0x12,%zmm28,%zmm29,%zmm30");
985
	asm volatile("valignq $0x12,%zmm25,%zmm26,%zmm27");
986

987
	/* AVX-512: Op code 0f 3a 08 */
988

989
	asm volatile("vroundps $0x5,%ymm6,%ymm2");
990
	asm volatile("vrndscaleps $0x12,%zmm25,%zmm26");
991

992
	/* AVX-512: Op code 0f 3a 09 */
993

994
	asm volatile("vroundpd $0x5,%ymm6,%ymm2");
995
	asm volatile("vrndscalepd $0x12,%zmm25,%zmm26");
996

997
	/* AVX-512: Op code 0f 3a 1a */
998

999
	asm volatile("vroundss $0x5,%xmm4,%xmm6,%xmm2");
1000
	asm volatile("vrndscaless $0x12,%xmm24,%xmm25,%xmm26{%k7}");
1001

1002
	/* AVX-512: Op code 0f 3a 0b */
1003

1004
	asm volatile("vroundsd $0x5,%xmm4,%xmm6,%xmm2");
1005
	asm volatile("vrndscalesd $0x12,%xmm24,%xmm25,%xmm26{%k7}");
1006

1007
	/* AVX-512: Op code 0f 3a 18 */
1008

1009
	asm volatile("vinsertf128 $0x5,%xmm4,%ymm4,%ymm6");
1010
	asm volatile("vinsertf32x4 $0x12,%xmm24,%zmm25,%zmm26{%k7}");
1011
	asm volatile("vinsertf64x2 $0x12,%xmm24,%zmm25,%zmm26{%k7}");
1012

1013
	/* AVX-512: Op code 0f 3a 19 */
1014

1015
	asm volatile("vextractf128 $0x5,%ymm4,%xmm4");
1016
	asm volatile("vextractf32x4 $0x12,%zmm25,%xmm26{%k7}");
1017
	asm volatile("vextractf64x2 $0x12,%zmm25,%xmm26{%k7}");
1018

1019
	/* AVX-512: Op code 0f 3a 1a */
1020

1021
	asm volatile("vinsertf32x8 $0x12,%ymm25,%zmm26,%zmm27{%k7}");
1022
	asm volatile("vinsertf64x4 $0x12,%ymm28,%zmm29,%zmm30{%k7}");
1023

1024
	/* AVX-512: Op code 0f 3a 1b */
1025

1026
	asm volatile("vextractf32x8 $0x12,%zmm29,%ymm30{%k7}");
1027
	asm volatile("vextractf64x4 $0x12,%zmm26,%ymm27{%k7}");
1028

1029
	/* AVX-512: Op code 0f 3a 1e */
1030

1031
	asm volatile("vpcmpud $0x12,%zmm29,%zmm30,%k5");
1032
	asm volatile("vpcmpuq $0x12,%zmm26,%zmm27,%k5");
1033

1034
	/* AVX-512: Op code 0f 3a 1f */
1035

1036
	asm volatile("vpcmpd $0x12,%zmm29,%zmm30,%k5");
1037
	asm volatile("vpcmpq $0x12,%zmm26,%zmm27,%k5");
1038

1039
	/* AVX-512: Op code 0f 3a 23 */
1040

1041
	asm volatile("vshuff32x4 $0x12,%zmm28,%zmm29,%zmm30");
1042
	asm volatile("vshuff64x2 $0x12,%zmm25,%zmm26,%zmm27");
1043

1044
	/* AVX-512: Op code 0f 3a 25 */
1045

1046
	asm volatile("vpternlogd $0x12,%zmm28,%zmm29,%zmm30");
1047
	asm volatile("vpternlogq $0x12,%zmm28,%zmm29,%zmm30");
1048

1049
	/* AVX-512: Op code 0f 3a 26 */
1050

1051
	asm volatile("vgetmantps $0x12,%zmm26,%zmm27");
1052
	asm volatile("vgetmantpd $0x12,%zmm29,%zmm30");
1053

1054
	/* AVX-512: Op code 0f 3a 27 */
1055

1056
	asm volatile("vgetmantss $0x12,%xmm25,%xmm26,%xmm27{%k7}");
1057
	asm volatile("vgetmantsd $0x12,%xmm28,%xmm29,%xmm30{%k7}");
1058

1059
	/* AVX-512: Op code 0f 3a 38 */
1060

1061
	asm volatile("vinserti128 $0x5,%xmm4,%ymm4,%ymm6");
1062
	asm volatile("vinserti32x4 $0x12,%xmm24,%zmm25,%zmm26{%k7}");
1063
	asm volatile("vinserti64x2 $0x12,%xmm24,%zmm25,%zmm26{%k7}");
1064

1065
	/* AVX-512: Op code 0f 3a 39 */
1066

1067
	asm volatile("vextracti128 $0x5,%ymm4,%xmm6");
1068
	asm volatile("vextracti32x4 $0x12,%zmm25,%xmm26{%k7}");
1069
	asm volatile("vextracti64x2 $0x12,%zmm25,%xmm26{%k7}");
1070

1071
	/* AVX-512: Op code 0f 3a 3a */
1072

1073
	asm volatile("vinserti32x8 $0x12,%ymm28,%zmm29,%zmm30{%k7}");
1074
	asm volatile("vinserti64x4 $0x12,%ymm25,%zmm26,%zmm27{%k7}");
1075

1076
	/* AVX-512: Op code 0f 3a 3b */
1077

1078
	asm volatile("vextracti32x8 $0x12,%zmm29,%ymm30{%k7}");
1079
	asm volatile("vextracti64x4 $0x12,%zmm26,%ymm27{%k7}");
1080

1081
	/* AVX-512: Op code 0f 3a 3e */
1082

1083
	asm volatile("vpcmpub $0x12,%zmm29,%zmm30,%k5");
1084
	asm volatile("vpcmpuw $0x12,%zmm26,%zmm27,%k5");
1085

1086
	/* AVX-512: Op code 0f 3a 3f */
1087

1088
	asm volatile("vpcmpb $0x12,%zmm29,%zmm30,%k5");
1089
	asm volatile("vpcmpw $0x12,%zmm26,%zmm27,%k5");
1090

1091
	/* AVX-512: Op code 0f 3a 43 */
1092

1093
	asm volatile("vmpsadbw $0x5,%ymm4,%ymm6,%ymm2");
1094
	asm volatile("vdbpsadbw $0x12,%zmm4,%zmm5,%zmm6");
1095

1096
	/* AVX-512: Op code 0f 3a 43 */
1097

1098
	asm volatile("vshufi32x4 $0x12,%zmm25,%zmm26,%zmm27");
1099
	asm volatile("vshufi64x2 $0x12,%zmm28,%zmm29,%zmm30");
1100

1101
	/* AVX-512: Op code 0f 3a 44 */
1102

1103
	asm volatile("vpclmulqdq $0x12,%xmm1,%xmm2,%xmm3");
1104
	asm volatile("vpclmulqdq $0x12,%ymm1,%ymm2,%ymm3");
1105
	asm volatile("vpclmulqdq $0x12,%zmm1,%zmm2,%zmm3");
1106
	asm volatile("vpclmulqdq $0x12,%zmm25,%zmm26,%zmm27");
1107

1108
	/* AVX-512: Op code 0f 3a 50 */
1109

1110
	asm volatile("vrangeps $0x12,%zmm25,%zmm26,%zmm27");
1111
	asm volatile("vrangepd $0x12,%zmm28,%zmm29,%zmm30");
1112

1113
	/* AVX-512: Op code 0f 3a 51 */
1114

1115
	asm volatile("vrangess $0x12,%xmm25,%xmm26,%xmm27");
1116
	asm volatile("vrangesd $0x12,%xmm28,%xmm29,%xmm30");
1117

1118
	/* AVX-512: Op code 0f 3a 54 */
1119

1120
	asm volatile("vfixupimmps $0x12,%zmm28,%zmm29,%zmm30");
1121
	asm volatile("vfixupimmpd $0x12,%zmm25,%zmm26,%zmm27");
1122

1123
	/* AVX-512: Op code 0f 3a 55 */
1124

1125
	asm volatile("vfixupimmss $0x12,%xmm28,%xmm29,%xmm30{%k7}");
1126
	asm volatile("vfixupimmsd $0x12,%xmm25,%xmm26,%xmm27{%k7}");
1127

1128
	/* AVX-512: Op code 0f 3a 56 */
1129

1130
	asm volatile("vreduceps $0x12,%zmm26,%zmm27");
1131
	asm volatile("vreducepd $0x12,%zmm29,%zmm30");
1132

1133
	/* AVX-512: Op code 0f 3a 57 */
1134

1135
	asm volatile("vreducess $0x12,%xmm25,%xmm26,%xmm27");
1136
	asm volatile("vreducesd $0x12,%xmm28,%xmm29,%xmm30");
1137

1138
	/* AVX-512: Op code 0f 3a 66 */
1139

1140
	asm volatile("vfpclassps $0x12,%zmm27,%k5");
1141
	asm volatile("vfpclasspd $0x12,%zmm30,%k5");
1142

1143
	/* AVX-512: Op code 0f 3a 67 */
1144

1145
	asm volatile("vfpclassss $0x12,%xmm27,%k5");
1146
	asm volatile("vfpclasssd $0x12,%xmm30,%k5");
1147

1148
	/* AVX-512: Op code 0f 3a 70 */
1149

1150
	asm volatile("vpshldw $0x12,%xmm1,%xmm2,%xmm3");
1151
	asm volatile("vpshldw $0x12,%ymm1,%ymm2,%ymm3");
1152
	asm volatile("vpshldw $0x12,%zmm1,%zmm2,%zmm3");
1153
	asm volatile("vpshldw $0x12,%zmm25,%zmm26,%zmm27");
1154

1155
	/* AVX-512: Op code 0f 3a 71 */
1156

1157
	asm volatile("vpshldd $0x12,%xmm1,%xmm2,%xmm3");
1158
	asm volatile("vpshldd $0x12,%ymm1,%ymm2,%ymm3");
1159
	asm volatile("vpshldd $0x12,%zmm1,%zmm2,%zmm3");
1160
	asm volatile("vpshldd $0x12,%zmm25,%zmm26,%zmm27");
1161

1162
	asm volatile("vpshldq $0x12,%xmm1,%xmm2,%xmm3");
1163
	asm volatile("vpshldq $0x12,%ymm1,%ymm2,%ymm3");
1164
	asm volatile("vpshldq $0x12,%zmm1,%zmm2,%zmm3");
1165
	asm volatile("vpshldq $0x12,%zmm25,%zmm26,%zmm27");
1166

1167
	/* AVX-512: Op code 0f 3a 72 */
1168

1169
	asm volatile("vpshrdw $0x12,%xmm1,%xmm2,%xmm3");
1170
	asm volatile("vpshrdw $0x12,%ymm1,%ymm2,%ymm3");
1171
	asm volatile("vpshrdw $0x12,%zmm1,%zmm2,%zmm3");
1172
	asm volatile("vpshrdw $0x12,%zmm25,%zmm26,%zmm27");
1173

1174
	/* AVX-512: Op code 0f 3a 73 */
1175

1176
	asm volatile("vpshrdd $0x12,%xmm1,%xmm2,%xmm3");
1177
	asm volatile("vpshrdd $0x12,%ymm1,%ymm2,%ymm3");
1178
	asm volatile("vpshrdd $0x12,%zmm1,%zmm2,%zmm3");
1179
	asm volatile("vpshrdd $0x12,%zmm25,%zmm26,%zmm27");
1180

1181
	asm volatile("vpshrdq $0x12,%xmm1,%xmm2,%xmm3");
1182
	asm volatile("vpshrdq $0x12,%ymm1,%ymm2,%ymm3");
1183
	asm volatile("vpshrdq $0x12,%zmm1,%zmm2,%zmm3");
1184
	asm volatile("vpshrdq $0x12,%zmm25,%zmm26,%zmm27");
1185

1186
	/* AVX-512: Op code 0f 3a ce */
1187

1188
	asm volatile("gf2p8affineqb $0x12,%xmm1,%xmm3");
1189

1190
	asm volatile("vgf2p8affineqb $0x12,%xmm1,%xmm2,%xmm3");
1191
	asm volatile("vgf2p8affineqb $0x12,%ymm1,%ymm2,%ymm3");
1192
	asm volatile("vgf2p8affineqb $0x12,%zmm1,%zmm2,%zmm3");
1193
	asm volatile("vgf2p8affineqb $0x12,%zmm25,%zmm26,%zmm27");
1194

1195
	/* AVX-512: Op code 0f 3a cf */
1196

1197
	asm volatile("gf2p8affineinvqb $0x12,%xmm1,%xmm3");
1198

1199
	asm volatile("vgf2p8affineinvqb $0x12,%xmm1,%xmm2,%xmm3");
1200
	asm volatile("vgf2p8affineinvqb $0x12,%ymm1,%ymm2,%ymm3");
1201
	asm volatile("vgf2p8affineinvqb $0x12,%zmm1,%zmm2,%zmm3");
1202
	asm volatile("vgf2p8affineinvqb $0x12,%zmm25,%zmm26,%zmm27");
1203

1204
	/* AVX-512: Op code 0f 72 (Grp13) */
1205

1206
	asm volatile("vprord $0x12,%zmm25,%zmm26");
1207
	asm volatile("vprorq $0x12,%zmm25,%zmm26");
1208
	asm volatile("vprold $0x12,%zmm29,%zmm30");
1209
	asm volatile("vprolq $0x12,%zmm29,%zmm30");
1210
	asm volatile("psrad  $0x2,%mm6");
1211
	asm volatile("vpsrad $0x5,%ymm6,%ymm2");
1212
	asm volatile("vpsrad $0x5,%zmm26,%zmm22");
1213
	asm volatile("vpsraq $0x5,%zmm26,%zmm22");
1214

1215
	/* AVX-512: Op code 0f 38 c6 (Grp18) */
1216

1217
	asm volatile("vgatherpf0dps 0x7b(%r14,%zmm31,8){%k1}");
1218
	asm volatile("vgatherpf0dpd 0x7b(%r14,%ymm31,8){%k1}");
1219
	asm volatile("vgatherpf1dps 0x7b(%r14,%zmm31,8){%k1}");
1220
	asm volatile("vgatherpf1dpd 0x7b(%r14,%ymm31,8){%k1}");
1221
	asm volatile("vscatterpf0dps 0x7b(%r14,%zmm31,8){%k1}");
1222
	asm volatile("vscatterpf0dpd 0x7b(%r14,%ymm31,8){%k1}");
1223
	asm volatile("vscatterpf1dps 0x7b(%r14,%zmm31,8){%k1}");
1224
	asm volatile("vscatterpf1dpd 0x7b(%r14,%ymm31,8){%k1}");
1225

1226
	/* AVX-512: Op code 0f 38 c7 (Grp19) */
1227

1228
	asm volatile("vgatherpf0qps 0x7b(%r14,%zmm31,8){%k1}");
1229
	asm volatile("vgatherpf0qpd 0x7b(%r14,%zmm31,8){%k1}");
1230
	asm volatile("vgatherpf1qps 0x7b(%r14,%zmm31,8){%k1}");
1231
	asm volatile("vgatherpf1qpd 0x7b(%r14,%zmm31,8){%k1}");
1232
	asm volatile("vscatterpf0qps 0x7b(%r14,%zmm31,8){%k1}");
1233
	asm volatile("vscatterpf0qpd 0x7b(%r14,%zmm31,8){%k1}");
1234
	asm volatile("vscatterpf1qps 0x7b(%r14,%zmm31,8){%k1}");
1235
	asm volatile("vscatterpf1qpd 0x7b(%r14,%zmm31,8){%k1}");
1236

1237
	/* AVX-512: Examples */
1238

1239
	asm volatile("vaddpd %zmm28,%zmm29,%zmm30");
1240
	asm volatile("vaddpd %zmm28,%zmm29,%zmm30{%k7}");
1241
	asm volatile("vaddpd %zmm28,%zmm29,%zmm30{%k7}{z}");
1242
	asm volatile("vaddpd {rn-sae},%zmm28,%zmm29,%zmm30");
1243
	asm volatile("vaddpd {ru-sae},%zmm28,%zmm29,%zmm30");
1244
	asm volatile("vaddpd {rd-sae},%zmm28,%zmm29,%zmm30");
1245
	asm volatile("vaddpd {rz-sae},%zmm28,%zmm29,%zmm30");
1246
	asm volatile("vaddpd (%rcx),%zmm29,%zmm30");
1247
	asm volatile("vaddpd 0x123(%rax,%r14,8),%zmm29,%zmm30");
1248
	asm volatile("vaddpd (%rcx){1to8},%zmm29,%zmm30");
1249
	asm volatile("vaddpd 0x1fc0(%rdx),%zmm29,%zmm30");
1250
	asm volatile("vaddpd 0x3f8(%rdx){1to8},%zmm29,%zmm30");
1251
	asm volatile("vcmpeq_uqps 0x1fc(%rdx){1to16},%zmm30,%k5");
1252
	asm volatile("vcmpltsd 0x123(%rax,%r14,8),%xmm29,%k5{%k7}");
1253
	asm volatile("vcmplesd {sae},%xmm28,%xmm29,%k5{%k7}");
1254
	asm volatile("vgetmantss $0x5b,0x123(%rax,%r14,8),%xmm29,%xmm30{%k7}");
1255

1256
	/* bndmk m64, bnd */
1257

1258
	asm volatile("bndmk (%rax), %bnd0");
1259
	asm volatile("bndmk (%r8), %bnd0");
1260
	asm volatile("bndmk (0x12345678), %bnd0");
1261
	asm volatile("bndmk (%rax), %bnd3");
1262
	asm volatile("bndmk (%rcx,%rax,1), %bnd0");
1263
	asm volatile("bndmk 0x12345678(,%rax,1), %bnd0");
1264
	asm volatile("bndmk (%rax,%rcx,1), %bnd0");
1265
	asm volatile("bndmk (%rax,%rcx,8), %bnd0");
1266
	asm volatile("bndmk 0x12(%rax), %bnd0");
1267
	asm volatile("bndmk 0x12(%rbp), %bnd0");
1268
	asm volatile("bndmk 0x12(%rcx,%rax,1), %bnd0");
1269
	asm volatile("bndmk 0x12(%rbp,%rax,1), %bnd0");
1270
	asm volatile("bndmk 0x12(%rax,%rcx,1), %bnd0");
1271
	asm volatile("bndmk 0x12(%rax,%rcx,8), %bnd0");
1272
	asm volatile("bndmk 0x12345678(%rax), %bnd0");
1273
	asm volatile("bndmk 0x12345678(%rbp), %bnd0");
1274
	asm volatile("bndmk 0x12345678(%rcx,%rax,1), %bnd0");
1275
	asm volatile("bndmk 0x12345678(%rbp,%rax,1), %bnd0");
1276
	asm volatile("bndmk 0x12345678(%rax,%rcx,1), %bnd0");
1277
	asm volatile("bndmk 0x12345678(%rax,%rcx,8), %bnd0");
1278

1279
	/* bndcl r/m64, bnd */
1280

1281
	asm volatile("bndcl (%rax), %bnd0");
1282
	asm volatile("bndcl (%r8), %bnd0");
1283
	asm volatile("bndcl (0x12345678), %bnd0");
1284
	asm volatile("bndcl (%rax), %bnd3");
1285
	asm volatile("bndcl (%rcx,%rax,1), %bnd0");
1286
	asm volatile("bndcl 0x12345678(,%rax,1), %bnd0");
1287
	asm volatile("bndcl (%rax,%rcx,1), %bnd0");
1288
	asm volatile("bndcl (%rax,%rcx,8), %bnd0");
1289
	asm volatile("bndcl 0x12(%rax), %bnd0");
1290
	asm volatile("bndcl 0x12(%rbp), %bnd0");
1291
	asm volatile("bndcl 0x12(%rcx,%rax,1), %bnd0");
1292
	asm volatile("bndcl 0x12(%rbp,%rax,1), %bnd0");
1293
	asm volatile("bndcl 0x12(%rax,%rcx,1), %bnd0");
1294
	asm volatile("bndcl 0x12(%rax,%rcx,8), %bnd0");
1295
	asm volatile("bndcl 0x12345678(%rax), %bnd0");
1296
	asm volatile("bndcl 0x12345678(%rbp), %bnd0");
1297
	asm volatile("bndcl 0x12345678(%rcx,%rax,1), %bnd0");
1298
	asm volatile("bndcl 0x12345678(%rbp,%rax,1), %bnd0");
1299
	asm volatile("bndcl 0x12345678(%rax,%rcx,1), %bnd0");
1300
	asm volatile("bndcl 0x12345678(%rax,%rcx,8), %bnd0");
1301
	asm volatile("bndcl %rax, %bnd0");
1302

1303
	/* bndcu r/m64, bnd */
1304

1305
	asm volatile("bndcu (%rax), %bnd0");
1306
	asm volatile("bndcu (%r8), %bnd0");
1307
	asm volatile("bndcu (0x12345678), %bnd0");
1308
	asm volatile("bndcu (%rax), %bnd3");
1309
	asm volatile("bndcu (%rcx,%rax,1), %bnd0");
1310
	asm volatile("bndcu 0x12345678(,%rax,1), %bnd0");
1311
	asm volatile("bndcu (%rax,%rcx,1), %bnd0");
1312
	asm volatile("bndcu (%rax,%rcx,8), %bnd0");
1313
	asm volatile("bndcu 0x12(%rax), %bnd0");
1314
	asm volatile("bndcu 0x12(%rbp), %bnd0");
1315
	asm volatile("bndcu 0x12(%rcx,%rax,1), %bnd0");
1316
	asm volatile("bndcu 0x12(%rbp,%rax,1), %bnd0");
1317
	asm volatile("bndcu 0x12(%rax,%rcx,1), %bnd0");
1318
	asm volatile("bndcu 0x12(%rax,%rcx,8), %bnd0");
1319
	asm volatile("bndcu 0x12345678(%rax), %bnd0");
1320
	asm volatile("bndcu 0x12345678(%rbp), %bnd0");
1321
	asm volatile("bndcu 0x12345678(%rcx,%rax,1), %bnd0");
1322
	asm volatile("bndcu 0x12345678(%rbp,%rax,1), %bnd0");
1323
	asm volatile("bndcu 0x12345678(%rax,%rcx,1), %bnd0");
1324
	asm volatile("bndcu 0x12345678(%rax,%rcx,8), %bnd0");
1325
	asm volatile("bndcu %rax, %bnd0");
1326

1327
	/* bndcn r/m64, bnd */
1328

1329
	asm volatile("bndcn (%rax), %bnd0");
1330
	asm volatile("bndcn (%r8), %bnd0");
1331
	asm volatile("bndcn (0x12345678), %bnd0");
1332
	asm volatile("bndcn (%rax), %bnd3");
1333
	asm volatile("bndcn (%rcx,%rax,1), %bnd0");
1334
	asm volatile("bndcn 0x12345678(,%rax,1), %bnd0");
1335
	asm volatile("bndcn (%rax,%rcx,1), %bnd0");
1336
	asm volatile("bndcn (%rax,%rcx,8), %bnd0");
1337
	asm volatile("bndcn 0x12(%rax), %bnd0");
1338
	asm volatile("bndcn 0x12(%rbp), %bnd0");
1339
	asm volatile("bndcn 0x12(%rcx,%rax,1), %bnd0");
1340
	asm volatile("bndcn 0x12(%rbp,%rax,1), %bnd0");
1341
	asm volatile("bndcn 0x12(%rax,%rcx,1), %bnd0");
1342
	asm volatile("bndcn 0x12(%rax,%rcx,8), %bnd0");
1343
	asm volatile("bndcn 0x12345678(%rax), %bnd0");
1344
	asm volatile("bndcn 0x12345678(%rbp), %bnd0");
1345
	asm volatile("bndcn 0x12345678(%rcx,%rax,1), %bnd0");
1346
	asm volatile("bndcn 0x12345678(%rbp,%rax,1), %bnd0");
1347
	asm volatile("bndcn 0x12345678(%rax,%rcx,1), %bnd0");
1348
	asm volatile("bndcn 0x12345678(%rax,%rcx,8), %bnd0");
1349
	asm volatile("bndcn %rax, %bnd0");
1350

1351
	/* bndmov m128, bnd */
1352

1353
	asm volatile("bndmov (%rax), %bnd0");
1354
	asm volatile("bndmov (%r8), %bnd0");
1355
	asm volatile("bndmov (0x12345678), %bnd0");
1356
	asm volatile("bndmov (%rax), %bnd3");
1357
	asm volatile("bndmov (%rcx,%rax,1), %bnd0");
1358
	asm volatile("bndmov 0x12345678(,%rax,1), %bnd0");
1359
	asm volatile("bndmov (%rax,%rcx,1), %bnd0");
1360
	asm volatile("bndmov (%rax,%rcx,8), %bnd0");
1361
	asm volatile("bndmov 0x12(%rax), %bnd0");
1362
	asm volatile("bndmov 0x12(%rbp), %bnd0");
1363
	asm volatile("bndmov 0x12(%rcx,%rax,1), %bnd0");
1364
	asm volatile("bndmov 0x12(%rbp,%rax,1), %bnd0");
1365
	asm volatile("bndmov 0x12(%rax,%rcx,1), %bnd0");
1366
	asm volatile("bndmov 0x12(%rax,%rcx,8), %bnd0");
1367
	asm volatile("bndmov 0x12345678(%rax), %bnd0");
1368
	asm volatile("bndmov 0x12345678(%rbp), %bnd0");
1369
	asm volatile("bndmov 0x12345678(%rcx,%rax,1), %bnd0");
1370
	asm volatile("bndmov 0x12345678(%rbp,%rax,1), %bnd0");
1371
	asm volatile("bndmov 0x12345678(%rax,%rcx,1), %bnd0");
1372
	asm volatile("bndmov 0x12345678(%rax,%rcx,8), %bnd0");
1373

1374
	/* bndmov bnd, m128 */
1375

1376
	asm volatile("bndmov %bnd0, (%rax)");
1377
	asm volatile("bndmov %bnd0, (%r8)");
1378
	asm volatile("bndmov %bnd0, (0x12345678)");
1379
	asm volatile("bndmov %bnd3, (%rax)");
1380
	asm volatile("bndmov %bnd0, (%rcx,%rax,1)");
1381
	asm volatile("bndmov %bnd0, 0x12345678(,%rax,1)");
1382
	asm volatile("bndmov %bnd0, (%rax,%rcx,1)");
1383
	asm volatile("bndmov %bnd0, (%rax,%rcx,8)");
1384
	asm volatile("bndmov %bnd0, 0x12(%rax)");
1385
	asm volatile("bndmov %bnd0, 0x12(%rbp)");
1386
	asm volatile("bndmov %bnd0, 0x12(%rcx,%rax,1)");
1387
	asm volatile("bndmov %bnd0, 0x12(%rbp,%rax,1)");
1388
	asm volatile("bndmov %bnd0, 0x12(%rax,%rcx,1)");
1389
	asm volatile("bndmov %bnd0, 0x12(%rax,%rcx,8)");
1390
	asm volatile("bndmov %bnd0, 0x12345678(%rax)");
1391
	asm volatile("bndmov %bnd0, 0x12345678(%rbp)");
1392
	asm volatile("bndmov %bnd0, 0x12345678(%rcx,%rax,1)");
1393
	asm volatile("bndmov %bnd0, 0x12345678(%rbp,%rax,1)");
1394
	asm volatile("bndmov %bnd0, 0x12345678(%rax,%rcx,1)");
1395
	asm volatile("bndmov %bnd0, 0x12345678(%rax,%rcx,8)");
1396

1397
	/* bndmov bnd2, bnd1 */
1398

1399
	asm volatile("bndmov %bnd0, %bnd1");
1400
	asm volatile("bndmov %bnd1, %bnd0");
1401

1402
	/* bndldx mib, bnd */
1403

1404
	asm volatile("bndldx (%rax), %bnd0");
1405
	asm volatile("bndldx (%r8), %bnd0");
1406
	asm volatile("bndldx (0x12345678), %bnd0");
1407
	asm volatile("bndldx (%rax), %bnd3");
1408
	asm volatile("bndldx (%rcx,%rax,1), %bnd0");
1409
	asm volatile("bndldx 0x12345678(,%rax,1), %bnd0");
1410
	asm volatile("bndldx (%rax,%rcx,1), %bnd0");
1411
	asm volatile("bndldx 0x12(%rax), %bnd0");
1412
	asm volatile("bndldx 0x12(%rbp), %bnd0");
1413
	asm volatile("bndldx 0x12(%rcx,%rax,1), %bnd0");
1414
	asm volatile("bndldx 0x12(%rbp,%rax,1), %bnd0");
1415
	asm volatile("bndldx 0x12(%rax,%rcx,1), %bnd0");
1416
	asm volatile("bndldx 0x12345678(%rax), %bnd0");
1417
	asm volatile("bndldx 0x12345678(%rbp), %bnd0");
1418
	asm volatile("bndldx 0x12345678(%rcx,%rax,1), %bnd0");
1419
	asm volatile("bndldx 0x12345678(%rbp,%rax,1), %bnd0");
1420
	asm volatile("bndldx 0x12345678(%rax,%rcx,1), %bnd0");
1421

1422
	/* bndstx bnd, mib */
1423

1424
	asm volatile("bndstx %bnd0, (%rax)");
1425
	asm volatile("bndstx %bnd0, (%r8)");
1426
	asm volatile("bndstx %bnd0, (0x12345678)");
1427
	asm volatile("bndstx %bnd3, (%rax)");
1428
	asm volatile("bndstx %bnd0, (%rcx,%rax,1)");
1429
	asm volatile("bndstx %bnd0, 0x12345678(,%rax,1)");
1430
	asm volatile("bndstx %bnd0, (%rax,%rcx,1)");
1431
	asm volatile("bndstx %bnd0, 0x12(%rax)");
1432
	asm volatile("bndstx %bnd0, 0x12(%rbp)");
1433
	asm volatile("bndstx %bnd0, 0x12(%rcx,%rax,1)");
1434
	asm volatile("bndstx %bnd0, 0x12(%rbp,%rax,1)");
1435
	asm volatile("bndstx %bnd0, 0x12(%rax,%rcx,1)");
1436
	asm volatile("bndstx %bnd0, 0x12345678(%rax)");
1437
	asm volatile("bndstx %bnd0, 0x12345678(%rbp)");
1438
	asm volatile("bndstx %bnd0, 0x12345678(%rcx,%rax,1)");
1439
	asm volatile("bndstx %bnd0, 0x12345678(%rbp,%rax,1)");
1440
	asm volatile("bndstx %bnd0, 0x12345678(%rax,%rcx,1)");
1441

1442
	/* bnd prefix on call, ret, jmp and all jcc */
1443

1444
	asm volatile("bnd call label1");  /* Expecting: call unconditional 0 */
1445
	asm volatile("bnd call *(%eax)"); /* Expecting: call indirect      0 */
1446
	asm volatile("bnd ret");          /* Expecting: ret  indirect      0 */
1447
	asm volatile("bnd jmp label1");   /* Expecting: jmp  unconditional 0 */
1448
	asm volatile("bnd jmp label1");   /* Expecting: jmp  unconditional 0 */
1449
	asm volatile("bnd jmp *(%ecx)");  /* Expecting: jmp  indirect      0 */
1450
	asm volatile("bnd jne label1");   /* Expecting: jcc  conditional   0 */
1451

1452
	/* sha1rnds4 imm8, xmm2/m128, xmm1 */
1453

1454
	asm volatile("sha1rnds4 $0x0, %xmm1, %xmm0");
1455
	asm volatile("sha1rnds4 $0x91, %xmm7, %xmm2");
1456
	asm volatile("sha1rnds4 $0x91, %xmm8, %xmm0");
1457
	asm volatile("sha1rnds4 $0x91, %xmm7, %xmm8");
1458
	asm volatile("sha1rnds4 $0x91, %xmm15, %xmm8");
1459
	asm volatile("sha1rnds4 $0x91, (%rax), %xmm0");
1460
	asm volatile("sha1rnds4 $0x91, (%r8), %xmm0");
1461
	asm volatile("sha1rnds4 $0x91, (0x12345678), %xmm0");
1462
	asm volatile("sha1rnds4 $0x91, (%rax), %xmm3");
1463
	asm volatile("sha1rnds4 $0x91, (%rcx,%rax,1), %xmm0");
1464
	asm volatile("sha1rnds4 $0x91, 0x12345678(,%rax,1), %xmm0");
1465
	asm volatile("sha1rnds4 $0x91, (%rax,%rcx,1), %xmm0");
1466
	asm volatile("sha1rnds4 $0x91, (%rax,%rcx,8), %xmm0");
1467
	asm volatile("sha1rnds4 $0x91, 0x12(%rax), %xmm0");
1468
	asm volatile("sha1rnds4 $0x91, 0x12(%rbp), %xmm0");
1469
	asm volatile("sha1rnds4 $0x91, 0x12(%rcx,%rax,1), %xmm0");
1470
	asm volatile("sha1rnds4 $0x91, 0x12(%rbp,%rax,1), %xmm0");
1471
	asm volatile("sha1rnds4 $0x91, 0x12(%rax,%rcx,1), %xmm0");
1472
	asm volatile("sha1rnds4 $0x91, 0x12(%rax,%rcx,8), %xmm0");
1473
	asm volatile("sha1rnds4 $0x91, 0x12345678(%rax), %xmm0");
1474
	asm volatile("sha1rnds4 $0x91, 0x12345678(%rbp), %xmm0");
1475
	asm volatile("sha1rnds4 $0x91, 0x12345678(%rcx,%rax,1), %xmm0");
1476
	asm volatile("sha1rnds4 $0x91, 0x12345678(%rbp,%rax,1), %xmm0");
1477
	asm volatile("sha1rnds4 $0x91, 0x12345678(%rax,%rcx,1), %xmm0");
1478
	asm volatile("sha1rnds4 $0x91, 0x12345678(%rax,%rcx,8), %xmm0");
1479
	asm volatile("sha1rnds4 $0x91, 0x12345678(%rax,%rcx,8), %xmm15");
1480

1481
	/* sha1nexte xmm2/m128, xmm1 */
1482

1483
	asm volatile("sha1nexte %xmm1, %xmm0");
1484
	asm volatile("sha1nexte %xmm7, %xmm2");
1485
	asm volatile("sha1nexte %xmm8, %xmm0");
1486
	asm volatile("sha1nexte %xmm7, %xmm8");
1487
	asm volatile("sha1nexte %xmm15, %xmm8");
1488
	asm volatile("sha1nexte (%rax), %xmm0");
1489
	asm volatile("sha1nexte (%r8), %xmm0");
1490
	asm volatile("sha1nexte (0x12345678), %xmm0");
1491
	asm volatile("sha1nexte (%rax), %xmm3");
1492
	asm volatile("sha1nexte (%rcx,%rax,1), %xmm0");
1493
	asm volatile("sha1nexte 0x12345678(,%rax,1), %xmm0");
1494
	asm volatile("sha1nexte (%rax,%rcx,1), %xmm0");
1495
	asm volatile("sha1nexte (%rax,%rcx,8), %xmm0");
1496
	asm volatile("sha1nexte 0x12(%rax), %xmm0");
1497
	asm volatile("sha1nexte 0x12(%rbp), %xmm0");
1498
	asm volatile("sha1nexte 0x12(%rcx,%rax,1), %xmm0");
1499
	asm volatile("sha1nexte 0x12(%rbp,%rax,1), %xmm0");
1500
	asm volatile("sha1nexte 0x12(%rax,%rcx,1), %xmm0");
1501
	asm volatile("sha1nexte 0x12(%rax,%rcx,8), %xmm0");
1502
	asm volatile("sha1nexte 0x12345678(%rax), %xmm0");
1503
	asm volatile("sha1nexte 0x12345678(%rbp), %xmm0");
1504
	asm volatile("sha1nexte 0x12345678(%rcx,%rax,1), %xmm0");
1505
	asm volatile("sha1nexte 0x12345678(%rbp,%rax,1), %xmm0");
1506
	asm volatile("sha1nexte 0x12345678(%rax,%rcx,1), %xmm0");
1507
	asm volatile("sha1nexte 0x12345678(%rax,%rcx,8), %xmm0");
1508
	asm volatile("sha1nexte 0x12345678(%rax,%rcx,8), %xmm15");
1509

1510
	/* sha1msg1 xmm2/m128, xmm1 */
1511

1512
	asm volatile("sha1msg1 %xmm1, %xmm0");
1513
	asm volatile("sha1msg1 %xmm7, %xmm2");
1514
	asm volatile("sha1msg1 %xmm8, %xmm0");
1515
	asm volatile("sha1msg1 %xmm7, %xmm8");
1516
	asm volatile("sha1msg1 %xmm15, %xmm8");
1517
	asm volatile("sha1msg1 (%rax), %xmm0");
1518
	asm volatile("sha1msg1 (%r8), %xmm0");
1519
	asm volatile("sha1msg1 (0x12345678), %xmm0");
1520
	asm volatile("sha1msg1 (%rax), %xmm3");
1521
	asm volatile("sha1msg1 (%rcx,%rax,1), %xmm0");
1522
	asm volatile("sha1msg1 0x12345678(,%rax,1), %xmm0");
1523
	asm volatile("sha1msg1 (%rax,%rcx,1), %xmm0");
1524
	asm volatile("sha1msg1 (%rax,%rcx,8), %xmm0");
1525
	asm volatile("sha1msg1 0x12(%rax), %xmm0");
1526
	asm volatile("sha1msg1 0x12(%rbp), %xmm0");
1527
	asm volatile("sha1msg1 0x12(%rcx,%rax,1), %xmm0");
1528
	asm volatile("sha1msg1 0x12(%rbp,%rax,1), %xmm0");
1529
	asm volatile("sha1msg1 0x12(%rax,%rcx,1), %xmm0");
1530
	asm volatile("sha1msg1 0x12(%rax,%rcx,8), %xmm0");
1531
	asm volatile("sha1msg1 0x12345678(%rax), %xmm0");
1532
	asm volatile("sha1msg1 0x12345678(%rbp), %xmm0");
1533
	asm volatile("sha1msg1 0x12345678(%rcx,%rax,1), %xmm0");
1534
	asm volatile("sha1msg1 0x12345678(%rbp,%rax,1), %xmm0");
1535
	asm volatile("sha1msg1 0x12345678(%rax,%rcx,1), %xmm0");
1536
	asm volatile("sha1msg1 0x12345678(%rax,%rcx,8), %xmm0");
1537
	asm volatile("sha1msg1 0x12345678(%rax,%rcx,8), %xmm15");
1538

1539
	/* sha1msg2 xmm2/m128, xmm1 */
1540

1541
	asm volatile("sha1msg2 %xmm1, %xmm0");
1542
	asm volatile("sha1msg2 %xmm7, %xmm2");
1543
	asm volatile("sha1msg2 %xmm8, %xmm0");
1544
	asm volatile("sha1msg2 %xmm7, %xmm8");
1545
	asm volatile("sha1msg2 %xmm15, %xmm8");
1546
	asm volatile("sha1msg2 (%rax), %xmm0");
1547
	asm volatile("sha1msg2 (%r8), %xmm0");
1548
	asm volatile("sha1msg2 (0x12345678), %xmm0");
1549
	asm volatile("sha1msg2 (%rax), %xmm3");
1550
	asm volatile("sha1msg2 (%rcx,%rax,1), %xmm0");
1551
	asm volatile("sha1msg2 0x12345678(,%rax,1), %xmm0");
1552
	asm volatile("sha1msg2 (%rax,%rcx,1), %xmm0");
1553
	asm volatile("sha1msg2 (%rax,%rcx,8), %xmm0");
1554
	asm volatile("sha1msg2 0x12(%rax), %xmm0");
1555
	asm volatile("sha1msg2 0x12(%rbp), %xmm0");
1556
	asm volatile("sha1msg2 0x12(%rcx,%rax,1), %xmm0");
1557
	asm volatile("sha1msg2 0x12(%rbp,%rax,1), %xmm0");
1558
	asm volatile("sha1msg2 0x12(%rax,%rcx,1), %xmm0");
1559
	asm volatile("sha1msg2 0x12(%rax,%rcx,8), %xmm0");
1560
	asm volatile("sha1msg2 0x12345678(%rax), %xmm0");
1561
	asm volatile("sha1msg2 0x12345678(%rbp), %xmm0");
1562
	asm volatile("sha1msg2 0x12345678(%rcx,%rax,1), %xmm0");
1563
	asm volatile("sha1msg2 0x12345678(%rbp,%rax,1), %xmm0");
1564
	asm volatile("sha1msg2 0x12345678(%rax,%rcx,1), %xmm0");
1565
	asm volatile("sha1msg2 0x12345678(%rax,%rcx,8), %xmm0");
1566
	asm volatile("sha1msg2 0x12345678(%rax,%rcx,8), %xmm15");
1567

1568
	/* sha256rnds2 <XMM0>, xmm2/m128, xmm1 */
1569
	/* Note sha256rnds2 has an implicit operand 'xmm0' */
1570

1571
	asm volatile("sha256rnds2 %xmm4, %xmm1");
1572
	asm volatile("sha256rnds2 %xmm7, %xmm2");
1573
	asm volatile("sha256rnds2 %xmm8, %xmm1");
1574
	asm volatile("sha256rnds2 %xmm7, %xmm8");
1575
	asm volatile("sha256rnds2 %xmm15, %xmm8");
1576
	asm volatile("sha256rnds2 (%rax), %xmm1");
1577
	asm volatile("sha256rnds2 (%r8), %xmm1");
1578
	asm volatile("sha256rnds2 (0x12345678), %xmm1");
1579
	asm volatile("sha256rnds2 (%rax), %xmm3");
1580
	asm volatile("sha256rnds2 (%rcx,%rax,1), %xmm1");
1581
	asm volatile("sha256rnds2 0x12345678(,%rax,1), %xmm1");
1582
	asm volatile("sha256rnds2 (%rax,%rcx,1), %xmm1");
1583
	asm volatile("sha256rnds2 (%rax,%rcx,8), %xmm1");
1584
	asm volatile("sha256rnds2 0x12(%rax), %xmm1");
1585
	asm volatile("sha256rnds2 0x12(%rbp), %xmm1");
1586
	asm volatile("sha256rnds2 0x12(%rcx,%rax,1), %xmm1");
1587
	asm volatile("sha256rnds2 0x12(%rbp,%rax,1), %xmm1");
1588
	asm volatile("sha256rnds2 0x12(%rax,%rcx,1), %xmm1");
1589
	asm volatile("sha256rnds2 0x12(%rax,%rcx,8), %xmm1");
1590
	asm volatile("sha256rnds2 0x12345678(%rax), %xmm1");
1591
	asm volatile("sha256rnds2 0x12345678(%rbp), %xmm1");
1592
	asm volatile("sha256rnds2 0x12345678(%rcx,%rax,1), %xmm1");
1593
	asm volatile("sha256rnds2 0x12345678(%rbp,%rax,1), %xmm1");
1594
	asm volatile("sha256rnds2 0x12345678(%rax,%rcx,1), %xmm1");
1595
	asm volatile("sha256rnds2 0x12345678(%rax,%rcx,8), %xmm1");
1596
	asm volatile("sha256rnds2 0x12345678(%rax,%rcx,8), %xmm15");
1597

1598
	/* sha256msg1 xmm2/m128, xmm1 */
1599

1600
	asm volatile("sha256msg1 %xmm1, %xmm0");
1601
	asm volatile("sha256msg1 %xmm7, %xmm2");
1602
	asm volatile("sha256msg1 %xmm8, %xmm0");
1603
	asm volatile("sha256msg1 %xmm7, %xmm8");
1604
	asm volatile("sha256msg1 %xmm15, %xmm8");
1605
	asm volatile("sha256msg1 (%rax), %xmm0");
1606
	asm volatile("sha256msg1 (%r8), %xmm0");
1607
	asm volatile("sha256msg1 (0x12345678), %xmm0");
1608
	asm volatile("sha256msg1 (%rax), %xmm3");
1609
	asm volatile("sha256msg1 (%rcx,%rax,1), %xmm0");
1610
	asm volatile("sha256msg1 0x12345678(,%rax,1), %xmm0");
1611
	asm volatile("sha256msg1 (%rax,%rcx,1), %xmm0");
1612
	asm volatile("sha256msg1 (%rax,%rcx,8), %xmm0");
1613
	asm volatile("sha256msg1 0x12(%rax), %xmm0");
1614
	asm volatile("sha256msg1 0x12(%rbp), %xmm0");
1615
	asm volatile("sha256msg1 0x12(%rcx,%rax,1), %xmm0");
1616
	asm volatile("sha256msg1 0x12(%rbp,%rax,1), %xmm0");
1617
	asm volatile("sha256msg1 0x12(%rax,%rcx,1), %xmm0");
1618
	asm volatile("sha256msg1 0x12(%rax,%rcx,8), %xmm0");
1619
	asm volatile("sha256msg1 0x12345678(%rax), %xmm0");
1620
	asm volatile("sha256msg1 0x12345678(%rbp), %xmm0");
1621
	asm volatile("sha256msg1 0x12345678(%rcx,%rax,1), %xmm0");
1622
	asm volatile("sha256msg1 0x12345678(%rbp,%rax,1), %xmm0");
1623
	asm volatile("sha256msg1 0x12345678(%rax,%rcx,1), %xmm0");
1624
	asm volatile("sha256msg1 0x12345678(%rax,%rcx,8), %xmm0");
1625
	asm volatile("sha256msg1 0x12345678(%rax,%rcx,8), %xmm15");
1626

1627
	/* sha256msg2 xmm2/m128, xmm1 */
1628

1629
	asm volatile("sha256msg2 %xmm1, %xmm0");
1630
	asm volatile("sha256msg2 %xmm7, %xmm2");
1631
	asm volatile("sha256msg2 %xmm8, %xmm0");
1632
	asm volatile("sha256msg2 %xmm7, %xmm8");
1633
	asm volatile("sha256msg2 %xmm15, %xmm8");
1634
	asm volatile("sha256msg2 (%rax), %xmm0");
1635
	asm volatile("sha256msg2 (%r8), %xmm0");
1636
	asm volatile("sha256msg2 (0x12345678), %xmm0");
1637
	asm volatile("sha256msg2 (%rax), %xmm3");
1638
	asm volatile("sha256msg2 (%rcx,%rax,1), %xmm0");
1639
	asm volatile("sha256msg2 0x12345678(,%rax,1), %xmm0");
1640
	asm volatile("sha256msg2 (%rax,%rcx,1), %xmm0");
1641
	asm volatile("sha256msg2 (%rax,%rcx,8), %xmm0");
1642
	asm volatile("sha256msg2 0x12(%rax), %xmm0");
1643
	asm volatile("sha256msg2 0x12(%rbp), %xmm0");
1644
	asm volatile("sha256msg2 0x12(%rcx,%rax,1), %xmm0");
1645
	asm volatile("sha256msg2 0x12(%rbp,%rax,1), %xmm0");
1646
	asm volatile("sha256msg2 0x12(%rax,%rcx,1), %xmm0");
1647
	asm volatile("sha256msg2 0x12(%rax,%rcx,8), %xmm0");
1648
	asm volatile("sha256msg2 0x12345678(%rax), %xmm0");
1649
	asm volatile("sha256msg2 0x12345678(%rbp), %xmm0");
1650
	asm volatile("sha256msg2 0x12345678(%rcx,%rax,1), %xmm0");
1651
	asm volatile("sha256msg2 0x12345678(%rbp,%rax,1), %xmm0");
1652
	asm volatile("sha256msg2 0x12345678(%rax,%rcx,1), %xmm0");
1653
	asm volatile("sha256msg2 0x12345678(%rax,%rcx,8), %xmm0");
1654
	asm volatile("sha256msg2 0x12345678(%rax,%rcx,8), %xmm15");
1655

1656
	/* clflushopt m8 */
1657

1658
	asm volatile("clflushopt (%rax)");
1659
	asm volatile("clflushopt (%r8)");
1660
	asm volatile("clflushopt (0x12345678)");
1661
	asm volatile("clflushopt 0x12345678(%rax,%rcx,8)");
1662
	asm volatile("clflushopt 0x12345678(%r8,%rcx,8)");
1663
	/* Also check instructions in the same group encoding as clflushopt */
1664
	asm volatile("clflush (%rax)");
1665
	asm volatile("clflush (%r8)");
1666
	asm volatile("sfence");
1667

1668
	/* clwb m8 */
1669

1670
	asm volatile("clwb (%rax)");
1671
	asm volatile("clwb (%r8)");
1672
	asm volatile("clwb (0x12345678)");
1673
	asm volatile("clwb 0x12345678(%rax,%rcx,8)");
1674
	asm volatile("clwb 0x12345678(%r8,%rcx,8)");
1675
	/* Also check instructions in the same group encoding as clwb */
1676
	asm volatile("xsaveopt (%rax)");
1677
	asm volatile("xsaveopt (%r8)");
1678
	asm volatile("mfence");
1679

1680
	/* cldemote m8 */
1681

1682
	asm volatile("cldemote (%rax)");
1683
	asm volatile("cldemote (%r8)");
1684
	asm volatile("cldemote (0x12345678)");
1685
	asm volatile("cldemote 0x12345678(%rax,%rcx,8)");
1686
	asm volatile("cldemote 0x12345678(%r8,%rcx,8)");
1687

1688
	/* xsavec mem */
1689

1690
	asm volatile("xsavec (%rax)");
1691
	asm volatile("xsavec (%r8)");
1692
	asm volatile("xsavec (0x12345678)");
1693
	asm volatile("xsavec 0x12345678(%rax,%rcx,8)");
1694
	asm volatile("xsavec 0x12345678(%r8,%rcx,8)");
1695

1696
	/* xsaves mem */
1697

1698
	asm volatile("xsaves (%rax)");
1699
	asm volatile("xsaves (%r8)");
1700
	asm volatile("xsaves (0x12345678)");
1701
	asm volatile("xsaves 0x12345678(%rax,%rcx,8)");
1702
	asm volatile("xsaves 0x12345678(%r8,%rcx,8)");
1703

1704
	/* xrstors mem */
1705

1706
	asm volatile("xrstors (%rax)");
1707
	asm volatile("xrstors (%r8)");
1708
	asm volatile("xrstors (0x12345678)");
1709
	asm volatile("xrstors 0x12345678(%rax,%rcx,8)");
1710
	asm volatile("xrstors 0x12345678(%r8,%rcx,8)");
1711

1712
	/* ptwrite */
1713

1714
	asm volatile("ptwrite (%rax)");
1715
	asm volatile("ptwrite (%r8)");
1716
	asm volatile("ptwrite (0x12345678)");
1717
	asm volatile("ptwrite 0x12345678(%rax,%rcx,8)");
1718
	asm volatile("ptwrite 0x12345678(%r8,%rcx,8)");
1719

1720
	asm volatile("ptwritel (%rax)");
1721
	asm volatile("ptwritel (%r8)");
1722
	asm volatile("ptwritel (0x12345678)");
1723
	asm volatile("ptwritel 0x12345678(%rax,%rcx,8)");
1724
	asm volatile("ptwritel 0x12345678(%r8,%rcx,8)");
1725

1726
	asm volatile("ptwriteq (%rax)");
1727
	asm volatile("ptwriteq (%r8)");
1728
	asm volatile("ptwriteq (0x12345678)");
1729
	asm volatile("ptwriteq 0x12345678(%rax,%rcx,8)");
1730
	asm volatile("ptwriteq 0x12345678(%r8,%rcx,8)");
1731

1732
	/* tpause */
1733

1734
	asm volatile("tpause %ebx");
1735
	asm volatile("tpause %r8d");
1736

1737
	/* umonitor */
1738

1739
	asm volatile("umonitor %eax");
1740
	asm volatile("umonitor %rax");
1741
	asm volatile("umonitor %r8d");
1742

1743
	/* umwait */
1744

1745
	asm volatile("umwait %eax");
1746
	asm volatile("umwait %r8d");
1747

1748
	/* movdiri */
1749

1750
	asm volatile("movdiri %rax,(%rbx)");
1751
	asm volatile("movdiri %rcx,0x12345678(%rax)");
1752

1753
	/* movdir64b */
1754

1755
	asm volatile("movdir64b (%rax),%rbx");
1756
	asm volatile("movdir64b 0x12345678(%rax),%rcx");
1757
	asm volatile("movdir64b (%eax),%ebx");
1758
	asm volatile("movdir64b 0x12345678(%eax),%ecx");
1759

1760
	/* enqcmd */
1761

1762
	asm volatile("enqcmd (%rax),%rbx");
1763
	asm volatile("enqcmd 0x12345678(%rax),%rcx");
1764
	asm volatile("enqcmd (%eax),%ebx");
1765
	asm volatile("enqcmd 0x12345678(%eax),%ecx");
1766

1767
	/* enqcmds */
1768

1769
	asm volatile("enqcmds (%rax),%rbx");
1770
	asm volatile("enqcmds 0x12345678(%rax),%rcx");
1771
	asm volatile("enqcmds (%eax),%ebx");
1772
	asm volatile("enqcmds 0x12345678(%eax),%ecx");
1773

1774
	/* incsspd/q */
1775

1776
	asm volatile("incsspd %eax");
1777
	asm volatile("incsspd %r8d");
1778
	asm volatile("incsspq %rax");
1779
	asm volatile("incsspq %r8");
1780
	/* Also check instructions in the same group encoding as incsspd/q */
1781
	asm volatile("xrstor (%rax)");
1782
	asm volatile("xrstor (%r8)");
1783
	asm volatile("xrstor (0x12345678)");
1784
	asm volatile("xrstor 0x12345678(%rax,%rcx,8)");
1785
	asm volatile("xrstor 0x12345678(%r8,%rcx,8)");
1786
	asm volatile("lfence");
1787

1788
	/* rdsspd/q */
1789

1790
	asm volatile("rdsspd %eax");
1791
	asm volatile("rdsspd %r8d");
1792
	asm volatile("rdsspq %rax");
1793
	asm volatile("rdsspq %r8");
1794

1795
	/* saveprevssp */
1796

1797
	asm volatile("saveprevssp");
1798

1799
	/* rstorssp */
1800

1801
	asm volatile("rstorssp (%rax)");
1802
	asm volatile("rstorssp (%r8)");
1803
	asm volatile("rstorssp (0x12345678)");
1804
	asm volatile("rstorssp 0x12345678(%rax,%rcx,8)");
1805
	asm volatile("rstorssp 0x12345678(%r8,%rcx,8)");
1806

1807
	/* wrssd/q */
1808

1809
	asm volatile("wrssd %ecx,(%rax)");
1810
	asm volatile("wrssd %edx,(%r8)");
1811
	asm volatile("wrssd %edx,(0x12345678)");
1812
	asm volatile("wrssd %edx,0x12345678(%rax,%rcx,8)");
1813
	asm volatile("wrssd %edx,0x12345678(%r8,%rcx,8)");
1814
	asm volatile("wrssq %rcx,(%rax)");
1815
	asm volatile("wrssq %rdx,(%r8)");
1816
	asm volatile("wrssq %rdx,(0x12345678)");
1817
	asm volatile("wrssq %rdx,0x12345678(%rax,%rcx,8)");
1818
	asm volatile("wrssq %rdx,0x12345678(%r8,%rcx,8)");
1819

1820
	/* wrussd/q */
1821

1822
	asm volatile("wrussd %ecx,(%rax)");
1823
	asm volatile("wrussd %edx,(%r8)");
1824
	asm volatile("wrussd %edx,(0x12345678)");
1825
	asm volatile("wrussd %edx,0x12345678(%rax,%rcx,8)");
1826
	asm volatile("wrussd %edx,0x12345678(%r8,%rcx,8)");
1827
	asm volatile("wrussq %rcx,(%rax)");
1828
	asm volatile("wrussq %rdx,(%r8)");
1829
	asm volatile("wrussq %rdx,(0x12345678)");
1830
	asm volatile("wrussq %rdx,0x12345678(%rax,%rcx,8)");
1831
	asm volatile("wrussq %rdx,0x12345678(%r8,%rcx,8)");
1832

1833
	/* setssbsy */
1834

1835
	asm volatile("setssbsy");
1836
	/* Also check instructions in the same group encoding as setssbsy */
1837
	asm volatile("rdpkru");
1838
	asm volatile("wrpkru");
1839

1840
	/* clrssbsy */
1841

1842
	asm volatile("clrssbsy (%rax)");
1843
	asm volatile("clrssbsy (%r8)");
1844
	asm volatile("clrssbsy (0x12345678)");
1845
	asm volatile("clrssbsy 0x12345678(%rax,%rcx,8)");
1846
	asm volatile("clrssbsy 0x12345678(%r8,%rcx,8)");
1847

1848
	/* endbr32/64 */
1849

1850
	asm volatile("endbr32");
1851
	asm volatile("endbr64");
1852

1853
	/* call with/without notrack prefix */
1854

1855
	asm volatile("callq *%rax");				/* Expecting: call indirect 0 */
1856
	asm volatile("callq *(%rax)");				/* Expecting: call indirect 0 */
1857
	asm volatile("callq *(%r8)");				/* Expecting: call indirect 0 */
1858
	asm volatile("callq *(0x12345678)");			/* Expecting: call indirect 0 */
1859
	asm volatile("callq *0x12345678(%rax,%rcx,8)");		/* Expecting: call indirect 0 */
1860
	asm volatile("callq *0x12345678(%r8,%rcx,8)");		/* Expecting: call indirect 0 */
1861

1862
	asm volatile("bnd callq *%rax");			/* Expecting: call indirect 0 */
1863
	asm volatile("bnd callq *(%rax)");			/* Expecting: call indirect 0 */
1864
	asm volatile("bnd callq *(%r8)");			/* Expecting: call indirect 0 */
1865
	asm volatile("bnd callq *(0x12345678)");		/* Expecting: call indirect 0 */
1866
	asm volatile("bnd callq *0x12345678(%rax,%rcx,8)");	/* Expecting: call indirect 0 */
1867
	asm volatile("bnd callq *0x12345678(%r8,%rcx,8)");	/* Expecting: call indirect 0 */
1868

1869
	asm volatile("notrack callq *%rax");			/* Expecting: call indirect 0 */
1870
	asm volatile("notrack callq *(%rax)");			/* Expecting: call indirect 0 */
1871
	asm volatile("notrack callq *(%r8)");			/* Expecting: call indirect 0 */
1872
	asm volatile("notrack callq *(0x12345678)");		/* Expecting: call indirect 0 */
1873
	asm volatile("notrack callq *0x12345678(%rax,%rcx,8)");	/* Expecting: call indirect 0 */
1874
	asm volatile("notrack callq *0x12345678(%r8,%rcx,8)");	/* Expecting: call indirect 0 */
1875

1876
	asm volatile("notrack bnd callq *%rax");		/* Expecting: call indirect 0 */
1877
	asm volatile("notrack bnd callq *(%rax)");		/* Expecting: call indirect 0 */
1878
	asm volatile("notrack bnd callq *(%r8)");		/* Expecting: call indirect 0 */
1879
	asm volatile("notrack bnd callq *(0x12345678)");	/* Expecting: call indirect 0 */
1880
	asm volatile("notrack bnd callq *0x12345678(%rax,%rcx,8)");	/* Expecting: call indirect 0 */
1881
	asm volatile("notrack bnd callq *0x12345678(%r8,%rcx,8)");	/* Expecting: call indirect 0 */
1882

1883
	/* jmp with/without notrack prefix */
1884

1885
	asm volatile("jmpq *%rax");				/* Expecting: jmp indirect 0 */
1886
	asm volatile("jmpq *(%rax)");				/* Expecting: jmp indirect 0 */
1887
	asm volatile("jmpq *(%r8)");				/* Expecting: jmp indirect 0 */
1888
	asm volatile("jmpq *(0x12345678)");			/* Expecting: jmp indirect 0 */
1889
	asm volatile("jmpq *0x12345678(%rax,%rcx,8)");		/* Expecting: jmp indirect 0 */
1890
	asm volatile("jmpq *0x12345678(%r8,%rcx,8)");		/* Expecting: jmp indirect 0 */
1891

1892
	asm volatile("bnd jmpq *%rax");				/* Expecting: jmp indirect 0 */
1893
	asm volatile("bnd jmpq *(%rax)");			/* Expecting: jmp indirect 0 */
1894
	asm volatile("bnd jmpq *(%r8)");			/* Expecting: jmp indirect 0 */
1895
	asm volatile("bnd jmpq *(0x12345678)");			/* Expecting: jmp indirect 0 */
1896
	asm volatile("bnd jmpq *0x12345678(%rax,%rcx,8)");	/* Expecting: jmp indirect 0 */
1897
	asm volatile("bnd jmpq *0x12345678(%r8,%rcx,8)");	/* Expecting: jmp indirect 0 */
1898

1899
	asm volatile("notrack jmpq *%rax");			/* Expecting: jmp indirect 0 */
1900
	asm volatile("notrack jmpq *(%rax)");			/* Expecting: jmp indirect 0 */
1901
	asm volatile("notrack jmpq *(%r8)");			/* Expecting: jmp indirect 0 */
1902
	asm volatile("notrack jmpq *(0x12345678)");		/* Expecting: jmp indirect 0 */
1903
	asm volatile("notrack jmpq *0x12345678(%rax,%rcx,8)");	/* Expecting: jmp indirect 0 */
1904
	asm volatile("notrack jmpq *0x12345678(%r8,%rcx,8)");	/* Expecting: jmp indirect 0 */
1905

1906
	asm volatile("notrack bnd jmpq *%rax");			/* Expecting: jmp indirect 0 */
1907
	asm volatile("notrack bnd jmpq *(%rax)");		/* Expecting: jmp indirect 0 */
1908
	asm volatile("notrack bnd jmpq *(%r8)");		/* Expecting: jmp indirect 0 */
1909
	asm volatile("notrack bnd jmpq *(0x12345678)");		/* Expecting: jmp indirect 0 */
1910
	asm volatile("notrack bnd jmpq *0x12345678(%rax,%rcx,8)");	/* Expecting: jmp indirect 0 */
1911
	asm volatile("notrack bnd jmpq *0x12345678(%r8,%rcx,8)");	/* Expecting: jmp indirect 0 */
1912

1913
	/* AMX */
1914

1915
	asm volatile("ldtilecfg (%rax,%rcx,8)");
1916
	asm volatile("ldtilecfg (%r8,%rcx,8)");
1917
	asm volatile("sttilecfg (%rax,%rcx,8)");
1918
	asm volatile("sttilecfg (%r8,%rcx,8)");
1919
	asm volatile("tdpbf16ps %tmm0, %tmm1, %tmm2");
1920
	asm volatile("tdpbssd %tmm0, %tmm1, %tmm2");
1921
	asm volatile("tdpbsud %tmm0, %tmm1, %tmm2");
1922
	asm volatile("tdpbusd %tmm0, %tmm1, %tmm2");
1923
	asm volatile("tdpbuud %tmm0, %tmm1, %tmm2");
1924
	asm volatile("tileloadd (%rax,%rcx,8), %tmm1");
1925
	asm volatile("tileloadd (%r8,%rcx,8), %tmm2");
1926
	asm volatile("tileloaddt1 (%rax,%rcx,8), %tmm1");
1927
	asm volatile("tileloaddt1 (%r8,%rcx,8), %tmm2");
1928
	asm volatile("tilerelease");
1929
	asm volatile("tilestored %tmm1, (%rax,%rcx,8)");
1930
	asm volatile("tilestored %tmm2, (%r8,%rcx,8)");
1931
	asm volatile("tilezero %tmm0");
1932
	asm volatile("tilezero %tmm7");
1933

1934
	/* User Interrupt */
1935

1936
	asm volatile("clui");
1937
	asm volatile("senduipi %rax");
1938
	asm volatile("senduipi %r8");
1939
	asm volatile("stui");
1940
	asm volatile("testui");
1941
	asm volatile("uiret");
1942

1943
	/* AVX512-FP16 */
1944

1945
	asm volatile("vaddph %zmm3, %zmm2, %zmm1");
1946
	asm volatile("vaddph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
1947
	asm volatile("vaddph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
1948
	asm volatile("vaddph %xmm3, %xmm2, %xmm1");
1949
	asm volatile("vaddph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
1950
	asm volatile("vaddph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
1951
	asm volatile("vaddph %ymm3, %ymm2, %ymm1");
1952
	asm volatile("vaddph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
1953
	asm volatile("vaddph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
1954
	asm volatile("vaddsh %xmm3, %xmm2, %xmm1");
1955
	asm volatile("vaddsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
1956
	asm volatile("vaddsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
1957
	asm volatile("vcmpph $0x12, %zmm3, %zmm2, %k5");
1958
	asm volatile("vcmpph $0x12, 0x12345678(%rax,%rcx,8), %zmm2, %k5");
1959
	asm volatile("vcmpph $0x12, 0x12345678(%eax,%ecx,8), %zmm2, %k5");
1960
	asm volatile("vcmpph $0x12, %xmm3, %xmm2, %k5");
1961
	asm volatile("vcmpph $0x12, 0x12345678(%rax,%rcx,8), %xmm2, %k5");
1962
	asm volatile("vcmpph $0x12, 0x12345678(%eax,%ecx,8), %xmm2, %k5");
1963
	asm volatile("vcmpph $0x12, %ymm3, %ymm2, %k5");
1964
	asm volatile("vcmpph $0x12, 0x12345678(%rax,%rcx,8), %ymm2, %k5");
1965
	asm volatile("vcmpph $0x12, 0x12345678(%eax,%ecx,8), %ymm2, %k5");
1966
	asm volatile("vcmpsh $0x12, %xmm3, %xmm2, %k5");
1967
	asm volatile("vcmpsh $0x12, 0x12345678(%rax,%rcx,8), %xmm2, %k5");
1968
	asm volatile("vcmpsh $0x12, 0x12345678(%eax,%ecx,8), %xmm2, %k5");
1969
	asm volatile("vcomish %xmm2, %xmm1");
1970
	asm volatile("vcomish 0x12345678(%rax,%rcx,8), %xmm1");
1971
	asm volatile("vcomish 0x12345678(%eax,%ecx,8), %xmm1");
1972
	asm volatile("vcvtdq2ph %zmm2, %ymm1");
1973
	asm volatile("vcvtdq2ph 0x12345678(%rax,%rcx,8), %ymm1");
1974
	asm volatile("vcvtdq2ph 0x12345678(%eax,%ecx,8), %ymm1");
1975
	asm volatile("vcvtdq2ph %xmm2, %xmm1");
1976
	asm volatile("vcvtdq2ph %ymm2, %xmm1");
1977
	asm volatile("vcvtpd2ph %zmm2, %xmm1");
1978
	asm volatile("vcvtpd2ph %xmm2, %xmm1");
1979
	asm volatile("vcvtpd2ph %ymm2, %xmm1");
1980
	asm volatile("vcvtph2dq %ymm2, %zmm1");
1981
	asm volatile("vcvtph2dq 0x12345678(%rax,%rcx,8), %zmm1");
1982
	asm volatile("vcvtph2dq 0x12345678(%eax,%ecx,8), %zmm1");
1983
	asm volatile("vcvtph2dq %xmm2, %xmm1");
1984
	asm volatile("vcvtph2dq 0x12345678(%rax,%rcx,8), %xmm1");
1985
	asm volatile("vcvtph2dq 0x12345678(%eax,%ecx,8), %xmm1");
1986
	asm volatile("vcvtph2dq %xmm2, %ymm1");
1987
	asm volatile("vcvtph2dq 0x12345678(%rax,%rcx,8), %ymm1");
1988
	asm volatile("vcvtph2dq 0x12345678(%eax,%ecx,8), %ymm1");
1989
	asm volatile("vcvtph2pd %xmm2, %zmm1");
1990
	asm volatile("vcvtph2pd 0x12345678(%rax,%rcx,8), %zmm1");
1991
	asm volatile("vcvtph2pd 0x12345678(%eax,%ecx,8), %zmm1");
1992
	asm volatile("vcvtph2pd %xmm2, %xmm1");
1993
	asm volatile("vcvtph2pd 0x12345678(%rax,%rcx,8), %xmm1");
1994
	asm volatile("vcvtph2pd 0x12345678(%eax,%ecx,8), %xmm1");
1995
	asm volatile("vcvtph2pd %xmm2, %ymm1");
1996
	asm volatile("vcvtph2pd 0x12345678(%rax,%rcx,8), %ymm1");
1997
	asm volatile("vcvtph2pd 0x12345678(%eax,%ecx,8), %ymm1");
1998
	asm volatile("vcvtph2ps %ymm2, %zmm1");
1999
	asm volatile("vcvtph2ps 0x12345678(%rax,%rcx,8), %zmm1");
2000
	asm volatile("vcvtph2ps 0x12345678(%eax,%ecx,8), %zmm1");
2001
	asm volatile("vcvtph2ps %xmm2, %xmm1");
2002
	asm volatile("vcvtph2ps 0x12345678(%rax,%rcx,8), %xmm1");
2003
	asm volatile("vcvtph2ps 0x12345678(%eax,%ecx,8), %xmm1");
2004
	asm volatile("vcvtph2ps %xmm2, %ymm1");
2005
	asm volatile("vcvtph2ps 0x12345678(%rax,%rcx,8), %ymm1");
2006
	asm volatile("vcvtph2ps 0x12345678(%eax,%ecx,8), %ymm1");
2007
	asm volatile("vcvtph2ps %xmm2, %xmm1");
2008
	asm volatile("vcvtph2ps 0x12345678(%rax,%rcx,8), %xmm1");
2009
	asm volatile("vcvtph2ps 0x12345678(%eax,%ecx,8), %xmm1");
2010
	asm volatile("vcvtph2ps %xmm2, %ymm1");
2011
	asm volatile("vcvtph2ps 0x12345678(%rax,%rcx,8), %ymm1");
2012
	asm volatile("vcvtph2ps 0x12345678(%eax,%ecx,8), %ymm1");
2013
	asm volatile("vcvtph2psx %ymm2, %zmm1");
2014
	asm volatile("vcvtph2psx 0x12345678(%rax,%rcx,8), %zmm1");
2015
	asm volatile("vcvtph2psx 0x12345678(%eax,%ecx,8), %zmm1");
2016
	asm volatile("vcvtph2psx %xmm2, %xmm1");
2017
	asm volatile("vcvtph2psx 0x12345678(%rax,%rcx,8), %xmm1");
2018
	asm volatile("vcvtph2psx 0x12345678(%eax,%ecx,8), %xmm1");
2019
	asm volatile("vcvtph2psx %xmm2, %ymm1");
2020
	asm volatile("vcvtph2psx 0x12345678(%rax,%rcx,8), %ymm1");
2021
	asm volatile("vcvtph2psx 0x12345678(%eax,%ecx,8), %ymm1");
2022
	asm volatile("vcvtph2qq %xmm2, %zmm1");
2023
	asm volatile("vcvtph2qq 0x12345678(%rax,%rcx,8), %zmm1");
2024
	asm volatile("vcvtph2qq 0x12345678(%eax,%ecx,8), %zmm1");
2025
	asm volatile("vcvtph2qq %xmm2, %xmm1");
2026
	asm volatile("vcvtph2qq 0x12345678(%rax,%rcx,8), %xmm1");
2027
	asm volatile("vcvtph2qq 0x12345678(%eax,%ecx,8), %xmm1");
2028
	asm volatile("vcvtph2qq %xmm2, %ymm1");
2029
	asm volatile("vcvtph2qq 0x12345678(%rax,%rcx,8), %ymm1");
2030
	asm volatile("vcvtph2qq 0x12345678(%eax,%ecx,8), %ymm1");
2031
	asm volatile("vcvtph2udq %ymm2, %zmm1");
2032
	asm volatile("vcvtph2udq 0x12345678(%rax,%rcx,8), %zmm1");
2033
	asm volatile("vcvtph2udq 0x12345678(%eax,%ecx,8), %zmm1");
2034
	asm volatile("vcvtph2udq %xmm2, %xmm1");
2035
	asm volatile("vcvtph2udq 0x12345678(%rax,%rcx,8), %xmm1");
2036
	asm volatile("vcvtph2udq 0x12345678(%eax,%ecx,8), %xmm1");
2037
	asm volatile("vcvtph2udq %xmm2, %ymm1");
2038
	asm volatile("vcvtph2udq 0x12345678(%rax,%rcx,8), %ymm1");
2039
	asm volatile("vcvtph2udq 0x12345678(%eax,%ecx,8), %ymm1");
2040
	asm volatile("vcvtph2uqq %xmm2, %zmm1");
2041
	asm volatile("vcvtph2uqq 0x12345678(%rax,%rcx,8), %zmm1");
2042
	asm volatile("vcvtph2uqq 0x12345678(%eax,%ecx,8), %zmm1");
2043
	asm volatile("vcvtph2uqq %xmm2, %xmm1");
2044
	asm volatile("vcvtph2uqq 0x12345678(%rax,%rcx,8), %xmm1");
2045
	asm volatile("vcvtph2uqq 0x12345678(%eax,%ecx,8), %xmm1");
2046
	asm volatile("vcvtph2uqq %xmm2, %ymm1");
2047
	asm volatile("vcvtph2uqq 0x12345678(%rax,%rcx,8), %ymm1");
2048
	asm volatile("vcvtph2uqq 0x12345678(%eax,%ecx,8), %ymm1");
2049
	asm volatile("vcvtph2uw %zmm2, %zmm1");
2050
	asm volatile("vcvtph2uw 0x12345678(%rax,%rcx,8), %zmm1");
2051
	asm volatile("vcvtph2uw 0x12345678(%eax,%ecx,8), %zmm1");
2052
	asm volatile("vcvtph2uw %xmm2, %xmm1");
2053
	asm volatile("vcvtph2uw 0x12345678(%rax,%rcx,8), %xmm1");
2054
	asm volatile("vcvtph2uw 0x12345678(%eax,%ecx,8), %xmm1");
2055
	asm volatile("vcvtph2uw %ymm2, %ymm1");
2056
	asm volatile("vcvtph2uw 0x12345678(%rax,%rcx,8), %ymm1");
2057
	asm volatile("vcvtph2uw 0x12345678(%eax,%ecx,8), %ymm1");
2058
	asm volatile("vcvtph2w %zmm2, %zmm1");
2059
	asm volatile("vcvtph2w 0x12345678(%rax,%rcx,8), %zmm1");
2060
	asm volatile("vcvtph2w 0x12345678(%eax,%ecx,8), %zmm1");
2061
	asm volatile("vcvtph2w %xmm2, %xmm1");
2062
	asm volatile("vcvtph2w 0x12345678(%rax,%rcx,8), %xmm1");
2063
	asm volatile("vcvtph2w 0x12345678(%eax,%ecx,8), %xmm1");
2064
	asm volatile("vcvtph2w %ymm2, %ymm1");
2065
	asm volatile("vcvtph2w 0x12345678(%rax,%rcx,8), %ymm1");
2066
	asm volatile("vcvtph2w 0x12345678(%eax,%ecx,8), %ymm1");
2067
	asm volatile("vcvtps2ph $0x12, %zmm1, 0x12345678(%rax,%rcx,8)");
2068
	asm volatile("vcvtps2ph $0x12, %zmm1, 0x12345678(%eax,%ecx,8)");
2069
	asm volatile("vcvtps2ph $0x12, %zmm2, %ymm1");
2070
	asm volatile("vcvtps2ph $0x12, %ymm1, 0x12345678(%rax,%rcx,8)");
2071
	asm volatile("vcvtps2ph $0x12, %ymm1, 0x12345678(%eax,%ecx,8)");
2072
	asm volatile("vcvtps2ph $0x12, %xmm1, 0x12345678(%rax,%rcx,8)");
2073
	asm volatile("vcvtps2ph $0x12, %xmm1, 0x12345678(%eax,%ecx,8)");
2074
	asm volatile("vcvtps2ph $0x12, %xmm2, %xmm1");
2075
	asm volatile("vcvtps2ph $0x12, %ymm2, %xmm1");
2076
	asm volatile("vcvtps2ph $0x12, %ymm2, %xmm1");
2077
	asm volatile("vcvtps2ph $0x12, %ymm2, 0x12345678(%rax,%rcx,8)");
2078
	asm volatile("vcvtps2ph $0x12, %ymm2, 0x12345678(%eax,%ecx,8)");
2079
	asm volatile("vcvtps2ph $0x12, %xmm2, %xmm1");
2080
	asm volatile("vcvtps2ph $0x12, %xmm2, 0x12345678(%rax,%rcx,8)");
2081
	asm volatile("vcvtps2ph $0x12, %xmm2, 0x12345678(%eax,%ecx,8)");
2082
	asm volatile("vcvtps2phx %zmm2, %ymm1");
2083
	asm volatile("vcvtps2phx 0x12345678(%rax,%rcx,8), %ymm1");
2084
	asm volatile("vcvtps2phx 0x12345678(%eax,%ecx,8), %ymm1");
2085
	asm volatile("vcvtps2phx %xmm2, %xmm1");
2086
	asm volatile("vcvtps2phx %ymm2, %xmm1");
2087
	asm volatile("vcvtqq2ph %zmm2, %xmm1");
2088
	asm volatile("vcvtqq2ph %xmm2, %xmm1");
2089
	asm volatile("vcvtqq2ph %ymm2, %xmm1");
2090
	asm volatile("vcvtsd2sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2091
	asm volatile("vcvtsh2sd 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2092
	asm volatile("vcvtsh2si 0x12345678(%eax,%ecx,8), %eax");
2093
	asm volatile("vcvtsh2si 0x12345678(%eax,%ecx,8), %rax");
2094
	asm volatile("vcvtsh2ss 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2095
	asm volatile("vcvtsh2usi %xmm1, %eax");
2096
	asm volatile("vcvtsh2usi 0x12345678(%rax,%rcx,8), %eax");
2097
	asm volatile("vcvtsh2usi 0x12345678(%eax,%ecx,8), %eax");
2098
	asm volatile("vcvtsh2usi %xmm1, %rax");
2099
	asm volatile("vcvtsh2usi 0x12345678(%rax,%rcx,8), %rax");
2100
	asm volatile("vcvtsh2usi 0x12345678(%eax,%ecx,8), %rax");
2101
	asm volatile("vcvtsi2sh %eax, %xmm2, %xmm1");
2102
	asm volatile("vcvtsi2sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2103
	asm volatile("vcvtsi2sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2104
	asm volatile("vcvtsi2sh %rax, %xmm2, %xmm1");
2105
	asm volatile("vcvtsi2sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2106
	asm volatile("vcvtsi2sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2107
	asm volatile("vcvtss2sh %xmm3, %xmm2, %xmm1");
2108
	asm volatile("vcvtss2sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2109
	asm volatile("vcvtss2sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2110
	asm volatile("vcvttph2dq %ymm2, %zmm1");
2111
	asm volatile("vcvttph2dq 0x12345678(%rax,%rcx,8), %zmm1");
2112
	asm volatile("vcvttph2dq 0x12345678(%eax,%ecx,8), %zmm1");
2113
	asm volatile("vcvttph2dq %xmm2, %xmm1");
2114
	asm volatile("vcvttph2dq 0x12345678(%rax,%rcx,8), %xmm1");
2115
	asm volatile("vcvttph2dq 0x12345678(%eax,%ecx,8), %xmm1");
2116
	asm volatile("vcvttph2dq %xmm2, %ymm1");
2117
	asm volatile("vcvttph2dq 0x12345678(%rax,%rcx,8), %ymm1");
2118
	asm volatile("vcvttph2dq 0x12345678(%eax,%ecx,8), %ymm1");
2119
	asm volatile("vcvttph2qq %xmm2, %zmm1");
2120
	asm volatile("vcvttph2qq 0x12345678(%rax,%rcx,8), %zmm1");
2121
	asm volatile("vcvttph2qq 0x12345678(%eax,%ecx,8), %zmm1");
2122
	asm volatile("vcvttph2qq %xmm2, %xmm1");
2123
	asm volatile("vcvttph2qq 0x12345678(%rax,%rcx,8), %xmm1");
2124
	asm volatile("vcvttph2qq 0x12345678(%eax,%ecx,8), %xmm1");
2125
	asm volatile("vcvttph2qq %xmm2, %ymm1");
2126
	asm volatile("vcvttph2qq 0x12345678(%rax,%rcx,8), %ymm1");
2127
	asm volatile("vcvttph2qq 0x12345678(%eax,%ecx,8), %ymm1");
2128
	asm volatile("vcvttph2udq %ymm2, %zmm1");
2129
	asm volatile("vcvttph2udq 0x12345678(%rax,%rcx,8), %zmm1");
2130
	asm volatile("vcvttph2udq 0x12345678(%eax,%ecx,8), %zmm1");
2131
	asm volatile("vcvttph2udq %xmm2, %xmm1");
2132
	asm volatile("vcvttph2udq 0x12345678(%rax,%rcx,8), %xmm1");
2133
	asm volatile("vcvttph2udq 0x12345678(%eax,%ecx,8), %xmm1");
2134
	asm volatile("vcvttph2udq %xmm2, %ymm1");
2135
	asm volatile("vcvttph2udq 0x12345678(%rax,%rcx,8), %ymm1");
2136
	asm volatile("vcvttph2udq 0x12345678(%eax,%ecx,8), %ymm1");
2137
	asm volatile("vcvttph2uqq %xmm2, %zmm1");
2138
	asm volatile("vcvttph2uqq 0x12345678(%rax,%rcx,8), %zmm1");
2139
	asm volatile("vcvttph2uqq 0x12345678(%eax,%ecx,8), %zmm1");
2140
	asm volatile("vcvttph2uqq %xmm2, %xmm1");
2141
	asm volatile("vcvttph2uqq 0x12345678(%rax,%rcx,8), %xmm1");
2142
	asm volatile("vcvttph2uqq 0x12345678(%eax,%ecx,8), %xmm1");
2143
	asm volatile("vcvttph2uqq %xmm2, %ymm1");
2144
	asm volatile("vcvttph2uqq 0x12345678(%rax,%rcx,8), %ymm1");
2145
	asm volatile("vcvttph2uqq 0x12345678(%eax,%ecx,8), %ymm1");
2146
	asm volatile("vcvttph2uw %zmm2, %zmm1");
2147
	asm volatile("vcvttph2uw 0x12345678(%rax,%rcx,8), %zmm1");
2148
	asm volatile("vcvttph2uw 0x12345678(%eax,%ecx,8), %zmm1");
2149
	asm volatile("vcvttph2uw %xmm2, %xmm1");
2150
	asm volatile("vcvttph2uw 0x12345678(%rax,%rcx,8), %xmm1");
2151
	asm volatile("vcvttph2uw 0x12345678(%eax,%ecx,8), %xmm1");
2152
	asm volatile("vcvttph2uw %ymm2, %ymm1");
2153
	asm volatile("vcvttph2uw 0x12345678(%rax,%rcx,8), %ymm1");
2154
	asm volatile("vcvttph2uw 0x12345678(%eax,%ecx,8), %ymm1");
2155
	asm volatile("vcvttph2w %zmm2, %zmm1");
2156
	asm volatile("vcvttph2w 0x12345678(%rax,%rcx,8), %zmm1");
2157
	asm volatile("vcvttph2w 0x12345678(%eax,%ecx,8), %zmm1");
2158
	asm volatile("vcvttph2w %xmm2, %xmm1");
2159
	asm volatile("vcvttph2w 0x12345678(%rax,%rcx,8), %xmm1");
2160
	asm volatile("vcvttph2w 0x12345678(%eax,%ecx,8), %xmm1");
2161
	asm volatile("vcvttph2w %ymm2, %ymm1");
2162
	asm volatile("vcvttph2w 0x12345678(%rax,%rcx,8), %ymm1");
2163
	asm volatile("vcvttph2w 0x12345678(%eax,%ecx,8), %ymm1");
2164
	asm volatile("vcvttsh2si %xmm1, %eax");
2165
	asm volatile("vcvttsh2si 0x12345678(%rax,%rcx,8), %eax");
2166
	asm volatile("vcvttsh2si 0x12345678(%eax,%ecx,8), %eax");
2167
	asm volatile("vcvttsh2si %xmm1, %rax");
2168
	asm volatile("vcvttsh2si 0x12345678(%rax,%rcx,8), %rax");
2169
	asm volatile("vcvttsh2si 0x12345678(%eax,%ecx,8), %rax");
2170
	asm volatile("vcvttsh2usi %xmm1, %eax");
2171
	asm volatile("vcvttsh2usi 0x12345678(%rax,%rcx,8), %eax");
2172
	asm volatile("vcvttsh2usi 0x12345678(%eax,%ecx,8), %eax");
2173
	asm volatile("vcvttsh2usi %xmm1, %rax");
2174
	asm volatile("vcvttsh2usi 0x12345678(%rax,%rcx,8), %rax");
2175
	asm volatile("vcvttsh2usi 0x12345678(%eax,%ecx,8), %rax");
2176
	asm volatile("vcvtudq2ph %zmm2, %ymm1");
2177
	asm volatile("vcvtudq2ph 0x12345678(%rax,%rcx,8), %ymm1");
2178
	asm volatile("vcvtudq2ph 0x12345678(%eax,%ecx,8), %ymm1");
2179
	asm volatile("vcvtudq2ph %xmm2, %xmm1");
2180
	asm volatile("vcvtudq2ph %ymm2, %xmm1");
2181
	asm volatile("vcvtuqq2ph %zmm2, %xmm1");
2182
	asm volatile("vcvtuqq2ph %xmm2, %xmm1");
2183
	asm volatile("vcvtuqq2ph %ymm2, %xmm1");
2184
	asm volatile("vcvtusi2sh %eax, %xmm2, %xmm1");
2185
	asm volatile("vcvtusi2sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2186
	asm volatile("vcvtusi2sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2187
	asm volatile("vcvtusi2sh %rax, %xmm2, %xmm1");
2188
	asm volatile("vcvtusi2sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2189
	asm volatile("vcvtusi2sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2190
	asm volatile("vcvtuw2ph %zmm2, %zmm1");
2191
	asm volatile("vcvtuw2ph 0x12345678(%rax,%rcx,8), %zmm1");
2192
	asm volatile("vcvtuw2ph 0x12345678(%eax,%ecx,8), %zmm1");
2193
	asm volatile("vcvtuw2ph %xmm2, %xmm1");
2194
	asm volatile("vcvtuw2ph 0x12345678(%rax,%rcx,8), %xmm1");
2195
	asm volatile("vcvtuw2ph 0x12345678(%eax,%ecx,8), %xmm1");
2196
	asm volatile("vcvtuw2ph %ymm2, %ymm1");
2197
	asm volatile("vcvtuw2ph 0x12345678(%rax,%rcx,8), %ymm1");
2198
	asm volatile("vcvtuw2ph 0x12345678(%eax,%ecx,8), %ymm1");
2199
	asm volatile("vcvtw2ph %zmm2, %zmm1");
2200
	asm volatile("vcvtw2ph 0x12345678(%rax,%rcx,8), %zmm1");
2201
	asm volatile("vcvtw2ph 0x12345678(%eax,%ecx,8), %zmm1");
2202
	asm volatile("vcvtw2ph %xmm2, %xmm1");
2203
	asm volatile("vcvtw2ph 0x12345678(%rax,%rcx,8), %xmm1");
2204
	asm volatile("vcvtw2ph 0x12345678(%eax,%ecx,8), %xmm1");
2205
	asm volatile("vcvtw2ph %ymm2, %ymm1");
2206
	asm volatile("vcvtw2ph 0x12345678(%rax,%rcx,8), %ymm1");
2207
	asm volatile("vcvtw2ph 0x12345678(%eax,%ecx,8), %ymm1");
2208
	asm volatile("vdivph %zmm3, %zmm2, %zmm1");
2209
	asm volatile("vdivph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2210
	asm volatile("vdivph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2211
	asm volatile("vdivph %xmm3, %xmm2, %xmm1");
2212
	asm volatile("vdivph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2213
	asm volatile("vdivph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2214
	asm volatile("vdivph %ymm3, %ymm2, %ymm1");
2215
	asm volatile("vdivph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2216
	asm volatile("vdivph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2217
	asm volatile("vdivsh %xmm3, %xmm2, %xmm1");
2218
	asm volatile("vdivsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2219
	asm volatile("vdivsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2220
	asm volatile("vfcmaddcph %zmm3, %zmm2, %zmm1");
2221
	asm volatile("vfcmaddcph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2222
	asm volatile("vfcmaddcph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2223
	asm volatile("vfcmaddcph %xmm3, %xmm2, %xmm1");
2224
	asm volatile("vfcmaddcph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2225
	asm volatile("vfcmaddcph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2226
	asm volatile("vfcmaddcph %ymm3, %ymm2, %ymm1");
2227
	asm volatile("vfcmaddcph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2228
	asm volatile("vfcmaddcph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2229
	asm volatile("vfcmaddcsh %xmm3, %xmm2, %xmm1");
2230
	asm volatile("vfcmaddcsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2231
	asm volatile("vfcmaddcsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2232
	asm volatile("vfcmulcph %zmm3, %zmm2, %zmm1");
2233
	asm volatile("vfcmulcph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2234
	asm volatile("vfcmulcph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2235
	asm volatile("vfcmulcph %xmm3, %xmm2, %xmm1");
2236
	asm volatile("vfcmulcph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2237
	asm volatile("vfcmulcph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2238
	asm volatile("vfcmulcph %ymm3, %ymm2, %ymm1");
2239
	asm volatile("vfcmulcph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2240
	asm volatile("vfcmulcph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2241
	asm volatile("vfcmulcsh %xmm3, %xmm2, %xmm1");
2242
	asm volatile("vfcmulcsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2243
	asm volatile("vfcmulcsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2244
	asm volatile("vfmadd132ph %zmm3, %zmm2, %zmm1");
2245
	asm volatile("vfmadd132ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2246
	asm volatile("vfmadd132ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2247
	asm volatile("vfmadd132ph %xmm3, %xmm2, %xmm1");
2248
	asm volatile("vfmadd132ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2249
	asm volatile("vfmadd132ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2250
	asm volatile("vfmadd132ph %ymm3, %ymm2, %ymm1");
2251
	asm volatile("vfmadd132ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2252
	asm volatile("vfmadd132ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2253
	asm volatile("vfmadd132sh %xmm3, %xmm2, %xmm1");
2254
	asm volatile("vfmadd132sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2255
	asm volatile("vfmadd132sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2256
	asm volatile("vfmadd213ph %zmm3, %zmm2, %zmm1");
2257
	asm volatile("vfmadd213ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2258
	asm volatile("vfmadd213ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2259
	asm volatile("vfmadd213ph %xmm3, %xmm2, %xmm1");
2260
	asm volatile("vfmadd213ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2261
	asm volatile("vfmadd213ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2262
	asm volatile("vfmadd213ph %ymm3, %ymm2, %ymm1");
2263
	asm volatile("vfmadd213ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2264
	asm volatile("vfmadd213ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2265
	asm volatile("vfmadd213sh %xmm3, %xmm2, %xmm1");
2266
	asm volatile("vfmadd213sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2267
	asm volatile("vfmadd213sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2268
	asm volatile("vfmadd231ph %zmm3, %zmm2, %zmm1");
2269
	asm volatile("vfmadd231ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2270
	asm volatile("vfmadd231ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2271
	asm volatile("vfmadd231ph %xmm3, %xmm2, %xmm1");
2272
	asm volatile("vfmadd231ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2273
	asm volatile("vfmadd231ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2274
	asm volatile("vfmadd231ph %ymm3, %ymm2, %ymm1");
2275
	asm volatile("vfmadd231ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2276
	asm volatile("vfmadd231ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2277
	asm volatile("vfmadd231sh %xmm3, %xmm2, %xmm1");
2278
	asm volatile("vfmadd231sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2279
	asm volatile("vfmadd231sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2280
	asm volatile("vfmaddcph %zmm3, %zmm2, %zmm1");
2281
	asm volatile("vfmaddcph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2282
	asm volatile("vfmaddcph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2283
	asm volatile("vfmaddcph %xmm3, %xmm2, %xmm1");
2284
	asm volatile("vfmaddcph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2285
	asm volatile("vfmaddcph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2286
	asm volatile("vfmaddcph %ymm3, %ymm2, %ymm1");
2287
	asm volatile("vfmaddcph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2288
	asm volatile("vfmaddcph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2289
	asm volatile("vfmaddcsh %xmm3, %xmm2, %xmm1");
2290
	asm volatile("vfmaddcsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2291
	asm volatile("vfmaddcsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2292
	asm volatile("vfmaddsub132ph %zmm3, %zmm2, %zmm1");
2293
	asm volatile("vfmaddsub132ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2294
	asm volatile("vfmaddsub132ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2295
	asm volatile("vfmaddsub132ph %xmm3, %xmm2, %xmm1");
2296
	asm volatile("vfmaddsub132ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2297
	asm volatile("vfmaddsub132ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2298
	asm volatile("vfmaddsub132ph %ymm3, %ymm2, %ymm1");
2299
	asm volatile("vfmaddsub132ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2300
	asm volatile("vfmaddsub132ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2301
	asm volatile("vfmaddsub213ph %zmm3, %zmm2, %zmm1");
2302
	asm volatile("vfmaddsub213ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2303
	asm volatile("vfmaddsub213ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2304
	asm volatile("vfmaddsub213ph %xmm3, %xmm2, %xmm1");
2305
	asm volatile("vfmaddsub213ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2306
	asm volatile("vfmaddsub213ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2307
	asm volatile("vfmaddsub213ph %ymm3, %ymm2, %ymm1");
2308
	asm volatile("vfmaddsub213ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2309
	asm volatile("vfmaddsub213ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2310
	asm volatile("vfmaddsub231ph %zmm3, %zmm2, %zmm1");
2311
	asm volatile("vfmaddsub231ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2312
	asm volatile("vfmaddsub231ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2313
	asm volatile("vfmaddsub231ph %xmm3, %xmm2, %xmm1");
2314
	asm volatile("vfmaddsub231ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2315
	asm volatile("vfmaddsub231ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2316
	asm volatile("vfmaddsub231ph %ymm3, %ymm2, %ymm1");
2317
	asm volatile("vfmaddsub231ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2318
	asm volatile("vfmaddsub231ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2319
	asm volatile("vfmsub132ph %zmm3, %zmm2, %zmm1");
2320
	asm volatile("vfmsub132ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2321
	asm volatile("vfmsub132ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2322
	asm volatile("vfmsub132ph %xmm3, %xmm2, %xmm1");
2323
	asm volatile("vfmsub132ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2324
	asm volatile("vfmsub132ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2325
	asm volatile("vfmsub132ph %ymm3, %ymm2, %ymm1");
2326
	asm volatile("vfmsub132ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2327
	asm volatile("vfmsub132ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2328
	asm volatile("vfmsub132sh %xmm3, %xmm2, %xmm1");
2329
	asm volatile("vfmsub132sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2330
	asm volatile("vfmsub132sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2331
	asm volatile("vfmsub213ph %zmm3, %zmm2, %zmm1");
2332
	asm volatile("vfmsub213ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2333
	asm volatile("vfmsub213ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2334
	asm volatile("vfmsub213ph %xmm3, %xmm2, %xmm1");
2335
	asm volatile("vfmsub213ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2336
	asm volatile("vfmsub213ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2337
	asm volatile("vfmsub213ph %ymm3, %ymm2, %ymm1");
2338
	asm volatile("vfmsub213ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2339
	asm volatile("vfmsub213ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2340
	asm volatile("vfmsub213sh %xmm3, %xmm2, %xmm1");
2341
	asm volatile("vfmsub213sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2342
	asm volatile("vfmsub213sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2343
	asm volatile("vfmsub231ph %zmm3, %zmm2, %zmm1");
2344
	asm volatile("vfmsub231ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2345
	asm volatile("vfmsub231ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2346
	asm volatile("vfmsub231ph %xmm3, %xmm2, %xmm1");
2347
	asm volatile("vfmsub231ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2348
	asm volatile("vfmsub231ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2349
	asm volatile("vfmsub231ph %ymm3, %ymm2, %ymm1");
2350
	asm volatile("vfmsub231ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2351
	asm volatile("vfmsub231ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2352
	asm volatile("vfmsub231sh %xmm3, %xmm2, %xmm1");
2353
	asm volatile("vfmsub231sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2354
	asm volatile("vfmsub231sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2355
	asm volatile("vfmsubadd132ph %zmm3, %zmm2, %zmm1");
2356
	asm volatile("vfmsubadd132ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2357
	asm volatile("vfmsubadd132ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2358
	asm volatile("vfmsubadd132ph %xmm3, %xmm2, %xmm1");
2359
	asm volatile("vfmsubadd132ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2360
	asm volatile("vfmsubadd132ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2361
	asm volatile("vfmsubadd132ph %ymm3, %ymm2, %ymm1");
2362
	asm volatile("vfmsubadd132ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2363
	asm volatile("vfmsubadd132ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2364
	asm volatile("vfmsubadd213ph %zmm3, %zmm2, %zmm1");
2365
	asm volatile("vfmsubadd213ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2366
	asm volatile("vfmsubadd213ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2367
	asm volatile("vfmsubadd213ph %xmm3, %xmm2, %xmm1");
2368
	asm volatile("vfmsubadd213ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2369
	asm volatile("vfmsubadd213ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2370
	asm volatile("vfmsubadd213ph %ymm3, %ymm2, %ymm1");
2371
	asm volatile("vfmsubadd213ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2372
	asm volatile("vfmsubadd213ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2373
	asm volatile("vfmsubadd231ph %zmm3, %zmm2, %zmm1");
2374
	asm volatile("vfmsubadd231ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2375
	asm volatile("vfmsubadd231ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2376
	asm volatile("vfmsubadd231ph %xmm3, %xmm2, %xmm1");
2377
	asm volatile("vfmsubadd231ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2378
	asm volatile("vfmsubadd231ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2379
	asm volatile("vfmsubadd231ph %ymm3, %ymm2, %ymm1");
2380
	asm volatile("vfmsubadd231ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2381
	asm volatile("vfmsubadd231ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2382
	asm volatile("vfmulcph %zmm3, %zmm2, %zmm1");
2383
	asm volatile("vfmulcph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2384
	asm volatile("vfmulcph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2385
	asm volatile("vfmulcph %xmm3, %xmm2, %xmm1");
2386
	asm volatile("vfmulcph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2387
	asm volatile("vfmulcph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2388
	asm volatile("vfmulcph %ymm3, %ymm2, %ymm1");
2389
	asm volatile("vfmulcph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2390
	asm volatile("vfmulcph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2391
	asm volatile("vfmulcsh %xmm3, %xmm2, %xmm1");
2392
	asm volatile("vfmulcsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2393
	asm volatile("vfmulcsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2394
	asm volatile("vfnmadd132ph %zmm3, %zmm2, %zmm1");
2395
	asm volatile("vfnmadd132ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2396
	asm volatile("vfnmadd132ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2397
	asm volatile("vfnmadd132ph %xmm3, %xmm2, %xmm1");
2398
	asm volatile("vfnmadd132ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2399
	asm volatile("vfnmadd132ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2400
	asm volatile("vfnmadd132ph %ymm3, %ymm2, %ymm1");
2401
	asm volatile("vfnmadd132ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2402
	asm volatile("vfnmadd132ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2403
	asm volatile("vfnmadd132sh %xmm3, %xmm2, %xmm1");
2404
	asm volatile("vfnmadd132sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2405
	asm volatile("vfnmadd132sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2406
	asm volatile("vfnmadd213ph %zmm3, %zmm2, %zmm1");
2407
	asm volatile("vfnmadd213ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2408
	asm volatile("vfnmadd213ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2409
	asm volatile("vfnmadd213ph %xmm3, %xmm2, %xmm1");
2410
	asm volatile("vfnmadd213ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2411
	asm volatile("vfnmadd213ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2412
	asm volatile("vfnmadd213ph %ymm3, %ymm2, %ymm1");
2413
	asm volatile("vfnmadd213ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2414
	asm volatile("vfnmadd213ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2415
	asm volatile("vfnmadd213sh %xmm3, %xmm2, %xmm1");
2416
	asm volatile("vfnmadd213sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2417
	asm volatile("vfnmadd213sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2418
	asm volatile("vfnmadd231ph %zmm3, %zmm2, %zmm1");
2419
	asm volatile("vfnmadd231ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2420
	asm volatile("vfnmadd231ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2421
	asm volatile("vfnmadd231ph %xmm3, %xmm2, %xmm1");
2422
	asm volatile("vfnmadd231ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2423
	asm volatile("vfnmadd231ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2424
	asm volatile("vfnmadd231ph %ymm3, %ymm2, %ymm1");
2425
	asm volatile("vfnmadd231ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2426
	asm volatile("vfnmadd231ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2427
	asm volatile("vfnmadd231sh %xmm3, %xmm2, %xmm1");
2428
	asm volatile("vfnmadd231sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2429
	asm volatile("vfnmadd231sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2430
	asm volatile("vfnmsub132ph %zmm3, %zmm2, %zmm1");
2431
	asm volatile("vfnmsub132ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2432
	asm volatile("vfnmsub132ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2433
	asm volatile("vfnmsub132ph %xmm3, %xmm2, %xmm1");
2434
	asm volatile("vfnmsub132ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2435
	asm volatile("vfnmsub132ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2436
	asm volatile("vfnmsub132ph %ymm3, %ymm2, %ymm1");
2437
	asm volatile("vfnmsub132ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2438
	asm volatile("vfnmsub132ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2439
	asm volatile("vfnmsub132sh %xmm3, %xmm2, %xmm1");
2440
	asm volatile("vfnmsub132sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2441
	asm volatile("vfnmsub132sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2442
	asm volatile("vfnmsub213ph %zmm3, %zmm2, %zmm1");
2443
	asm volatile("vfnmsub213ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2444
	asm volatile("vfnmsub213ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2445
	asm volatile("vfnmsub213ph %xmm3, %xmm2, %xmm1");
2446
	asm volatile("vfnmsub213ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2447
	asm volatile("vfnmsub213ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2448
	asm volatile("vfnmsub213ph %ymm3, %ymm2, %ymm1");
2449
	asm volatile("vfnmsub213ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2450
	asm volatile("vfnmsub213ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2451
	asm volatile("vfnmsub213sh %xmm3, %xmm2, %xmm1");
2452
	asm volatile("vfnmsub213sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2453
	asm volatile("vfnmsub213sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2454
	asm volatile("vfnmsub231ph %zmm3, %zmm2, %zmm1");
2455
	asm volatile("vfnmsub231ph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2456
	asm volatile("vfnmsub231ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2457
	asm volatile("vfnmsub231ph %xmm3, %xmm2, %xmm1");
2458
	asm volatile("vfnmsub231ph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2459
	asm volatile("vfnmsub231ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2460
	asm volatile("vfnmsub231ph %ymm3, %ymm2, %ymm1");
2461
	asm volatile("vfnmsub231ph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2462
	asm volatile("vfnmsub231ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2463
	asm volatile("vfnmsub231sh %xmm3, %xmm2, %xmm1");
2464
	asm volatile("vfnmsub231sh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2465
	asm volatile("vfnmsub231sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2466
	asm volatile("vfpclassph $0x12, %zmm1, %k5");
2467
	asm volatile("vfpclassph $0x12, %xmm1, %k5");
2468
	asm volatile("vfpclassph $0x12, %ymm1, %k5");
2469
	asm volatile("vfpclasssh $0x12, %xmm1, %k5");
2470
	asm volatile("vfpclasssh $0x12, 0x12345678(%rax,%rcx,8), %k5");
2471
	asm volatile("vfpclasssh $0x12, 0x12345678(%eax,%ecx,8), %k5");
2472
	asm volatile("vgetexpph %zmm2, %zmm1");
2473
	asm volatile("vgetexpph 0x12345678(%rax,%rcx,8), %zmm1");
2474
	asm volatile("vgetexpph 0x12345678(%eax,%ecx,8), %zmm1");
2475
	asm volatile("vgetexpph %xmm2, %xmm1");
2476
	asm volatile("vgetexpph 0x12345678(%rax,%rcx,8), %xmm1");
2477
	asm volatile("vgetexpph 0x12345678(%eax,%ecx,8), %xmm1");
2478
	asm volatile("vgetexpph %ymm2, %ymm1");
2479
	asm volatile("vgetexpph 0x12345678(%rax,%rcx,8), %ymm1");
2480
	asm volatile("vgetexpph 0x12345678(%eax,%ecx,8), %ymm1");
2481
	asm volatile("vgetexpsh %xmm3, %xmm2, %xmm1");
2482
	asm volatile("vgetexpsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2483
	asm volatile("vgetexpsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2484
	asm volatile("vgetmantph $0x12, %zmm2, %zmm1");
2485
	asm volatile("vgetmantph $0x12, 0x12345678(%rax,%rcx,8), %zmm1");
2486
	asm volatile("vgetmantph $0x12, 0x12345678(%eax,%ecx,8), %zmm1");
2487
	asm volatile("vgetmantph $0x12, %xmm2, %xmm1");
2488
	asm volatile("vgetmantph $0x12, 0x12345678(%rax,%rcx,8), %xmm1");
2489
	asm volatile("vgetmantph $0x12, 0x12345678(%eax,%ecx,8), %xmm1");
2490
	asm volatile("vgetmantph $0x12, %ymm2, %ymm1");
2491
	asm volatile("vgetmantph $0x12, 0x12345678(%rax,%rcx,8), %ymm1");
2492
	asm volatile("vgetmantph $0x12, 0x12345678(%eax,%ecx,8), %ymm1");
2493
	asm volatile("vgetmantsh $0x12, %xmm3, %xmm2, %xmm1");
2494
	asm volatile("vgetmantsh $0x12, 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2495
	asm volatile("vgetmantsh $0x12, 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2496
	asm volatile("vmaxph %zmm3, %zmm2, %zmm1");
2497
	asm volatile("vmaxph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2498
	asm volatile("vmaxph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2499
	asm volatile("vmaxph %xmm3, %xmm2, %xmm1");
2500
	asm volatile("vmaxph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2501
	asm volatile("vmaxph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2502
	asm volatile("vmaxph %ymm3, %ymm2, %ymm1");
2503
	asm volatile("vmaxph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2504
	asm volatile("vmaxph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2505
	asm volatile("vmaxsh %xmm3, %xmm2, %xmm1");
2506
	asm volatile("vmaxsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2507
	asm volatile("vmaxsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2508
	asm volatile("vminph %zmm3, %zmm2, %zmm1");
2509
	asm volatile("vminph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2510
	asm volatile("vminph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2511
	asm volatile("vminph %xmm3, %xmm2, %xmm1");
2512
	asm volatile("vminph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2513
	asm volatile("vminph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2514
	asm volatile("vminph %ymm3, %ymm2, %ymm1");
2515
	asm volatile("vminph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2516
	asm volatile("vminph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2517
	asm volatile("vminsh %xmm3, %xmm2, %xmm1");
2518
	asm volatile("vminsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2519
	asm volatile("vminsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2520
	asm volatile("vmovsh %xmm1, 0x12345678(%rax,%rcx,8)");
2521
	asm volatile("vmovsh %xmm1, 0x12345678(%eax,%ecx,8)");
2522
	asm volatile("vmovsh 0x12345678(%rax,%rcx,8), %xmm1");
2523
	asm volatile("vmovsh 0x12345678(%eax,%ecx,8), %xmm1");
2524
	asm volatile("vmovsh %xmm3, %xmm2, %xmm1");
2525
	asm volatile("vmovw %xmm1, %eax");
2526
	asm volatile("vmovw %xmm1, 0x12345678(%rax,%rcx,8)");
2527
	asm volatile("vmovw %xmm1, 0x12345678(%eax,%ecx,8)");
2528
	asm volatile("vmovw %eax, %xmm1");
2529
	asm volatile("vmovw 0x12345678(%rax,%rcx,8), %xmm1");
2530
	asm volatile("vmovw 0x12345678(%eax,%ecx,8), %xmm1");
2531
	asm volatile("vmulph %zmm3, %zmm2, %zmm1");
2532
	asm volatile("vmulph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2533
	asm volatile("vmulph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2534
	asm volatile("vmulph %xmm3, %xmm2, %xmm1");
2535
	asm volatile("vmulph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2536
	asm volatile("vmulph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2537
	asm volatile("vmulph %ymm3, %ymm2, %ymm1");
2538
	asm volatile("vmulph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2539
	asm volatile("vmulph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2540
	asm volatile("vmulsh %xmm3, %xmm2, %xmm1");
2541
	asm volatile("vmulsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2542
	asm volatile("vmulsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2543
	asm volatile("vrcpph %zmm2, %zmm1");
2544
	asm volatile("vrcpph 0x12345678(%rax,%rcx,8), %zmm1");
2545
	asm volatile("vrcpph 0x12345678(%eax,%ecx,8), %zmm1");
2546
	asm volatile("vrcpph %xmm2, %xmm1");
2547
	asm volatile("vrcpph 0x12345678(%rax,%rcx,8), %xmm1");
2548
	asm volatile("vrcpph 0x12345678(%eax,%ecx,8), %xmm1");
2549
	asm volatile("vrcpph %ymm2, %ymm1");
2550
	asm volatile("vrcpph 0x12345678(%rax,%rcx,8), %ymm1");
2551
	asm volatile("vrcpph 0x12345678(%eax,%ecx,8), %ymm1");
2552
	asm volatile("vrcpsh %xmm3, %xmm2, %xmm1");
2553
	asm volatile("vrcpsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2554
	asm volatile("vrcpsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2555
	asm volatile("vreduceph $0x12, %zmm2, %zmm1");
2556
	asm volatile("vreduceph $0x12, 0x12345678(%rax,%rcx,8), %zmm1");
2557
	asm volatile("vreduceph $0x12, 0x12345678(%eax,%ecx,8), %zmm1");
2558
	asm volatile("vreduceph $0x12, %xmm2, %xmm1");
2559
	asm volatile("vreduceph $0x12, 0x12345678(%rax,%rcx,8), %xmm1");
2560
	asm volatile("vreduceph $0x12, 0x12345678(%eax,%ecx,8), %xmm1");
2561
	asm volatile("vreduceph $0x12, %ymm2, %ymm1");
2562
	asm volatile("vreduceph $0x12, 0x12345678(%rax,%rcx,8), %ymm1");
2563
	asm volatile("vreduceph $0x12, 0x12345678(%eax,%ecx,8), %ymm1");
2564
	asm volatile("vreducesh $0x12, %xmm3, %xmm2, %xmm1");
2565
	asm volatile("vreducesh $0x12, 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2566
	asm volatile("vreducesh $0x12, 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2567
	asm volatile("vrndscaleph $0x12, %zmm2, %zmm1");
2568
	asm volatile("vrndscaleph $0x12, 0x12345678(%rax,%rcx,8), %zmm1");
2569
	asm volatile("vrndscaleph $0x12, 0x12345678(%eax,%ecx,8), %zmm1");
2570
	asm volatile("vrndscaleph $0x12, %xmm2, %xmm1");
2571
	asm volatile("vrndscaleph $0x12, 0x12345678(%rax,%rcx,8), %xmm1");
2572
	asm volatile("vrndscaleph $0x12, 0x12345678(%eax,%ecx,8), %xmm1");
2573
	asm volatile("vrndscaleph $0x12, %ymm2, %ymm1");
2574
	asm volatile("vrndscaleph $0x12, 0x12345678(%rax,%rcx,8), %ymm1");
2575
	asm volatile("vrndscaleph $0x12, 0x12345678(%eax,%ecx,8), %ymm1");
2576
	asm volatile("vrndscalesh $0x12, %xmm3, %xmm2, %xmm1");
2577
	asm volatile("vrndscalesh $0x12, 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2578
	asm volatile("vrndscalesh $0x12, 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2579
	asm volatile("vrsqrtph %zmm2, %zmm1");
2580
	asm volatile("vrsqrtph 0x12345678(%rax,%rcx,8), %zmm1");
2581
	asm volatile("vrsqrtph 0x12345678(%eax,%ecx,8), %zmm1");
2582
	asm volatile("vrsqrtph %xmm2, %xmm1");
2583
	asm volatile("vrsqrtph 0x12345678(%rax,%rcx,8), %xmm1");
2584
	asm volatile("vrsqrtph 0x12345678(%eax,%ecx,8), %xmm1");
2585
	asm volatile("vrsqrtph %ymm2, %ymm1");
2586
	asm volatile("vrsqrtph 0x12345678(%rax,%rcx,8), %ymm1");
2587
	asm volatile("vrsqrtph 0x12345678(%eax,%ecx,8), %ymm1");
2588
	asm volatile("vrsqrtsh %xmm3, %xmm2, %xmm1");
2589
	asm volatile("vrsqrtsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2590
	asm volatile("vrsqrtsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2591
	asm volatile("vscalefph %zmm3, %zmm2, %zmm1");
2592
	asm volatile("vscalefph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2593
	asm volatile("vscalefph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2594
	asm volatile("vscalefph %xmm3, %xmm2, %xmm1");
2595
	asm volatile("vscalefph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2596
	asm volatile("vscalefph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2597
	asm volatile("vscalefph %ymm3, %ymm2, %ymm1");
2598
	asm volatile("vscalefph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2599
	asm volatile("vscalefph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2600
	asm volatile("vscalefsh %xmm3, %xmm2, %xmm1");
2601
	asm volatile("vscalefsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2602
	asm volatile("vscalefsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2603
	asm volatile("vsqrtph %zmm2, %zmm1");
2604
	asm volatile("vsqrtph 0x12345678(%rax,%rcx,8), %zmm1");
2605
	asm volatile("vsqrtph 0x12345678(%eax,%ecx,8), %zmm1");
2606
	asm volatile("vsqrtph %xmm2, %xmm1");
2607
	asm volatile("vsqrtph 0x12345678(%rax,%rcx,8), %xmm1");
2608
	asm volatile("vsqrtph 0x12345678(%eax,%ecx,8), %xmm1");
2609
	asm volatile("vsqrtph %ymm2, %ymm1");
2610
	asm volatile("vsqrtph 0x12345678(%rax,%rcx,8), %ymm1");
2611
	asm volatile("vsqrtph 0x12345678(%eax,%ecx,8), %ymm1");
2612
	asm volatile("vsqrtsh %xmm3, %xmm2, %xmm1");
2613
	asm volatile("vsqrtsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2614
	asm volatile("vsqrtsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2615
	asm volatile("vsubph %zmm3, %zmm2, %zmm1");
2616
	asm volatile("vsubph 0x12345678(%rax,%rcx,8), %zmm2, %zmm1");
2617
	asm volatile("vsubph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
2618
	asm volatile("vsubph %xmm3, %xmm2, %xmm1");
2619
	asm volatile("vsubph 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2620
	asm volatile("vsubph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2621
	asm volatile("vsubph %ymm3, %ymm2, %ymm1");
2622
	asm volatile("vsubph 0x12345678(%rax,%rcx,8), %ymm2, %ymm1");
2623
	asm volatile("vsubph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
2624
	asm volatile("vsubsh %xmm3, %xmm2, %xmm1");
2625
	asm volatile("vsubsh 0x12345678(%rax,%rcx,8), %xmm2, %xmm1");
2626
	asm volatile("vsubsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
2627
	asm volatile("vucomish %xmm2, %xmm1");
2628
	asm volatile("vucomish 0x12345678(%rax,%rcx,8), %xmm1");
2629
	asm volatile("vucomish 0x12345678(%eax,%ecx,8), %xmm1");
2630

2631
	/* Key Locker */
2632

2633
	asm volatile("loadiwkey %xmm1, %xmm2");
2634
	asm volatile("encodekey128 %eax, %edx");
2635
	asm volatile("encodekey256 %eax, %edx");
2636
	asm volatile("aesenc128kl 0x77(%rdx), %xmm3");
2637
	asm volatile("aesenc256kl 0x77(%rdx), %xmm3");
2638
	asm volatile("aesdec128kl 0x77(%rdx), %xmm3");
2639
	asm volatile("aesdec256kl 0x77(%rdx), %xmm3");
2640
	asm volatile("aesencwide128kl	0x77(%rdx)");
2641
	asm volatile("aesencwide256kl	0x77(%rdx)");
2642
	asm volatile("aesdecwide128kl	0x77(%rdx)");
2643
	asm volatile("aesdecwide256kl	0x77(%rdx)");
2644

2645
	/* Remote Atomic Operations */
2646

2647
	asm volatile("aadd %ecx,(%rax)");
2648
	asm volatile("aadd %edx,(%r8)");
2649
	asm volatile("aadd %edx,0x12345678(%rax,%rcx,8)");
2650
	asm volatile("aadd %edx,0x12345678(%r8,%rcx,8)");
2651
	asm volatile("aadd %rcx,(%rax)");
2652
	asm volatile("aadd %rdx,(%r8)");
2653
	asm volatile("aadd %rdx,(0x12345678)");
2654
	asm volatile("aadd %rdx,0x12345678(%rax,%rcx,8)");
2655
	asm volatile("aadd %rdx,0x12345678(%r8,%rcx,8)");
2656

2657
	asm volatile("aand %ecx,(%rax)");
2658
	asm volatile("aand %edx,(%r8)");
2659
	asm volatile("aand %edx,0x12345678(%rax,%rcx,8)");
2660
	asm volatile("aand %edx,0x12345678(%r8,%rcx,8)");
2661
	asm volatile("aand %rcx,(%rax)");
2662
	asm volatile("aand %rdx,(%r8)");
2663
	asm volatile("aand %rdx,(0x12345678)");
2664
	asm volatile("aand %rdx,0x12345678(%rax,%rcx,8)");
2665
	asm volatile("aand %rdx,0x12345678(%r8,%rcx,8)");
2666

2667
	asm volatile("aor %ecx,(%rax)");
2668
	asm volatile("aor %edx,(%r8)");
2669
	asm volatile("aor %edx,0x12345678(%rax,%rcx,8)");
2670
	asm volatile("aor %edx,0x12345678(%r8,%rcx,8)");
2671
	asm volatile("aor %rcx,(%rax)");
2672
	asm volatile("aor %rdx,(%r8)");
2673
	asm volatile("aor %rdx,(0x12345678)");
2674
	asm volatile("aor %rdx,0x12345678(%rax,%rcx,8)");
2675
	asm volatile("aor %rdx,0x12345678(%r8,%rcx,8)");
2676

2677
	asm volatile("axor %ecx,(%rax)");
2678
	asm volatile("axor %edx,(%r8)");
2679
	asm volatile("axor %edx,0x12345678(%rax,%rcx,8)");
2680
	asm volatile("axor %edx,0x12345678(%r8,%rcx,8)");
2681
	asm volatile("axor %rcx,(%rax)");
2682
	asm volatile("axor %rdx,(%r8)");
2683
	asm volatile("axor %rdx,(0x12345678)");
2684
	asm volatile("axor %rdx,0x12345678(%rax,%rcx,8)");
2685
	asm volatile("axor %rdx,0x12345678(%r8,%rcx,8)");
2686

2687
	/* VEX CMPxxXADD */
2688

2689
	asm volatile("cmpbexadd %ebx,%ecx,(%r9)");
2690
	asm volatile("cmpbxadd %ebx,%ecx,(%r9)");
2691
	asm volatile("cmplexadd %ebx,%ecx,(%r9)");
2692
	asm volatile("cmplxadd %ebx,%ecx,(%r9)");
2693
	asm volatile("cmpnbexadd %ebx,%ecx,(%r9)");
2694
	asm volatile("cmpnbxadd %ebx,%ecx,(%r9)");
2695
	asm volatile("cmpnlexadd %ebx,%ecx,(%r9)");
2696
	asm volatile("cmpnlxadd %ebx,%ecx,(%r9)");
2697
	asm volatile("cmpnoxadd %ebx,%ecx,(%r9)");
2698
	asm volatile("cmpnpxadd %ebx,%ecx,(%r9)");
2699
	asm volatile("cmpnsxadd %ebx,%ecx,(%r9)");
2700
	asm volatile("cmpnzxadd %ebx,%ecx,(%r9)");
2701
	asm volatile("cmpoxadd %ebx,%ecx,(%r9)");
2702
	asm volatile("cmppxadd %ebx,%ecx,(%r9)");
2703
	asm volatile("cmpsxadd %ebx,%ecx,(%r9)");
2704
	asm volatile("cmpzxadd %ebx,%ecx,(%r9)");
2705

2706
	/* Pre-fetch */
2707

2708
	asm volatile("prefetch (%rax)");
2709
	asm volatile("prefetcht0 (%rax)");
2710
	asm volatile("prefetcht1 (%rax)");
2711
	asm volatile("prefetcht2 (%rax)");
2712
	asm volatile("prefetchnta (%rax)");
2713
	asm volatile("prefetchit0 0x12345678(%rip)");
2714
	asm volatile("prefetchit1 0x12345678(%rip)");
2715

2716
	/* MSR List */
2717

2718
	asm volatile("rdmsrlist");
2719
	asm volatile("wrmsrlist");
2720

2721
	/* User Read/Write MSR */
2722

2723
	asm volatile("urdmsr %rdx,%rax");
2724
	asm volatile("urdmsr %rdx,%r22");
2725
	asm volatile("urdmsr $0x7f,%r12");
2726
	asm volatile("uwrmsr %rax,%rdx");
2727
	asm volatile("uwrmsr %r22,%rdx");
2728
	asm volatile("uwrmsr %r12,$0x7f");
2729

2730
	/* AVX NE Convert */
2731

2732
	asm volatile("vbcstnebf162ps (%rcx),%xmm6");
2733
	asm volatile("vbcstnesh2ps (%rcx),%xmm6");
2734
	asm volatile("vcvtneebf162ps (%rcx),%xmm6");
2735
	asm volatile("vcvtneeph2ps (%rcx),%xmm6");
2736
	asm volatile("vcvtneobf162ps (%rcx),%xmm6");
2737
	asm volatile("vcvtneoph2ps (%rcx),%xmm6");
2738
	asm volatile("vcvtneps2bf16 %xmm1,%xmm6");
2739

2740
	/* FRED */
2741

2742
	asm volatile("erets");	/* Expecting: erets indirect 0 */
2743
	asm volatile("eretu");	/* Expecting: eretu indirect 0 */
2744

2745
	/* AMX Complex */
2746

2747
	asm volatile("tcmmimfp16ps %tmm1,%tmm2,%tmm3");
2748
	asm volatile("tcmmrlfp16ps %tmm1,%tmm2,%tmm3");
2749

2750
	/* AMX FP16 */
2751

2752
	asm volatile("tdpfp16ps %tmm1,%tmm2,%tmm3");
2753

2754
	/* REX2 */
2755

2756
	asm volatile("test $0x5, %r18b");
2757
	asm volatile("test $0x5, %r18d");
2758
	asm volatile("test $0x5, %r18");
2759
	asm volatile("test $0x5, %r18w");
2760
	asm volatile("imull %eax, %r14d");
2761
	asm volatile("imull %eax, %r17d");
2762
	asm volatile("punpckldq (%r18), %mm2");
2763
	asm volatile("leal (%rax), %r16d");
2764
	asm volatile("leal (%rax), %r31d");
2765
	asm volatile("leal (,%r16), %eax");
2766
	asm volatile("leal (,%r31), %eax");
2767
	asm volatile("leal (%r16), %eax");
2768
	asm volatile("leal (%r31), %eax");
2769
	asm volatile("leaq (%rax), %r15");
2770
	asm volatile("leaq (%rax), %r16");
2771
	asm volatile("leaq (%r15), %rax");
2772
	asm volatile("leaq (%r16), %rax");
2773
	asm volatile("leaq (,%r15), %rax");
2774
	asm volatile("leaq (,%r16), %rax");
2775
	asm volatile("add (%r16), %r8");
2776
	asm volatile("add (%r16), %r15");
2777
	asm volatile("mov (,%r9), %r16");
2778
	asm volatile("mov (,%r14), %r16");
2779
	asm volatile("sub (%r10), %r31");
2780
	asm volatile("sub (%r13), %r31");
2781
	asm volatile("leal 1(%r16, %r21), %eax");
2782
	asm volatile("leal 1(%r16, %r26), %r31d");
2783
	asm volatile("leal 129(%r21, %r9), %eax");
2784
	asm volatile("leal 129(%r26, %r9), %r31d");
2785
	/*
2786
	 * Have to use .byte for jmpabs because gas does not support the
2787
	 * mnemonic for some reason, but then it also gets the source line wrong
2788
	 * with .byte, so the following is a workaround.
2789
	 */
2790
	asm volatile(""); /* Expecting: jmp indirect 0 */
2791
	asm volatile(".byte 0xd5, 0x00, 0xa1, 0xef, 0xcd, 0xab, 0x90, 0x78, 0x56, 0x34, 0x12");
2792
	asm volatile("pushp %rbx");
2793
	asm volatile("pushp %r16");
2794
	asm volatile("pushp %r31");
2795
	asm volatile("popp %r31");
2796
	asm volatile("popp %r16");
2797
	asm volatile("popp %rbx");
2798

2799
	/* APX */
2800

2801
	asm volatile("bextr %r25d,%edx,%r10d");
2802
	asm volatile("bextr %r25d,0x123(%r31,%rax,4),%edx");
2803
	asm volatile("bextr %r31,%r15,%r11");
2804
	asm volatile("bextr %r31,0x123(%r31,%rax,4),%r15");
2805
	asm volatile("blsi %r25d,%edx");
2806
	asm volatile("blsi %r31,%r15");
2807
	asm volatile("blsi 0x123(%r31,%rax,4),%r25d");
2808
	asm volatile("blsi 0x123(%r31,%rax,4),%r31");
2809
	asm volatile("blsmsk %r25d,%edx");
2810
	asm volatile("blsmsk %r31,%r15");
2811
	asm volatile("blsmsk 0x123(%r31,%rax,4),%r25d");
2812
	asm volatile("blsmsk 0x123(%r31,%rax,4),%r31");
2813
	asm volatile("blsr %r25d,%edx");
2814
	asm volatile("blsr %r31,%r15");
2815
	asm volatile("blsr 0x123(%r31,%rax,4),%r25d");
2816
	asm volatile("blsr 0x123(%r31,%rax,4),%r31");
2817
	asm volatile("bzhi %r25d,%edx,%r10d");
2818
	asm volatile("bzhi %r25d,0x123(%r31,%rax,4),%edx");
2819
	asm volatile("bzhi %r31,%r15,%r11");
2820
	asm volatile("bzhi %r31,0x123(%r31,%rax,4),%r15");
2821
	asm volatile("cmpbexadd %r25d,%edx,0x123(%r31,%rax,4)");
2822
	asm volatile("cmpbexadd %r31,%r15,0x123(%r31,%rax,4)");
2823
	asm volatile("cmpbxadd %r25d,%edx,0x123(%r31,%rax,4)");
2824
	asm volatile("cmpbxadd %r31,%r15,0x123(%r31,%rax,4)");
2825
	asm volatile("cmplxadd %r25d,%edx,0x123(%r31,%rax,4)");
2826
	asm volatile("cmplxadd %r31,%r15,0x123(%r31,%rax,4)");
2827
	asm volatile("cmpnbexadd %r25d,%edx,0x123(%r31,%rax,4)");
2828
	asm volatile("cmpnbexadd %r31,%r15,0x123(%r31,%rax,4)");
2829
	asm volatile("cmpnbxadd %r25d,%edx,0x123(%r31,%rax,4)");
2830
	asm volatile("cmpnbxadd %r31,%r15,0x123(%r31,%rax,4)");
2831
	asm volatile("cmpnlexadd %r25d,%edx,0x123(%r31,%rax,4)");
2832
	asm volatile("cmpnlexadd %r31,%r15,0x123(%r31,%rax,4)");
2833
	asm volatile("cmpnlxadd %r25d,%edx,0x123(%r31,%rax,4)");
2834
	asm volatile("cmpnlxadd %r31,%r15,0x123(%r31,%rax,4)");
2835
	asm volatile("cmpnoxadd %r25d,%edx,0x123(%r31,%rax,4)");
2836
	asm volatile("cmpnoxadd %r31,%r15,0x123(%r31,%rax,4)");
2837
	asm volatile("cmpnpxadd %r25d,%edx,0x123(%r31,%rax,4)");
2838
	asm volatile("cmpnpxadd %r31,%r15,0x123(%r31,%rax,4)");
2839
	asm volatile("cmpnsxadd %r25d,%edx,0x123(%r31,%rax,4)");
2840
	asm volatile("cmpnsxadd %r31,%r15,0x123(%r31,%rax,4)");
2841
	asm volatile("cmpnzxadd %r25d,%edx,0x123(%r31,%rax,4)");
2842
	asm volatile("cmpnzxadd %r31,%r15,0x123(%r31,%rax,4)");
2843
	asm volatile("cmpoxadd %r25d,%edx,0x123(%r31,%rax,4)");
2844
	asm volatile("cmpoxadd %r31,%r15,0x123(%r31,%rax,4)");
2845
	asm volatile("cmppxadd %r25d,%edx,0x123(%r31,%rax,4)");
2846
	asm volatile("cmppxadd %r31,%r15,0x123(%r31,%rax,4)");
2847
	asm volatile("cmpsxadd %r25d,%edx,0x123(%r31,%rax,4)");
2848
	asm volatile("cmpsxadd %r31,%r15,0x123(%r31,%rax,4)");
2849
	asm volatile("cmpzxadd %r25d,%edx,0x123(%r31,%rax,4)");
2850
	asm volatile("cmpzxadd %r31,%r15,0x123(%r31,%rax,4)");
2851
	asm volatile("crc32q %r31, %r22");
2852
	asm volatile("crc32q (%r31), %r22");
2853
	asm volatile("crc32b %r19b, %r17");
2854
	asm volatile("crc32b %r19b, %r21d");
2855
	asm volatile("crc32b (%r19),%ebx");
2856
	asm volatile("crc32l %r31d, %r23d");
2857
	asm volatile("crc32l (%r31), %r23d");
2858
	asm volatile("crc32w %r31w, %r21d");
2859
	asm volatile("crc32w (%r31),%r21d");
2860
	asm volatile("crc32 %rax, %r18");
2861
	asm volatile("enqcmd 0x123(%r31d,%eax,4),%r25d");
2862
	asm volatile("enqcmd 0x123(%r31,%rax,4),%r31");
2863
	asm volatile("enqcmds 0x123(%r31d,%eax,4),%r25d");
2864
	asm volatile("enqcmds 0x123(%r31,%rax,4),%r31");
2865
	asm volatile("invept 0x123(%r31,%rax,4),%r31");
2866
	asm volatile("invpcid 0x123(%r31,%rax,4),%r31");
2867
	asm volatile("invvpid 0x123(%r31,%rax,4),%r31");
2868
	asm volatile("kmovb %k5,%r25d");
2869
	asm volatile("kmovb %k5,0x123(%r31,%rax,4)");
2870
	asm volatile("kmovb %r25d,%k5");
2871
	asm volatile("kmovb 0x123(%r31,%rax,4),%k5");
2872
	asm volatile("kmovd %k5,%r25d");
2873
	asm volatile("kmovd %k5,0x123(%r31,%rax,4)");
2874
	asm volatile("kmovd %r25d,%k5");
2875
	asm volatile("kmovd 0x123(%r31,%rax,4),%k5");
2876
	asm volatile("kmovq %k5,%r31");
2877
	asm volatile("kmovq %k5,0x123(%r31,%rax,4)");
2878
	asm volatile("kmovq %r31,%k5");
2879
	asm volatile("kmovq 0x123(%r31,%rax,4),%k5");
2880
	asm volatile("kmovw %k5,%r25d");
2881
	asm volatile("kmovw %k5,0x123(%r31,%rax,4)");
2882
	asm volatile("kmovw %r25d,%k5");
2883
	asm volatile("kmovw 0x123(%r31,%rax,4),%k5");
2884
	asm volatile("ldtilecfg 0x123(%r31,%rax,4)");
2885
	asm volatile("movbe %r18w,%ax");
2886
	asm volatile("movbe %r15w,%ax");
2887
	asm volatile("movbe %r18w,0x123(%r16,%rax,4)");
2888
	asm volatile("movbe %r18w,0x123(%r31,%rax,4)");
2889
	asm volatile("movbe %r25d,%edx");
2890
	asm volatile("movbe %r15d,%edx");
2891
	asm volatile("movbe %r25d,0x123(%r16,%rax,4)");
2892
	asm volatile("movbe %r31,%r15");
2893
	asm volatile("movbe %r8,%r15");
2894
	asm volatile("movbe %r31,0x123(%r16,%rax,4)");
2895
	asm volatile("movbe %r31,0x123(%r31,%rax,4)");
2896
	asm volatile("movbe 0x123(%r16,%rax,4),%r31");
2897
	asm volatile("movbe 0x123(%r31,%rax,4),%r18w");
2898
	asm volatile("movbe 0x123(%r31,%rax,4),%r25d");
2899
	asm volatile("movdir64b 0x123(%r31d,%eax,4),%r25d");
2900
	asm volatile("movdir64b 0x123(%r31,%rax,4),%r31");
2901
	asm volatile("movdiri %r25d,0x123(%r31,%rax,4)");
2902
	asm volatile("movdiri %r31,0x123(%r31,%rax,4)");
2903
	asm volatile("pdep %r25d,%edx,%r10d");
2904
	asm volatile("pdep %r31,%r15,%r11");
2905
	asm volatile("pdep 0x123(%r31,%rax,4),%r25d,%edx");
2906
	asm volatile("pdep 0x123(%r31,%rax,4),%r31,%r15");
2907
	asm volatile("pext %r25d,%edx,%r10d");
2908
	asm volatile("pext %r31,%r15,%r11");
2909
	asm volatile("pext 0x123(%r31,%rax,4),%r25d,%edx");
2910
	asm volatile("pext 0x123(%r31,%rax,4),%r31,%r15");
2911
	asm volatile("shlx %r25d,%edx,%r10d");
2912
	asm volatile("shlx %r25d,0x123(%r31,%rax,4),%edx");
2913
	asm volatile("shlx %r31,%r15,%r11");
2914
	asm volatile("shlx %r31,0x123(%r31,%rax,4),%r15");
2915
	asm volatile("shrx %r25d,%edx,%r10d");
2916
	asm volatile("shrx %r25d,0x123(%r31,%rax,4),%edx");
2917
	asm volatile("shrx %r31,%r15,%r11");
2918
	asm volatile("shrx %r31,0x123(%r31,%rax,4),%r15");
2919
	asm volatile("sttilecfg 0x123(%r31,%rax,4)");
2920
	asm volatile("tileloadd 0x123(%r31,%rax,4),%tmm6");
2921
	asm volatile("tileloaddt1 0x123(%r31,%rax,4),%tmm6");
2922
	asm volatile("tilestored %tmm6,0x123(%r31,%rax,4)");
2923
	asm volatile("vbroadcastf128 (%r16),%ymm3");
2924
	asm volatile("vbroadcasti128 (%r16),%ymm3");
2925
	asm volatile("vextractf128 $1,%ymm3,(%r16)");
2926
	asm volatile("vextracti128 $1,%ymm3,(%r16)");
2927
	asm volatile("vinsertf128 $1,(%r16),%ymm3,%ymm8");
2928
	asm volatile("vinserti128 $1,(%r16),%ymm3,%ymm8");
2929
	asm volatile("vroundpd $1,(%r24),%xmm6");
2930
	asm volatile("vroundps $2,(%r24),%xmm6");
2931
	asm volatile("vroundsd $3,(%r24),%xmm6,%xmm3");
2932
	asm volatile("vroundss $4,(%r24),%xmm6,%xmm3");
2933
	asm volatile("wrssd %r25d,0x123(%r31,%rax,4)");
2934
	asm volatile("wrssq %r31,0x123(%r31,%rax,4)");
2935
	asm volatile("wrussd %r25d,0x123(%r31,%rax,4)");
2936
	asm volatile("wrussq %r31,0x123(%r31,%rax,4)");
2937

2938
	/* APX new data destination */
2939

2940
	asm volatile("adc $0x1234,%ax,%r30w");
2941
	asm volatile("adc %r15b,%r17b,%r18b");
2942
	asm volatile("adc %r15d,(%r8),%r18d");
2943
	asm volatile("adc (%r15,%rax,1),%r16b,%r8b");
2944
	asm volatile("adc (%r15,%rax,1),%r16w,%r8w");
2945
	asm volatile("adcl $0x11,(%r19,%rax,4),%r20d");
2946
	asm volatile("adcx %r15d,%r8d,%r18d");
2947
	asm volatile("adcx (%r15,%r31,1),%r8");
2948
	asm volatile("adcx (%r15,%r31,1),%r8d,%r18d");
2949
	asm volatile("add $0x1234,%ax,%r30w");
2950
	asm volatile("add $0x12344433,%r15,%r16");
2951
	asm volatile("add $0x34,%r13b,%r17b");
2952
	asm volatile("add $0xfffffffff4332211,%rax,%r8");
2953
	asm volatile("add %r31,%r8,%r16");
2954
	asm volatile("add %r31,(%r8),%r16");
2955
	asm volatile("add %r31,(%r8,%r16,8),%r16");
2956
	asm volatile("add %r31b,%r8b,%r16b");
2957
	asm volatile("add %r31d,%r8d,%r16d");
2958
	asm volatile("add %r31w,%r8w,%r16w");
2959
	asm volatile("add (%r31),%r8,%r16");
2960
	asm volatile("add 0x9090(%r31,%r16,1),%r8,%r16");
2961
	asm volatile("addb %r31b,%r8b,%r16b");
2962
	asm volatile("addl %r31d,%r8d,%r16d");
2963
	asm volatile("addl $0x11,(%r19,%rax,4),%r20d");
2964
	asm volatile("addq %r31,%r8,%r16");
2965
	asm volatile("addq $0x12344433,(%r15,%rcx,4),%r16");
2966
	asm volatile("addw %r31w,%r8w,%r16w");
2967
	asm volatile("adox %r15d,%r8d,%r18d");
2968
	asm volatile("{load} add %r31,%r8,%r16");
2969
	asm volatile("{store} add %r31,%r8,%r16");
2970
	asm volatile("adox (%r15,%r31,1),%r8");
2971
	asm volatile("adox (%r15,%r31,1),%r8d,%r18d");
2972
	asm volatile("and $0x1234,%ax,%r30w");
2973
	asm volatile("and %r15b,%r17b,%r18b");
2974
	asm volatile("and %r15d,(%r8),%r18d");
2975
	asm volatile("and (%r15,%rax,1),%r16b,%r8b");
2976
	asm volatile("and (%r15,%rax,1),%r16w,%r8w");
2977
	asm volatile("andl $0x11,(%r19,%rax,4),%r20d");
2978
	asm volatile("cmova 0x90909090(%eax),%edx,%r8d");
2979
	asm volatile("cmovae 0x90909090(%eax),%edx,%r8d");
2980
	asm volatile("cmovb 0x90909090(%eax),%edx,%r8d");
2981
	asm volatile("cmovbe 0x90909090(%eax),%edx,%r8d");
2982
	asm volatile("cmove 0x90909090(%eax),%edx,%r8d");
2983
	asm volatile("cmovg 0x90909090(%eax),%edx,%r8d");
2984
	asm volatile("cmovge 0x90909090(%eax),%edx,%r8d");
2985
	asm volatile("cmovl 0x90909090(%eax),%edx,%r8d");
2986
	asm volatile("cmovle 0x90909090(%eax),%edx,%r8d");
2987
	asm volatile("cmovne 0x90909090(%eax),%edx,%r8d");
2988
	asm volatile("cmovno 0x90909090(%eax),%edx,%r8d");
2989
	asm volatile("cmovnp 0x90909090(%eax),%edx,%r8d");
2990
	asm volatile("cmovns 0x90909090(%eax),%edx,%r8d");
2991
	asm volatile("cmovo 0x90909090(%eax),%edx,%r8d");
2992
	asm volatile("cmovp 0x90909090(%eax),%edx,%r8d");
2993
	asm volatile("cmovs 0x90909090(%eax),%edx,%r8d");
2994
	asm volatile("dec %rax,%r17");
2995
	asm volatile("decb (%r31,%r12,1),%r8b");
2996
	asm volatile("imul 0x909(%rax,%r31,8),%rdx,%r25");
2997
	asm volatile("imul 0x90909(%eax),%edx,%r8d");
2998
	asm volatile("inc %r31,%r16");
2999
	asm volatile("inc %r31,%r8");
3000
	asm volatile("inc %rax,%rbx");
3001
	asm volatile("neg %rax,%r17");
3002
	asm volatile("negb (%r31,%r12,1),%r8b");
3003
	asm volatile("not %rax,%r17");
3004
	asm volatile("notb (%r31,%r12,1),%r8b");
3005
	asm volatile("or $0x1234,%ax,%r30w");
3006
	asm volatile("or %r15b,%r17b,%r18b");
3007
	asm volatile("or %r15d,(%r8),%r18d");
3008
	asm volatile("or (%r15,%rax,1),%r16b,%r8b");
3009
	asm volatile("or (%r15,%rax,1),%r16w,%r8w");
3010
	asm volatile("orl $0x11,(%r19,%rax,4),%r20d");
3011
	asm volatile("rcl $0x2,%r12b,%r31b");
3012
	asm volatile("rcl %cl,%r16b,%r8b");
3013
	asm volatile("rclb $0x1,(%rax),%r31b");
3014
	asm volatile("rcll $0x2,(%rax),%r31d");
3015
	asm volatile("rclw $0x1,(%rax),%r31w");
3016
	asm volatile("rclw %cl,(%r19,%rax,4),%r31w");
3017
	asm volatile("rcr $0x2,%r12b,%r31b");
3018
	asm volatile("rcr %cl,%r16b,%r8b");
3019
	asm volatile("rcrb $0x1,(%rax),%r31b");
3020
	asm volatile("rcrl $0x2,(%rax),%r31d");
3021
	asm volatile("rcrw $0x1,(%rax),%r31w");
3022
	asm volatile("rcrw %cl,(%r19,%rax,4),%r31w");
3023
	asm volatile("rol $0x2,%r12b,%r31b");
3024
	asm volatile("rol %cl,%r16b,%r8b");
3025
	asm volatile("rolb $0x1,(%rax),%r31b");
3026
	asm volatile("roll $0x2,(%rax),%r31d");
3027
	asm volatile("rolw $0x1,(%rax),%r31w");
3028
	asm volatile("rolw %cl,(%r19,%rax,4),%r31w");
3029
	asm volatile("ror $0x2,%r12b,%r31b");
3030
	asm volatile("ror %cl,%r16b,%r8b");
3031
	asm volatile("rorb $0x1,(%rax),%r31b");
3032
	asm volatile("rorl $0x2,(%rax),%r31d");
3033
	asm volatile("rorw $0x1,(%rax),%r31w");
3034
	asm volatile("rorw %cl,(%r19,%rax,4),%r31w");
3035
	asm volatile("sar $0x2,%r12b,%r31b");
3036
	asm volatile("sar %cl,%r16b,%r8b");
3037
	asm volatile("sarb $0x1,(%rax),%r31b");
3038
	asm volatile("sarl $0x2,(%rax),%r31d");
3039
	asm volatile("sarw $0x1,(%rax),%r31w");
3040
	asm volatile("sarw %cl,(%r19,%rax,4),%r31w");
3041
	asm volatile("sbb $0x1234,%ax,%r30w");
3042
	asm volatile("sbb %r15b,%r17b,%r18b");
3043
	asm volatile("sbb %r15d,(%r8),%r18d");
3044
	asm volatile("sbb (%r15,%rax,1),%r16b,%r8b");
3045
	asm volatile("sbb (%r15,%rax,1),%r16w,%r8w");
3046
	asm volatile("sbbl $0x11,(%r19,%rax,4),%r20d");
3047
	asm volatile("shl $0x2,%r12b,%r31b");
3048
	asm volatile("shl $0x2,%r12b,%r31b");
3049
	asm volatile("shl %cl,%r16b,%r8b");
3050
	asm volatile("shl %cl,%r16b,%r8b");
3051
	asm volatile("shlb $0x1,(%rax),%r31b");
3052
	asm volatile("shlb $0x1,(%rax),%r31b");
3053
	asm volatile("shld $0x1,%r12,(%rax),%r31");
3054
	asm volatile("shld $0x2,%r15d,(%rax),%r31d");
3055
	asm volatile("shld $0x2,%r8w,%r12w,%r31w");
3056
	asm volatile("shld %cl,%r12,%r16,%r8");
3057
	asm volatile("shld %cl,%r13w,(%r19,%rax,4),%r31w");
3058
	asm volatile("shld %cl,%r9w,(%rax),%r31w");
3059
	asm volatile("shll $0x2,(%rax),%r31d");
3060
	asm volatile("shll $0x2,(%rax),%r31d");
3061
	asm volatile("shlw $0x1,(%rax),%r31w");
3062
	asm volatile("shlw $0x1,(%rax),%r31w");
3063
	asm volatile("shlw %cl,(%r19,%rax,4),%r31w");
3064
	asm volatile("shlw %cl,(%r19,%rax,4),%r31w");
3065
	asm volatile("shr $0x2,%r12b,%r31b");
3066
	asm volatile("shr %cl,%r16b,%r8b");
3067
	asm volatile("shrb $0x1,(%rax),%r31b");
3068
	asm volatile("shrd $0x1,%r12,(%rax),%r31");
3069
	asm volatile("shrd $0x2,%r15d,(%rax),%r31d");
3070
	asm volatile("shrd $0x2,%r8w,%r12w,%r31w");
3071
	asm volatile("shrd %cl,%r12,%r16,%r8");
3072
	asm volatile("shrd %cl,%r13w,(%r19,%rax,4),%r31w");
3073
	asm volatile("shrd %cl,%r9w,(%rax),%r31w");
3074
	asm volatile("shrl $0x2,(%rax),%r31d");
3075
	asm volatile("shrw $0x1,(%rax),%r31w");
3076
	asm volatile("shrw %cl,(%r19,%rax,4),%r31w");
3077
	asm volatile("sub $0x1234,%ax,%r30w");
3078
	asm volatile("sub %r15b,%r17b,%r18b");
3079
	asm volatile("sub %r15d,(%r8),%r18d");
3080
	asm volatile("sub (%r15,%rax,1),%r16b,%r8b");
3081
	asm volatile("sub (%r15,%rax,1),%r16w,%r8w");
3082
	asm volatile("subl $0x11,(%r19,%rax,4),%r20d");
3083
	asm volatile("xor $0x1234,%ax,%r30w");
3084
	asm volatile("xor %r15b,%r17b,%r18b");
3085
	asm volatile("xor %r15d,(%r8),%r18d");
3086
	asm volatile("xor (%r15,%rax,1),%r16b,%r8b");
3087
	asm volatile("xor (%r15,%rax,1),%r16w,%r8w");
3088
	asm volatile("xorl $0x11,(%r19,%rax,4),%r20d");
3089

3090
	/* APX suppress status flags */
3091

3092
	asm volatile("{nf} add %bl,%dl,%r8b");
3093
	asm volatile("{nf} add %dx,%ax,%r9w");
3094
	asm volatile("{nf} add 0x123(%r8,%rax,4),%bl,%dl");
3095
	asm volatile("{nf} add 0x123(%r8,%rax,4),%dx,%ax");
3096
	asm volatile("{nf} or %bl,%dl,%r8b");
3097
	asm volatile("{nf} or %dx,%ax,%r9w");
3098
	asm volatile("{nf} or 0x123(%r8,%rax,4),%bl,%dl");
3099
	asm volatile("{nf} or 0x123(%r8,%rax,4),%dx,%ax");
3100
	asm volatile("{nf} and %bl,%dl,%r8b");
3101
	asm volatile("{nf} and %dx,%ax,%r9w");
3102
	asm volatile("{nf} and 0x123(%r8,%rax,4),%bl,%dl");
3103
	asm volatile("{nf} and 0x123(%r8,%rax,4),%dx,%ax");
3104
	asm volatile("{nf} shld $0x7b,%dx,%ax,%r9w");
3105
	asm volatile("{nf} sub %bl,%dl,%r8b");
3106
	asm volatile("{nf} sub %dx,%ax,%r9w");
3107
	asm volatile("{nf} sub 0x123(%r8,%rax,4),%bl,%dl");
3108
	asm volatile("{nf} sub 0x123(%r8,%rax,4),%dx,%ax");
3109
	asm volatile("{nf} shrd $0x7b,%dx,%ax,%r9w");
3110
	asm volatile("{nf} xor %bl,%dl,%r8b");
3111
	asm volatile("{nf} xor %r31,%r31");
3112
	asm volatile("{nf} xor 0x123(%r8,%rax,4),%bl,%dl");
3113
	asm volatile("{nf} xor 0x123(%r8,%rax,4),%dx,%ax");
3114
	asm volatile("{nf} imul $0xff90,%r9,%r15");
3115
	asm volatile("{nf} imul $0x7b,%r9,%r15");
3116
	asm volatile("{nf} xor $0x7b,%bl,%dl");
3117
	asm volatile("{nf} xor $0x7b,%dx,%ax");
3118
	asm volatile("{nf} popcnt %r9,%r31");
3119
	asm volatile("{nf} shld %cl,%dx,%ax,%r9w");
3120
	asm volatile("{nf} shrd %cl,%dx,%ax,%r9w");
3121
	asm volatile("{nf} imul %r9,%r31,%r11");
3122
	asm volatile("{nf} sar $0x7b,%bl,%dl");
3123
	asm volatile("{nf} sar $0x7b,%dx,%ax");
3124
	asm volatile("{nf} sar $1,%bl,%dl");
3125
	asm volatile("{nf} sar $1,%dx,%ax");
3126
	asm volatile("{nf} sar %cl,%bl,%dl");
3127
	asm volatile("{nf} sar %cl,%dx,%ax");
3128
	asm volatile("{nf} andn %r9,%r31,%r11");
3129
	asm volatile("{nf} blsi %r9,%r31");
3130
	asm volatile("{nf} tzcnt %r9,%r31");
3131
	asm volatile("{nf} lzcnt %r9,%r31");
3132
	asm volatile("{nf} idiv %bl");
3133
	asm volatile("{nf} idiv %dx");
3134
	asm volatile("{nf} dec %bl,%dl");
3135
	asm volatile("{nf} dec %dx,%ax");
3136

3137
#else  /* #ifdef __x86_64__ */
3138

3139
	/* bound r32, mem (same op code as EVEX prefix) */
3140

3141
	asm volatile("bound %eax, 0x12345678(%ecx)");
3142
	asm volatile("bound %ecx, 0x12345678(%eax)");
3143
	asm volatile("bound %edx, 0x12345678(%eax)");
3144
	asm volatile("bound %ebx, 0x12345678(%eax)");
3145
	asm volatile("bound %esp, 0x12345678(%eax)");
3146
	asm volatile("bound %ebp, 0x12345678(%eax)");
3147
	asm volatile("bound %esi, 0x12345678(%eax)");
3148
	asm volatile("bound %edi, 0x12345678(%eax)");
3149
	asm volatile("bound %ecx, (%eax)");
3150
	asm volatile("bound %eax, (0x12345678)");
3151
	asm volatile("bound %edx, (%ecx,%eax,1)");
3152
	asm volatile("bound %edx, 0x12345678(,%eax,1)");
3153
	asm volatile("bound %edx, (%eax,%ecx,1)");
3154
	asm volatile("bound %edx, (%eax,%ecx,8)");
3155
	asm volatile("bound %edx, 0x12(%eax)");
3156
	asm volatile("bound %edx, 0x12(%ebp)");
3157
	asm volatile("bound %edx, 0x12(%ecx,%eax,1)");
3158
	asm volatile("bound %edx, 0x12(%ebp,%eax,1)");
3159
	asm volatile("bound %edx, 0x12(%eax,%ecx,1)");
3160
	asm volatile("bound %edx, 0x12(%eax,%ecx,8)");
3161
	asm volatile("bound %edx, 0x12345678(%eax)");
3162
	asm volatile("bound %edx, 0x12345678(%ebp)");
3163
	asm volatile("bound %edx, 0x12345678(%ecx,%eax,1)");
3164
	asm volatile("bound %edx, 0x12345678(%ebp,%eax,1)");
3165
	asm volatile("bound %edx, 0x12345678(%eax,%ecx,1)");
3166
	asm volatile("bound %edx, 0x12345678(%eax,%ecx,8)");
3167

3168
	/* bound r16, mem (same op code as EVEX prefix) */
3169

3170
	asm volatile("bound %ax, 0x12345678(%ecx)");
3171
	asm volatile("bound %cx, 0x12345678(%eax)");
3172
	asm volatile("bound %dx, 0x12345678(%eax)");
3173
	asm volatile("bound %bx, 0x12345678(%eax)");
3174
	asm volatile("bound %sp, 0x12345678(%eax)");
3175
	asm volatile("bound %bp, 0x12345678(%eax)");
3176
	asm volatile("bound %si, 0x12345678(%eax)");
3177
	asm volatile("bound %di, 0x12345678(%eax)");
3178
	asm volatile("bound %cx, (%eax)");
3179
	asm volatile("bound %ax, (0x12345678)");
3180
	asm volatile("bound %dx, (%ecx,%eax,1)");
3181
	asm volatile("bound %dx, 0x12345678(,%eax,1)");
3182
	asm volatile("bound %dx, (%eax,%ecx,1)");
3183
	asm volatile("bound %dx, (%eax,%ecx,8)");
3184
	asm volatile("bound %dx, 0x12(%eax)");
3185
	asm volatile("bound %dx, 0x12(%ebp)");
3186
	asm volatile("bound %dx, 0x12(%ecx,%eax,1)");
3187
	asm volatile("bound %dx, 0x12(%ebp,%eax,1)");
3188
	asm volatile("bound %dx, 0x12(%eax,%ecx,1)");
3189
	asm volatile("bound %dx, 0x12(%eax,%ecx,8)");
3190
	asm volatile("bound %dx, 0x12345678(%eax)");
3191
	asm volatile("bound %dx, 0x12345678(%ebp)");
3192
	asm volatile("bound %dx, 0x12345678(%ecx,%eax,1)");
3193
	asm volatile("bound %dx, 0x12345678(%ebp,%eax,1)");
3194
	asm volatile("bound %dx, 0x12345678(%eax,%ecx,1)");
3195
	asm volatile("bound %dx, 0x12345678(%eax,%ecx,8)");
3196

3197
	/* AVX-512: Instructions with the same op codes as Mask Instructions  */
3198

3199
	asm volatile("cmovno %eax,%ebx");
3200
	asm volatile("cmovno 0x12345678(%eax),%ecx");
3201
	asm volatile("cmovno 0x12345678(%eax),%cx");
3202

3203
	asm volatile("cmove  %eax,%ebx");
3204
	asm volatile("cmove 0x12345678(%eax),%ecx");
3205
	asm volatile("cmove 0x12345678(%eax),%cx");
3206

3207
	asm volatile("seto    0x12345678(%eax)");
3208
	asm volatile("setno   0x12345678(%eax)");
3209
	asm volatile("setb    0x12345678(%eax)");
3210
	asm volatile("setc    0x12345678(%eax)");
3211
	asm volatile("setnae  0x12345678(%eax)");
3212
	asm volatile("setae   0x12345678(%eax)");
3213
	asm volatile("setnb   0x12345678(%eax)");
3214
	asm volatile("setnc   0x12345678(%eax)");
3215
	asm volatile("sets    0x12345678(%eax)");
3216
	asm volatile("setns   0x12345678(%eax)");
3217

3218
	/* AVX-512: Mask Instructions */
3219

3220
	asm volatile("kandw  %k7,%k6,%k5");
3221
	asm volatile("kandq  %k7,%k6,%k5");
3222
	asm volatile("kandb  %k7,%k6,%k5");
3223
	asm volatile("kandd  %k7,%k6,%k5");
3224

3225
	asm volatile("kandnw  %k7,%k6,%k5");
3226
	asm volatile("kandnq  %k7,%k6,%k5");
3227
	asm volatile("kandnb  %k7,%k6,%k5");
3228
	asm volatile("kandnd  %k7,%k6,%k5");
3229

3230
	asm volatile("knotw  %k7,%k6");
3231
	asm volatile("knotq  %k7,%k6");
3232
	asm volatile("knotb  %k7,%k6");
3233
	asm volatile("knotd  %k7,%k6");
3234

3235
	asm volatile("korw  %k7,%k6,%k5");
3236
	asm volatile("korq  %k7,%k6,%k5");
3237
	asm volatile("korb  %k7,%k6,%k5");
3238
	asm volatile("kord  %k7,%k6,%k5");
3239

3240
	asm volatile("kxnorw  %k7,%k6,%k5");
3241
	asm volatile("kxnorq  %k7,%k6,%k5");
3242
	asm volatile("kxnorb  %k7,%k6,%k5");
3243
	asm volatile("kxnord  %k7,%k6,%k5");
3244

3245
	asm volatile("kxorw  %k7,%k6,%k5");
3246
	asm volatile("kxorq  %k7,%k6,%k5");
3247
	asm volatile("kxorb  %k7,%k6,%k5");
3248
	asm volatile("kxord  %k7,%k6,%k5");
3249

3250
	asm volatile("kaddw  %k7,%k6,%k5");
3251
	asm volatile("kaddq  %k7,%k6,%k5");
3252
	asm volatile("kaddb  %k7,%k6,%k5");
3253
	asm volatile("kaddd  %k7,%k6,%k5");
3254

3255
	asm volatile("kunpckbw %k7,%k6,%k5");
3256
	asm volatile("kunpckwd %k7,%k6,%k5");
3257
	asm volatile("kunpckdq %k7,%k6,%k5");
3258

3259
	asm volatile("kmovw  %k6,%k5");
3260
	asm volatile("kmovw  (%ecx),%k5");
3261
	asm volatile("kmovw  0x123(%eax,%ecx,8),%k5");
3262
	asm volatile("kmovw  %k5,(%ecx)");
3263
	asm volatile("kmovw  %k5,0x123(%eax,%ecx,8)");
3264
	asm volatile("kmovw  %eax,%k5");
3265
	asm volatile("kmovw  %ebp,%k5");
3266
	asm volatile("kmovw  %k5,%eax");
3267
	asm volatile("kmovw  %k5,%ebp");
3268

3269
	asm volatile("kmovq  %k6,%k5");
3270
	asm volatile("kmovq  (%ecx),%k5");
3271
	asm volatile("kmovq  0x123(%eax,%ecx,8),%k5");
3272
	asm volatile("kmovq  %k5,(%ecx)");
3273
	asm volatile("kmovq  %k5,0x123(%eax,%ecx,8)");
3274

3275
	asm volatile("kmovb  %k6,%k5");
3276
	asm volatile("kmovb  (%ecx),%k5");
3277
	asm volatile("kmovb  0x123(%eax,%ecx,8),%k5");
3278
	asm volatile("kmovb  %k5,(%ecx)");
3279
	asm volatile("kmovb  %k5,0x123(%eax,%ecx,8)");
3280
	asm volatile("kmovb  %eax,%k5");
3281
	asm volatile("kmovb  %ebp,%k5");
3282
	asm volatile("kmovb  %k5,%eax");
3283
	asm volatile("kmovb  %k5,%ebp");
3284

3285
	asm volatile("kmovd  %k6,%k5");
3286
	asm volatile("kmovd  (%ecx),%k5");
3287
	asm volatile("kmovd  0x123(%eax,%ecx,8),%k5");
3288
	asm volatile("kmovd  %k5,(%ecx)");
3289
	asm volatile("kmovd  %k5,0x123(%eax,%ecx,8)");
3290
	asm volatile("kmovd  %eax,%k5");
3291
	asm volatile("kmovd  %ebp,%k5");
3292
	asm volatile("kmovd  %k5,%eax");
3293
	asm volatile("kmovd  %k5,%ebp");
3294

3295
	asm volatile("kortestw %k6,%k5");
3296
	asm volatile("kortestq %k6,%k5");
3297
	asm volatile("kortestb %k6,%k5");
3298
	asm volatile("kortestd %k6,%k5");
3299

3300
	asm volatile("ktestw %k6,%k5");
3301
	asm volatile("ktestq %k6,%k5");
3302
	asm volatile("ktestb %k6,%k5");
3303
	asm volatile("ktestd %k6,%k5");
3304

3305
	asm volatile("kshiftrw $0x12,%k6,%k5");
3306
	asm volatile("kshiftrq $0x5b,%k6,%k5");
3307
	asm volatile("kshiftlw $0x12,%k6,%k5");
3308
	asm volatile("kshiftlq $0x5b,%k6,%k5");
3309

3310
	/* AVX-512: Op code 0f 5b */
3311
	asm volatile("vcvtdq2ps %xmm5,%xmm6");
3312
	asm volatile("vcvtqq2ps %zmm5,%ymm6{%k7}");
3313
	asm volatile("vcvtps2dq %xmm5,%xmm6");
3314
	asm volatile("vcvttps2dq %xmm5,%xmm6");
3315

3316
	/* AVX-512: Op code 0f 6f */
3317

3318
	asm volatile("movq   %mm0,%mm4");
3319
	asm volatile("vmovdqa %ymm4,%ymm6");
3320
	asm volatile("vmovdqa32 %zmm5,%zmm6");
3321
	asm volatile("vmovdqa64 %zmm5,%zmm6");
3322
	asm volatile("vmovdqu %ymm4,%ymm6");
3323
	asm volatile("vmovdqu32 %zmm5,%zmm6");
3324
	asm volatile("vmovdqu64 %zmm5,%zmm6");
3325
	asm volatile("vmovdqu8 %zmm5,%zmm6");
3326
	asm volatile("vmovdqu16 %zmm5,%zmm6");
3327

3328
	/* AVX-512: Op code 0f 78 */
3329

3330
	asm volatile("vmread %eax,%ebx");
3331
	asm volatile("vcvttps2udq %zmm5,%zmm6");
3332
	asm volatile("vcvttpd2udq %zmm5,%ymm6{%k7}");
3333
	asm volatile("vcvttsd2usi %xmm6,%eax");
3334
	asm volatile("vcvttss2usi %xmm6,%eax");
3335
	asm volatile("vcvttps2uqq %ymm5,%zmm6{%k7}");
3336
	asm volatile("vcvttpd2uqq %zmm5,%zmm6");
3337

3338
	/* AVX-512: Op code 0f 79 */
3339

3340
	asm volatile("vmwrite %eax,%ebx");
3341
	asm volatile("vcvtps2udq %zmm5,%zmm6");
3342
	asm volatile("vcvtpd2udq %zmm5,%ymm6{%k7}");
3343
	asm volatile("vcvtsd2usi %xmm6,%eax");
3344
	asm volatile("vcvtss2usi %xmm6,%eax");
3345
	asm volatile("vcvtps2uqq %ymm5,%zmm6{%k7}");
3346
	asm volatile("vcvtpd2uqq %zmm5,%zmm6");
3347

3348
	/* AVX-512: Op code 0f 7a */
3349

3350
	asm volatile("vcvtudq2pd %ymm5,%zmm6{%k7}");
3351
	asm volatile("vcvtuqq2pd %zmm5,%zmm6");
3352
	asm volatile("vcvtudq2ps %zmm5,%zmm6");
3353
	asm volatile("vcvtuqq2ps %zmm5,%ymm6{%k7}");
3354
	asm volatile("vcvttps2qq %ymm5,%zmm6{%k7}");
3355
	asm volatile("vcvttpd2qq %zmm5,%zmm6");
3356

3357
	/* AVX-512: Op code 0f 7b */
3358

3359
	asm volatile("vcvtusi2sd %eax,%xmm5,%xmm6");
3360
	asm volatile("vcvtusi2ss %eax,%xmm5,%xmm6");
3361
	asm volatile("vcvtps2qq %ymm5,%zmm6{%k7}");
3362
	asm volatile("vcvtpd2qq %zmm5,%zmm6");
3363

3364
	/* AVX-512: Op code 0f 7f */
3365

3366
	asm volatile("movq.s  %mm0,%mm4");
3367
	asm volatile("vmovdqa.s %ymm5,%ymm6");
3368
	asm volatile("vmovdqa32.s %zmm5,%zmm6");
3369
	asm volatile("vmovdqa64.s %zmm5,%zmm6");
3370
	asm volatile("vmovdqu.s %ymm5,%ymm6");
3371
	asm volatile("vmovdqu32.s %zmm5,%zmm6");
3372
	asm volatile("vmovdqu64.s %zmm5,%zmm6");
3373
	asm volatile("vmovdqu8.s %zmm5,%zmm6");
3374
	asm volatile("vmovdqu16.s %zmm5,%zmm6");
3375

3376
	/* AVX-512: Op code 0f db */
3377

3378
	asm volatile("pand  %mm1,%mm2");
3379
	asm volatile("pand  %xmm1,%xmm2");
3380
	asm volatile("vpand  %ymm4,%ymm6,%ymm2");
3381
	asm volatile("vpandd %zmm4,%zmm5,%zmm6");
3382
	asm volatile("vpandq %zmm4,%zmm5,%zmm6");
3383

3384
	/* AVX-512: Op code 0f df */
3385

3386
	asm volatile("pandn  %mm1,%mm2");
3387
	asm volatile("pandn  %xmm1,%xmm2");
3388
	asm volatile("vpandn %ymm4,%ymm6,%ymm2");
3389
	asm volatile("vpandnd %zmm4,%zmm5,%zmm6");
3390
	asm volatile("vpandnq %zmm4,%zmm5,%zmm6");
3391

3392
	/* AVX-512: Op code 0f e6 */
3393

3394
	asm volatile("vcvttpd2dq %xmm1,%xmm2");
3395
	asm volatile("vcvtdq2pd %xmm5,%xmm6");
3396
	asm volatile("vcvtdq2pd %ymm5,%zmm6{%k7}");
3397
	asm volatile("vcvtqq2pd %zmm5,%zmm6");
3398
	asm volatile("vcvtpd2dq %xmm1,%xmm2");
3399

3400
	/* AVX-512: Op code 0f eb */
3401

3402
	asm volatile("por   %mm4,%mm6");
3403
	asm volatile("vpor   %ymm4,%ymm6,%ymm2");
3404
	asm volatile("vpord  %zmm4,%zmm5,%zmm6");
3405
	asm volatile("vporq  %zmm4,%zmm5,%zmm6");
3406

3407
	/* AVX-512: Op code 0f ef */
3408

3409
	asm volatile("pxor   %mm4,%mm6");
3410
	asm volatile("vpxor  %ymm4,%ymm6,%ymm2");
3411
	asm volatile("vpxord %zmm4,%zmm5,%zmm6");
3412
	asm volatile("vpxorq %zmm4,%zmm5,%zmm6");
3413

3414
	/* AVX-512: Op code 0f 38 10 */
3415

3416
	asm volatile("pblendvb %xmm1,%xmm0");
3417
	asm volatile("vpsrlvw %zmm4,%zmm5,%zmm6");
3418
	asm volatile("vpmovuswb %zmm5,%ymm6{%k7}");
3419

3420
	/* AVX-512: Op code 0f 38 11 */
3421

3422
	asm volatile("vpmovusdb %zmm5,%xmm6{%k7}");
3423
	asm volatile("vpsravw %zmm4,%zmm5,%zmm6");
3424

3425
	/* AVX-512: Op code 0f 38 12 */
3426

3427
	asm volatile("vpmovusqb %zmm5,%xmm6{%k7}");
3428
	asm volatile("vpsllvw %zmm4,%zmm5,%zmm6");
3429

3430
	/* AVX-512: Op code 0f 38 13 */
3431

3432
	asm volatile("vcvtph2ps %xmm3,%ymm5");
3433
	asm volatile("vcvtph2ps %ymm5,%zmm6{%k7}");
3434
	asm volatile("vpmovusdw %zmm5,%ymm6{%k7}");
3435

3436
	/* AVX-512: Op code 0f 38 14 */
3437

3438
	asm volatile("blendvps %xmm1,%xmm0");
3439
	asm volatile("vpmovusqw %zmm5,%xmm6{%k7}");
3440
	asm volatile("vprorvd %zmm4,%zmm5,%zmm6");
3441
	asm volatile("vprorvq %zmm4,%zmm5,%zmm6");
3442

3443
	/* AVX-512: Op code 0f 38 15 */
3444

3445
	asm volatile("blendvpd %xmm1,%xmm0");
3446
	asm volatile("vpmovusqd %zmm5,%ymm6{%k7}");
3447
	asm volatile("vprolvd %zmm4,%zmm5,%zmm6");
3448
	asm volatile("vprolvq %zmm4,%zmm5,%zmm6");
3449

3450
	/* AVX-512: Op code 0f 38 16 */
3451

3452
	asm volatile("vpermps %ymm4,%ymm6,%ymm2");
3453
	asm volatile("vpermps %ymm4,%ymm6,%ymm2{%k7}");
3454
	asm volatile("vpermpd %ymm4,%ymm6,%ymm2{%k7}");
3455

3456
	/* AVX-512: Op code 0f 38 19 */
3457

3458
	asm volatile("vbroadcastsd %xmm4,%ymm6");
3459
	asm volatile("vbroadcastf32x2 %xmm7,%zmm6");
3460

3461
	/* AVX-512: Op code 0f 38 1a */
3462

3463
	asm volatile("vbroadcastf128 (%ecx),%ymm4");
3464
	asm volatile("vbroadcastf32x4 (%ecx),%zmm6");
3465
	asm volatile("vbroadcastf64x2 (%ecx),%zmm6");
3466

3467
	/* AVX-512: Op code 0f 38 1b */
3468

3469
	asm volatile("vbroadcastf32x8 (%ecx),%zmm6");
3470
	asm volatile("vbroadcastf64x4 (%ecx),%zmm6");
3471

3472
	/* AVX-512: Op code 0f 38 1f */
3473

3474
	asm volatile("vpabsq %zmm4,%zmm6");
3475

3476
	/* AVX-512: Op code 0f 38 20 */
3477

3478
	asm volatile("vpmovsxbw %xmm4,%xmm5");
3479
	asm volatile("vpmovswb %zmm5,%ymm6{%k7}");
3480

3481
	/* AVX-512: Op code 0f 38 21 */
3482

3483
	asm volatile("vpmovsxbd %xmm4,%ymm6");
3484
	asm volatile("vpmovsdb %zmm5,%xmm6{%k7}");
3485

3486
	/* AVX-512: Op code 0f 38 22 */
3487

3488
	asm volatile("vpmovsxbq %xmm4,%ymm4");
3489
	asm volatile("vpmovsqb %zmm5,%xmm6{%k7}");
3490

3491
	/* AVX-512: Op code 0f 38 23 */
3492

3493
	asm volatile("vpmovsxwd %xmm4,%ymm4");
3494
	asm volatile("vpmovsdw %zmm5,%ymm6{%k7}");
3495

3496
	/* AVX-512: Op code 0f 38 24 */
3497

3498
	asm volatile("vpmovsxwq %xmm4,%ymm6");
3499
	asm volatile("vpmovsqw %zmm5,%xmm6{%k7}");
3500

3501
	/* AVX-512: Op code 0f 38 25 */
3502

3503
	asm volatile("vpmovsxdq %xmm4,%ymm4");
3504
	asm volatile("vpmovsqd %zmm5,%ymm6{%k7}");
3505

3506
	/* AVX-512: Op code 0f 38 26 */
3507

3508
	asm volatile("vptestmb %zmm5,%zmm6,%k5");
3509
	asm volatile("vptestmw %zmm5,%zmm6,%k5");
3510
	asm volatile("vptestnmb %zmm4,%zmm5,%k5");
3511
	asm volatile("vptestnmw %zmm4,%zmm5,%k5");
3512

3513
	/* AVX-512: Op code 0f 38 27 */
3514

3515
	asm volatile("vptestmd %zmm5,%zmm6,%k5");
3516
	asm volatile("vptestmq %zmm5,%zmm6,%k5");
3517
	asm volatile("vptestnmd %zmm4,%zmm5,%k5");
3518
	asm volatile("vptestnmq %zmm4,%zmm5,%k5");
3519

3520
	/* AVX-512: Op code 0f 38 28 */
3521

3522
	asm volatile("vpmuldq %ymm4,%ymm6,%ymm2");
3523
	asm volatile("vpmovm2b %k5,%zmm6");
3524
	asm volatile("vpmovm2w %k5,%zmm6");
3525

3526
	/* AVX-512: Op code 0f 38 29 */
3527

3528
	asm volatile("vpcmpeqq %ymm4,%ymm6,%ymm2");
3529
	asm volatile("vpmovb2m %zmm6,%k5");
3530
	asm volatile("vpmovw2m %zmm6,%k5");
3531

3532
	/* AVX-512: Op code 0f 38 2a */
3533

3534
	asm volatile("vmovntdqa (%ecx),%ymm4");
3535
	asm volatile("vpbroadcastmb2q %k6,%zmm1");
3536

3537
	/* AVX-512: Op code 0f 38 2c */
3538

3539
	asm volatile("vmaskmovps (%ecx),%ymm4,%ymm6");
3540
	asm volatile("vscalefps %zmm4,%zmm5,%zmm6");
3541
	asm volatile("vscalefpd %zmm4,%zmm5,%zmm6");
3542

3543
	/* AVX-512: Op code 0f 38 2d */
3544

3545
	asm volatile("vmaskmovpd (%ecx),%ymm4,%ymm6");
3546
	asm volatile("vscalefss %xmm4,%xmm5,%xmm6{%k7}");
3547
	asm volatile("vscalefsd %xmm4,%xmm5,%xmm6{%k7}");
3548

3549
	/* AVX-512: Op code 0f 38 30 */
3550

3551
	asm volatile("vpmovzxbw %xmm4,%ymm4");
3552
	asm volatile("vpmovwb %zmm5,%ymm6{%k7}");
3553

3554
	/* AVX-512: Op code 0f 38 31 */
3555

3556
	asm volatile("vpmovzxbd %xmm4,%ymm6");
3557
	asm volatile("vpmovdb %zmm5,%xmm6{%k7}");
3558

3559
	/* AVX-512: Op code 0f 38 32 */
3560

3561
	asm volatile("vpmovzxbq %xmm4,%ymm4");
3562
	asm volatile("vpmovqb %zmm5,%xmm6{%k7}");
3563

3564
	/* AVX-512: Op code 0f 38 33 */
3565

3566
	asm volatile("vpmovzxwd %xmm4,%ymm4");
3567
	asm volatile("vpmovdw %zmm5,%ymm6{%k7}");
3568

3569
	/* AVX-512: Op code 0f 38 34 */
3570

3571
	asm volatile("vpmovzxwq %xmm4,%ymm6");
3572
	asm volatile("vpmovqw %zmm5,%xmm6{%k7}");
3573

3574
	/* AVX-512: Op code 0f 38 35 */
3575

3576
	asm volatile("vpmovzxdq %xmm4,%ymm4");
3577
	asm volatile("vpmovqd %zmm5,%ymm6{%k7}");
3578

3579
	/* AVX-512: Op code 0f 38 36 */
3580

3581
	asm volatile("vpermd %ymm4,%ymm6,%ymm2");
3582
	asm volatile("vpermd %ymm4,%ymm6,%ymm2{%k7}");
3583
	asm volatile("vpermq %ymm4,%ymm6,%ymm2{%k7}");
3584

3585
	/* AVX-512: Op code 0f 38 38 */
3586

3587
	asm volatile("vpminsb %ymm4,%ymm6,%ymm2");
3588
	asm volatile("vpmovm2d %k5,%zmm6");
3589
	asm volatile("vpmovm2q %k5,%zmm6");
3590

3591
	/* AVX-512: Op code 0f 38 39 */
3592

3593
	asm volatile("vpminsd %xmm1,%xmm2,%xmm3");
3594
	asm volatile("vpminsd %zmm4,%zmm5,%zmm6");
3595
	asm volatile("vpminsq %zmm4,%zmm5,%zmm6");
3596
	asm volatile("vpmovd2m %zmm6,%k5");
3597
	asm volatile("vpmovq2m %zmm6,%k5");
3598

3599
	/* AVX-512: Op code 0f 38 3a */
3600

3601
	asm volatile("vpminuw %ymm4,%ymm6,%ymm2");
3602
	asm volatile("vpbroadcastmw2d %k6,%zmm6");
3603

3604
	/* AVX-512: Op code 0f 38 3b */
3605

3606
	asm volatile("vpminud %ymm4,%ymm6,%ymm2");
3607
	asm volatile("vpminud %zmm4,%zmm5,%zmm6");
3608
	asm volatile("vpminuq %zmm4,%zmm5,%zmm6");
3609

3610
	/* AVX-512: Op code 0f 38 3d */
3611

3612
	asm volatile("vpmaxsd %ymm4,%ymm6,%ymm2");
3613
	asm volatile("vpmaxsd %zmm4,%zmm5,%zmm6");
3614
	asm volatile("vpmaxsq %zmm4,%zmm5,%zmm6");
3615

3616
	/* AVX-512: Op code 0f 38 3f */
3617

3618
	asm volatile("vpmaxud %ymm4,%ymm6,%ymm2");
3619
	asm volatile("vpmaxud %zmm4,%zmm5,%zmm6");
3620
	asm volatile("vpmaxuq %zmm4,%zmm5,%zmm6");
3621

3622
	/* AVX-512: Op code 0f 38 40 */
3623

3624
	asm volatile("vpmulld %ymm4,%ymm6,%ymm2");
3625
	asm volatile("vpmulld %zmm4,%zmm5,%zmm6");
3626
	asm volatile("vpmullq %zmm4,%zmm5,%zmm6");
3627

3628
	/* AVX-512: Op code 0f 38 42 */
3629

3630
	asm volatile("vgetexpps %zmm5,%zmm6");
3631
	asm volatile("vgetexppd %zmm5,%zmm6");
3632

3633
	/* AVX-512: Op code 0f 38 43 */
3634

3635
	asm volatile("vgetexpss %xmm4,%xmm5,%xmm6{%k7}");
3636
	asm volatile("vgetexpsd %xmm2,%xmm3,%xmm4{%k7}");
3637

3638
	/* AVX-512: Op code 0f 38 44 */
3639

3640
	asm volatile("vplzcntd %zmm5,%zmm6");
3641
	asm volatile("vplzcntq %zmm5,%zmm6");
3642

3643
	/* AVX-512: Op code 0f 38 46 */
3644

3645
	asm volatile("vpsravd %ymm4,%ymm6,%ymm2");
3646
	asm volatile("vpsravd %zmm4,%zmm5,%zmm6");
3647
	asm volatile("vpsravq %zmm4,%zmm5,%zmm6");
3648

3649
	/* AVX-512: Op code 0f 38 4c */
3650

3651
	asm volatile("vrcp14ps %zmm5,%zmm6");
3652
	asm volatile("vrcp14pd %zmm5,%zmm6");
3653

3654
	/* AVX-512: Op code 0f 38 4d */
3655

3656
	asm volatile("vrcp14ss %xmm4,%xmm5,%xmm6{%k7}");
3657
	asm volatile("vrcp14sd %xmm4,%xmm5,%xmm6{%k7}");
3658

3659
	/* AVX-512: Op code 0f 38 4e */
3660

3661
	asm volatile("vrsqrt14ps %zmm5,%zmm6");
3662
	asm volatile("vrsqrt14pd %zmm5,%zmm6");
3663

3664
	/* AVX-512: Op code 0f 38 4f */
3665

3666
	asm volatile("vrsqrt14ss %xmm4,%xmm5,%xmm6{%k7}");
3667
	asm volatile("vrsqrt14sd %xmm4,%xmm5,%xmm6{%k7}");
3668

3669
	/* AVX-512: Op code 0f 38 50 */
3670

3671
	asm volatile("vpdpbusd %xmm1, %xmm2, %xmm3");
3672
	asm volatile("vpdpbusd %ymm1, %ymm2, %ymm3");
3673
	asm volatile("vpdpbusd %zmm1, %zmm2, %zmm3");
3674
	asm volatile("vpdpbusd 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3675

3676
	/* AVX-512: Op code 0f 38 51 */
3677

3678
	asm volatile("vpdpbusds %xmm1, %xmm2, %xmm3");
3679
	asm volatile("vpdpbusds %ymm1, %ymm2, %ymm3");
3680
	asm volatile("vpdpbusds %zmm1, %zmm2, %zmm3");
3681
	asm volatile("vpdpbusds 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3682

3683
	/* AVX-512: Op code 0f 38 52 */
3684

3685
	asm volatile("vdpbf16ps %xmm1, %xmm2, %xmm3");
3686
	asm volatile("vdpbf16ps %ymm1, %ymm2, %ymm3");
3687
	asm volatile("vdpbf16ps %zmm1, %zmm2, %zmm3");
3688
	asm volatile("vdpbf16ps 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3689

3690
	asm volatile("vpdpwssd %xmm1, %xmm2, %xmm3");
3691
	asm volatile("vpdpwssd %ymm1, %ymm2, %ymm3");
3692
	asm volatile("vpdpwssd %zmm1, %zmm2, %zmm3");
3693
	asm volatile("vpdpwssd 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3694

3695
	asm volatile("vp4dpwssd (%eax), %zmm0, %zmm4");
3696
	asm volatile("vp4dpwssd 0x12345678(%eax,%ecx,8),%zmm0,%zmm4");
3697

3698
	/* AVX-512: Op code 0f 38 53 */
3699

3700
	asm volatile("vpdpwssds %xmm1, %xmm2, %xmm3");
3701
	asm volatile("vpdpwssds %ymm1, %ymm2, %ymm3");
3702
	asm volatile("vpdpwssds %zmm1, %zmm2, %zmm3");
3703
	asm volatile("vpdpwssds 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3704

3705
	asm volatile("vp4dpwssds (%eax), %zmm0, %zmm4");
3706
	asm volatile("vp4dpwssds 0x12345678(%eax,%ecx,8),%zmm0,%zmm4");
3707

3708
	/* AVX-512: Op code 0f 38 54 */
3709

3710
	asm volatile("vpopcntb %xmm1, %xmm2");
3711
	asm volatile("vpopcntb %ymm1, %ymm2");
3712
	asm volatile("vpopcntb %zmm1, %zmm2");
3713
	asm volatile("vpopcntb 0x12345678(%eax,%ecx,8),%zmm2");
3714

3715
	asm volatile("vpopcntw %xmm1, %xmm2");
3716
	asm volatile("vpopcntw %ymm1, %ymm2");
3717
	asm volatile("vpopcntw %zmm1, %zmm2");
3718
	asm volatile("vpopcntw 0x12345678(%eax,%ecx,8),%zmm2");
3719

3720
	/* AVX-512: Op code 0f 38 55 */
3721

3722
	asm volatile("vpopcntd %xmm1, %xmm2");
3723
	asm volatile("vpopcntd %ymm1, %ymm2");
3724
	asm volatile("vpopcntd %zmm1, %zmm2");
3725
	asm volatile("vpopcntd 0x12345678(%eax,%ecx,8),%zmm2");
3726

3727
	asm volatile("vpopcntq %xmm1, %xmm2");
3728
	asm volatile("vpopcntq %ymm1, %ymm2");
3729
	asm volatile("vpopcntq %zmm1, %zmm2");
3730
	asm volatile("vpopcntq 0x12345678(%eax,%ecx,8),%zmm2");
3731

3732
	/* AVX-512: Op code 0f 38 59 */
3733

3734
	asm volatile("vpbroadcastq %xmm4,%xmm6");
3735
	asm volatile("vbroadcasti32x2 %xmm7,%zmm6");
3736

3737
	/* AVX-512: Op code 0f 38 5a */
3738

3739
	asm volatile("vbroadcasti128 (%ecx),%ymm4");
3740
	asm volatile("vbroadcasti32x4 (%ecx),%zmm6");
3741
	asm volatile("vbroadcasti64x2 (%ecx),%zmm6");
3742

3743
	/* AVX-512: Op code 0f 38 5b */
3744

3745
	asm volatile("vbroadcasti32x8 (%ecx),%zmm6");
3746
	asm volatile("vbroadcasti64x4 (%ecx),%zmm6");
3747

3748
	/* AVX-512: Op code 0f 38 62 */
3749

3750
	asm volatile("vpexpandb %xmm1, %xmm2");
3751
	asm volatile("vpexpandb %ymm1, %ymm2");
3752
	asm volatile("vpexpandb %zmm1, %zmm2");
3753
	asm volatile("vpexpandb 0x12345678(%eax,%ecx,8),%zmm2");
3754

3755
	asm volatile("vpexpandw %xmm1, %xmm2");
3756
	asm volatile("vpexpandw %ymm1, %ymm2");
3757
	asm volatile("vpexpandw %zmm1, %zmm2");
3758
	asm volatile("vpexpandw 0x12345678(%eax,%ecx,8),%zmm2");
3759

3760
	/* AVX-512: Op code 0f 38 63 */
3761

3762
	asm volatile("vpcompressb %xmm1, %xmm2");
3763
	asm volatile("vpcompressb %ymm1, %ymm2");
3764
	asm volatile("vpcompressb %zmm1, %zmm2");
3765
	asm volatile("vpcompressb %zmm2,0x12345678(%eax,%ecx,8)");
3766

3767
	asm volatile("vpcompressw %xmm1, %xmm2");
3768
	asm volatile("vpcompressw %ymm1, %ymm2");
3769
	asm volatile("vpcompressw %zmm1, %zmm2");
3770
	asm volatile("vpcompressw %zmm2,0x12345678(%eax,%ecx,8)");
3771

3772
	/* AVX-512: Op code 0f 38 64 */
3773

3774
	asm volatile("vpblendmd %zmm4,%zmm5,%zmm6");
3775
	asm volatile("vpblendmq %zmm4,%zmm5,%zmm6");
3776

3777
	/* AVX-512: Op code 0f 38 65 */
3778

3779
	asm volatile("vblendmps %zmm4,%zmm5,%zmm6");
3780
	asm volatile("vblendmpd %zmm4,%zmm5,%zmm6");
3781

3782
	/* AVX-512: Op code 0f 38 66 */
3783

3784
	asm volatile("vpblendmb %zmm4,%zmm5,%zmm6");
3785
	asm volatile("vpblendmw %zmm4,%zmm5,%zmm6");
3786

3787
	/* AVX-512: Op code 0f 38 68 */
3788

3789
	asm volatile("vp2intersectd %xmm1, %xmm2, %k3");
3790
	asm volatile("vp2intersectd %ymm1, %ymm2, %k3");
3791
	asm volatile("vp2intersectd %zmm1, %zmm2, %k3");
3792
	asm volatile("vp2intersectd 0x12345678(%eax,%ecx,8),%zmm2,%k3");
3793

3794
	asm volatile("vp2intersectq %xmm1, %xmm2, %k3");
3795
	asm volatile("vp2intersectq %ymm1, %ymm2, %k3");
3796
	asm volatile("vp2intersectq %zmm1, %zmm2, %k3");
3797
	asm volatile("vp2intersectq 0x12345678(%eax,%ecx,8),%zmm2,%k3");
3798

3799
	/* AVX-512: Op code 0f 38 70 */
3800

3801
	asm volatile("vpshldvw %xmm1, %xmm2, %xmm3");
3802
	asm volatile("vpshldvw %ymm1, %ymm2, %ymm3");
3803
	asm volatile("vpshldvw %zmm1, %zmm2, %zmm3");
3804
	asm volatile("vpshldvw 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3805

3806
	/* AVX-512: Op code 0f 38 71 */
3807

3808
	asm volatile("vpshldvd %xmm1, %xmm2, %xmm3");
3809
	asm volatile("vpshldvd %ymm1, %ymm2, %ymm3");
3810
	asm volatile("vpshldvd %zmm1, %zmm2, %zmm3");
3811
	asm volatile("vpshldvd 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3812

3813
	asm volatile("vpshldvq %xmm1, %xmm2, %xmm3");
3814
	asm volatile("vpshldvq %ymm1, %ymm2, %ymm3");
3815
	asm volatile("vpshldvq %zmm1, %zmm2, %zmm3");
3816
	asm volatile("vpshldvq 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3817

3818
	/* AVX-512: Op code 0f 38 72 */
3819

3820
	asm volatile("vcvtne2ps2bf16 %xmm1, %xmm2, %xmm3");
3821
	asm volatile("vcvtne2ps2bf16 %ymm1, %ymm2, %ymm3");
3822
	asm volatile("vcvtne2ps2bf16 %zmm1, %zmm2, %zmm3");
3823
	asm volatile("vcvtne2ps2bf16 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3824

3825
	asm volatile("vcvtneps2bf16 %xmm1, %xmm2");
3826
	asm volatile("vcvtneps2bf16 %ymm1, %xmm2");
3827
	asm volatile("vcvtneps2bf16 %zmm1, %ymm2");
3828
	asm volatile("vcvtneps2bf16 0x12345678(%eax,%ecx,8),%ymm2");
3829

3830
	asm volatile("vpshrdvw %xmm1, %xmm2, %xmm3");
3831
	asm volatile("vpshrdvw %ymm1, %ymm2, %ymm3");
3832
	asm volatile("vpshrdvw %zmm1, %zmm2, %zmm3");
3833
	asm volatile("vpshrdvw 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3834

3835
	/* AVX-512: Op code 0f 38 73 */
3836

3837
	asm volatile("vpshrdvd %xmm1, %xmm2, %xmm3");
3838
	asm volatile("vpshrdvd %ymm1, %ymm2, %ymm3");
3839
	asm volatile("vpshrdvd %zmm1, %zmm2, %zmm3");
3840
	asm volatile("vpshrdvd 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3841

3842
	asm volatile("vpshrdvq %xmm1, %xmm2, %xmm3");
3843
	asm volatile("vpshrdvq %ymm1, %ymm2, %ymm3");
3844
	asm volatile("vpshrdvq %zmm1, %zmm2, %zmm3");
3845
	asm volatile("vpshrdvq 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3846

3847
	/* AVX-512: Op code 0f 38 75 */
3848

3849
	asm volatile("vpermi2b %zmm4,%zmm5,%zmm6");
3850
	asm volatile("vpermi2w %zmm4,%zmm5,%zmm6");
3851

3852
	/* AVX-512: Op code 0f 38 76 */
3853

3854
	asm volatile("vpermi2d %zmm4,%zmm5,%zmm6");
3855
	asm volatile("vpermi2q %zmm4,%zmm5,%zmm6");
3856

3857
	/* AVX-512: Op code 0f 38 77 */
3858

3859
	asm volatile("vpermi2ps %zmm4,%zmm5,%zmm6");
3860
	asm volatile("vpermi2pd %zmm4,%zmm5,%zmm6");
3861

3862
	/* AVX-512: Op code 0f 38 7a */
3863

3864
	asm volatile("vpbroadcastb %eax,%xmm3");
3865

3866
	/* AVX-512: Op code 0f 38 7b */
3867

3868
	asm volatile("vpbroadcastw %eax,%xmm3");
3869

3870
	/* AVX-512: Op code 0f 38 7c */
3871

3872
	asm volatile("vpbroadcastd %eax,%xmm3");
3873

3874
	/* AVX-512: Op code 0f 38 7d */
3875

3876
	asm volatile("vpermt2b %zmm4,%zmm5,%zmm6");
3877
	asm volatile("vpermt2w %zmm4,%zmm5,%zmm6");
3878

3879
	/* AVX-512: Op code 0f 38 7e */
3880

3881
	asm volatile("vpermt2d %zmm4,%zmm5,%zmm6");
3882
	asm volatile("vpermt2q %zmm4,%zmm5,%zmm6");
3883

3884
	/* AVX-512: Op code 0f 38 7f */
3885

3886
	asm volatile("vpermt2ps %zmm4,%zmm5,%zmm6");
3887
	asm volatile("vpermt2pd %zmm4,%zmm5,%zmm6");
3888

3889
	/* AVX-512: Op code 0f 38 83 */
3890

3891
	asm volatile("vpmultishiftqb %zmm4,%zmm5,%zmm6");
3892

3893
	/* AVX-512: Op code 0f 38 88 */
3894

3895
	asm volatile("vexpandps (%ecx),%zmm6");
3896
	asm volatile("vexpandpd (%ecx),%zmm6");
3897

3898
	/* AVX-512: Op code 0f 38 89 */
3899

3900
	asm volatile("vpexpandd (%ecx),%zmm6");
3901
	asm volatile("vpexpandq (%ecx),%zmm6");
3902

3903
	/* AVX-512: Op code 0f 38 8a */
3904

3905
	asm volatile("vcompressps %zmm6,(%ecx)");
3906
	asm volatile("vcompresspd %zmm6,(%ecx)");
3907

3908
	/* AVX-512: Op code 0f 38 8b */
3909

3910
	asm volatile("vpcompressd %zmm6,(%ecx)");
3911
	asm volatile("vpcompressq %zmm6,(%ecx)");
3912

3913
	/* AVX-512: Op code 0f 38 8d */
3914

3915
	asm volatile("vpermb %zmm4,%zmm5,%zmm6");
3916
	asm volatile("vpermw %zmm4,%zmm5,%zmm6");
3917

3918
	/* AVX-512: Op code 0f 38 8f */
3919

3920
	asm volatile("vpshufbitqmb %xmm1, %xmm2, %k3");
3921
	asm volatile("vpshufbitqmb %ymm1, %ymm2, %k3");
3922
	asm volatile("vpshufbitqmb %zmm1, %zmm2, %k3");
3923
	asm volatile("vpshufbitqmb 0x12345678(%eax,%ecx,8),%zmm2,%k3");
3924

3925
	/* AVX-512: Op code 0f 38 90 */
3926

3927
	asm volatile("vpgatherdd %xmm2,0x02(%ebp,%xmm7,2),%xmm1");
3928
	asm volatile("vpgatherdq %xmm2,0x04(%ebp,%xmm7,2),%xmm1");
3929
	asm volatile("vpgatherdd 0x7b(%ebp,%zmm7,8),%zmm6{%k1}");
3930
	asm volatile("vpgatherdq 0x7b(%ebp,%ymm7,8),%zmm6{%k1}");
3931

3932
	/* AVX-512: Op code 0f 38 91 */
3933

3934
	asm volatile("vpgatherqd %xmm2,0x02(%ebp,%xmm7,2),%xmm1");
3935
	asm volatile("vpgatherqq %xmm2,0x02(%ebp,%xmm7,2),%xmm1");
3936
	asm volatile("vpgatherqd 0x7b(%ebp,%zmm7,8),%ymm6{%k1}");
3937
	asm volatile("vpgatherqq 0x7b(%ebp,%zmm7,8),%zmm6{%k1}");
3938

3939
	/* AVX-512: Op code 0f 38 9a */
3940

3941
	asm volatile("vfmsub132ps %xmm1, %xmm2, %xmm3");
3942
	asm volatile("vfmsub132ps %ymm1, %ymm2, %ymm3");
3943
	asm volatile("vfmsub132ps %zmm1, %zmm2, %zmm3");
3944
	asm volatile("vfmsub132ps 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3945

3946
	asm volatile("vfmsub132pd %xmm1, %xmm2, %xmm3");
3947
	asm volatile("vfmsub132pd %ymm1, %ymm2, %ymm3");
3948
	asm volatile("vfmsub132pd %zmm1, %zmm2, %zmm3");
3949
	asm volatile("vfmsub132pd 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3950

3951
	asm volatile("v4fmaddps (%eax), %zmm0, %zmm4");
3952
	asm volatile("v4fmaddps 0x12345678(%eax,%ecx,8),%zmm0,%zmm4");
3953

3954
	/* AVX-512: Op code 0f 38 9b */
3955

3956
	asm volatile("vfmsub132ss %xmm1, %xmm2, %xmm3");
3957
	asm volatile("vfmsub132ss 0x12345678(%eax,%ecx,8),%xmm2,%xmm3");
3958

3959
	asm volatile("vfmsub132sd %xmm1, %xmm2, %xmm3");
3960
	asm volatile("vfmsub132sd 0x12345678(%eax,%ecx,8),%xmm2,%xmm3");
3961

3962
	asm volatile("v4fmaddss (%eax), %xmm0, %xmm4");
3963
	asm volatile("v4fmaddss 0x12345678(%eax,%ecx,8),%xmm0,%xmm4");
3964

3965
	/* AVX-512: Op code 0f 38 a0 */
3966

3967
	asm volatile("vpscatterdd %zmm6,0x7b(%ebp,%zmm7,8){%k1}");
3968
	asm volatile("vpscatterdq %zmm6,0x7b(%ebp,%ymm7,8){%k1}");
3969

3970
	/* AVX-512: Op code 0f 38 a1 */
3971

3972
	asm volatile("vpscatterqd %ymm6,0x7b(%ebp,%zmm7,8){%k1}");
3973
	asm volatile("vpscatterqq %ymm6,0x7b(%ebp,%ymm7,8){%k1}");
3974

3975
	/* AVX-512: Op code 0f 38 a2 */
3976

3977
	asm volatile("vscatterdps %zmm6,0x7b(%ebp,%zmm7,8){%k1}");
3978
	asm volatile("vscatterdpd %zmm6,0x7b(%ebp,%ymm7,8){%k1}");
3979

3980
	/* AVX-512: Op code 0f 38 a3 */
3981

3982
	asm volatile("vscatterqps %ymm6,0x7b(%ebp,%zmm7,8){%k1}");
3983
	asm volatile("vscatterqpd %zmm6,0x7b(%ebp,%zmm7,8){%k1}");
3984

3985
	/* AVX-512: Op code 0f 38 aa */
3986

3987
	asm volatile("vfmsub213ps %xmm1, %xmm2, %xmm3");
3988
	asm volatile("vfmsub213ps %ymm1, %ymm2, %ymm3");
3989
	asm volatile("vfmsub213ps %zmm1, %zmm2, %zmm3");
3990
	asm volatile("vfmsub213ps 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3991

3992
	asm volatile("vfmsub213pd %xmm1, %xmm2, %xmm3");
3993
	asm volatile("vfmsub213pd %ymm1, %ymm2, %ymm3");
3994
	asm volatile("vfmsub213pd %zmm1, %zmm2, %zmm3");
3995
	asm volatile("vfmsub213pd 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
3996

3997
	asm volatile("v4fnmaddps (%eax), %zmm0, %zmm4");
3998
	asm volatile("v4fnmaddps 0x12345678(%eax,%ecx,8),%zmm0,%zmm4");
3999

4000
	/* AVX-512: Op code 0f 38 ab */
4001

4002
	asm volatile("vfmsub213ss %xmm1, %xmm2, %xmm3");
4003
	asm volatile("vfmsub213ss 0x12345678(%eax,%ecx,8),%xmm2,%xmm3");
4004

4005
	asm volatile("vfmsub213sd %xmm1, %xmm2, %xmm3");
4006
	asm volatile("vfmsub213sd 0x12345678(%eax,%ecx,8),%xmm2,%xmm3");
4007

4008
	asm volatile("v4fnmaddss (%eax), %xmm0, %xmm4");
4009
	asm volatile("v4fnmaddss 0x12345678(%eax,%ecx,8),%xmm0,%xmm4");
4010

4011
	/* AVX-512: Op code 0f 38 b4 */
4012

4013
	asm volatile("vpmadd52luq %zmm4,%zmm5,%zmm6");
4014

4015
	/* AVX-512: Op code 0f 38 b5 */
4016

4017
	asm volatile("vpmadd52huq %zmm4,%zmm5,%zmm6");
4018

4019
	/* AVX-512: Op code 0f 38 c4 */
4020

4021
	asm volatile("vpconflictd %zmm5,%zmm6");
4022
	asm volatile("vpconflictq %zmm5,%zmm6");
4023

4024
	/* AVX-512: Op code 0f 38 c8 */
4025

4026
	asm volatile("vexp2ps %zmm6,%zmm7");
4027
	asm volatile("vexp2pd %zmm6,%zmm7");
4028

4029
	/* AVX-512: Op code 0f 38 ca */
4030

4031
	asm volatile("vrcp28ps %zmm6,%zmm7");
4032
	asm volatile("vrcp28pd %zmm6,%zmm7");
4033

4034
	/* AVX-512: Op code 0f 38 cb */
4035

4036
	asm volatile("vrcp28ss %xmm5,%xmm6,%xmm7{%k7}");
4037
	asm volatile("vrcp28sd %xmm5,%xmm6,%xmm7{%k7}");
4038

4039
	/* AVX-512: Op code 0f 38 cc */
4040

4041
	asm volatile("vrsqrt28ps %zmm6,%zmm7");
4042
	asm volatile("vrsqrt28pd %zmm6,%zmm7");
4043

4044
	/* AVX-512: Op code 0f 38 cd */
4045

4046
	asm volatile("vrsqrt28ss %xmm5,%xmm6,%xmm7{%k7}");
4047
	asm volatile("vrsqrt28sd %xmm5,%xmm6,%xmm7{%k7}");
4048

4049
	/* AVX-512: Op code 0f 38 cf */
4050

4051
	asm volatile("gf2p8mulb %xmm1, %xmm3");
4052
	asm volatile("gf2p8mulb 0x12345678(%eax,%ecx,8),%xmm3");
4053

4054
	asm volatile("vgf2p8mulb %xmm1, %xmm2, %xmm3");
4055
	asm volatile("vgf2p8mulb %ymm1, %ymm2, %ymm3");
4056
	asm volatile("vgf2p8mulb %zmm1, %zmm2, %zmm3");
4057
	asm volatile("vgf2p8mulb 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
4058

4059
	/* AVX-512: Op code 0f 38 dc */
4060

4061
	asm volatile("vaesenc %xmm1, %xmm2, %xmm3");
4062
	asm volatile("vaesenc %ymm1, %ymm2, %ymm3");
4063
	asm volatile("vaesenc %zmm1, %zmm2, %zmm3");
4064
	asm volatile("vaesenc 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
4065

4066
	/* AVX-512: Op code 0f 38 dd */
4067

4068
	asm volatile("vaesenclast %xmm1, %xmm2, %xmm3");
4069
	asm volatile("vaesenclast %ymm1, %ymm2, %ymm3");
4070
	asm volatile("vaesenclast %zmm1, %zmm2, %zmm3");
4071
	asm volatile("vaesenclast 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
4072

4073
	/* AVX-512: Op code 0f 38 de */
4074

4075
	asm volatile("vaesdec %xmm1, %xmm2, %xmm3");
4076
	asm volatile("vaesdec %ymm1, %ymm2, %ymm3");
4077
	asm volatile("vaesdec %zmm1, %zmm2, %zmm3");
4078
	asm volatile("vaesdec 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
4079

4080
	/* AVX-512: Op code 0f 38 df */
4081

4082
	asm volatile("vaesdeclast %xmm1, %xmm2, %xmm3");
4083
	asm volatile("vaesdeclast %ymm1, %ymm2, %ymm3");
4084
	asm volatile("vaesdeclast %zmm1, %zmm2, %zmm3");
4085
	asm volatile("vaesdeclast 0x12345678(%eax,%ecx,8),%zmm2,%zmm3");
4086

4087
	/* AVX-512: Op code 0f 3a 03 */
4088

4089
	asm volatile("valignd $0x12,%zmm5,%zmm6,%zmm7");
4090
	asm volatile("valignq $0x12,%zmm5,%zmm6,%zmm7");
4091

4092
	/* AVX-512: Op code 0f 3a 08 */
4093

4094
	asm volatile("vroundps $0x5,%ymm6,%ymm2");
4095
	asm volatile("vrndscaleps $0x12,%zmm5,%zmm6");
4096

4097
	/* AVX-512: Op code 0f 3a 09 */
4098

4099
	asm volatile("vroundpd $0x5,%ymm6,%ymm2");
4100
	asm volatile("vrndscalepd $0x12,%zmm5,%zmm6");
4101

4102
	/* AVX-512: Op code 0f 3a 0a */
4103

4104
	asm volatile("vroundss $0x5,%xmm4,%xmm6,%xmm2");
4105
	asm volatile("vrndscaless $0x12,%xmm4,%xmm5,%xmm6{%k7}");
4106

4107
	/* AVX-512: Op code 0f 3a 0b */
4108

4109
	asm volatile("vroundsd $0x5,%xmm4,%xmm6,%xmm2");
4110
	asm volatile("vrndscalesd $0x12,%xmm4,%xmm5,%xmm6{%k7}");
4111

4112
	/* AVX-512: Op code 0f 3a 18 */
4113

4114
	asm volatile("vinsertf128 $0x5,%xmm4,%ymm4,%ymm6");
4115
	asm volatile("vinsertf32x4 $0x12,%xmm4,%zmm5,%zmm6{%k7}");
4116
	asm volatile("vinsertf64x2 $0x12,%xmm4,%zmm5,%zmm6{%k7}");
4117

4118
	/* AVX-512: Op code 0f 3a 19 */
4119

4120
	asm volatile("vextractf128 $0x5,%ymm4,%xmm4");
4121
	asm volatile("vextractf32x4 $0x12,%zmm5,%xmm6{%k7}");
4122
	asm volatile("vextractf64x2 $0x12,%zmm5,%xmm6{%k7}");
4123

4124
	/* AVX-512: Op code 0f 3a 1a */
4125

4126
	asm volatile("vinsertf32x8 $0x12,%ymm5,%zmm6,%zmm7{%k7}");
4127
	asm volatile("vinsertf64x4 $0x12,%ymm5,%zmm6,%zmm7{%k7}");
4128

4129
	/* AVX-512: Op code 0f 3a 1b */
4130

4131
	asm volatile("vextractf32x8 $0x12,%zmm6,%ymm7{%k7}");
4132
	asm volatile("vextractf64x4 $0x12,%zmm6,%ymm7{%k7}");
4133

4134
	/* AVX-512: Op code 0f 3a 1e */
4135

4136
	asm volatile("vpcmpud $0x12,%zmm6,%zmm7,%k5");
4137
	asm volatile("vpcmpuq $0x12,%zmm6,%zmm7,%k5");
4138

4139
	/* AVX-512: Op code 0f 3a 1f */
4140

4141
	asm volatile("vpcmpd $0x12,%zmm6,%zmm7,%k5");
4142
	asm volatile("vpcmpq $0x12,%zmm6,%zmm7,%k5");
4143

4144
	/* AVX-512: Op code 0f 3a 23 */
4145

4146
	asm volatile("vshuff32x4 $0x12,%zmm5,%zmm6,%zmm7");
4147
	asm volatile("vshuff64x2 $0x12,%zmm5,%zmm6,%zmm7");
4148

4149
	/* AVX-512: Op code 0f 3a 25 */
4150

4151
	asm volatile("vpternlogd $0x12,%zmm5,%zmm6,%zmm7");
4152
	asm volatile("vpternlogq $0x12,%zmm5,%zmm6,%zmm7");
4153

4154
	/* AVX-512: Op code 0f 3a 26 */
4155

4156
	asm volatile("vgetmantps $0x12,%zmm6,%zmm7");
4157
	asm volatile("vgetmantpd $0x12,%zmm6,%zmm7");
4158

4159
	/* AVX-512: Op code 0f 3a 27 */
4160

4161
	asm volatile("vgetmantss $0x12,%xmm5,%xmm6,%xmm7{%k7}");
4162
	asm volatile("vgetmantsd $0x12,%xmm5,%xmm6,%xmm7{%k7}");
4163

4164
	/* AVX-512: Op code 0f 3a 38 */
4165

4166
	asm volatile("vinserti128 $0x5,%xmm4,%ymm4,%ymm6");
4167
	asm volatile("vinserti32x4 $0x12,%xmm4,%zmm5,%zmm6{%k7}");
4168
	asm volatile("vinserti64x2 $0x12,%xmm4,%zmm5,%zmm6{%k7}");
4169

4170
	/* AVX-512: Op code 0f 3a 39 */
4171

4172
	asm volatile("vextracti128 $0x5,%ymm4,%xmm6");
4173
	asm volatile("vextracti32x4 $0x12,%zmm5,%xmm6{%k7}");
4174
	asm volatile("vextracti64x2 $0x12,%zmm5,%xmm6{%k7}");
4175

4176
	/* AVX-512: Op code 0f 3a 3a */
4177

4178
	asm volatile("vinserti32x8 $0x12,%ymm5,%zmm6,%zmm7{%k7}");
4179
	asm volatile("vinserti64x4 $0x12,%ymm5,%zmm6,%zmm7{%k7}");
4180

4181
	/* AVX-512: Op code 0f 3a 3b */
4182

4183
	asm volatile("vextracti32x8 $0x12,%zmm6,%ymm7{%k7}");
4184
	asm volatile("vextracti64x4 $0x12,%zmm6,%ymm7{%k7}");
4185

4186
	/* AVX-512: Op code 0f 3a 3e */
4187

4188
	asm volatile("vpcmpub $0x12,%zmm6,%zmm7,%k5");
4189
	asm volatile("vpcmpuw $0x12,%zmm6,%zmm7,%k5");
4190

4191
	/* AVX-512: Op code 0f 3a 3f */
4192

4193
	asm volatile("vpcmpb $0x12,%zmm6,%zmm7,%k5");
4194
	asm volatile("vpcmpw $0x12,%zmm6,%zmm7,%k5");
4195

4196
	/* AVX-512: Op code 0f 3a 42 */
4197

4198
	asm volatile("vmpsadbw $0x5,%ymm4,%ymm6,%ymm2");
4199
	asm volatile("vdbpsadbw $0x12,%zmm4,%zmm5,%zmm6");
4200

4201
	/* AVX-512: Op code 0f 3a 43 */
4202

4203
	asm volatile("vshufi32x4 $0x12,%zmm5,%zmm6,%zmm7");
4204
	asm volatile("vshufi64x2 $0x12,%zmm5,%zmm6,%zmm7");
4205

4206
	/* AVX-512: Op code 0f 3a 44 */
4207

4208
	asm volatile("vpclmulqdq $0x12,%xmm1,%xmm2,%xmm3");
4209
	asm volatile("vpclmulqdq $0x12,%ymm1,%ymm2,%ymm3");
4210
	asm volatile("vpclmulqdq $0x12,%zmm1,%zmm2,%zmm3");
4211

4212
	/* AVX-512: Op code 0f 3a 50 */
4213

4214
	asm volatile("vrangeps $0x12,%zmm5,%zmm6,%zmm7");
4215
	asm volatile("vrangepd $0x12,%zmm5,%zmm6,%zmm7");
4216

4217
	/* AVX-512: Op code 0f 3a 51 */
4218

4219
	asm volatile("vrangess $0x12,%xmm5,%xmm6,%xmm7");
4220
	asm volatile("vrangesd $0x12,%xmm5,%xmm6,%xmm7");
4221

4222
	/* AVX-512: Op code 0f 3a 54 */
4223

4224
	asm volatile("vfixupimmps $0x12,%zmm5,%zmm6,%zmm7");
4225
	asm volatile("vfixupimmpd $0x12,%zmm5,%zmm6,%zmm7");
4226

4227
	/* AVX-512: Op code 0f 3a 55 */
4228

4229
	asm volatile("vfixupimmss $0x12,%xmm5,%xmm6,%xmm7{%k7}");
4230
	asm volatile("vfixupimmsd $0x12,%xmm5,%xmm6,%xmm7{%k7}");
4231

4232
	/* AVX-512: Op code 0f 3a 56 */
4233

4234
	asm volatile("vreduceps $0x12,%zmm6,%zmm7");
4235
	asm volatile("vreducepd $0x12,%zmm6,%zmm7");
4236

4237
	/* AVX-512: Op code 0f 3a 57 */
4238

4239
	asm volatile("vreducess $0x12,%xmm5,%xmm6,%xmm7");
4240
	asm volatile("vreducesd $0x12,%xmm5,%xmm6,%xmm7");
4241

4242
	/* AVX-512: Op code 0f 3a 66 */
4243

4244
	asm volatile("vfpclassps $0x12,%zmm7,%k5");
4245
	asm volatile("vfpclasspd $0x12,%zmm7,%k5");
4246

4247
	/* AVX-512: Op code 0f 3a 67 */
4248

4249
	asm volatile("vfpclassss $0x12,%xmm7,%k5");
4250
	asm volatile("vfpclasssd $0x12,%xmm7,%k5");
4251

4252
	/* AVX-512: Op code 0f 3a 70 */
4253

4254
	asm volatile("vpshldw $0x12,%xmm1,%xmm2,%xmm3");
4255
	asm volatile("vpshldw $0x12,%ymm1,%ymm2,%ymm3");
4256
	asm volatile("vpshldw $0x12,%zmm1,%zmm2,%zmm3");
4257

4258
	/* AVX-512: Op code 0f 3a 71 */
4259

4260
	asm volatile("vpshldd $0x12,%xmm1,%xmm2,%xmm3");
4261
	asm volatile("vpshldd $0x12,%ymm1,%ymm2,%ymm3");
4262
	asm volatile("vpshldd $0x12,%zmm1,%zmm2,%zmm3");
4263

4264
	asm volatile("vpshldq $0x12,%xmm1,%xmm2,%xmm3");
4265
	asm volatile("vpshldq $0x12,%ymm1,%ymm2,%ymm3");
4266
	asm volatile("vpshldq $0x12,%zmm1,%zmm2,%zmm3");
4267

4268
	/* AVX-512: Op code 0f 3a 72 */
4269

4270
	asm volatile("vpshrdw $0x12,%xmm1,%xmm2,%xmm3");
4271
	asm volatile("vpshrdw $0x12,%ymm1,%ymm2,%ymm3");
4272
	asm volatile("vpshrdw $0x12,%zmm1,%zmm2,%zmm3");
4273

4274
	/* AVX-512: Op code 0f 3a 73 */
4275

4276
	asm volatile("vpshrdd $0x12,%xmm1,%xmm2,%xmm3");
4277
	asm volatile("vpshrdd $0x12,%ymm1,%ymm2,%ymm3");
4278
	asm volatile("vpshrdd $0x12,%zmm1,%zmm2,%zmm3");
4279

4280
	asm volatile("vpshrdq $0x12,%xmm1,%xmm2,%xmm3");
4281
	asm volatile("vpshrdq $0x12,%ymm1,%ymm2,%ymm3");
4282
	asm volatile("vpshrdq $0x12,%zmm1,%zmm2,%zmm3");
4283

4284
	/* AVX-512: Op code 0f 3a ce */
4285

4286
	asm volatile("gf2p8affineqb $0x12,%xmm1,%xmm3");
4287

4288
	asm volatile("vgf2p8affineqb $0x12,%xmm1,%xmm2,%xmm3");
4289
	asm volatile("vgf2p8affineqb $0x12,%ymm1,%ymm2,%ymm3");
4290
	asm volatile("vgf2p8affineqb $0x12,%zmm1,%zmm2,%zmm3");
4291

4292
	/* AVX-512: Op code 0f 3a cf */
4293

4294
	asm volatile("gf2p8affineinvqb $0x12,%xmm1,%xmm3");
4295

4296
	asm volatile("vgf2p8affineinvqb $0x12,%xmm1,%xmm2,%xmm3");
4297
	asm volatile("vgf2p8affineinvqb $0x12,%ymm1,%ymm2,%ymm3");
4298
	asm volatile("vgf2p8affineinvqb $0x12,%zmm1,%zmm2,%zmm3");
4299

4300
	/* AVX-512: Op code 0f 72 (Grp13) */
4301

4302
	asm volatile("vprord $0x12,%zmm5,%zmm6");
4303
	asm volatile("vprorq $0x12,%zmm5,%zmm6");
4304
	asm volatile("vprold $0x12,%zmm5,%zmm6");
4305
	asm volatile("vprolq $0x12,%zmm5,%zmm6");
4306
	asm volatile("psrad  $0x2,%mm6");
4307
	asm volatile("vpsrad $0x5,%ymm6,%ymm2");
4308
	asm volatile("vpsrad $0x5,%zmm6,%zmm2");
4309
	asm volatile("vpsraq $0x5,%zmm6,%zmm2");
4310

4311
	/* AVX-512: Op code 0f 38 c6 (Grp18) */
4312

4313
	asm volatile("vgatherpf0dps 0x7b(%ebp,%zmm7,8){%k1}");
4314
	asm volatile("vgatherpf0dpd 0x7b(%ebp,%ymm7,8){%k1}");
4315
	asm volatile("vgatherpf1dps 0x7b(%ebp,%zmm7,8){%k1}");
4316
	asm volatile("vgatherpf1dpd 0x7b(%ebp,%ymm7,8){%k1}");
4317
	asm volatile("vscatterpf0dps 0x7b(%ebp,%zmm7,8){%k1}");
4318
	asm volatile("vscatterpf0dpd 0x7b(%ebp,%ymm7,8){%k1}");
4319
	asm volatile("vscatterpf1dps 0x7b(%ebp,%zmm7,8){%k1}");
4320
	asm volatile("vscatterpf1dpd 0x7b(%ebp,%ymm7,8){%k1}");
4321

4322
	/* AVX-512: Op code 0f 38 c7 (Grp19) */
4323

4324
	asm volatile("vgatherpf0qps 0x7b(%ebp,%zmm7,8){%k1}");
4325
	asm volatile("vgatherpf0qpd 0x7b(%ebp,%zmm7,8){%k1}");
4326
	asm volatile("vgatherpf1qps 0x7b(%ebp,%zmm7,8){%k1}");
4327
	asm volatile("vgatherpf1qpd 0x7b(%ebp,%zmm7,8){%k1}");
4328
	asm volatile("vscatterpf0qps 0x7b(%ebp,%zmm7,8){%k1}");
4329
	asm volatile("vscatterpf0qpd 0x7b(%ebp,%zmm7,8){%k1}");
4330
	asm volatile("vscatterpf1qps 0x7b(%ebp,%zmm7,8){%k1}");
4331
	asm volatile("vscatterpf1qpd 0x7b(%ebp,%zmm7,8){%k1}");
4332

4333
	/* AVX-512: Examples */
4334

4335
	asm volatile("vaddpd %zmm4,%zmm5,%zmm6");
4336
	asm volatile("vaddpd %zmm4,%zmm5,%zmm6{%k7}");
4337
	asm volatile("vaddpd %zmm4,%zmm5,%zmm6{%k7}{z}");
4338
	asm volatile("vaddpd {rn-sae},%zmm4,%zmm5,%zmm6");
4339
	asm volatile("vaddpd {ru-sae},%zmm4,%zmm5,%zmm6");
4340
	asm volatile("vaddpd {rd-sae},%zmm4,%zmm5,%zmm6");
4341
	asm volatile("vaddpd {rz-sae},%zmm4,%zmm5,%zmm6");
4342
	asm volatile("vaddpd (%ecx),%zmm5,%zmm6");
4343
	asm volatile("vaddpd 0x123(%eax,%ecx,8),%zmm5,%zmm6");
4344
	asm volatile("vaddpd (%ecx){1to8},%zmm5,%zmm6");
4345
	asm volatile("vaddpd 0x1fc0(%edx),%zmm5,%zmm6");
4346
	asm volatile("vaddpd 0x3f8(%edx){1to8},%zmm5,%zmm6");
4347
	asm volatile("vcmpeq_uqps 0x1fc(%edx){1to16},%zmm6,%k5");
4348
	asm volatile("vcmpltsd 0x123(%eax,%ecx,8),%xmm3,%k5{%k7}");
4349
	asm volatile("vcmplesd {sae},%xmm4,%xmm5,%k5{%k7}");
4350
	asm volatile("vgetmantss $0x5b,0x123(%eax,%ecx,8),%xmm4,%xmm5{%k7}");
4351

4352
	/* bndmk m32, bnd */
4353

4354
	asm volatile("bndmk (%eax), %bnd0");
4355
	asm volatile("bndmk (0x12345678), %bnd0");
4356
	asm volatile("bndmk (%eax), %bnd3");
4357
	asm volatile("bndmk (%ecx,%eax,1), %bnd0");
4358
	asm volatile("bndmk 0x12345678(,%eax,1), %bnd0");
4359
	asm volatile("bndmk (%eax,%ecx,1), %bnd0");
4360
	asm volatile("bndmk (%eax,%ecx,8), %bnd0");
4361
	asm volatile("bndmk 0x12(%eax), %bnd0");
4362
	asm volatile("bndmk 0x12(%ebp), %bnd0");
4363
	asm volatile("bndmk 0x12(%ecx,%eax,1), %bnd0");
4364
	asm volatile("bndmk 0x12(%ebp,%eax,1), %bnd0");
4365
	asm volatile("bndmk 0x12(%eax,%ecx,1), %bnd0");
4366
	asm volatile("bndmk 0x12(%eax,%ecx,8), %bnd0");
4367
	asm volatile("bndmk 0x12345678(%eax), %bnd0");
4368
	asm volatile("bndmk 0x12345678(%ebp), %bnd0");
4369
	asm volatile("bndmk 0x12345678(%ecx,%eax,1), %bnd0");
4370
	asm volatile("bndmk 0x12345678(%ebp,%eax,1), %bnd0");
4371
	asm volatile("bndmk 0x12345678(%eax,%ecx,1), %bnd0");
4372
	asm volatile("bndmk 0x12345678(%eax,%ecx,8), %bnd0");
4373

4374
	/* bndcl r/m32, bnd */
4375

4376
	asm volatile("bndcl (%eax), %bnd0");
4377
	asm volatile("bndcl (0x12345678), %bnd0");
4378
	asm volatile("bndcl (%eax), %bnd3");
4379
	asm volatile("bndcl (%ecx,%eax,1), %bnd0");
4380
	asm volatile("bndcl 0x12345678(,%eax,1), %bnd0");
4381
	asm volatile("bndcl (%eax,%ecx,1), %bnd0");
4382
	asm volatile("bndcl (%eax,%ecx,8), %bnd0");
4383
	asm volatile("bndcl 0x12(%eax), %bnd0");
4384
	asm volatile("bndcl 0x12(%ebp), %bnd0");
4385
	asm volatile("bndcl 0x12(%ecx,%eax,1), %bnd0");
4386
	asm volatile("bndcl 0x12(%ebp,%eax,1), %bnd0");
4387
	asm volatile("bndcl 0x12(%eax,%ecx,1), %bnd0");
4388
	asm volatile("bndcl 0x12(%eax,%ecx,8), %bnd0");
4389
	asm volatile("bndcl 0x12345678(%eax), %bnd0");
4390
	asm volatile("bndcl 0x12345678(%ebp), %bnd0");
4391
	asm volatile("bndcl 0x12345678(%ecx,%eax,1), %bnd0");
4392
	asm volatile("bndcl 0x12345678(%ebp,%eax,1), %bnd0");
4393
	asm volatile("bndcl 0x12345678(%eax,%ecx,1), %bnd0");
4394
	asm volatile("bndcl 0x12345678(%eax,%ecx,8), %bnd0");
4395
	asm volatile("bndcl %eax, %bnd0");
4396

4397
	/* bndcu r/m32, bnd */
4398

4399
	asm volatile("bndcu (%eax), %bnd0");
4400
	asm volatile("bndcu (0x12345678), %bnd0");
4401
	asm volatile("bndcu (%eax), %bnd3");
4402
	asm volatile("bndcu (%ecx,%eax,1), %bnd0");
4403
	asm volatile("bndcu 0x12345678(,%eax,1), %bnd0");
4404
	asm volatile("bndcu (%eax,%ecx,1), %bnd0");
4405
	asm volatile("bndcu (%eax,%ecx,8), %bnd0");
4406
	asm volatile("bndcu 0x12(%eax), %bnd0");
4407
	asm volatile("bndcu 0x12(%ebp), %bnd0");
4408
	asm volatile("bndcu 0x12(%ecx,%eax,1), %bnd0");
4409
	asm volatile("bndcu 0x12(%ebp,%eax,1), %bnd0");
4410
	asm volatile("bndcu 0x12(%eax,%ecx,1), %bnd0");
4411
	asm volatile("bndcu 0x12(%eax,%ecx,8), %bnd0");
4412
	asm volatile("bndcu 0x12345678(%eax), %bnd0");
4413
	asm volatile("bndcu 0x12345678(%ebp), %bnd0");
4414
	asm volatile("bndcu 0x12345678(%ecx,%eax,1), %bnd0");
4415
	asm volatile("bndcu 0x12345678(%ebp,%eax,1), %bnd0");
4416
	asm volatile("bndcu 0x12345678(%eax,%ecx,1), %bnd0");
4417
	asm volatile("bndcu 0x12345678(%eax,%ecx,8), %bnd0");
4418
	asm volatile("bndcu %eax, %bnd0");
4419

4420
	/* bndcn r/m32, bnd */
4421

4422
	asm volatile("bndcn (%eax), %bnd0");
4423
	asm volatile("bndcn (0x12345678), %bnd0");
4424
	asm volatile("bndcn (%eax), %bnd3");
4425
	asm volatile("bndcn (%ecx,%eax,1), %bnd0");
4426
	asm volatile("bndcn 0x12345678(,%eax,1), %bnd0");
4427
	asm volatile("bndcn (%eax,%ecx,1), %bnd0");
4428
	asm volatile("bndcn (%eax,%ecx,8), %bnd0");
4429
	asm volatile("bndcn 0x12(%eax), %bnd0");
4430
	asm volatile("bndcn 0x12(%ebp), %bnd0");
4431
	asm volatile("bndcn 0x12(%ecx,%eax,1), %bnd0");
4432
	asm volatile("bndcn 0x12(%ebp,%eax,1), %bnd0");
4433
	asm volatile("bndcn 0x12(%eax,%ecx,1), %bnd0");
4434
	asm volatile("bndcn 0x12(%eax,%ecx,8), %bnd0");
4435
	asm volatile("bndcn 0x12345678(%eax), %bnd0");
4436
	asm volatile("bndcn 0x12345678(%ebp), %bnd0");
4437
	asm volatile("bndcn 0x12345678(%ecx,%eax,1), %bnd0");
4438
	asm volatile("bndcn 0x12345678(%ebp,%eax,1), %bnd0");
4439
	asm volatile("bndcn 0x12345678(%eax,%ecx,1), %bnd0");
4440
	asm volatile("bndcn 0x12345678(%eax,%ecx,8), %bnd0");
4441
	asm volatile("bndcn %eax, %bnd0");
4442

4443
	/* bndmov m64, bnd */
4444

4445
	asm volatile("bndmov (%eax), %bnd0");
4446
	asm volatile("bndmov (0x12345678), %bnd0");
4447
	asm volatile("bndmov (%eax), %bnd3");
4448
	asm volatile("bndmov (%ecx,%eax,1), %bnd0");
4449
	asm volatile("bndmov 0x12345678(,%eax,1), %bnd0");
4450
	asm volatile("bndmov (%eax,%ecx,1), %bnd0");
4451
	asm volatile("bndmov (%eax,%ecx,8), %bnd0");
4452
	asm volatile("bndmov 0x12(%eax), %bnd0");
4453
	asm volatile("bndmov 0x12(%ebp), %bnd0");
4454
	asm volatile("bndmov 0x12(%ecx,%eax,1), %bnd0");
4455
	asm volatile("bndmov 0x12(%ebp,%eax,1), %bnd0");
4456
	asm volatile("bndmov 0x12(%eax,%ecx,1), %bnd0");
4457
	asm volatile("bndmov 0x12(%eax,%ecx,8), %bnd0");
4458
	asm volatile("bndmov 0x12345678(%eax), %bnd0");
4459
	asm volatile("bndmov 0x12345678(%ebp), %bnd0");
4460
	asm volatile("bndmov 0x12345678(%ecx,%eax,1), %bnd0");
4461
	asm volatile("bndmov 0x12345678(%ebp,%eax,1), %bnd0");
4462
	asm volatile("bndmov 0x12345678(%eax,%ecx,1), %bnd0");
4463
	asm volatile("bndmov 0x12345678(%eax,%ecx,8), %bnd0");
4464

4465
	/* bndmov bnd, m64 */
4466

4467
	asm volatile("bndmov %bnd0, (%eax)");
4468
	asm volatile("bndmov %bnd0, (0x12345678)");
4469
	asm volatile("bndmov %bnd3, (%eax)");
4470
	asm volatile("bndmov %bnd0, (%ecx,%eax,1)");
4471
	asm volatile("bndmov %bnd0, 0x12345678(,%eax,1)");
4472
	asm volatile("bndmov %bnd0, (%eax,%ecx,1)");
4473
	asm volatile("bndmov %bnd0, (%eax,%ecx,8)");
4474
	asm volatile("bndmov %bnd0, 0x12(%eax)");
4475
	asm volatile("bndmov %bnd0, 0x12(%ebp)");
4476
	asm volatile("bndmov %bnd0, 0x12(%ecx,%eax,1)");
4477
	asm volatile("bndmov %bnd0, 0x12(%ebp,%eax,1)");
4478
	asm volatile("bndmov %bnd0, 0x12(%eax,%ecx,1)");
4479
	asm volatile("bndmov %bnd0, 0x12(%eax,%ecx,8)");
4480
	asm volatile("bndmov %bnd0, 0x12345678(%eax)");
4481
	asm volatile("bndmov %bnd0, 0x12345678(%ebp)");
4482
	asm volatile("bndmov %bnd0, 0x12345678(%ecx,%eax,1)");
4483
	asm volatile("bndmov %bnd0, 0x12345678(%ebp,%eax,1)");
4484
	asm volatile("bndmov %bnd0, 0x12345678(%eax,%ecx,1)");
4485
	asm volatile("bndmov %bnd0, 0x12345678(%eax,%ecx,8)");
4486

4487
	/* bndmov bnd2, bnd1 */
4488

4489
	asm volatile("bndmov %bnd0, %bnd1");
4490
	asm volatile("bndmov %bnd1, %bnd0");
4491

4492
	/* bndldx mib, bnd */
4493

4494
	asm volatile("bndldx (%eax), %bnd0");
4495
	asm volatile("bndldx (0x12345678), %bnd0");
4496
	asm volatile("bndldx (%eax), %bnd3");
4497
	asm volatile("bndldx (%ecx,%eax,1), %bnd0");
4498
	asm volatile("bndldx 0x12345678(,%eax,1), %bnd0");
4499
	asm volatile("bndldx (%eax,%ecx,1), %bnd0");
4500
	asm volatile("bndldx 0x12(%eax), %bnd0");
4501
	asm volatile("bndldx 0x12(%ebp), %bnd0");
4502
	asm volatile("bndldx 0x12(%ecx,%eax,1), %bnd0");
4503
	asm volatile("bndldx 0x12(%ebp,%eax,1), %bnd0");
4504
	asm volatile("bndldx 0x12(%eax,%ecx,1), %bnd0");
4505
	asm volatile("bndldx 0x12345678(%eax), %bnd0");
4506
	asm volatile("bndldx 0x12345678(%ebp), %bnd0");
4507
	asm volatile("bndldx 0x12345678(%ecx,%eax,1), %bnd0");
4508
	asm volatile("bndldx 0x12345678(%ebp,%eax,1), %bnd0");
4509
	asm volatile("bndldx 0x12345678(%eax,%ecx,1), %bnd0");
4510

4511
	/* bndstx bnd, mib */
4512

4513
	asm volatile("bndstx %bnd0, (%eax)");
4514
	asm volatile("bndstx %bnd0, (0x12345678)");
4515
	asm volatile("bndstx %bnd3, (%eax)");
4516
	asm volatile("bndstx %bnd0, (%ecx,%eax,1)");
4517
	asm volatile("bndstx %bnd0, 0x12345678(,%eax,1)");
4518
	asm volatile("bndstx %bnd0, (%eax,%ecx,1)");
4519
	asm volatile("bndstx %bnd0, 0x12(%eax)");
4520
	asm volatile("bndstx %bnd0, 0x12(%ebp)");
4521
	asm volatile("bndstx %bnd0, 0x12(%ecx,%eax,1)");
4522
	asm volatile("bndstx %bnd0, 0x12(%ebp,%eax,1)");
4523
	asm volatile("bndstx %bnd0, 0x12(%eax,%ecx,1)");
4524
	asm volatile("bndstx %bnd0, 0x12345678(%eax)");
4525
	asm volatile("bndstx %bnd0, 0x12345678(%ebp)");
4526
	asm volatile("bndstx %bnd0, 0x12345678(%ecx,%eax,1)");
4527
	asm volatile("bndstx %bnd0, 0x12345678(%ebp,%eax,1)");
4528
	asm volatile("bndstx %bnd0, 0x12345678(%eax,%ecx,1)");
4529

4530
	/* bnd prefix on call, ret, jmp and all jcc */
4531

4532
	asm volatile("bnd call label1");  /* Expecting: call unconditional 0xfffffffc */
4533
	asm volatile("bnd call *(%eax)"); /* Expecting: call indirect      0 */
4534
	asm volatile("bnd ret");          /* Expecting: ret  indirect      0 */
4535
	asm volatile("bnd jmp label1");   /* Expecting: jmp  unconditional 0xfffffffc */
4536
	asm volatile("bnd jmp label1");   /* Expecting: jmp  unconditional 0xfffffffc */
4537
	asm volatile("bnd jmp *(%ecx)");  /* Expecting: jmp  indirect      0 */
4538
	asm volatile("bnd jne label1");   /* Expecting: jcc  conditional   0xfffffffc */
4539

4540
	/* sha1rnds4 imm8, xmm2/m128, xmm1 */
4541

4542
	asm volatile("sha1rnds4 $0x0, %xmm1, %xmm0");
4543
	asm volatile("sha1rnds4 $0x91, %xmm7, %xmm2");
4544
	asm volatile("sha1rnds4 $0x91, (%eax), %xmm0");
4545
	asm volatile("sha1rnds4 $0x91, (0x12345678), %xmm0");
4546
	asm volatile("sha1rnds4 $0x91, (%eax), %xmm3");
4547
	asm volatile("sha1rnds4 $0x91, (%ecx,%eax,1), %xmm0");
4548
	asm volatile("sha1rnds4 $0x91, 0x12345678(,%eax,1), %xmm0");
4549
	asm volatile("sha1rnds4 $0x91, (%eax,%ecx,1), %xmm0");
4550
	asm volatile("sha1rnds4 $0x91, (%eax,%ecx,8), %xmm0");
4551
	asm volatile("sha1rnds4 $0x91, 0x12(%eax), %xmm0");
4552
	asm volatile("sha1rnds4 $0x91, 0x12(%ebp), %xmm0");
4553
	asm volatile("sha1rnds4 $0x91, 0x12(%ecx,%eax,1), %xmm0");
4554
	asm volatile("sha1rnds4 $0x91, 0x12(%ebp,%eax,1), %xmm0");
4555
	asm volatile("sha1rnds4 $0x91, 0x12(%eax,%ecx,1), %xmm0");
4556
	asm volatile("sha1rnds4 $0x91, 0x12(%eax,%ecx,8), %xmm0");
4557
	asm volatile("sha1rnds4 $0x91, 0x12345678(%eax), %xmm0");
4558
	asm volatile("sha1rnds4 $0x91, 0x12345678(%ebp), %xmm0");
4559
	asm volatile("sha1rnds4 $0x91, 0x12345678(%ecx,%eax,1), %xmm0");
4560
	asm volatile("sha1rnds4 $0x91, 0x12345678(%ebp,%eax,1), %xmm0");
4561
	asm volatile("sha1rnds4 $0x91, 0x12345678(%eax,%ecx,1), %xmm0");
4562
	asm volatile("sha1rnds4 $0x91, 0x12345678(%eax,%ecx,8), %xmm0");
4563

4564
	/* sha1nexte xmm2/m128, xmm1 */
4565

4566
	asm volatile("sha1nexte %xmm1, %xmm0");
4567
	asm volatile("sha1nexte %xmm7, %xmm2");
4568
	asm volatile("sha1nexte (%eax), %xmm0");
4569
	asm volatile("sha1nexte (0x12345678), %xmm0");
4570
	asm volatile("sha1nexte (%eax), %xmm3");
4571
	asm volatile("sha1nexte (%ecx,%eax,1), %xmm0");
4572
	asm volatile("sha1nexte 0x12345678(,%eax,1), %xmm0");
4573
	asm volatile("sha1nexte (%eax,%ecx,1), %xmm0");
4574
	asm volatile("sha1nexte (%eax,%ecx,8), %xmm0");
4575
	asm volatile("sha1nexte 0x12(%eax), %xmm0");
4576
	asm volatile("sha1nexte 0x12(%ebp), %xmm0");
4577
	asm volatile("sha1nexte 0x12(%ecx,%eax,1), %xmm0");
4578
	asm volatile("sha1nexte 0x12(%ebp,%eax,1), %xmm0");
4579
	asm volatile("sha1nexte 0x12(%eax,%ecx,1), %xmm0");
4580
	asm volatile("sha1nexte 0x12(%eax,%ecx,8), %xmm0");
4581
	asm volatile("sha1nexte 0x12345678(%eax), %xmm0");
4582
	asm volatile("sha1nexte 0x12345678(%ebp), %xmm0");
4583
	asm volatile("sha1nexte 0x12345678(%ecx,%eax,1), %xmm0");
4584
	asm volatile("sha1nexte 0x12345678(%ebp,%eax,1), %xmm0");
4585
	asm volatile("sha1nexte 0x12345678(%eax,%ecx,1), %xmm0");
4586
	asm volatile("sha1nexte 0x12345678(%eax,%ecx,8), %xmm0");
4587

4588
	/* sha1msg1 xmm2/m128, xmm1 */
4589

4590
	asm volatile("sha1msg1 %xmm1, %xmm0");
4591
	asm volatile("sha1msg1 %xmm7, %xmm2");
4592
	asm volatile("sha1msg1 (%eax), %xmm0");
4593
	asm volatile("sha1msg1 (0x12345678), %xmm0");
4594
	asm volatile("sha1msg1 (%eax), %xmm3");
4595
	asm volatile("sha1msg1 (%ecx,%eax,1), %xmm0");
4596
	asm volatile("sha1msg1 0x12345678(,%eax,1), %xmm0");
4597
	asm volatile("sha1msg1 (%eax,%ecx,1), %xmm0");
4598
	asm volatile("sha1msg1 (%eax,%ecx,8), %xmm0");
4599
	asm volatile("sha1msg1 0x12(%eax), %xmm0");
4600
	asm volatile("sha1msg1 0x12(%ebp), %xmm0");
4601
	asm volatile("sha1msg1 0x12(%ecx,%eax,1), %xmm0");
4602
	asm volatile("sha1msg1 0x12(%ebp,%eax,1), %xmm0");
4603
	asm volatile("sha1msg1 0x12(%eax,%ecx,1), %xmm0");
4604
	asm volatile("sha1msg1 0x12(%eax,%ecx,8), %xmm0");
4605
	asm volatile("sha1msg1 0x12345678(%eax), %xmm0");
4606
	asm volatile("sha1msg1 0x12345678(%ebp), %xmm0");
4607
	asm volatile("sha1msg1 0x12345678(%ecx,%eax,1), %xmm0");
4608
	asm volatile("sha1msg1 0x12345678(%ebp,%eax,1), %xmm0");
4609
	asm volatile("sha1msg1 0x12345678(%eax,%ecx,1), %xmm0");
4610
	asm volatile("sha1msg1 0x12345678(%eax,%ecx,8), %xmm0");
4611

4612
	/* sha1msg2 xmm2/m128, xmm1 */
4613

4614
	asm volatile("sha1msg2 %xmm1, %xmm0");
4615
	asm volatile("sha1msg2 %xmm7, %xmm2");
4616
	asm volatile("sha1msg2 (%eax), %xmm0");
4617
	asm volatile("sha1msg2 (0x12345678), %xmm0");
4618
	asm volatile("sha1msg2 (%eax), %xmm3");
4619
	asm volatile("sha1msg2 (%ecx,%eax,1), %xmm0");
4620
	asm volatile("sha1msg2 0x12345678(,%eax,1), %xmm0");
4621
	asm volatile("sha1msg2 (%eax,%ecx,1), %xmm0");
4622
	asm volatile("sha1msg2 (%eax,%ecx,8), %xmm0");
4623
	asm volatile("sha1msg2 0x12(%eax), %xmm0");
4624
	asm volatile("sha1msg2 0x12(%ebp), %xmm0");
4625
	asm volatile("sha1msg2 0x12(%ecx,%eax,1), %xmm0");
4626
	asm volatile("sha1msg2 0x12(%ebp,%eax,1), %xmm0");
4627
	asm volatile("sha1msg2 0x12(%eax,%ecx,1), %xmm0");
4628
	asm volatile("sha1msg2 0x12(%eax,%ecx,8), %xmm0");
4629
	asm volatile("sha1msg2 0x12345678(%eax), %xmm0");
4630
	asm volatile("sha1msg2 0x12345678(%ebp), %xmm0");
4631
	asm volatile("sha1msg2 0x12345678(%ecx,%eax,1), %xmm0");
4632
	asm volatile("sha1msg2 0x12345678(%ebp,%eax,1), %xmm0");
4633
	asm volatile("sha1msg2 0x12345678(%eax,%ecx,1), %xmm0");
4634
	asm volatile("sha1msg2 0x12345678(%eax,%ecx,8), %xmm0");
4635

4636
	/* sha256rnds2 <XMM0>, xmm2/m128, xmm1 */
4637
	/* Note sha256rnds2 has an implicit operand 'xmm0' */
4638

4639
	asm volatile("sha256rnds2 %xmm4, %xmm1");
4640
	asm volatile("sha256rnds2 %xmm7, %xmm2");
4641
	asm volatile("sha256rnds2 (%eax), %xmm1");
4642
	asm volatile("sha256rnds2 (0x12345678), %xmm1");
4643
	asm volatile("sha256rnds2 (%eax), %xmm3");
4644
	asm volatile("sha256rnds2 (%ecx,%eax,1), %xmm1");
4645
	asm volatile("sha256rnds2 0x12345678(,%eax,1), %xmm1");
4646
	asm volatile("sha256rnds2 (%eax,%ecx,1), %xmm1");
4647
	asm volatile("sha256rnds2 (%eax,%ecx,8), %xmm1");
4648
	asm volatile("sha256rnds2 0x12(%eax), %xmm1");
4649
	asm volatile("sha256rnds2 0x12(%ebp), %xmm1");
4650
	asm volatile("sha256rnds2 0x12(%ecx,%eax,1), %xmm1");
4651
	asm volatile("sha256rnds2 0x12(%ebp,%eax,1), %xmm1");
4652
	asm volatile("sha256rnds2 0x12(%eax,%ecx,1), %xmm1");
4653
	asm volatile("sha256rnds2 0x12(%eax,%ecx,8), %xmm1");
4654
	asm volatile("sha256rnds2 0x12345678(%eax), %xmm1");
4655
	asm volatile("sha256rnds2 0x12345678(%ebp), %xmm1");
4656
	asm volatile("sha256rnds2 0x12345678(%ecx,%eax,1), %xmm1");
4657
	asm volatile("sha256rnds2 0x12345678(%ebp,%eax,1), %xmm1");
4658
	asm volatile("sha256rnds2 0x12345678(%eax,%ecx,1), %xmm1");
4659
	asm volatile("sha256rnds2 0x12345678(%eax,%ecx,8), %xmm1");
4660

4661
	/* sha256msg1 xmm2/m128, xmm1 */
4662

4663
	asm volatile("sha256msg1 %xmm1, %xmm0");
4664
	asm volatile("sha256msg1 %xmm7, %xmm2");
4665
	asm volatile("sha256msg1 (%eax), %xmm0");
4666
	asm volatile("sha256msg1 (0x12345678), %xmm0");
4667
	asm volatile("sha256msg1 (%eax), %xmm3");
4668
	asm volatile("sha256msg1 (%ecx,%eax,1), %xmm0");
4669
	asm volatile("sha256msg1 0x12345678(,%eax,1), %xmm0");
4670
	asm volatile("sha256msg1 (%eax,%ecx,1), %xmm0");
4671
	asm volatile("sha256msg1 (%eax,%ecx,8), %xmm0");
4672
	asm volatile("sha256msg1 0x12(%eax), %xmm0");
4673
	asm volatile("sha256msg1 0x12(%ebp), %xmm0");
4674
	asm volatile("sha256msg1 0x12(%ecx,%eax,1), %xmm0");
4675
	asm volatile("sha256msg1 0x12(%ebp,%eax,1), %xmm0");
4676
	asm volatile("sha256msg1 0x12(%eax,%ecx,1), %xmm0");
4677
	asm volatile("sha256msg1 0x12(%eax,%ecx,8), %xmm0");
4678
	asm volatile("sha256msg1 0x12345678(%eax), %xmm0");
4679
	asm volatile("sha256msg1 0x12345678(%ebp), %xmm0");
4680
	asm volatile("sha256msg1 0x12345678(%ecx,%eax,1), %xmm0");
4681
	asm volatile("sha256msg1 0x12345678(%ebp,%eax,1), %xmm0");
4682
	asm volatile("sha256msg1 0x12345678(%eax,%ecx,1), %xmm0");
4683
	asm volatile("sha256msg1 0x12345678(%eax,%ecx,8), %xmm0");
4684

4685
	/* sha256msg2 xmm2/m128, xmm1 */
4686

4687
	asm volatile("sha256msg2 %xmm1, %xmm0");
4688
	asm volatile("sha256msg2 %xmm7, %xmm2");
4689
	asm volatile("sha256msg2 (%eax), %xmm0");
4690
	asm volatile("sha256msg2 (0x12345678), %xmm0");
4691
	asm volatile("sha256msg2 (%eax), %xmm3");
4692
	asm volatile("sha256msg2 (%ecx,%eax,1), %xmm0");
4693
	asm volatile("sha256msg2 0x12345678(,%eax,1), %xmm0");
4694
	asm volatile("sha256msg2 (%eax,%ecx,1), %xmm0");
4695
	asm volatile("sha256msg2 (%eax,%ecx,8), %xmm0");
4696
	asm volatile("sha256msg2 0x12(%eax), %xmm0");
4697
	asm volatile("sha256msg2 0x12(%ebp), %xmm0");
4698
	asm volatile("sha256msg2 0x12(%ecx,%eax,1), %xmm0");
4699
	asm volatile("sha256msg2 0x12(%ebp,%eax,1), %xmm0");
4700
	asm volatile("sha256msg2 0x12(%eax,%ecx,1), %xmm0");
4701
	asm volatile("sha256msg2 0x12(%eax,%ecx,8), %xmm0");
4702
	asm volatile("sha256msg2 0x12345678(%eax), %xmm0");
4703
	asm volatile("sha256msg2 0x12345678(%ebp), %xmm0");
4704
	asm volatile("sha256msg2 0x12345678(%ecx,%eax,1), %xmm0");
4705
	asm volatile("sha256msg2 0x12345678(%ebp,%eax,1), %xmm0");
4706
	asm volatile("sha256msg2 0x12345678(%eax,%ecx,1), %xmm0");
4707
	asm volatile("sha256msg2 0x12345678(%eax,%ecx,8), %xmm0");
4708

4709
	/* clflushopt m8 */
4710

4711
	asm volatile("clflushopt (%eax)");
4712
	asm volatile("clflushopt (0x12345678)");
4713
	asm volatile("clflushopt 0x12345678(%eax,%ecx,8)");
4714
	/* Also check instructions in the same group encoding as clflushopt */
4715
	asm volatile("clflush (%eax)");
4716
	asm volatile("sfence");
4717

4718
	/* clwb m8 */
4719

4720
	asm volatile("clwb (%eax)");
4721
	asm volatile("clwb (0x12345678)");
4722
	asm volatile("clwb 0x12345678(%eax,%ecx,8)");
4723
	/* Also check instructions in the same group encoding as clwb */
4724
	asm volatile("xsaveopt (%eax)");
4725
	asm volatile("mfence");
4726

4727
	/* cldemote m8 */
4728

4729
	asm volatile("cldemote (%eax)");
4730
	asm volatile("cldemote (0x12345678)");
4731
	asm volatile("cldemote 0x12345678(%eax,%ecx,8)");
4732

4733
	/* xsavec mem */
4734

4735
	asm volatile("xsavec (%eax)");
4736
	asm volatile("xsavec (0x12345678)");
4737
	asm volatile("xsavec 0x12345678(%eax,%ecx,8)");
4738

4739
	/* xsaves mem */
4740

4741
	asm volatile("xsaves (%eax)");
4742
	asm volatile("xsaves (0x12345678)");
4743
	asm volatile("xsaves 0x12345678(%eax,%ecx,8)");
4744

4745
	/* xrstors mem */
4746

4747
	asm volatile("xrstors (%eax)");
4748
	asm volatile("xrstors (0x12345678)");
4749
	asm volatile("xrstors 0x12345678(%eax,%ecx,8)");
4750

4751
	/* ptwrite */
4752

4753
	asm volatile("ptwrite (%eax)");
4754
	asm volatile("ptwrite (0x12345678)");
4755
	asm volatile("ptwrite 0x12345678(%eax,%ecx,8)");
4756

4757
	asm volatile("ptwritel (%eax)");
4758
	asm volatile("ptwritel (0x12345678)");
4759
	asm volatile("ptwritel 0x12345678(%eax,%ecx,8)");
4760

4761
	/* tpause */
4762

4763
	asm volatile("tpause %ebx");
4764

4765
	/* umonitor */
4766

4767
	asm volatile("umonitor %ax");
4768
	asm volatile("umonitor %eax");
4769

4770
	/* umwait */
4771

4772
	asm volatile("umwait %eax");
4773

4774
	/* movdiri */
4775

4776
	asm volatile("movdiri %eax,(%ebx)");
4777
	asm volatile("movdiri %ecx,0x12345678(%eax)");
4778

4779
	/* movdir64b */
4780

4781
	asm volatile("movdir64b (%eax),%ebx");
4782
	asm volatile("movdir64b 0x12345678(%eax),%ecx");
4783
	asm volatile("movdir64b (%si),%bx");
4784
	asm volatile("movdir64b 0x1234(%si),%cx");
4785

4786
	/* enqcmd */
4787

4788
	asm volatile("enqcmd (%eax),%ebx");
4789
	asm volatile("enqcmd 0x12345678(%eax),%ecx");
4790
	asm volatile("enqcmd (%si),%bx");
4791
	asm volatile("enqcmd 0x1234(%si),%cx");
4792

4793
	/* enqcmds */
4794

4795
	asm volatile("enqcmds (%eax),%ebx");
4796
	asm volatile("enqcmds 0x12345678(%eax),%ecx");
4797
	asm volatile("enqcmds (%si),%bx");
4798
	asm volatile("enqcmds 0x1234(%si),%cx");
4799

4800
	/* incsspd */
4801

4802
	asm volatile("incsspd %eax");
4803
	/* Also check instructions in the same group encoding as incsspd */
4804
	asm volatile("xrstor (%eax)");
4805
	asm volatile("xrstor (0x12345678)");
4806
	asm volatile("xrstor 0x12345678(%eax,%ecx,8)");
4807
	asm volatile("lfence");
4808

4809
	/* rdsspd */
4810

4811
	asm volatile("rdsspd %eax");
4812

4813
	/* saveprevssp */
4814

4815
	asm volatile("saveprevssp");
4816

4817
	/* rstorssp */
4818

4819
	asm volatile("rstorssp (%eax)");
4820
	asm volatile("rstorssp (0x12345678)");
4821
	asm volatile("rstorssp 0x12345678(%eax,%ecx,8)");
4822

4823
	/* wrssd */
4824

4825
	asm volatile("wrssd %ecx,(%eax)");
4826
	asm volatile("wrssd %edx,(0x12345678)");
4827
	asm volatile("wrssd %edx,0x12345678(%eax,%ecx,8)");
4828

4829
	/* wrussd */
4830

4831
	asm volatile("wrussd %ecx,(%eax)");
4832
	asm volatile("wrussd %edx,(0x12345678)");
4833
	asm volatile("wrussd %edx,0x12345678(%eax,%ecx,8)");
4834

4835
	/* setssbsy */
4836

4837
	asm volatile("setssbsy");
4838
	/* Also check instructions in the same group encoding as setssbsy */
4839
	asm volatile("rdpkru");
4840
	asm volatile("wrpkru");
4841

4842
	/* clrssbsy */
4843

4844
	asm volatile("clrssbsy (%eax)");
4845
	asm volatile("clrssbsy (0x12345678)");
4846
	asm volatile("clrssbsy 0x12345678(%eax,%ecx,8)");
4847

4848
	/* endbr32/64 */
4849

4850
	asm volatile("endbr32");
4851
	asm volatile("endbr64");
4852

4853
	/* call with/without notrack prefix */
4854

4855
	asm volatile("call *%eax");				/* Expecting: call indirect 0 */
4856
	asm volatile("call *(%eax)");				/* Expecting: call indirect 0 */
4857
	asm volatile("call *(0x12345678)");			/* Expecting: call indirect 0 */
4858
	asm volatile("call *0x12345678(%eax,%ecx,8)");		/* Expecting: call indirect 0 */
4859

4860
	asm volatile("bnd call *%eax");				/* Expecting: call indirect 0 */
4861
	asm volatile("bnd call *(%eax)");			/* Expecting: call indirect 0 */
4862
	asm volatile("bnd call *(0x12345678)");			/* Expecting: call indirect 0 */
4863
	asm volatile("bnd call *0x12345678(%eax,%ecx,8)");	/* Expecting: call indirect 0 */
4864

4865
	asm volatile("notrack call *%eax");			/* Expecting: call indirect 0 */
4866
	asm volatile("notrack call *(%eax)");			/* Expecting: call indirect 0 */
4867
	asm volatile("notrack call *(0x12345678)");		/* Expecting: call indirect 0 */
4868
	asm volatile("notrack call *0x12345678(%eax,%ecx,8)");	/* Expecting: call indirect 0 */
4869

4870
	asm volatile("notrack bnd call *%eax");			/* Expecting: call indirect 0 */
4871
	asm volatile("notrack bnd call *(%eax)");		/* Expecting: call indirect 0 */
4872
	asm volatile("notrack bnd call *(0x12345678)");		/* Expecting: call indirect 0 */
4873
	asm volatile("notrack bnd call *0x12345678(%eax,%ecx,8)"); /* Expecting: call indirect 0 */
4874

4875
	/* jmp with/without notrack prefix */
4876

4877
	asm volatile("jmp *%eax");				/* Expecting: jmp indirect 0 */
4878
	asm volatile("jmp *(%eax)");				/* Expecting: jmp indirect 0 */
4879
	asm volatile("jmp *(0x12345678)");			/* Expecting: jmp indirect 0 */
4880
	asm volatile("jmp *0x12345678(%eax,%ecx,8)");		/* Expecting: jmp indirect 0 */
4881

4882
	asm volatile("bnd jmp *%eax");				/* Expecting: jmp indirect 0 */
4883
	asm volatile("bnd jmp *(%eax)");			/* Expecting: jmp indirect 0 */
4884
	asm volatile("bnd jmp *(0x12345678)");			/* Expecting: jmp indirect 0 */
4885
	asm volatile("bnd jmp *0x12345678(%eax,%ecx,8)");	/* Expecting: jmp indirect 0 */
4886

4887
	asm volatile("notrack jmp *%eax");			/* Expecting: jmp indirect 0 */
4888
	asm volatile("notrack jmp *(%eax)");			/* Expecting: jmp indirect 0 */
4889
	asm volatile("notrack jmp *(0x12345678)");		/* Expecting: jmp indirect 0 */
4890
	asm volatile("notrack jmp *0x12345678(%eax,%ecx,8)");	/* Expecting: jmp indirect 0 */
4891

4892
	asm volatile("notrack bnd jmp *%eax");			/* Expecting: jmp indirect 0 */
4893
	asm volatile("notrack bnd jmp *(%eax)");		/* Expecting: jmp indirect 0 */
4894
	asm volatile("notrack bnd jmp *(0x12345678)");		/* Expecting: jmp indirect 0 */
4895
	asm volatile("notrack bnd jmp *0x12345678(%eax,%ecx,8)"); /* Expecting: jmp indirect 0 */
4896

4897
	/* AVX512-FP16 */
4898

4899
	asm volatile("vaddph %zmm3, %zmm2, %zmm1");
4900
	asm volatile("vaddph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
4901
	asm volatile("vaddph %xmm3, %xmm2, %xmm1");
4902
	asm volatile("vaddph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
4903
	asm volatile("vaddph %ymm3, %ymm2, %ymm1");
4904
	asm volatile("vaddph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
4905
	asm volatile("vaddsh %xmm3, %xmm2, %xmm1");
4906
	asm volatile("vaddsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
4907
	asm volatile("vcmpph $0x12, %zmm3, %zmm2, %k5");
4908
	asm volatile("vcmpph $0x12, 0x12345678(%eax,%ecx,8), %zmm2, %k5");
4909
	asm volatile("vcmpph $0x12, %xmm3, %xmm2, %k5");
4910
	asm volatile("vcmpph $0x12, 0x12345678(%eax,%ecx,8), %xmm2, %k5");
4911
	asm volatile("vcmpph $0x12, %ymm3, %ymm2, %k5");
4912
	asm volatile("vcmpph $0x12, 0x12345678(%eax,%ecx,8), %ymm2, %k5");
4913
	asm volatile("vcmpsh $0x12, %xmm3, %xmm2, %k5");
4914
	asm volatile("vcmpsh $0x12, 0x12345678(%eax,%ecx,8), %xmm2, %k5");
4915
	asm volatile("vcomish %xmm2, %xmm1");
4916
	asm volatile("vcomish 0x12345678(%eax,%ecx,8), %xmm1");
4917
	asm volatile("vcvtdq2ph %zmm2, %ymm1");
4918
	asm volatile("vcvtdq2ph 0x12345678(%eax,%ecx,8), %ymm1");
4919
	asm volatile("vcvtdq2ph %xmm2, %xmm1");
4920
	asm volatile("vcvtdq2ph %ymm2, %xmm1");
4921
	asm volatile("vcvtpd2ph %zmm2, %xmm1");
4922
	asm volatile("vcvtpd2ph %xmm2, %xmm1");
4923
	asm volatile("vcvtpd2ph %ymm2, %xmm1");
4924
	asm volatile("vcvtph2dq %ymm2, %zmm1");
4925
	asm volatile("vcvtph2dq 0x12345678(%eax,%ecx,8), %zmm1");
4926
	asm volatile("vcvtph2dq %xmm2, %xmm1");
4927
	asm volatile("vcvtph2dq 0x12345678(%eax,%ecx,8), %xmm1");
4928
	asm volatile("vcvtph2dq %xmm2, %ymm1");
4929
	asm volatile("vcvtph2dq 0x12345678(%eax,%ecx,8), %ymm1");
4930
	asm volatile("vcvtph2pd %xmm2, %zmm1");
4931
	asm volatile("vcvtph2pd 0x12345678(%eax,%ecx,8), %zmm1");
4932
	asm volatile("vcvtph2pd %xmm2, %xmm1");
4933
	asm volatile("vcvtph2pd 0x12345678(%eax,%ecx,8), %xmm1");
4934
	asm volatile("vcvtph2pd %xmm2, %ymm1");
4935
	asm volatile("vcvtph2pd 0x12345678(%eax,%ecx,8), %ymm1");
4936
	asm volatile("vcvtph2ps %ymm2, %zmm1");
4937
	asm volatile("vcvtph2ps 0x12345678(%eax,%ecx,8), %zmm1");
4938
	asm volatile("vcvtph2ps %xmm2, %xmm1");
4939
	asm volatile("vcvtph2ps 0x12345678(%eax,%ecx,8), %xmm1");
4940
	asm volatile("vcvtph2ps %xmm2, %ymm1");
4941
	asm volatile("vcvtph2ps 0x12345678(%eax,%ecx,8), %ymm1");
4942
	asm volatile("vcvtph2ps %xmm2, %xmm1");
4943
	asm volatile("vcvtph2ps 0x12345678(%eax,%ecx,8), %xmm1");
4944
	asm volatile("vcvtph2ps %xmm2, %ymm1");
4945
	asm volatile("vcvtph2ps 0x12345678(%eax,%ecx,8), %ymm1");
4946
	asm volatile("vcvtph2psx %ymm2, %zmm1");
4947
	asm volatile("vcvtph2psx 0x12345678(%eax,%ecx,8), %zmm1");
4948
	asm volatile("vcvtph2psx %xmm2, %xmm1");
4949
	asm volatile("vcvtph2psx 0x12345678(%eax,%ecx,8), %xmm1");
4950
	asm volatile("vcvtph2psx %xmm2, %ymm1");
4951
	asm volatile("vcvtph2psx 0x12345678(%eax,%ecx,8), %ymm1");
4952
	asm volatile("vcvtph2qq %xmm2, %zmm1");
4953
	asm volatile("vcvtph2qq 0x12345678(%eax,%ecx,8), %zmm1");
4954
	asm volatile("vcvtph2qq %xmm2, %xmm1");
4955
	asm volatile("vcvtph2qq 0x12345678(%eax,%ecx,8), %xmm1");
4956
	asm volatile("vcvtph2qq %xmm2, %ymm1");
4957
	asm volatile("vcvtph2qq 0x12345678(%eax,%ecx,8), %ymm1");
4958
	asm volatile("vcvtph2udq %ymm2, %zmm1");
4959
	asm volatile("vcvtph2udq 0x12345678(%eax,%ecx,8), %zmm1");
4960
	asm volatile("vcvtph2udq %xmm2, %xmm1");
4961
	asm volatile("vcvtph2udq 0x12345678(%eax,%ecx,8), %xmm1");
4962
	asm volatile("vcvtph2udq %xmm2, %ymm1");
4963
	asm volatile("vcvtph2udq 0x12345678(%eax,%ecx,8), %ymm1");
4964
	asm volatile("vcvtph2uqq %xmm2, %zmm1");
4965
	asm volatile("vcvtph2uqq 0x12345678(%eax,%ecx,8), %zmm1");
4966
	asm volatile("vcvtph2uqq %xmm2, %xmm1");
4967
	asm volatile("vcvtph2uqq 0x12345678(%eax,%ecx,8), %xmm1");
4968
	asm volatile("vcvtph2uqq %xmm2, %ymm1");
4969
	asm volatile("vcvtph2uqq 0x12345678(%eax,%ecx,8), %ymm1");
4970
	asm volatile("vcvtph2uw %zmm2, %zmm1");
4971
	asm volatile("vcvtph2uw 0x12345678(%eax,%ecx,8), %zmm1");
4972
	asm volatile("vcvtph2uw %xmm2, %xmm1");
4973
	asm volatile("vcvtph2uw 0x12345678(%eax,%ecx,8), %xmm1");
4974
	asm volatile("vcvtph2uw %ymm2, %ymm1");
4975
	asm volatile("vcvtph2uw 0x12345678(%eax,%ecx,8), %ymm1");
4976
	asm volatile("vcvtph2w %zmm2, %zmm1");
4977
	asm volatile("vcvtph2w 0x12345678(%eax,%ecx,8), %zmm1");
4978
	asm volatile("vcvtph2w %xmm2, %xmm1");
4979
	asm volatile("vcvtph2w 0x12345678(%eax,%ecx,8), %xmm1");
4980
	asm volatile("vcvtph2w %ymm2, %ymm1");
4981
	asm volatile("vcvtph2w 0x12345678(%eax,%ecx,8), %ymm1");
4982
	asm volatile("vcvtps2ph $0x12, %zmm1, 0x12345678(%eax,%ecx,8)");
4983
	asm volatile("vcvtps2ph $0x12, %zmm2, %ymm1");
4984
	asm volatile("vcvtps2ph $0x12, %ymm1, 0x12345678(%eax,%ecx,8)");
4985
	asm volatile("vcvtps2ph $0x12, %xmm1, 0x12345678(%eax,%ecx,8)");
4986
	asm volatile("vcvtps2ph $0x12, %xmm2, %xmm1");
4987
	asm volatile("vcvtps2ph $0x12, %ymm2, %xmm1");
4988
	asm volatile("vcvtps2ph $0x12, %ymm2, %xmm1");
4989
	asm volatile("vcvtps2ph $0x12, %ymm2, 0x12345678(%eax,%ecx,8)");
4990
	asm volatile("vcvtps2ph $0x12, %xmm2, %xmm1");
4991
	asm volatile("vcvtps2ph $0x12, %xmm2, 0x12345678(%eax,%ecx,8)");
4992
	asm volatile("vcvtps2phx %zmm2, %ymm1");
4993
	asm volatile("vcvtps2phx 0x12345678(%eax,%ecx,8), %ymm1");
4994
	asm volatile("vcvtps2phx %xmm2, %xmm1");
4995
	asm volatile("vcvtps2phx %ymm2, %xmm1");
4996
	asm volatile("vcvtqq2ph %zmm2, %xmm1");
4997
	asm volatile("vcvtqq2ph %xmm2, %xmm1");
4998
	asm volatile("vcvtqq2ph %ymm2, %xmm1");
4999
	asm volatile("vcvtsd2sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5000
	asm volatile("vcvtsh2sd 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5001
	asm volatile("vcvtsh2si 0x12345678(%eax,%ecx,8), %eax");
5002
	asm volatile("vcvtsh2ss 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5003
	asm volatile("vcvtsh2usi %xmm1, %eax");
5004
	asm volatile("vcvtsh2usi 0x12345678(%eax,%ecx,8), %eax");
5005
	asm volatile("vcvtsi2sh %eax, %xmm2, %xmm1");
5006
	asm volatile("vcvtsi2sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5007
	asm volatile("vcvtsi2sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5008
	asm volatile("vcvtss2sh %xmm3, %xmm2, %xmm1");
5009
	asm volatile("vcvtss2sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5010
	asm volatile("vcvttph2dq %ymm2, %zmm1");
5011
	asm volatile("vcvttph2dq 0x12345678(%eax,%ecx,8), %zmm1");
5012
	asm volatile("vcvttph2dq %xmm2, %xmm1");
5013
	asm volatile("vcvttph2dq 0x12345678(%eax,%ecx,8), %xmm1");
5014
	asm volatile("vcvttph2dq %xmm2, %ymm1");
5015
	asm volatile("vcvttph2dq 0x12345678(%eax,%ecx,8), %ymm1");
5016
	asm volatile("vcvttph2qq %xmm2, %zmm1");
5017
	asm volatile("vcvttph2qq 0x12345678(%eax,%ecx,8), %zmm1");
5018
	asm volatile("vcvttph2qq %xmm2, %xmm1");
5019
	asm volatile("vcvttph2qq 0x12345678(%eax,%ecx,8), %xmm1");
5020
	asm volatile("vcvttph2qq %xmm2, %ymm1");
5021
	asm volatile("vcvttph2qq 0x12345678(%eax,%ecx,8), %ymm1");
5022
	asm volatile("vcvttph2udq %ymm2, %zmm1");
5023
	asm volatile("vcvttph2udq 0x12345678(%eax,%ecx,8), %zmm1");
5024
	asm volatile("vcvttph2udq %xmm2, %xmm1");
5025
	asm volatile("vcvttph2udq 0x12345678(%eax,%ecx,8), %xmm1");
5026
	asm volatile("vcvttph2udq %xmm2, %ymm1");
5027
	asm volatile("vcvttph2udq 0x12345678(%eax,%ecx,8), %ymm1");
5028
	asm volatile("vcvttph2uqq %xmm2, %zmm1");
5029
	asm volatile("vcvttph2uqq 0x12345678(%eax,%ecx,8), %zmm1");
5030
	asm volatile("vcvttph2uqq %xmm2, %xmm1");
5031
	asm volatile("vcvttph2uqq 0x12345678(%eax,%ecx,8), %xmm1");
5032
	asm volatile("vcvttph2uqq %xmm2, %ymm1");
5033
	asm volatile("vcvttph2uqq 0x12345678(%eax,%ecx,8), %ymm1");
5034
	asm volatile("vcvttph2uw %zmm2, %zmm1");
5035
	asm volatile("vcvttph2uw 0x12345678(%eax,%ecx,8), %zmm1");
5036
	asm volatile("vcvttph2uw %xmm2, %xmm1");
5037
	asm volatile("vcvttph2uw 0x12345678(%eax,%ecx,8), %xmm1");
5038
	asm volatile("vcvttph2uw %ymm2, %ymm1");
5039
	asm volatile("vcvttph2uw 0x12345678(%eax,%ecx,8), %ymm1");
5040
	asm volatile("vcvttph2w %zmm2, %zmm1");
5041
	asm volatile("vcvttph2w 0x12345678(%eax,%ecx,8), %zmm1");
5042
	asm volatile("vcvttph2w %xmm2, %xmm1");
5043
	asm volatile("vcvttph2w 0x12345678(%eax,%ecx,8), %xmm1");
5044
	asm volatile("vcvttph2w %ymm2, %ymm1");
5045
	asm volatile("vcvttph2w 0x12345678(%eax,%ecx,8), %ymm1");
5046
	asm volatile("vcvttsh2si %xmm1, %eax");
5047
	asm volatile("vcvttsh2si 0x12345678(%eax,%ecx,8), %eax");
5048
	asm volatile("vcvttsh2usi %xmm1, %eax");
5049
	asm volatile("vcvttsh2usi 0x12345678(%eax,%ecx,8), %eax");
5050
	asm volatile("vcvtudq2ph %zmm2, %ymm1");
5051
	asm volatile("vcvtudq2ph 0x12345678(%eax,%ecx,8), %ymm1");
5052
	asm volatile("vcvtudq2ph %xmm2, %xmm1");
5053
	asm volatile("vcvtudq2ph %ymm2, %xmm1");
5054
	asm volatile("vcvtuqq2ph %zmm2, %xmm1");
5055
	asm volatile("vcvtuqq2ph %xmm2, %xmm1");
5056
	asm volatile("vcvtuqq2ph %ymm2, %xmm1");
5057
	asm volatile("vcvtusi2sh %eax, %xmm2, %xmm1");
5058
	asm volatile("vcvtusi2sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5059
	asm volatile("vcvtusi2sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5060
	asm volatile("vcvtuw2ph %zmm2, %zmm1");
5061
	asm volatile("vcvtuw2ph 0x12345678(%eax,%ecx,8), %zmm1");
5062
	asm volatile("vcvtuw2ph %xmm2, %xmm1");
5063
	asm volatile("vcvtuw2ph 0x12345678(%eax,%ecx,8), %xmm1");
5064
	asm volatile("vcvtuw2ph %ymm2, %ymm1");
5065
	asm volatile("vcvtuw2ph 0x12345678(%eax,%ecx,8), %ymm1");
5066
	asm volatile("vcvtw2ph %zmm2, %zmm1");
5067
	asm volatile("vcvtw2ph 0x12345678(%eax,%ecx,8), %zmm1");
5068
	asm volatile("vcvtw2ph %xmm2, %xmm1");
5069
	asm volatile("vcvtw2ph 0x12345678(%eax,%ecx,8), %xmm1");
5070
	asm volatile("vcvtw2ph %ymm2, %ymm1");
5071
	asm volatile("vcvtw2ph 0x12345678(%eax,%ecx,8), %ymm1");
5072
	asm volatile("vdivph %zmm3, %zmm2, %zmm1");
5073
	asm volatile("vdivph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5074
	asm volatile("vdivph %xmm3, %xmm2, %xmm1");
5075
	asm volatile("vdivph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5076
	asm volatile("vdivph %ymm3, %ymm2, %ymm1");
5077
	asm volatile("vdivph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5078
	asm volatile("vdivsh %xmm3, %xmm2, %xmm1");
5079
	asm volatile("vdivsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5080
	asm volatile("vfcmaddcph %zmm3, %zmm2, %zmm1");
5081
	asm volatile("vfcmaddcph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5082
	asm volatile("vfcmaddcph %xmm3, %xmm2, %xmm1");
5083
	asm volatile("vfcmaddcph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5084
	asm volatile("vfcmaddcph %ymm3, %ymm2, %ymm1");
5085
	asm volatile("vfcmaddcph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5086
	asm volatile("vfcmaddcsh %xmm3, %xmm2, %xmm1");
5087
	asm volatile("vfcmaddcsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5088
	asm volatile("vfcmulcph %zmm3, %zmm2, %zmm1");
5089
	asm volatile("vfcmulcph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5090
	asm volatile("vfcmulcph %xmm3, %xmm2, %xmm1");
5091
	asm volatile("vfcmulcph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5092
	asm volatile("vfcmulcph %ymm3, %ymm2, %ymm1");
5093
	asm volatile("vfcmulcph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5094
	asm volatile("vfcmulcsh %xmm3, %xmm2, %xmm1");
5095
	asm volatile("vfcmulcsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5096
	asm volatile("vfmadd132ph %zmm3, %zmm2, %zmm1");
5097
	asm volatile("vfmadd132ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5098
	asm volatile("vfmadd132ph %xmm3, %xmm2, %xmm1");
5099
	asm volatile("vfmadd132ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5100
	asm volatile("vfmadd132ph %ymm3, %ymm2, %ymm1");
5101
	asm volatile("vfmadd132ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5102
	asm volatile("vfmadd132sh %xmm3, %xmm2, %xmm1");
5103
	asm volatile("vfmadd132sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5104
	asm volatile("vfmadd213ph %zmm3, %zmm2, %zmm1");
5105
	asm volatile("vfmadd213ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5106
	asm volatile("vfmadd213ph %xmm3, %xmm2, %xmm1");
5107
	asm volatile("vfmadd213ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5108
	asm volatile("vfmadd213ph %ymm3, %ymm2, %ymm1");
5109
	asm volatile("vfmadd213ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5110
	asm volatile("vfmadd213sh %xmm3, %xmm2, %xmm1");
5111
	asm volatile("vfmadd213sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5112
	asm volatile("vfmadd231ph %zmm3, %zmm2, %zmm1");
5113
	asm volatile("vfmadd231ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5114
	asm volatile("vfmadd231ph %xmm3, %xmm2, %xmm1");
5115
	asm volatile("vfmadd231ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5116
	asm volatile("vfmadd231ph %ymm3, %ymm2, %ymm1");
5117
	asm volatile("vfmadd231ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5118
	asm volatile("vfmadd231sh %xmm3, %xmm2, %xmm1");
5119
	asm volatile("vfmadd231sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5120
	asm volatile("vfmaddcph %zmm3, %zmm2, %zmm1");
5121
	asm volatile("vfmaddcph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5122
	asm volatile("vfmaddcph %xmm3, %xmm2, %xmm1");
5123
	asm volatile("vfmaddcph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5124
	asm volatile("vfmaddcph %ymm3, %ymm2, %ymm1");
5125
	asm volatile("vfmaddcph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5126
	asm volatile("vfmaddcsh %xmm3, %xmm2, %xmm1");
5127
	asm volatile("vfmaddcsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5128
	asm volatile("vfmaddsub132ph %zmm3, %zmm2, %zmm1");
5129
	asm volatile("vfmaddsub132ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5130
	asm volatile("vfmaddsub132ph %xmm3, %xmm2, %xmm1");
5131
	asm volatile("vfmaddsub132ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5132
	asm volatile("vfmaddsub132ph %ymm3, %ymm2, %ymm1");
5133
	asm volatile("vfmaddsub132ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5134
	asm volatile("vfmaddsub213ph %zmm3, %zmm2, %zmm1");
5135
	asm volatile("vfmaddsub213ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5136
	asm volatile("vfmaddsub213ph %xmm3, %xmm2, %xmm1");
5137
	asm volatile("vfmaddsub213ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5138
	asm volatile("vfmaddsub213ph %ymm3, %ymm2, %ymm1");
5139
	asm volatile("vfmaddsub213ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5140
	asm volatile("vfmaddsub231ph %zmm3, %zmm2, %zmm1");
5141
	asm volatile("vfmaddsub231ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5142
	asm volatile("vfmaddsub231ph %xmm3, %xmm2, %xmm1");
5143
	asm volatile("vfmaddsub231ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5144
	asm volatile("vfmaddsub231ph %ymm3, %ymm2, %ymm1");
5145
	asm volatile("vfmaddsub231ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5146
	asm volatile("vfmsub132ph %zmm3, %zmm2, %zmm1");
5147
	asm volatile("vfmsub132ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5148
	asm volatile("vfmsub132ph %xmm3, %xmm2, %xmm1");
5149
	asm volatile("vfmsub132ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5150
	asm volatile("vfmsub132ph %ymm3, %ymm2, %ymm1");
5151
	asm volatile("vfmsub132ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5152
	asm volatile("vfmsub132sh %xmm3, %xmm2, %xmm1");
5153
	asm volatile("vfmsub132sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5154
	asm volatile("vfmsub213ph %zmm3, %zmm2, %zmm1");
5155
	asm volatile("vfmsub213ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5156
	asm volatile("vfmsub213ph %xmm3, %xmm2, %xmm1");
5157
	asm volatile("vfmsub213ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5158
	asm volatile("vfmsub213ph %ymm3, %ymm2, %ymm1");
5159
	asm volatile("vfmsub213ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5160
	asm volatile("vfmsub213sh %xmm3, %xmm2, %xmm1");
5161
	asm volatile("vfmsub213sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5162
	asm volatile("vfmsub231ph %zmm3, %zmm2, %zmm1");
5163
	asm volatile("vfmsub231ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5164
	asm volatile("vfmsub231ph %xmm3, %xmm2, %xmm1");
5165
	asm volatile("vfmsub231ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5166
	asm volatile("vfmsub231ph %ymm3, %ymm2, %ymm1");
5167
	asm volatile("vfmsub231ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5168
	asm volatile("vfmsub231sh %xmm3, %xmm2, %xmm1");
5169
	asm volatile("vfmsub231sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5170
	asm volatile("vfmsubadd132ph %zmm3, %zmm2, %zmm1");
5171
	asm volatile("vfmsubadd132ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5172
	asm volatile("vfmsubadd132ph %xmm3, %xmm2, %xmm1");
5173
	asm volatile("vfmsubadd132ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5174
	asm volatile("vfmsubadd132ph %ymm3, %ymm2, %ymm1");
5175
	asm volatile("vfmsubadd132ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5176
	asm volatile("vfmsubadd213ph %zmm3, %zmm2, %zmm1");
5177
	asm volatile("vfmsubadd213ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5178
	asm volatile("vfmsubadd213ph %xmm3, %xmm2, %xmm1");
5179
	asm volatile("vfmsubadd213ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5180
	asm volatile("vfmsubadd213ph %ymm3, %ymm2, %ymm1");
5181
	asm volatile("vfmsubadd213ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5182
	asm volatile("vfmsubadd231ph %zmm3, %zmm2, %zmm1");
5183
	asm volatile("vfmsubadd231ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5184
	asm volatile("vfmsubadd231ph %xmm3, %xmm2, %xmm1");
5185
	asm volatile("vfmsubadd231ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5186
	asm volatile("vfmsubadd231ph %ymm3, %ymm2, %ymm1");
5187
	asm volatile("vfmsubadd231ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5188
	asm volatile("vfmulcph %zmm3, %zmm2, %zmm1");
5189
	asm volatile("vfmulcph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5190
	asm volatile("vfmulcph %xmm3, %xmm2, %xmm1");
5191
	asm volatile("vfmulcph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5192
	asm volatile("vfmulcph %ymm3, %ymm2, %ymm1");
5193
	asm volatile("vfmulcph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5194
	asm volatile("vfmulcsh %xmm3, %xmm2, %xmm1");
5195
	asm volatile("vfmulcsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5196
	asm volatile("vfnmadd132ph %zmm3, %zmm2, %zmm1");
5197
	asm volatile("vfnmadd132ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5198
	asm volatile("vfnmadd132ph %xmm3, %xmm2, %xmm1");
5199
	asm volatile("vfnmadd132ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5200
	asm volatile("vfnmadd132ph %ymm3, %ymm2, %ymm1");
5201
	asm volatile("vfnmadd132ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5202
	asm volatile("vfnmadd132sh %xmm3, %xmm2, %xmm1");
5203
	asm volatile("vfnmadd132sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5204
	asm volatile("vfnmadd213ph %zmm3, %zmm2, %zmm1");
5205
	asm volatile("vfnmadd213ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5206
	asm volatile("vfnmadd213ph %xmm3, %xmm2, %xmm1");
5207
	asm volatile("vfnmadd213ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5208
	asm volatile("vfnmadd213ph %ymm3, %ymm2, %ymm1");
5209
	asm volatile("vfnmadd213ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5210
	asm volatile("vfnmadd213sh %xmm3, %xmm2, %xmm1");
5211
	asm volatile("vfnmadd213sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5212
	asm volatile("vfnmadd231ph %zmm3, %zmm2, %zmm1");
5213
	asm volatile("vfnmadd231ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5214
	asm volatile("vfnmadd231ph %xmm3, %xmm2, %xmm1");
5215
	asm volatile("vfnmadd231ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5216
	asm volatile("vfnmadd231ph %ymm3, %ymm2, %ymm1");
5217
	asm volatile("vfnmadd231ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5218
	asm volatile("vfnmadd231sh %xmm3, %xmm2, %xmm1");
5219
	asm volatile("vfnmadd231sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5220
	asm volatile("vfnmsub132ph %zmm3, %zmm2, %zmm1");
5221
	asm volatile("vfnmsub132ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5222
	asm volatile("vfnmsub132ph %xmm3, %xmm2, %xmm1");
5223
	asm volatile("vfnmsub132ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5224
	asm volatile("vfnmsub132ph %ymm3, %ymm2, %ymm1");
5225
	asm volatile("vfnmsub132ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5226
	asm volatile("vfnmsub132sh %xmm3, %xmm2, %xmm1");
5227
	asm volatile("vfnmsub132sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5228
	asm volatile("vfnmsub213ph %zmm3, %zmm2, %zmm1");
5229
	asm volatile("vfnmsub213ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5230
	asm volatile("vfnmsub213ph %xmm3, %xmm2, %xmm1");
5231
	asm volatile("vfnmsub213ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5232
	asm volatile("vfnmsub213ph %ymm3, %ymm2, %ymm1");
5233
	asm volatile("vfnmsub213ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5234
	asm volatile("vfnmsub213sh %xmm3, %xmm2, %xmm1");
5235
	asm volatile("vfnmsub213sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5236
	asm volatile("vfnmsub231ph %zmm3, %zmm2, %zmm1");
5237
	asm volatile("vfnmsub231ph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5238
	asm volatile("vfnmsub231ph %xmm3, %xmm2, %xmm1");
5239
	asm volatile("vfnmsub231ph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5240
	asm volatile("vfnmsub231ph %ymm3, %ymm2, %ymm1");
5241
	asm volatile("vfnmsub231ph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5242
	asm volatile("vfnmsub231sh %xmm3, %xmm2, %xmm1");
5243
	asm volatile("vfnmsub231sh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5244
	asm volatile("vfpclassph $0x12, %zmm1, %k5");
5245
	asm volatile("vfpclassph $0x12, %xmm1, %k5");
5246
	asm volatile("vfpclassph $0x12, %ymm1, %k5");
5247
	asm volatile("vfpclasssh $0x12, %xmm1, %k5");
5248
	asm volatile("vfpclasssh $0x12, 0x12345678(%eax,%ecx,8), %k5");
5249
	asm volatile("vgetexpph %zmm2, %zmm1");
5250
	asm volatile("vgetexpph 0x12345678(%eax,%ecx,8), %zmm1");
5251
	asm volatile("vgetexpph %xmm2, %xmm1");
5252
	asm volatile("vgetexpph 0x12345678(%eax,%ecx,8), %xmm1");
5253
	asm volatile("vgetexpph %ymm2, %ymm1");
5254
	asm volatile("vgetexpph 0x12345678(%eax,%ecx,8), %ymm1");
5255
	asm volatile("vgetexpsh %xmm3, %xmm2, %xmm1");
5256
	asm volatile("vgetexpsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5257
	asm volatile("vgetmantph $0x12, %zmm2, %zmm1");
5258
	asm volatile("vgetmantph $0x12, 0x12345678(%eax,%ecx,8), %zmm1");
5259
	asm volatile("vgetmantph $0x12, %xmm2, %xmm1");
5260
	asm volatile("vgetmantph $0x12, 0x12345678(%eax,%ecx,8), %xmm1");
5261
	asm volatile("vgetmantph $0x12, %ymm2, %ymm1");
5262
	asm volatile("vgetmantph $0x12, 0x12345678(%eax,%ecx,8), %ymm1");
5263
	asm volatile("vgetmantsh $0x12, %xmm3, %xmm2, %xmm1");
5264
	asm volatile("vgetmantsh $0x12, 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5265
	asm volatile("vmaxph %zmm3, %zmm2, %zmm1");
5266
	asm volatile("vmaxph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5267
	asm volatile("vmaxph %xmm3, %xmm2, %xmm1");
5268
	asm volatile("vmaxph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5269
	asm volatile("vmaxph %ymm3, %ymm2, %ymm1");
5270
	asm volatile("vmaxph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5271
	asm volatile("vmaxsh %xmm3, %xmm2, %xmm1");
5272
	asm volatile("vmaxsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5273
	asm volatile("vminph %zmm3, %zmm2, %zmm1");
5274
	asm volatile("vminph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5275
	asm volatile("vminph %xmm3, %xmm2, %xmm1");
5276
	asm volatile("vminph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5277
	asm volatile("vminph %ymm3, %ymm2, %ymm1");
5278
	asm volatile("vminph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5279
	asm volatile("vminsh %xmm3, %xmm2, %xmm1");
5280
	asm volatile("vminsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5281
	asm volatile("vmovsh %xmm1, 0x12345678(%eax,%ecx,8)");
5282
	asm volatile("vmovsh 0x12345678(%eax,%ecx,8), %xmm1");
5283
	asm volatile("vmovsh %xmm3, %xmm2, %xmm1");
5284
	asm volatile("vmovw %xmm1, %eax");
5285
	asm volatile("vmovw %xmm1, 0x12345678(%eax,%ecx,8)");
5286
	asm volatile("vmovw %eax, %xmm1");
5287
	asm volatile("vmovw 0x12345678(%eax,%ecx,8), %xmm1");
5288
	asm volatile("vmulph %zmm3, %zmm2, %zmm1");
5289
	asm volatile("vmulph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5290
	asm volatile("vmulph %xmm3, %xmm2, %xmm1");
5291
	asm volatile("vmulph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5292
	asm volatile("vmulph %ymm3, %ymm2, %ymm1");
5293
	asm volatile("vmulph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5294
	asm volatile("vmulsh %xmm3, %xmm2, %xmm1");
5295
	asm volatile("vmulsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5296
	asm volatile("vrcpph %zmm2, %zmm1");
5297
	asm volatile("vrcpph 0x12345678(%eax,%ecx,8), %zmm1");
5298
	asm volatile("vrcpph %xmm2, %xmm1");
5299
	asm volatile("vrcpph 0x12345678(%eax,%ecx,8), %xmm1");
5300
	asm volatile("vrcpph %ymm2, %ymm1");
5301
	asm volatile("vrcpph 0x12345678(%eax,%ecx,8), %ymm1");
5302
	asm volatile("vrcpsh %xmm3, %xmm2, %xmm1");
5303
	asm volatile("vrcpsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5304
	asm volatile("vreduceph $0x12, %zmm2, %zmm1");
5305
	asm volatile("vreduceph $0x12, 0x12345678(%eax,%ecx,8), %zmm1");
5306
	asm volatile("vreduceph $0x12, %xmm2, %xmm1");
5307
	asm volatile("vreduceph $0x12, 0x12345678(%eax,%ecx,8), %xmm1");
5308
	asm volatile("vreduceph $0x12, %ymm2, %ymm1");
5309
	asm volatile("vreduceph $0x12, 0x12345678(%eax,%ecx,8), %ymm1");
5310
	asm volatile("vreducesh $0x12, %xmm3, %xmm2, %xmm1");
5311
	asm volatile("vreducesh $0x12, 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5312
	asm volatile("vrndscaleph $0x12, %zmm2, %zmm1");
5313
	asm volatile("vrndscaleph $0x12, 0x12345678(%eax,%ecx,8), %zmm1");
5314
	asm volatile("vrndscaleph $0x12, %xmm2, %xmm1");
5315
	asm volatile("vrndscaleph $0x12, 0x12345678(%eax,%ecx,8), %xmm1");
5316
	asm volatile("vrndscaleph $0x12, %ymm2, %ymm1");
5317
	asm volatile("vrndscaleph $0x12, 0x12345678(%eax,%ecx,8), %ymm1");
5318
	asm volatile("vrndscalesh $0x12, %xmm3, %xmm2, %xmm1");
5319
	asm volatile("vrndscalesh $0x12, 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5320
	asm volatile("vrsqrtph %zmm2, %zmm1");
5321
	asm volatile("vrsqrtph 0x12345678(%eax,%ecx,8), %zmm1");
5322
	asm volatile("vrsqrtph %xmm2, %xmm1");
5323
	asm volatile("vrsqrtph 0x12345678(%eax,%ecx,8), %xmm1");
5324
	asm volatile("vrsqrtph %ymm2, %ymm1");
5325
	asm volatile("vrsqrtph 0x12345678(%eax,%ecx,8), %ymm1");
5326
	asm volatile("vrsqrtsh %xmm3, %xmm2, %xmm1");
5327
	asm volatile("vrsqrtsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5328
	asm volatile("vscalefph %zmm3, %zmm2, %zmm1");
5329
	asm volatile("vscalefph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5330
	asm volatile("vscalefph %xmm3, %xmm2, %xmm1");
5331
	asm volatile("vscalefph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5332
	asm volatile("vscalefph %ymm3, %ymm2, %ymm1");
5333
	asm volatile("vscalefph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5334
	asm volatile("vscalefsh %xmm3, %xmm2, %xmm1");
5335
	asm volatile("vscalefsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5336
	asm volatile("vsqrtph %zmm2, %zmm1");
5337
	asm volatile("vsqrtph 0x12345678(%eax,%ecx,8), %zmm1");
5338
	asm volatile("vsqrtph %xmm2, %xmm1");
5339
	asm volatile("vsqrtph 0x12345678(%eax,%ecx,8), %xmm1");
5340
	asm volatile("vsqrtph %ymm2, %ymm1");
5341
	asm volatile("vsqrtph 0x12345678(%eax,%ecx,8), %ymm1");
5342
	asm volatile("vsqrtsh %xmm3, %xmm2, %xmm1");
5343
	asm volatile("vsqrtsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5344
	asm volatile("vsubph %zmm3, %zmm2, %zmm1");
5345
	asm volatile("vsubph 0x12345678(%eax,%ecx,8), %zmm2, %zmm1");
5346
	asm volatile("vsubph %xmm3, %xmm2, %xmm1");
5347
	asm volatile("vsubph 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5348
	asm volatile("vsubph %ymm3, %ymm2, %ymm1");
5349
	asm volatile("vsubph 0x12345678(%eax,%ecx,8), %ymm2, %ymm1");
5350
	asm volatile("vsubsh %xmm3, %xmm2, %xmm1");
5351
	asm volatile("vsubsh 0x12345678(%eax,%ecx,8), %xmm2, %xmm1");
5352
	asm volatile("vucomish %xmm2, %xmm1");
5353
	asm volatile("vucomish 0x12345678(%eax,%ecx,8), %xmm1");
5354

5355
#endif /* #ifndef __x86_64__ */
5356

5357
	/* Key Locker */
5358

5359
	asm volatile("	loadiwkey %xmm1, %xmm2");
5360
	asm volatile("	encodekey128 %eax, %edx");
5361
	asm volatile("	encodekey256 %eax, %edx");
5362
	asm volatile("	aesenc128kl 0x77(%edx), %xmm3");
5363
	asm volatile("	aesenc256kl 0x77(%edx), %xmm3");
5364
	asm volatile("	aesdec128kl 0x77(%edx), %xmm3");
5365
	asm volatile("	aesdec256kl 0x77(%edx), %xmm3");
5366
	asm volatile("	aesencwide128kl	0x77(%edx)");
5367
	asm volatile("	aesencwide256kl	0x77(%edx)");
5368
	asm volatile("	aesdecwide128kl	0x77(%edx)");
5369
	asm volatile("	aesdecwide256kl	0x77(%edx)");
5370

5371
	/* Remote Atomic Operations */
5372

5373
	asm volatile("aadd %ecx,(%eax)");
5374
	asm volatile("aadd %edx,(0x12345678)");
5375
	asm volatile("aadd %edx,0x12345678(%eax,%ecx,8)");
5376

5377
	asm volatile("aand %ecx,(%eax)");
5378
	asm volatile("aand %edx,(0x12345678)");
5379
	asm volatile("aand %edx,0x12345678(%eax,%ecx,8)");
5380

5381
	asm volatile("aor %ecx,(%eax)");
5382
	asm volatile("aor %edx,(0x12345678)");
5383
	asm volatile("aor %edx,0x12345678(%eax,%ecx,8)");
5384

5385
	asm volatile("axor %ecx,(%eax)");
5386
	asm volatile("axor %edx,(0x12345678)");
5387
	asm volatile("axor %edx,0x12345678(%eax,%ecx,8)");
5388

5389
	/* AVX NE Convert */
5390

5391
	asm volatile("vbcstnebf162ps (%ecx),%xmm6");
5392
	asm volatile("vbcstnesh2ps (%ecx),%xmm6");
5393
	asm volatile("vcvtneebf162ps (%ecx),%xmm6");
5394
	asm volatile("vcvtneeph2ps (%ecx),%xmm6");
5395
	asm volatile("vcvtneobf162ps (%ecx),%xmm6");
5396
	asm volatile("vcvtneoph2ps (%ecx),%xmm6");
5397
	asm volatile("vcvtneps2bf16 %xmm1,%xmm6");
5398

5399
	/* AVX VNNI INT16 */
5400

5401
	asm volatile("vpdpbssd %xmm1,%xmm2,%xmm3");
5402
	asm volatile("vpdpbssds %xmm1,%xmm2,%xmm3");
5403
	asm volatile("vpdpbsud %xmm1,%xmm2,%xmm3");
5404
	asm volatile("vpdpbsuds %xmm1,%xmm2,%xmm3");
5405
	asm volatile("vpdpbuud %xmm1,%xmm2,%xmm3");
5406
	asm volatile("vpdpbuuds %xmm1,%xmm2,%xmm3");
5407
	asm volatile("vpdpwsud %xmm1,%xmm2,%xmm3");
5408
	asm volatile("vpdpwsuds %xmm1,%xmm2,%xmm3");
5409
	asm volatile("vpdpwusd %xmm1,%xmm2,%xmm3");
5410
	asm volatile("vpdpwusds %xmm1,%xmm2,%xmm3");
5411
	asm volatile("vpdpwuud %xmm1,%xmm2,%xmm3");
5412
	asm volatile("vpdpwuuds %xmm1,%xmm2,%xmm3");
5413

5414
	/* AVX IFMA */
5415

5416
	asm volatile("vpmadd52huq %xmm1,%xmm2,%xmm3");
5417
	asm volatile("vpmadd52luq %xmm1,%xmm2,%xmm3");
5418

5419
	/* AVX SHA512 */
5420

5421
	asm volatile("vsha512msg1 %xmm1,%ymm2");
5422
	asm volatile("vsha512msg2 %ymm1,%ymm2");
5423
	asm volatile("vsha512rnds2 %xmm1,%ymm2,%ymm3");
5424

5425
	/* AVX SM3 */
5426

5427
	asm volatile("vsm3msg1 %xmm1,%xmm2,%xmm3");
5428
	asm volatile("vsm3msg2 %xmm1,%xmm2,%xmm3");
5429
	asm volatile("vsm3rnds2 $0xa1,%xmm1,%xmm2,%xmm3");
5430

5431
	/* AVX SM4 */
5432

5433
	asm volatile("vsm4key4 %xmm1,%xmm2,%xmm3");
5434
	asm volatile("vsm4rnds4 %xmm1,%xmm2,%xmm3");
5435

5436
	/* Pre-fetch */
5437

5438
	asm volatile("prefetch (%eax)");
5439
	asm volatile("prefetcht0 (%eax)");
5440
	asm volatile("prefetcht1 (%eax)");
5441
	asm volatile("prefetcht2 (%eax)");
5442
	asm volatile("prefetchnta (%eax)");
5443

5444
	/* Non-serializing write MSR */
5445

5446
	asm volatile("wrmsrns");
5447

5448
	/* Prediction history reset */
5449

5450
	asm volatile("hreset $0");
5451

5452
	/* Serialize instruction execution */
5453

5454
	asm volatile("serialize");
5455

5456
	/* TSX suspend load address tracking */
5457

5458
	asm volatile("xresldtrk");
5459
	asm volatile("xsusldtrk");
5460

5461
	/* SGX */
5462

5463
	asm volatile("encls");
5464
	asm volatile("enclu");
5465
	asm volatile("enclv");
5466

5467
	/* pconfig */
5468

5469
	asm volatile("pconfig");
5470

5471
	/* wbnoinvd */
5472

5473
	asm volatile("wbnoinvd");
5474

5475
	/* Following line is a marker for the awk script - do not change */
5476
	asm volatile("rdtsc"); /* Stop here */
5477

5478
	return 0;
5479
}
5480

5481
Product

Resources

Company
