Debian Codegraph @

internal/engine/wazevo/backend/isa/amd64/instr_encoding_test.go

raw
1 package amd64
2
3 import (
4 "encoding/hex"
5 "runtime"
6 "testing"
7
8 "github.com/tetratelabs/wazero/internal/testing/require"
9 )
10
11 func TestInstruction_format_encode(t *testing.T) {
12 _, _, m := newSetupWithMockContext()
13 defer func() { runtime.KeepAlive(m) }()
14 newAmodeImmReg := m.newAmodeImmReg
15 newAmodeRegRegShift := m.newAmodeRegRegShift
16 allocateExitSeq := m.allocateExitSeq
17
18 for _, tc := range []struct {
19 setup func(*instruction)
20 want string
21 wantFormat string
22 }{
23 {
24 setup: func(i *instruction) { i.asRet() },
25 wantFormat: "ret",
26 want: "c3",
27 },
28 {
29 setup: func(i *instruction) { i.asImm(r14VReg, 1234567, false) },
30 wantFormat: "movl $1234567, %r14d",
31 want: "41be87d61200",
32 },
33 {
34 setup: func(i *instruction) {
35 v := -126
36 i.asImm(r14VReg, uint64(int64(v)), false)
37 },
38 wantFormat: "movl $-126, %r14d",
39 want: "41be82ffffff",
40 },
41 {
42 setup: func(i *instruction) { i.asImm(r14VReg, 0x200000000, true) },
43 want: "49be0000000002000000",
44 wantFormat: "movabsq $8589934592, %r14",
45 },
46 {
47 setup: func(i *instruction) {
48 v := -126
49 i.asImm(r14VReg, uint64(int64(v)), true)
50 },
51 want: "49c7c682ffffff",
52 wantFormat: "movabsq $-126, %r14",
53 },
54 {
55 setup: func(i *instruction) { i.asImm(rcxVReg, 1234567, false) },
56 wantFormat: "movl $1234567, %ecx",
57 want: "b987d61200",
58 },
59 {
60 setup: func(i *instruction) {
61 v := -126
62 i.asImm(rcxVReg, uint64(int64(v)), false)
63 },
64 wantFormat: "movl $-126, %ecx",
65 want: "b982ffffff",
66 },
67 {
68 setup: func(i *instruction) { i.asImm(rcxVReg, 0x200000000, true) },
69 want: "48b90000000002000000",
70 wantFormat: "movabsq $8589934592, %rcx",
71 },
72 {
73 setup: func(i *instruction) {
74 v := -126
75 i.asImm(rcxVReg, uint64(int64(v)), true)
76 },
77 want: "48c7c182ffffff",
78 wantFormat: "movabsq $-126, %rcx",
79 },
80 {
81 setup: func(i *instruction) { i.asSignExtendData(false) },
82 want: "99",
83 wantFormat: "cdq",
84 },
85 {
86 setup: func(i *instruction) { i.asSignExtendData(true) },
87 want: "4899",
88 wantFormat: "cqo",
89 },
90 {
91 setup: func(i *instruction) { i.asDiv(newOperandReg(raxVReg), true, true) },
92 want: "48f7f8",
93 wantFormat: "idivq %rax",
94 },
95 {
96 setup: func(i *instruction) { i.asDiv(newOperandReg(raxVReg), false, true) },
97 want: "48f7f0",
98 wantFormat: "divq %rax",
99 },
100 {
101 setup: func(i *instruction) { i.asDiv(newOperandReg(raxVReg), true, false) },
102 want: "f7f8",
103 wantFormat: "idivl %eax",
104 },
105 {
106 setup: func(i *instruction) { i.asDiv(newOperandReg(raxVReg), false, false) },
107 want: "f7f0",
108 wantFormat: "divl %eax",
109 },
110 {
111 setup: func(i *instruction) { i.asDiv(newOperandMem(newAmodeImmReg(123, raxVReg)), true, true) },
112 want: "48f7787b",
113 wantFormat: "idivq 123(%rax)",
114 },
115 {
116 setup: func(i *instruction) { i.asDiv(newOperandMem(newAmodeImmReg(123, raxVReg)), false, true) },
117 want: "48f7707b",
118 wantFormat: "divq 123(%rax)",
119 },
120 {
121 setup: func(i *instruction) { i.asDiv(newOperandMem(newAmodeImmReg(123, raxVReg)), true, false) },
122 want: "f7787b",
123 wantFormat: "idivl 123(%rax)",
124 },
125 {
126 setup: func(i *instruction) { i.asDiv(newOperandMem(newAmodeImmReg(123, raxVReg)), false, false) },
127 want: "f7707b",
128 wantFormat: "divl 123(%rax)",
129 },
130 {
131 setup: func(i *instruction) { i.asMovRR(raxVReg, rdiVReg, false) },
132 want: "89c7",
133 wantFormat: "movl %eax, %edi",
134 },
135 {
136 setup: func(i *instruction) { i.asMovRR(raxVReg, r15VReg, false) },
137 want: "4189c7",
138 wantFormat: "movl %eax, %r15d",
139 },
140 {
141 setup: func(i *instruction) { i.asMovRR(r14VReg, r15VReg, false) },
142 want: "4589f7",
143 wantFormat: "movl %r14d, %r15d",
144 },
145 {
146 setup: func(i *instruction) { i.asMovRR(raxVReg, rcxVReg, true) },
147 want: "4889c1",
148 wantFormat: "movq %rax, %rcx",
149 },
150 {
151 setup: func(i *instruction) { i.asMovRR(raxVReg, r15VReg, true) },
152 want: "4989c7",
153 wantFormat: "movq %rax, %r15",
154 },
155 {
156 setup: func(i *instruction) { i.asMovRR(r11VReg, r12VReg, true) },
157 want: "4d89dc",
158 wantFormat: "movq %r11, %r12",
159 },
160 {
161 setup: func(i *instruction) { i.asNot(newOperandReg(raxVReg), false) },
162 want: "f7d0",
163 wantFormat: "notl %eax",
164 },
165 {
166 setup: func(i *instruction) { i.asNot(newOperandReg(raxVReg), true) },
167 want: "48f7d0",
168 wantFormat: "notq %rax",
169 },
170 {
171 setup: func(i *instruction) { i.asNeg(newOperandReg(raxVReg), false) },
172 want: "f7d8",
173 wantFormat: "negl %eax",
174 },
175 {
176 setup: func(i *instruction) { i.asNeg(newOperandReg(raxVReg), true) },
177 want: "48f7d8",
178 wantFormat: "negq %rax",
179 },
180 {
181 setup: func(i *instruction) { i.asMulHi(newOperandReg(rsiVReg), true, false) },
182 want: "f7ee",
183 wantFormat: "imull %esi",
184 },
185 {
186 setup: func(i *instruction) { i.asMulHi(newOperandReg(r14VReg), false, false) },
187 want: "41f7e6",
188 wantFormat: "mull %r14d",
189 },
190 {
191 setup: func(i *instruction) { i.asMulHi(newOperandReg(r15VReg), true, true) },
192 want: "49f7ef",
193 wantFormat: "imulq %r15",
194 },
195 {
196 setup: func(i *instruction) { i.asMulHi(newOperandReg(rdiVReg), false, true) },
197 want: "48f7e7",
198 wantFormat: "mulq %rdi",
199 },
200 {
201 setup: func(i *instruction) { i.asMulHi(newOperandMem(newAmodeImmReg(123, raxVReg)), true, false) },
202 want: "f7687b",
203 wantFormat: "imull 123(%rax)",
204 },
205 {
206 setup: func(i *instruction) { i.asMulHi(newOperandMem(newAmodeImmReg(123, raxVReg)), false, false) },
207 want: "f7607b",
208 wantFormat: "mull 123(%rax)",
209 },
210 {
211 setup: func(i *instruction) { i.asMulHi(newOperandMem(newAmodeImmReg(123, raxVReg)), true, true) },
212 want: "48f7687b",
213 wantFormat: "imulq 123(%rax)",
214 },
215 {
216 setup: func(i *instruction) { i.asMulHi(newOperandMem(newAmodeImmReg(123, raxVReg)), false, true) },
217 want: "48f7607b",
218 wantFormat: "mulq 123(%rax)",
219 },
220 // bsr
221 {
222 setup: func(i *instruction) { i.asUnaryRmR(unaryRmROpcodeBsr, newOperandReg(raxVReg), rdiVReg, false) },
223 want: "0fbdf8",
224 wantFormat: "bsrl %eax, %edi",
225 },
226 {
227 setup: func(i *instruction) {
228 i.asUnaryRmR(unaryRmROpcodeBsr, newOperandMem(newAmodeImmReg(123, raxVReg)), rdiVReg, false)
229 },
230 want: "0fbd787b",
231 wantFormat: "bsrl 123(%rax), %edi",
232 },
233 // bsf
234 {
235 setup: func(i *instruction) { i.asUnaryRmR(unaryRmROpcodeBsf, newOperandReg(raxVReg), rdiVReg, false) },
236 want: "0fbcf8",
237 wantFormat: "bsfl %eax, %edi",
238 },
239 {
240 setup: func(i *instruction) {
241 i.asUnaryRmR(unaryRmROpcodeBsf, newOperandMem(newAmodeImmReg(123, raxVReg)), rdiVReg, false)
242 },
243 want: "0fbc787b",
244 wantFormat: "bsfl 123(%rax), %edi",
245 },
246 // tzcnt
247 {
248 setup: func(i *instruction) { i.asUnaryRmR(unaryRmROpcodeTzcnt, newOperandReg(raxVReg), rdiVReg, false) },
249 want: "f30fbcf8",
250 wantFormat: "tzcntl %eax, %edi",
251 },
252 {
253 setup: func(i *instruction) {
254 i.asUnaryRmR(unaryRmROpcodeTzcnt, newOperandMem(newAmodeImmReg(123, raxVReg)), rdiVReg, false)
255 },
256 want: "f30fbc787b",
257 wantFormat: "tzcntl 123(%rax), %edi",
258 },
259 // lzcnt
260 {
261 setup: func(i *instruction) { i.asUnaryRmR(unaryRmROpcodeLzcnt, newOperandReg(raxVReg), rdiVReg, false) },
262 want: "f30fbdf8",
263 wantFormat: "lzcntl %eax, %edi",
264 },
265 {
266 setup: func(i *instruction) {
267 i.asUnaryRmR(unaryRmROpcodeLzcnt, newOperandMem(newAmodeImmReg(123, raxVReg)), rdiVReg, false)
268 },
269 want: "f30fbd787b",
270 wantFormat: "lzcntl 123(%rax), %edi",
271 },
272 // popcnt
273 {
274 setup: func(i *instruction) { i.asUnaryRmR(unaryRmROpcodePopcnt, newOperandReg(raxVReg), rdiVReg, false) },
275 want: "f30fb8f8",
276 wantFormat: "popcntl %eax, %edi",
277 },
278 {
279 setup: func(i *instruction) {
280 i.asUnaryRmR(unaryRmROpcodePopcnt, newOperandMem(newAmodeImmReg(123, raxVReg)), rdiVReg, false)
281 },
282 want: "f30fb8787b",
283 wantFormat: "popcntl 123(%rax), %edi",
284 },
285 // bsr
286 {
287 setup: func(i *instruction) { i.asUnaryRmR(unaryRmROpcodeBsr, newOperandReg(raxVReg), rdiVReg, true) },
288 want: "480fbdf8",
289 wantFormat: "bsrq %rax, %rdi",
290 },
291 {
292 setup: func(i *instruction) {
293 i.asUnaryRmR(unaryRmROpcodeBsr, newOperandMem(newAmodeImmReg(123, raxVReg)), rdiVReg, true)
294 },
295 want: "480fbd787b",
296 wantFormat: "bsrq 123(%rax), %rdi",
297 },
298 // bsf
299 {
300 setup: func(i *instruction) { i.asUnaryRmR(unaryRmROpcodeBsf, newOperandReg(raxVReg), rdiVReg, true) },
301 want: "480fbcf8",
302 wantFormat: "bsfq %rax, %rdi",
303 },
304 {
305 setup: func(i *instruction) {
306 i.asUnaryRmR(unaryRmROpcodeBsf, newOperandMem(newAmodeImmReg(123, raxVReg)), rdiVReg, true)
307 },
308 want: "480fbc787b",
309 wantFormat: "bsfq 123(%rax), %rdi",
310 },
311 // tzcnt
312 {
313 setup: func(i *instruction) { i.asUnaryRmR(unaryRmROpcodeTzcnt, newOperandReg(raxVReg), rdiVReg, true) },
314 want: "f3480fbcf8",
315 wantFormat: "tzcntq %rax, %rdi",
316 },
317 {
318 setup: func(i *instruction) {
319 i.asUnaryRmR(unaryRmROpcodeTzcnt, newOperandMem(newAmodeImmReg(123, raxVReg)), rdiVReg, true)
320 },
321 want: "f3480fbc787b",
322 wantFormat: "tzcntq 123(%rax), %rdi",
323 },
324 // lzcnt
325 {
326 setup: func(i *instruction) { i.asUnaryRmR(unaryRmROpcodeLzcnt, newOperandReg(raxVReg), rdiVReg, true) },
327 want: "f3480fbdf8",
328 wantFormat: "lzcntq %rax, %rdi",
329 },
330 {
331 setup: func(i *instruction) {
332 i.asUnaryRmR(unaryRmROpcodeLzcnt, newOperandMem(newAmodeImmReg(123, raxVReg)), rdiVReg, true)
333 },
334 want: "f3480fbd787b",
335 wantFormat: "lzcntq 123(%rax), %rdi",
336 },
337 // popcnt
338 {
339 setup: func(i *instruction) { i.asUnaryRmR(unaryRmROpcodePopcnt, newOperandReg(raxVReg), rdiVReg, true) },
340 want: "f3480fb8f8",
341 wantFormat: "popcntq %rax, %rdi",
342 },
343 {
344 setup: func(i *instruction) {
345 i.asUnaryRmR(unaryRmROpcodePopcnt, newOperandMem(newAmodeImmReg(123, raxVReg)), rdiVReg, true)
346 },
347 want: "f3480fb8787b",
348 wantFormat: "popcntq 123(%rax), %rdi",
349 },
350 // addss
351 {
352 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeAddss, newOperandReg(xmm1VReg), xmm0VReg) },
353 want: "f30f58c1",
354 wantFormat: "addss %xmm1, %xmm0",
355 },
356 {
357 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeAddss, newOperandReg(xmm13VReg), xmm11VReg) },
358 want: "f3450f58dd",
359 wantFormat: "addss %xmm13, %xmm11",
360 },
361 {
362 setup: func(i *instruction) {
363 i.asXmmRmR(sseOpcodeAddss, newOperandMem(newAmodeImmReg(0, r13VReg)), xmm11VReg)
364 },
365 want: "f3450f585d00",
366 wantFormat: "addss (%r13), %xmm11",
367 },
368 {
369 setup: func(i *instruction) {
370 i.asXmmRmR(sseOpcodeAddss, newOperandMem(newAmodeImmReg(123, r13VReg)), xmm11VReg)
371 },
372 want: "f3450f585d7b",
373 wantFormat: "addss 123(%r13), %xmm11",
374 },
375 {
376 setup: func(i *instruction) {
377 i.asXmmRmR(sseOpcodeAddss, newOperandMem(newAmodeImmReg(1<<25, r13VReg)), xmm11VReg)
378 },
379 want: "f3450f589d00000002",
380 wantFormat: "addss 33554432(%r13), %xmm11",
381 },
382 {
383 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeAddsd, newOperandReg(xmm1VReg), xmm0VReg) },
384 want: "f20f58c1",
385 wantFormat: "addsd %xmm1, %xmm0",
386 },
387 {
388 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeAddsd, newOperandReg(xmm13VReg), xmm11VReg) },
389 want: "f2450f58dd",
390 wantFormat: "addsd %xmm13, %xmm11",
391 },
392 {
393 setup: func(i *instruction) {
394 i.asXmmRmR(sseOpcodeAddsd, newOperandMem(newAmodeImmReg(0, rbpVReg)), xmm11VReg)
395 },
396 want: "f2440f585d00",
397 wantFormat: "addsd (%rbp), %xmm11",
398 },
399 {
400 setup: func(i *instruction) {
401 i.asXmmRmR(sseOpcodeAddsd, newOperandMem(newAmodeImmReg(123, rbpVReg)), xmm11VReg)
402 },
403 want: "f2440f585d7b",
404 wantFormat: "addsd 123(%rbp), %xmm11",
405 },
406 {
407 setup: func(i *instruction) {
408 i.asXmmRmR(sseOpcodeAddsd, newOperandMem(newAmodeImmReg(1<<25, rbpVReg)), xmm11VReg)
409 },
410 want: "f2440f589d00000002",
411 wantFormat: "addsd 33554432(%rbp), %xmm11",
412 },
413 {
414 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeAddps, newOperandReg(xmm1VReg), xmm0VReg) },
415 want: "0f58c1",
416 wantFormat: "addps %xmm1, %xmm0",
417 },
418 {
419 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeAddpd, newOperandReg(xmm1VReg), xmm0VReg) },
420 want: "660f58c1",
421 wantFormat: "addpd %xmm1, %xmm0",
422 },
423 {
424 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeAddss, newOperandReg(xmm1VReg), xmm0VReg) },
425 want: "f30f58c1",
426 wantFormat: "addss %xmm1, %xmm0",
427 },
428 {
429 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeAddsd, newOperandReg(xmm1VReg), xmm0VReg) },
430 want: "f20f58c1",
431 wantFormat: "addsd %xmm1, %xmm0",
432 },
433 {
434 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeAndps, newOperandReg(xmm1VReg), xmm0VReg) },
435 want: "0f54c1",
436 wantFormat: "andps %xmm1, %xmm0",
437 },
438 {
439 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeAndpd, newOperandReg(xmm1VReg), xmm0VReg) },
440 want: "660f54c1",
441 wantFormat: "andpd %xmm1, %xmm0",
442 },
443 {
444 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeAndnps, newOperandReg(xmm1VReg), xmm0VReg) },
445 want: "0f55c1",
446 wantFormat: "andnps %xmm1, %xmm0",
447 },
448 {
449 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeAndnpd, newOperandReg(xmm1VReg), xmm0VReg) },
450 want: "660f55c1",
451 wantFormat: "andnpd %xmm1, %xmm0",
452 },
453 {
454 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeBlendvpd, newOperandReg(xmm1VReg), xmm0VReg) },
455 want: "660f3815c1",
456 wantFormat: "blendvpd %xmm1, %xmm0",
457 },
458 {
459 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeBlendvps, newOperandReg(xmm1VReg), xmm0VReg) },
460 want: "660f3814c1",
461 wantFormat: "blendvps %xmm1, %xmm0",
462 },
463 {
464 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeCvttps2dq, newOperandReg(xmm1VReg), xmm0VReg) },
465 want: "f30f5bc1",
466 wantFormat: "cvttps2dq %xmm1, %xmm0",
467 },
468 {
469 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeCvtdq2ps, newOperandReg(xmm1VReg), xmm0VReg) },
470 want: "0f5bc1",
471 wantFormat: "cvtdq2ps %xmm1, %xmm0",
472 },
473 {
474 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeCvtdq2pd, newOperandReg(xmm1VReg), xmm0VReg) },
475 want: "f30fe6c1",
476 wantFormat: "cvtdq2pd %xmm1, %xmm0",
477 },
478 {
479 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeDivps, newOperandReg(xmm1VReg), xmm0VReg) },
480 want: "0f5ec1",
481 wantFormat: "divps %xmm1, %xmm0",
482 },
483 {
484 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeDivpd, newOperandReg(xmm1VReg), xmm0VReg) },
485 want: "660f5ec1",
486 wantFormat: "divpd %xmm1, %xmm0",
487 },
488 {
489 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeDivss, newOperandReg(xmm1VReg), xmm0VReg) },
490 want: "f30f5ec1",
491 wantFormat: "divss %xmm1, %xmm0",
492 },
493 {
494 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeDivsd, newOperandReg(xmm1VReg), xmm0VReg) },
495 want: "f20f5ec1",
496 wantFormat: "divsd %xmm1, %xmm0",
497 },
498 {
499 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMaxps, newOperandReg(xmm1VReg), xmm0VReg) },
500 want: "0f5fc1",
501 wantFormat: "maxps %xmm1, %xmm0",
502 },
503 {
504 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMaxpd, newOperandReg(xmm1VReg), xmm0VReg) },
505 want: "660f5fc1",
506 wantFormat: "maxpd %xmm1, %xmm0",
507 },
508 {
509 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMaxss, newOperandReg(xmm1VReg), xmm0VReg) },
510 want: "f30f5fc1",
511 wantFormat: "maxss %xmm1, %xmm0",
512 },
513 {
514 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMaxsd, newOperandReg(xmm1VReg), xmm0VReg) },
515 want: "f20f5fc1",
516 wantFormat: "maxsd %xmm1, %xmm0",
517 },
518 {
519 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMinps, newOperandReg(xmm1VReg), xmm0VReg) },
520 want: "0f5dc1",
521 wantFormat: "minps %xmm1, %xmm0",
522 },
523 {
524 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePaddsw, newOperandReg(xmm7VReg), xmm6VReg) },
525 want: "660fedf7",
526 wantFormat: "paddsw %xmm7, %xmm6",
527 },
528 {
529 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePaddusb, newOperandReg(xmm1VReg), xmm0VReg) },
530 want: "660fdcc1",
531 wantFormat: "paddusb %xmm1, %xmm0",
532 },
533 {
534 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePaddusw, newOperandReg(xmm1VReg), xmm0VReg) },
535 want: "660fddc1",
536 wantFormat: "paddusw %xmm1, %xmm0",
537 },
538 {
539 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePand, newOperandReg(xmm1VReg), xmm0VReg) },
540 want: "660fdbc1",
541 wantFormat: "pand %xmm1, %xmm0",
542 },
543 {
544 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePandn, newOperandReg(xmm1VReg), xmm0VReg) },
545 want: "660fdfc1",
546 wantFormat: "pandn %xmm1, %xmm0",
547 },
548 {
549 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePavgb, newOperandReg(xmm1VReg), xmm0VReg) },
550 want: "660fe0c1",
551 wantFormat: "pavgb %xmm1, %xmm0",
552 },
553 {
554 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePavgw, newOperandReg(xmm1VReg), xmm0VReg) },
555 want: "660fe3c1",
556 wantFormat: "pavgw %xmm1, %xmm0",
557 },
558 {
559 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePcmpeqb, newOperandReg(xmm1VReg), xmm0VReg) },
560 want: "660f74c1",
561 wantFormat: "pcmpeqb %xmm1, %xmm0",
562 },
563 {
564 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePcmpeqw, newOperandReg(xmm1VReg), xmm0VReg) },
565 want: "660f75c1",
566 wantFormat: "pcmpeqw %xmm1, %xmm0",
567 },
568 {
569 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePcmpeqd, newOperandReg(xmm1VReg), xmm0VReg) },
570 want: "660f76c1",
571 wantFormat: "pcmpeqd %xmm1, %xmm0",
572 },
573 {
574 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePcmpeqq, newOperandReg(xmm1VReg), xmm0VReg) },
575 want: "660f3829c1",
576 wantFormat: "pcmpeqq %xmm1, %xmm0",
577 },
578 {
579 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePcmpgtb, newOperandReg(xmm1VReg), xmm0VReg) },
580 want: "660f64c1",
581 wantFormat: "pcmpgtb %xmm1, %xmm0",
582 },
583 {
584 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePcmpgtw, newOperandReg(xmm1VReg), xmm0VReg) },
585 want: "660f65c1",
586 wantFormat: "pcmpgtw %xmm1, %xmm0",
587 },
588 {
589 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePcmpgtd, newOperandReg(xmm1VReg), xmm0VReg) },
590 want: "660f66c1",
591 wantFormat: "pcmpgtd %xmm1, %xmm0",
592 },
593 {
594 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePcmpgtq, newOperandReg(xmm1VReg), xmm0VReg) },
595 want: "660f3837c1",
596 wantFormat: "pcmpgtq %xmm1, %xmm0",
597 },
598 {
599 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePmaddwd, newOperandReg(xmm1VReg), xmm0VReg) },
600 want: "660ff5c1",
601 wantFormat: "pmaddwd %xmm1, %xmm0",
602 },
603 {
604 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePmaxsb, newOperandReg(xmm1VReg), xmm0VReg) },
605 want: "660f383cc1",
606 wantFormat: "pmaxsb %xmm1, %xmm0",
607 },
608 {
609 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePmaxsw, newOperandReg(xmm1VReg), xmm0VReg) },
610 want: "660feec1",
611 wantFormat: "pmaxsw %xmm1, %xmm0",
612 },
613 {
614 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePmaxsd, newOperandReg(xmm1VReg), xmm0VReg) },
615 want: "660f383dc1",
616 wantFormat: "pmaxsd %xmm1, %xmm0",
617 },
618 {
619 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePmaxub, newOperandReg(xmm1VReg), xmm0VReg) },
620 want: "660fdec1",
621 wantFormat: "pmaxub %xmm1, %xmm0",
622 },
623 {
624 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePmaxuw, newOperandReg(xmm1VReg), xmm0VReg) },
625 want: "660f383ec1",
626 wantFormat: "pmaxuw %xmm1, %xmm0",
627 },
628 {
629 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePmaxud, newOperandReg(xmm1VReg), xmm0VReg) },
630 want: "660f383fc1",
631 wantFormat: "pmaxud %xmm1, %xmm0",
632 },
633 {
634 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePminsb, newOperandReg(xmm1VReg), xmm0VReg) },
635 want: "660f3838c1",
636 wantFormat: "pminsb %xmm1, %xmm0",
637 },
638 {
639 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePminsw, newOperandReg(xmm1VReg), xmm0VReg) },
640 want: "660feac1",
641 wantFormat: "pminsw %xmm1, %xmm0",
642 },
643 {
644 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePminsd, newOperandReg(xmm1VReg), xmm0VReg) },
645 want: "660f3839c1",
646 wantFormat: "pminsd %xmm1, %xmm0",
647 },
648 {
649 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePminub, newOperandReg(xmm1VReg), xmm0VReg) },
650 want: "660fdac1",
651 wantFormat: "pminub %xmm1, %xmm0",
652 },
653 {
654 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePminuw, newOperandReg(xmm1VReg), xmm0VReg) },
655 want: "660f383ac1",
656 wantFormat: "pminuw %xmm1, %xmm0",
657 },
658 {
659 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePminud, newOperandReg(xmm1VReg), xmm0VReg) },
660 want: "660f383bc1",
661 wantFormat: "pminud %xmm1, %xmm0",
662 },
663 {
664 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePmulld, newOperandReg(xmm1VReg), xmm0VReg) },
665 want: "660f3840c1",
666 wantFormat: "pmulld %xmm1, %xmm0",
667 },
668 {
669 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePmullw, newOperandReg(xmm1VReg), xmm0VReg) },
670 want: "660fd5c1",
671 wantFormat: "pmullw %xmm1, %xmm0",
672 },
673 {
674 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePmuludq, newOperandReg(xmm1VReg), xmm0VReg) },
675 want: "660ff4c1",
676 wantFormat: "pmuludq %xmm1, %xmm0",
677 },
678 {
679 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePor, newOperandReg(xmm1VReg), xmm0VReg) },
680 want: "660febc1",
681 wantFormat: "por %xmm1, %xmm0",
682 },
683 {
684 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePshufb, newOperandReg(xmm1VReg), xmm0VReg) },
685 want: "660f3800c1",
686 wantFormat: "pshufb %xmm1, %xmm0",
687 },
688 {
689 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePsubb, newOperandReg(xmm1VReg), xmm0VReg) },
690 want: "660ff8c1",
691 wantFormat: "psubb %xmm1, %xmm0",
692 },
693 {
694 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePsubd, newOperandReg(xmm1VReg), xmm0VReg) },
695 want: "660ffac1",
696 wantFormat: "psubd %xmm1, %xmm0",
697 },
698 {
699 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePsubq, newOperandReg(xmm1VReg), xmm0VReg) },
700 want: "660ffbc1",
701 wantFormat: "psubq %xmm1, %xmm0",
702 },
703 {
704 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePsubw, newOperandReg(xmm1VReg), xmm0VReg) },
705 want: "660ff9c1",
706 wantFormat: "psubw %xmm1, %xmm0",
707 },
708 {
709 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePsubsb, newOperandReg(xmm1VReg), xmm0VReg) },
710 want: "660fe8c1",
711 wantFormat: "psubsb %xmm1, %xmm0",
712 },
713 {
714 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePsubsw, newOperandReg(xmm1VReg), xmm0VReg) },
715 want: "660fe9c1",
716 wantFormat: "psubsw %xmm1, %xmm0",
717 },
718 {
719 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePsubusb, newOperandReg(xmm1VReg), xmm0VReg) },
720 want: "660fd8c1",
721 wantFormat: "psubusb %xmm1, %xmm0",
722 },
723 {
724 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePsubusw, newOperandReg(xmm1VReg), xmm0VReg) },
725 want: "660fd9c1",
726 wantFormat: "psubusw %xmm1, %xmm0",
727 },
728 {
729 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePunpckhbw, newOperandReg(xmm1VReg), xmm0VReg) },
730 want: "660f68c1",
731 wantFormat: "punpckhbw %xmm1, %xmm0",
732 },
733 {
734 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePunpcklbw, newOperandReg(xmm1VReg), xmm0VReg) },
735 want: "660f60c1",
736 wantFormat: "punpcklbw %xmm1, %xmm0",
737 },
738 {
739 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePxor, newOperandReg(xmm1VReg), xmm0VReg) },
740 want: "660fefc1",
741 wantFormat: "pxor %xmm1, %xmm0",
742 },
743 {
744 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeSubps, newOperandReg(xmm1VReg), xmm0VReg) },
745 want: "0f5cc1",
746 wantFormat: "subps %xmm1, %xmm0",
747 },
748 {
749 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeSubpd, newOperandReg(xmm1VReg), xmm0VReg) },
750 want: "660f5cc1",
751 wantFormat: "subpd %xmm1, %xmm0",
752 },
753 {
754 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeSubss, newOperandReg(xmm1VReg), xmm0VReg) },
755 want: "f30f5cc1",
756 wantFormat: "subss %xmm1, %xmm0",
757 },
758 {
759 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeSubsd, newOperandReg(xmm1VReg), xmm0VReg) },
760 want: "f20f5cc1",
761 wantFormat: "subsd %xmm1, %xmm0",
762 },
763 {
764 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeXorps, newOperandReg(xmm1VReg), xmm0VReg) },
765 want: "0f57c1",
766 wantFormat: "xorps %xmm1, %xmm0",
767 },
768 {
769 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeXorps, newOperandReg(xmm1VReg), xmm0VReg) },
770 want: "0f57c1",
771 wantFormat: "xorps %xmm1, %xmm0",
772 },
773 {
774 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeXorpd, newOperandReg(xmm1VReg), xmm0VReg) },
775 want: "660f57c1",
776 wantFormat: "xorpd %xmm1, %xmm0",
777 },
778 {
779 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeXorpd, newOperandReg(xmm1VReg), xmm0VReg) },
780 want: "660f57c1",
781 wantFormat: "xorpd %xmm1, %xmm0",
782 },
783 {
784 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMinpd, newOperandReg(xmm1VReg), xmm0VReg) },
785 want: "660f5dc1",
786 wantFormat: "minpd %xmm1, %xmm0",
787 },
788 {
789 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMinss, newOperandReg(xmm1VReg), xmm0VReg) },
790 want: "f30f5dc1",
791 wantFormat: "minss %xmm1, %xmm0",
792 },
793 {
794 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMinsd, newOperandReg(xmm1VReg), xmm0VReg) },
795 want: "f20f5dc1",
796 wantFormat: "minsd %xmm1, %xmm0",
797 },
798 {
799 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMovlhps, newOperandReg(xmm1VReg), xmm0VReg) },
800 want: "0f16c1",
801 wantFormat: "movlhps %xmm1, %xmm0",
802 },
803 {
804 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMovsd, newOperandReg(xmm1VReg), xmm0VReg) },
805 want: "f20f10c1",
806 wantFormat: "movsd %xmm1, %xmm0",
807 },
808 {
809 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMulps, newOperandReg(xmm1VReg), xmm0VReg) },
810 want: "0f59c1",
811 wantFormat: "mulps %xmm1, %xmm0",
812 },
813 {
814 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMulpd, newOperandReg(xmm1VReg), xmm0VReg) },
815 want: "660f59c1",
816 wantFormat: "mulpd %xmm1, %xmm0",
817 },
818 {
819 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMulss, newOperandReg(xmm1VReg), xmm0VReg) },
820 want: "f30f59c1",
821 wantFormat: "mulss %xmm1, %xmm0",
822 },
823 {
824 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeMulsd, newOperandReg(xmm1VReg), xmm0VReg) },
825 want: "f20f59c1",
826 wantFormat: "mulsd %xmm1, %xmm0",
827 },
828 {
829 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeOrpd, newOperandReg(xmm1VReg), xmm0VReg) },
830 want: "660f56c1",
831 wantFormat: "orpd %xmm1, %xmm0",
832 },
833 {
834 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeOrps, newOperandReg(xmm1VReg), xmm0VReg) },
835 want: "0f56c1",
836 wantFormat: "orps %xmm1, %xmm0",
837 },
838 {
839 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePackssdw, newOperandReg(xmm1VReg), xmm0VReg) },
840 want: "660f6bc1",
841 wantFormat: "packssdw %xmm1, %xmm0",
842 },
843 {
844 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePacksswb, newOperandReg(xmm1VReg), xmm0VReg) },
845 want: "660f63c1",
846 wantFormat: "packsswb %xmm1, %xmm0",
847 },
848 {
849 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePackusdw, newOperandReg(xmm1VReg), xmm0VReg) },
850 want: "660f382bc1",
851 wantFormat: "packusdw %xmm1, %xmm0",
852 },
853 {
854 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePackuswb, newOperandReg(xmm1VReg), xmm0VReg) },
855 want: "660f67c1",
856 wantFormat: "packuswb %xmm1, %xmm0",
857 },
858 {
859 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePaddb, newOperandReg(xmm1VReg), xmm0VReg) },
860 want: "660ffcc1",
861 wantFormat: "paddb %xmm1, %xmm0",
862 },
863 {
864 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePaddd, newOperandReg(xmm1VReg), xmm0VReg) },
865 want: "660ffec1",
866 wantFormat: "paddd %xmm1, %xmm0",
867 },
868 {
869 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePaddq, newOperandReg(xmm1VReg), xmm0VReg) },
870 want: "660fd4c1",
871 wantFormat: "paddq %xmm1, %xmm0",
872 },
873 {
874 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePaddw, newOperandReg(xmm1VReg), xmm0VReg) },
875 want: "660ffdc1",
876 wantFormat: "paddw %xmm1, %xmm0",
877 },
878 {
879 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePaddsb, newOperandReg(xmm1VReg), xmm0VReg) },
880 want: "660fecc1",
881 wantFormat: "paddsb %xmm1, %xmm0",
882 },
883 {
884 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeCvtss2sd, newOperandReg(xmm1VReg), xmm0VReg) },
885 want: "f30f5ac1",
886 wantFormat: "cvtss2sd %xmm1, %xmm0",
887 },
888 {
889 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeCvtsd2ss, newOperandReg(xmm1VReg), xmm0VReg) },
890 want: "f20f5ac1",
891 wantFormat: "cvtsd2ss %xmm1, %xmm0",
892 },
893 {
894 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeMovaps, newOperandReg(xmm1VReg), xmm0VReg) },
895 want: "0f28c1",
896 wantFormat: "movaps %xmm1, %xmm0",
897 },
898 {
899 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeMovapd, newOperandReg(xmm1VReg), xmm0VReg) },
900 want: "660f28c1",
901 wantFormat: "movapd %xmm1, %xmm0",
902 },
903 {
904 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeMovdqa, newOperandReg(xmm1VReg), xmm0VReg) },
905 want: "660f6fc1",
906 wantFormat: "movdqa %xmm1, %xmm0",
907 },
908 {
909 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeMovdqu, newOperandReg(xmm1VReg), xmm0VReg) },
910 want: "f30f6fc1",
911 wantFormat: "movdqu %xmm1, %xmm0",
912 },
913 {
914 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeMovsd, newOperandReg(xmm1VReg), xmm0VReg) },
915 want: "f20f10c1",
916 wantFormat: "movsd %xmm1, %xmm0",
917 },
918 {
919 setup: func(i *instruction) {
920 i.asXmmUnaryRmR(sseOpcodeMovsd, newOperandMem(newAmodeImmReg(16, r12VReg)), xmm0VReg)
921 },
922 want: "f2410f10442410",
923 wantFormat: "movsd 16(%r12), %xmm0",
924 },
925 {
926 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeMovss, newOperandReg(xmm1VReg), xmm0VReg) },
927 want: "f30f10c1",
928 wantFormat: "movss %xmm1, %xmm0",
929 },
930 {
931 setup: func(i *instruction) {
932 i.asXmmUnaryRmR(sseOpcodeMovss, newOperandMem(newAmodeImmReg(160, r12VReg)), xmm15VReg)
933 },
934 want: "f3450f10bc24a0000000",
935 wantFormat: "movss 160(%r12), %xmm15",
936 },
937 {
938 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeMovups, newOperandReg(xmm1VReg), xmm0VReg) },
939 want: "0f10c1",
940 wantFormat: "movups %xmm1, %xmm0",
941 },
942 {
943 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeMovupd, newOperandReg(xmm1VReg), xmm0VReg) },
944 want: "660f10c1",
945 wantFormat: "movupd %xmm1, %xmm0",
946 },
947 {
948 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePabsb, newOperandReg(xmm1VReg), xmm0VReg) },
949 want: "660f381cc1",
950 wantFormat: "pabsb %xmm1, %xmm0",
951 },
952 {
953 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePabsw, newOperandReg(xmm1VReg), xmm0VReg) },
954 want: "660f381dc1",
955 wantFormat: "pabsw %xmm1, %xmm0",
956 },
957 {
958 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePabsd, newOperandReg(xmm1VReg), xmm0VReg) },
959 want: "660f381ec1",
960 wantFormat: "pabsd %xmm1, %xmm0",
961 },
962 {
963 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePmovsxbd, newOperandReg(xmm1VReg), xmm0VReg) },
964 want: "660f3821c1",
965 wantFormat: "pmovsxbd %xmm1, %xmm0",
966 },
967 {
968 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePmovsxbw, newOperandReg(xmm1VReg), xmm0VReg) },
969 want: "660f3820c1",
970 wantFormat: "pmovsxbw %xmm1, %xmm0",
971 },
972 {
973 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePmovsxbq, newOperandReg(xmm1VReg), xmm0VReg) },
974 want: "660f3822c1",
975 wantFormat: "pmovsxbq %xmm1, %xmm0",
976 },
977 {
978 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePmovsxwd, newOperandReg(xmm1VReg), xmm0VReg) },
979 want: "660f3823c1",
980 wantFormat: "pmovsxwd %xmm1, %xmm0",
981 },
982 {
983 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePmovsxwq, newOperandReg(xmm1VReg), xmm0VReg) },
984 want: "660f3824c1",
985 wantFormat: "pmovsxwq %xmm1, %xmm0",
986 },
987 {
988 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePmovsxdq, newOperandReg(xmm1VReg), xmm0VReg) },
989 want: "660f3825c1",
990 wantFormat: "pmovsxdq %xmm1, %xmm0",
991 },
992 {
993 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePmovzxbd, newOperandReg(xmm1VReg), xmm0VReg) },
994 want: "660f3831c1",
995 wantFormat: "pmovzxbd %xmm1, %xmm0",
996 },
997 {
998 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePmovzxbw, newOperandReg(xmm1VReg), xmm0VReg) },
999 want: "660f3830c1",
1000 wantFormat: "pmovzxbw %xmm1, %xmm0",
1001 },
1002 {
1003 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePmovzxbq, newOperandReg(xmm1VReg), xmm0VReg) },
1004 want: "660f3832c1",
1005 wantFormat: "pmovzxbq %xmm1, %xmm0",
1006 },
1007 {
1008 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePmovzxwd, newOperandReg(xmm1VReg), xmm0VReg) },
1009 want: "660f3833c1",
1010 wantFormat: "pmovzxwd %xmm1, %xmm0",
1011 },
1012 {
1013 setup: func(i *instruction) {
1014 i.asXmmUnaryRmR(sseOpcodePmovzxwd, newOperandMem(newAmodeImmReg(0, rbpVReg)), xmm11VReg)
1015 },
1016 want: "66440f38335d00",
1017 wantFormat: "pmovzxwd (%rbp), %xmm11",
1018 },
1019 {
1020 setup: func(i *instruction) {
1021 i.asXmmUnaryRmR(sseOpcodePmovzxwd, newOperandMem(newAmodeImmReg(123, rbpVReg)), xmm11VReg)
1022 },
1023 want: "66440f38335d7b",
1024 wantFormat: "pmovzxwd 123(%rbp), %xmm11",
1025 },
1026 {
1027 setup: func(i *instruction) {
1028 i.asXmmUnaryRmR(sseOpcodePmovzxwd, newOperandMem(newAmodeImmReg(1<<25, rbpVReg)), xmm11VReg)
1029 },
1030 want: "66440f38339d00000002",
1031 wantFormat: "pmovzxwd 33554432(%rbp), %xmm11",
1032 },
1033 {
1034 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePmovzxwq, newOperandReg(xmm1VReg), xmm0VReg) },
1035 want: "660f3834c1",
1036 wantFormat: "pmovzxwq %xmm1, %xmm0",
1037 },
1038 {
1039 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodePmovzxdq, newOperandReg(xmm1VReg), xmm0VReg) },
1040 want: "660f3835c1",
1041 wantFormat: "pmovzxdq %xmm1, %xmm0",
1042 },
1043 {
1044 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeSqrtps, newOperandReg(xmm1VReg), xmm0VReg) },
1045 want: "0f51c1",
1046 wantFormat: "sqrtps %xmm1, %xmm0",
1047 },
1048 {
1049 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeSqrtpd, newOperandReg(xmm1VReg), xmm0VReg) },
1050 want: "660f51c1",
1051 wantFormat: "sqrtpd %xmm1, %xmm0",
1052 },
1053 {
1054 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeSqrtss, newOperandReg(xmm1VReg), xmm0VReg) },
1055 want: "f30f51c1",
1056 wantFormat: "sqrtss %xmm1, %xmm0",
1057 },
1058 {
1059 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeSqrtsd, newOperandReg(xmm1VReg), xmm0VReg) },
1060 want: "f20f51c1",
1061 wantFormat: "sqrtsd %xmm1, %xmm0",
1062 },
1063 {
1064 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeSqrtsd, newOperandReg(xmm15VReg), xmm0VReg) },
1065 want: "f2410f51c7",
1066 wantFormat: "sqrtsd %xmm15, %xmm0",
1067 },
1068 {
1069 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeSqrtsd, newOperandReg(xmm1VReg), xmm15VReg) },
1070 want: "f2440f51f9",
1071 wantFormat: "sqrtsd %xmm1, %xmm15",
1072 },
1073 {
1074 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeSqrtsd, newOperandReg(xmm11VReg), xmm15VReg) },
1075 want: "f2450f51fb",
1076 wantFormat: "sqrtsd %xmm11, %xmm15",
1077 },
1078 {
1079 setup: func(i *instruction) {
1080 i.asXmmUnaryRmRImm(sseOpcodeRoundss, uint8(roundingModeNearest), newOperandReg(xmm11VReg), xmm15VReg)
1081 },
1082 want: "66450f3a0afb00",
1083 wantFormat: "roundss $0, %xmm11, %xmm15",
1084 },
1085 {
1086 setup: func(i *instruction) {
1087 i.asXmmUnaryRmRImm(sseOpcodeRoundss, uint8(roundingModeDown), newOperandReg(xmm11VReg), xmm15VReg)
1088 },
1089 want: "66450f3a0afb01",
1090 wantFormat: "roundss $1, %xmm11, %xmm15",
1091 },
1092 {
1093 setup: func(i *instruction) {
1094 i.asXmmUnaryRmRImm(sseOpcodeRoundss, uint8(roundingModeUp), newOperandReg(xmm11VReg), xmm15VReg)
1095 },
1096 want: "66450f3a0afb02",
1097 wantFormat: "roundss $2, %xmm11, %xmm15",
1098 },
1099 {
1100 setup: func(i *instruction) {
1101 i.asXmmUnaryRmRImm(sseOpcodeRoundss, uint8(roundingModeZero), newOperandReg(xmm11VReg), xmm15VReg)
1102 },
1103 want: "66450f3a0afb03",
1104 wantFormat: "roundss $3, %xmm11, %xmm15",
1105 },
1106 {
1107 setup: func(i *instruction) {
1108 i.asXmmUnaryRmRImm(sseOpcodeRoundss, uint8(roundingModeNearest), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm15VReg)
1109 },
1110 want: "66440f3a0a787b00",
1111 wantFormat: "roundss $0, 123(%rax), %xmm15",
1112 },
1113 {
1114 setup: func(i *instruction) {
1115 i.asXmmUnaryRmRImm(sseOpcodeRoundss, uint8(roundingModeDown), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm15VReg)
1116 },
1117 want: "66440f3a0a787b01",
1118 wantFormat: "roundss $1, 123(%rax), %xmm15",
1119 },
1120 {
1121 setup: func(i *instruction) {
1122 i.asXmmUnaryRmRImm(sseOpcodeRoundss, uint8(roundingModeUp), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm15VReg)
1123 },
1124 want: "66440f3a0a787b02",
1125 wantFormat: "roundss $2, 123(%rax), %xmm15",
1126 },
1127 {
1128 setup: func(i *instruction) {
1129 i.asXmmUnaryRmRImm(sseOpcodeRoundss, uint8(roundingModeZero), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm15VReg)
1130 },
1131 want: "66440f3a0a787b03",
1132 wantFormat: "roundss $3, 123(%rax), %xmm15",
1133 },
1134 {
1135 setup: func(i *instruction) {
1136 i.asXmmUnaryRmRImm(sseOpcodeRoundsd, uint8(roundingModeNearest), newOperandReg(xmm11VReg), xmm15VReg)
1137 },
1138 want: "66450f3a0bfb00",
1139 wantFormat: "roundsd $0, %xmm11, %xmm15",
1140 },
1141 {
1142 setup: func(i *instruction) {
1143 i.asXmmUnaryRmRImm(sseOpcodeRoundsd, uint8(roundingModeDown), newOperandReg(xmm11VReg), xmm15VReg)
1144 },
1145 want: "66450f3a0bfb01",
1146 wantFormat: "roundsd $1, %xmm11, %xmm15",
1147 },
1148 {
1149 setup: func(i *instruction) {
1150 i.asXmmUnaryRmRImm(sseOpcodeRoundsd, uint8(roundingModeUp), newOperandReg(xmm11VReg), xmm15VReg)
1151 },
1152 want: "66450f3a0bfb02",
1153 wantFormat: "roundsd $2, %xmm11, %xmm15",
1154 },
1155 {
1156 setup: func(i *instruction) {
1157 i.asXmmUnaryRmRImm(sseOpcodeRoundsd, uint8(roundingModeZero), newOperandReg(xmm11VReg), xmm15VReg)
1158 },
1159 want: "66450f3a0bfb03",
1160 wantFormat: "roundsd $3, %xmm11, %xmm15",
1161 },
1162 {
1163 setup: func(i *instruction) {
1164 i.asXmmUnaryRmRImm(sseOpcodeRoundsd, uint8(roundingModeNearest), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm15VReg)
1165 },
1166 want: "66440f3a0b787b00",
1167 wantFormat: "roundsd $0, 123(%rax), %xmm15",
1168 },
1169 {
1170 setup: func(i *instruction) {
1171 i.asXmmUnaryRmRImm(sseOpcodeRoundsd, uint8(roundingModeDown), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm15VReg)
1172 },
1173 want: "66440f3a0b787b01",
1174 wantFormat: "roundsd $1, 123(%rax), %xmm15",
1175 },
1176 {
1177 setup: func(i *instruction) {
1178 i.asXmmUnaryRmRImm(sseOpcodeRoundsd, uint8(roundingModeUp), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm15VReg)
1179 },
1180 want: "66440f3a0b787b02",
1181 wantFormat: "roundsd $2, 123(%rax), %xmm15",
1182 },
1183 {
1184 setup: func(i *instruction) {
1185 i.asXmmUnaryRmRImm(sseOpcodeRoundsd, uint8(roundingModeZero), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm15VReg)
1186 },
1187 want: "66440f3a0b787b03",
1188 wantFormat: "roundsd $3, 123(%rax), %xmm15",
1189 },
1190 {
1191 setup: func(i *instruction) { i.asXmmCmpRmR(sseOpcodePtest, newOperandReg(xmm1VReg), xmm0VReg) },
1192 want: "660f3817c1",
1193 wantFormat: "ptest %xmm1, %xmm0",
1194 },
1195 {
1196 setup: func(i *instruction) { i.asXmmCmpRmR(sseOpcodeUcomisd, newOperandReg(xmm1VReg), xmm0VReg) },
1197 want: "660f2ec1",
1198 wantFormat: "ucomisd %xmm1, %xmm0",
1199 },
1200 {
1201 setup: func(i *instruction) { i.asXmmCmpRmR(sseOpcodeUcomiss, newOperandReg(xmm1VReg), xmm0VReg) },
1202 want: "0f2ec1",
1203 wantFormat: "ucomiss %xmm1, %xmm0",
1204 },
1205 {
1206 setup: func(i *instruction) {
1207 i.asXmmCmpRmR(sseOpcodePtest, newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1208 },
1209 want: "660f3817407b",
1210 wantFormat: "ptest 123(%rax), %xmm0",
1211 },
1212 {
1213 setup: func(i *instruction) {
1214 i.asXmmCmpRmR(sseOpcodeUcomisd, newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1215 },
1216 want: "660f2e407b",
1217 wantFormat: "ucomisd 123(%rax), %xmm0",
1218 },
1219 {
1220 setup: func(i *instruction) {
1221 i.asXmmCmpRmR(sseOpcodeUcomiss, newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1222 },
1223 want: "0f2e407b",
1224 wantFormat: "ucomiss 123(%rax), %xmm0",
1225 },
1226 // movd
1227 {
1228 setup: func(i *instruction) { i.asGprToXmm(sseOpcodeMovd, newOperandReg(rdiVReg), xmm0VReg, false) },
1229 want: "660f6ec7",
1230 wantFormat: "movd %edi, %xmm0",
1231 },
1232 {
1233 setup: func(i *instruction) {
1234 i.asGprToXmm(sseOpcodeMovd, newOperandMem(newAmodeImmReg(0, rspVReg)), xmm0VReg, true)
1235 },
1236 want: "66480f6e0424",
1237 wantFormat: "movd (%rsp), %xmm0",
1238 },
1239 {
1240 setup: func(i *instruction) {
1241 i.asGprToXmm(sseOpcodeMovd, newOperandMem(newAmodeImmReg(123, rspVReg)), xmm0VReg, true)
1242 },
1243 want: "66480f6e44247b",
1244 wantFormat: "movd 123(%rsp), %xmm0",
1245 },
1246 {
1247 setup: func(i *instruction) {
1248 i.asGprToXmm(sseOpcodeMovd, newOperandMem(newAmodeImmReg(1<<25, rspVReg)), xmm0VReg, true)
1249 },
1250 want: "66480f6e842400000002",
1251 wantFormat: "movd 33554432(%rsp), %xmm0",
1252 },
1253 // movq
1254 {
1255 setup: func(i *instruction) { i.asGprToXmm(sseOpcodeMovq, newOperandReg(rcxVReg), xmm0VReg, true) },
1256 want: "66480f6ec1",
1257 wantFormat: "movq %rcx, %xmm0",
1258 },
1259 // cvtsi2ss
1260 {
1261 setup: func(i *instruction) { i.asGprToXmm(sseOpcodeCvtsi2ss, newOperandReg(rdiVReg), xmm0VReg, true) },
1262 want: "f3480f2ac7",
1263 wantFormat: "cvtsi2ss %rdi, %xmm0",
1264 },
1265 {
1266 setup: func(i *instruction) { i.asGprToXmm(sseOpcodeCvtsi2ss, newOperandReg(rdiVReg), xmm0VReg, false) },
1267 want: "f30f2ac7",
1268 wantFormat: "cvtsi2ss %edi, %xmm0",
1269 },
1270 {
1271 setup: func(i *instruction) {
1272 i.asGprToXmm(sseOpcodeCvtsi2ss, newOperandMem(newAmodeImmReg(0, rspVReg)), xmm0VReg, true)
1273 },
1274 want: "f3480f2a0424",
1275 wantFormat: "cvtsi2ss (%rsp), %xmm0",
1276 },
1277 {
1278 setup: func(i *instruction) {
1279 i.asGprToXmm(sseOpcodeCvtsi2ss, newOperandMem(newAmodeImmReg(123, rspVReg)), xmm0VReg, true)
1280 },
1281 want: "f3480f2a44247b",
1282 wantFormat: "cvtsi2ss 123(%rsp), %xmm0",
1283 },
1284 {
1285 setup: func(i *instruction) {
1286 i.asGprToXmm(sseOpcodeCvtsi2ss, newOperandMem(newAmodeImmReg(123, rspVReg)), xmm15VReg, false)
1287 },
1288 want: "f3440f2a7c247b",
1289 wantFormat: "cvtsi2ss 123(%rsp), %xmm15",
1290 },
1291 {
1292 setup: func(i *instruction) {
1293 i.asGprToXmm(sseOpcodeCvtsi2ss, newOperandMem(newAmodeImmReg(1<<25, rspVReg)), xmm0VReg, true)
1294 },
1295 want: "f3480f2a842400000002",
1296 wantFormat: "cvtsi2ss 33554432(%rsp), %xmm0",
1297 },
1298 // cvtsi2sd
1299 {
1300 setup: func(i *instruction) { i.asGprToXmm(sseOpcodeCvtsi2sd, newOperandReg(rdiVReg), xmm0VReg, true) },
1301 want: "f2480f2ac7",
1302 wantFormat: "cvtsi2sd %rdi, %xmm0",
1303 },
1304 {
1305 setup: func(i *instruction) { i.asGprToXmm(sseOpcodeCvtsi2sd, newOperandReg(rdiVReg), xmm0VReg, false) },
1306 want: "f20f2ac7",
1307 wantFormat: "cvtsi2sd %edi, %xmm0",
1308 },
1309 {
1310 // This is actually equivalent to movq, because of _64=true.
1311 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodeMovd, xmm0VReg, rdiVReg, true) },
1312 want: "66480f7ec7",
1313 wantFormat: "movd %xmm0, %rdi",
1314 },
1315 {
1316 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodeMovd, xmm0VReg, rdiVReg, false) },
1317 want: "660f7ec7",
1318 wantFormat: "movd %xmm0, %edi",
1319 },
1320 {
1321 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodeMovq, xmm0VReg, rdiVReg, true) },
1322 want: "66480f7ec7",
1323 wantFormat: "movq %xmm0, %rdi",
1324 },
1325 // This is actually equivalent to movq, because of _64=false.
1326 {
1327 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodeMovq, xmm0VReg, rdiVReg, false) },
1328 want: "660f7ec7",
1329 wantFormat: "movq %xmm0, %edi",
1330 },
1331 {
1332 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodeCvttss2si, xmm0VReg, rdiVReg, true) },
1333 want: "f3480f2cf8",
1334 wantFormat: "cvttss2si %xmm0, %rdi",
1335 },
1336 {
1337 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodeCvttss2si, xmm0VReg, rdiVReg, false) },
1338 want: "f30f2cf8",
1339 wantFormat: "cvttss2si %xmm0, %edi",
1340 },
1341 {
1342 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodeCvttsd2si, xmm0VReg, rdiVReg, true) },
1343 want: "f2480f2cf8",
1344 wantFormat: "cvttsd2si %xmm0, %rdi",
1345 },
1346 {
1347 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodeCvttsd2si, xmm0VReg, rdiVReg, false) },
1348 want: "f20f2cf8",
1349 wantFormat: "cvttsd2si %xmm0, %edi",
1350 },
1351 {
1352 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodeMovmskps, xmm1VReg, xmm0VReg, true) },
1353 want: "480f50c1",
1354 wantFormat: "movmskps %xmm1, %xmm0",
1355 },
1356 {
1357 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodeMovmskpd, xmm1VReg, xmm0VReg, true) },
1358 want: "66480f50c1",
1359 wantFormat: "movmskpd %xmm1, %xmm0",
1360 },
1361 {
1362 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodePmovmskb, xmm1VReg, xmm0VReg, true) },
1363 want: "66480fd7c1",
1364 wantFormat: "pmovmskb %xmm1, %xmm0",
1365 },
1366 {
1367 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodeMovmskps, xmm1VReg, xmm0VReg, false) },
1368 want: "0f50c1",
1369 wantFormat: "movmskps %xmm1, %xmm0",
1370 },
1371 {
1372 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodeMovmskpd, xmm1VReg, xmm0VReg, false) },
1373 want: "660f50c1",
1374 wantFormat: "movmskpd %xmm1, %xmm0",
1375 },
1376 {
1377 setup: func(i *instruction) { i.asXmmToGpr(sseOpcodePmovmskb, xmm1VReg, xmm0VReg, false) },
1378 want: "660fd7c1",
1379 wantFormat: "pmovmskb %xmm1, %xmm0",
1380 },
1381 {
1382 setup: func(i *instruction) {
1383 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredEQ_OQ), newOperandReg(xmm1VReg), xmm0VReg)
1384 },
1385 want: "660fc2c100",
1386 wantFormat: "cmppd $0, %xmm1, %xmm0",
1387 },
1388 {
1389 setup: func(i *instruction) {
1390 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredLT_OS), newOperandReg(xmm1VReg), xmm0VReg)
1391 },
1392 want: "660fc2c101",
1393 wantFormat: "cmppd $1, %xmm1, %xmm0",
1394 },
1395 {
1396 setup: func(i *instruction) {
1397 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredLE_OS), newOperandReg(xmm1VReg), xmm0VReg)
1398 },
1399 want: "660fc2c102",
1400 wantFormat: "cmppd $2, %xmm1, %xmm0",
1401 },
1402 {
1403 setup: func(i *instruction) {
1404 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredUNORD_Q), newOperandReg(xmm1VReg), xmm0VReg)
1405 },
1406 want: "660fc2c103",
1407 wantFormat: "cmppd $3, %xmm1, %xmm0",
1408 },
1409 {
1410 setup: func(i *instruction) {
1411 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNEQ_UQ), newOperandReg(xmm1VReg), xmm0VReg)
1412 },
1413 want: "660fc2c104",
1414 wantFormat: "cmppd $4, %xmm1, %xmm0",
1415 },
1416 {
1417 setup: func(i *instruction) {
1418 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNLT_US), newOperandReg(xmm1VReg), xmm0VReg)
1419 },
1420 want: "660fc2c105",
1421 wantFormat: "cmppd $5, %xmm1, %xmm0",
1422 },
1423 {
1424 setup: func(i *instruction) {
1425 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNLE_US), newOperandReg(xmm1VReg), xmm0VReg)
1426 },
1427 want: "660fc2c106",
1428 wantFormat: "cmppd $6, %xmm1, %xmm0",
1429 },
1430 {
1431 setup: func(i *instruction) {
1432 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredORD_Q), newOperandReg(xmm1VReg), xmm0VReg)
1433 },
1434 want: "660fc2c107",
1435 wantFormat: "cmppd $7, %xmm1, %xmm0",
1436 },
1437 {
1438 setup: func(i *instruction) {
1439 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredEQ_UQ), newOperandReg(xmm1VReg), xmm0VReg)
1440 },
1441 want: "660fc2c108",
1442 wantFormat: "cmppd $8, %xmm1, %xmm0",
1443 },
1444 {
1445 setup: func(i *instruction) {
1446 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNGE_US), newOperandReg(xmm1VReg), xmm0VReg)
1447 },
1448 want: "660fc2c109",
1449 wantFormat: "cmppd $9, %xmm1, %xmm0",
1450 },
1451 {
1452 setup: func(i *instruction) {
1453 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNGT_US), newOperandReg(xmm1VReg), xmm0VReg)
1454 },
1455 want: "660fc2c10a",
1456 wantFormat: "cmppd $10, %xmm1, %xmm0",
1457 },
1458 {
1459 setup: func(i *instruction) {
1460 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredFALSE_OQ), newOperandReg(xmm1VReg), xmm0VReg)
1461 },
1462 want: "660fc2c10b",
1463 wantFormat: "cmppd $11, %xmm1, %xmm0",
1464 },
1465 {
1466 setup: func(i *instruction) {
1467 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNEQ_OQ), newOperandReg(xmm1VReg), xmm0VReg)
1468 },
1469 want: "660fc2c10c",
1470 wantFormat: "cmppd $12, %xmm1, %xmm0",
1471 },
1472 {
1473 setup: func(i *instruction) {
1474 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredGE_OS), newOperandReg(xmm1VReg), xmm0VReg)
1475 },
1476 want: "660fc2c10d",
1477 wantFormat: "cmppd $13, %xmm1, %xmm0",
1478 },
1479 {
1480 setup: func(i *instruction) {
1481 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredGT_OS), newOperandReg(xmm1VReg), xmm0VReg)
1482 },
1483 want: "660fc2c10e",
1484 wantFormat: "cmppd $14, %xmm1, %xmm0",
1485 },
1486 {
1487 setup: func(i *instruction) {
1488 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredTRUE_UQ), newOperandReg(xmm1VReg), xmm0VReg)
1489 },
1490 want: "660fc2c10f",
1491 wantFormat: "cmppd $15, %xmm1, %xmm0",
1492 },
1493 {
1494 setup: func(i *instruction) {
1495 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredEQ_OS), newOperandReg(xmm1VReg), xmm0VReg)
1496 },
1497 want: "660fc2c110",
1498 wantFormat: "cmppd $16, %xmm1, %xmm0",
1499 },
1500 {
1501 setup: func(i *instruction) {
1502 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredLT_OQ), newOperandReg(xmm1VReg), xmm0VReg)
1503 },
1504 want: "660fc2c111",
1505 wantFormat: "cmppd $17, %xmm1, %xmm0",
1506 },
1507 {
1508 setup: func(i *instruction) {
1509 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredLE_OQ), newOperandReg(xmm1VReg), xmm0VReg)
1510 },
1511 want: "660fc2c112",
1512 wantFormat: "cmppd $18, %xmm1, %xmm0",
1513 },
1514 {
1515 setup: func(i *instruction) {
1516 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredUNORD_S), newOperandReg(xmm1VReg), xmm0VReg)
1517 },
1518 want: "660fc2c113",
1519 wantFormat: "cmppd $19, %xmm1, %xmm0",
1520 },
1521 {
1522 setup: func(i *instruction) {
1523 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNEQ_US), newOperandReg(xmm1VReg), xmm0VReg)
1524 },
1525 want: "660fc2c114",
1526 wantFormat: "cmppd $20, %xmm1, %xmm0",
1527 },
1528 {
1529 setup: func(i *instruction) {
1530 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNLT_UQ), newOperandReg(xmm1VReg), xmm0VReg)
1531 },
1532 want: "660fc2c115",
1533 wantFormat: "cmppd $21, %xmm1, %xmm0",
1534 },
1535 {
1536 setup: func(i *instruction) {
1537 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNLE_UQ), newOperandReg(xmm1VReg), xmm0VReg)
1538 },
1539 want: "660fc2c116",
1540 wantFormat: "cmppd $22, %xmm1, %xmm0",
1541 },
1542 {
1543 setup: func(i *instruction) {
1544 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredORD_S), newOperandReg(xmm1VReg), xmm0VReg)
1545 },
1546 want: "660fc2c117",
1547 wantFormat: "cmppd $23, %xmm1, %xmm0",
1548 },
1549 {
1550 setup: func(i *instruction) {
1551 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredEQ_US), newOperandReg(xmm1VReg), xmm0VReg)
1552 },
1553 want: "660fc2c118",
1554 wantFormat: "cmppd $24, %xmm1, %xmm0",
1555 },
1556 {
1557 setup: func(i *instruction) {
1558 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNGE_UQ), newOperandReg(xmm1VReg), xmm0VReg)
1559 },
1560 want: "660fc2c119",
1561 wantFormat: "cmppd $25, %xmm1, %xmm0",
1562 },
1563 {
1564 setup: func(i *instruction) {
1565 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNGT_UQ), newOperandReg(xmm1VReg), xmm0VReg)
1566 },
1567 want: "660fc2c11a",
1568 wantFormat: "cmppd $26, %xmm1, %xmm0",
1569 },
1570 {
1571 setup: func(i *instruction) {
1572 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredFALSE_OS), newOperandReg(xmm1VReg), xmm0VReg)
1573 },
1574 want: "660fc2c11b",
1575 wantFormat: "cmppd $27, %xmm1, %xmm0",
1576 },
1577 {
1578 setup: func(i *instruction) {
1579 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNEQ_OS), newOperandReg(xmm1VReg), xmm0VReg)
1580 },
1581 want: "660fc2c11c",
1582 wantFormat: "cmppd $28, %xmm1, %xmm0",
1583 },
1584 {
1585 setup: func(i *instruction) {
1586 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredGE_OQ), newOperandReg(xmm1VReg), xmm0VReg)
1587 },
1588 want: "660fc2c11d",
1589 wantFormat: "cmppd $29, %xmm1, %xmm0",
1590 },
1591 {
1592 setup: func(i *instruction) {
1593 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredGT_OQ), newOperandReg(xmm1VReg), xmm0VReg)
1594 },
1595 want: "660fc2c11e",
1596 wantFormat: "cmppd $30, %xmm1, %xmm0",
1597 },
1598 {
1599 setup: func(i *instruction) {
1600 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredTRUE_US), newOperandReg(xmm1VReg), xmm0VReg)
1601 },
1602 want: "660fc2c11f",
1603 wantFormat: "cmppd $31, %xmm1, %xmm0",
1604 },
1605 {
1606 setup: func(i *instruction) {
1607 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredEQ_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1608 },
1609 want: "660fc2407b00",
1610 wantFormat: "cmppd $0, 123(%rax), %xmm0",
1611 },
1612 {
1613 setup: func(i *instruction) {
1614 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredLT_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1615 },
1616 want: "660fc2407b01",
1617 wantFormat: "cmppd $1, 123(%rax), %xmm0",
1618 },
1619 {
1620 setup: func(i *instruction) {
1621 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredLE_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1622 },
1623 want: "660fc2407b02",
1624 wantFormat: "cmppd $2, 123(%rax), %xmm0",
1625 },
1626 {
1627 setup: func(i *instruction) {
1628 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredUNORD_Q), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1629 },
1630 want: "660fc2407b03",
1631 wantFormat: "cmppd $3, 123(%rax), %xmm0",
1632 },
1633 {
1634 setup: func(i *instruction) {
1635 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNEQ_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1636 },
1637 want: "660fc2407b04",
1638 wantFormat: "cmppd $4, 123(%rax), %xmm0",
1639 },
1640 {
1641 setup: func(i *instruction) {
1642 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNLT_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1643 },
1644 want: "660fc2407b05",
1645 wantFormat: "cmppd $5, 123(%rax), %xmm0",
1646 },
1647 {
1648 setup: func(i *instruction) {
1649 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNLE_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1650 },
1651 want: "660fc2407b06",
1652 wantFormat: "cmppd $6, 123(%rax), %xmm0",
1653 },
1654 {
1655 setup: func(i *instruction) {
1656 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredORD_Q), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1657 },
1658 want: "660fc2407b07",
1659 wantFormat: "cmppd $7, 123(%rax), %xmm0",
1660 },
1661 {
1662 setup: func(i *instruction) {
1663 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredEQ_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1664 },
1665 want: "660fc2407b08",
1666 wantFormat: "cmppd $8, 123(%rax), %xmm0",
1667 },
1668 {
1669 setup: func(i *instruction) {
1670 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNGE_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1671 },
1672 want: "660fc2407b09",
1673 wantFormat: "cmppd $9, 123(%rax), %xmm0",
1674 },
1675 {
1676 setup: func(i *instruction) {
1677 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNGT_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1678 },
1679 want: "660fc2407b0a",
1680 wantFormat: "cmppd $10, 123(%rax), %xmm0",
1681 },
1682 {
1683 setup: func(i *instruction) {
1684 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredFALSE_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1685 },
1686 want: "660fc2407b0b",
1687 wantFormat: "cmppd $11, 123(%rax), %xmm0",
1688 },
1689 {
1690 setup: func(i *instruction) {
1691 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNEQ_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1692 },
1693 want: "660fc2407b0c",
1694 wantFormat: "cmppd $12, 123(%rax), %xmm0",
1695 },
1696 {
1697 setup: func(i *instruction) {
1698 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredGE_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1699 },
1700 want: "660fc2407b0d",
1701 wantFormat: "cmppd $13, 123(%rax), %xmm0",
1702 },
1703 {
1704 setup: func(i *instruction) {
1705 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredGT_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1706 },
1707 want: "660fc2407b0e",
1708 wantFormat: "cmppd $14, 123(%rax), %xmm0",
1709 },
1710 {
1711 setup: func(i *instruction) {
1712 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredTRUE_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1713 },
1714 want: "660fc2407b0f",
1715 wantFormat: "cmppd $15, 123(%rax), %xmm0",
1716 },
1717 {
1718 setup: func(i *instruction) {
1719 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredEQ_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1720 },
1721 want: "660fc2407b10",
1722 wantFormat: "cmppd $16, 123(%rax), %xmm0",
1723 },
1724 {
1725 setup: func(i *instruction) {
1726 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredLT_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1727 },
1728 want: "660fc2407b11",
1729 wantFormat: "cmppd $17, 123(%rax), %xmm0",
1730 },
1731 {
1732 setup: func(i *instruction) {
1733 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredLE_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1734 },
1735 want: "660fc2407b12",
1736 wantFormat: "cmppd $18, 123(%rax), %xmm0",
1737 },
1738 {
1739 setup: func(i *instruction) {
1740 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredUNORD_S), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1741 },
1742 want: "660fc2407b13",
1743 wantFormat: "cmppd $19, 123(%rax), %xmm0",
1744 },
1745 {
1746 setup: func(i *instruction) {
1747 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNEQ_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1748 },
1749 want: "660fc2407b14",
1750 wantFormat: "cmppd $20, 123(%rax), %xmm0",
1751 },
1752 {
1753 setup: func(i *instruction) {
1754 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNLT_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1755 },
1756 want: "660fc2407b15",
1757 wantFormat: "cmppd $21, 123(%rax), %xmm0",
1758 },
1759 {
1760 setup: func(i *instruction) {
1761 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNLE_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1762 },
1763 want: "660fc2407b16",
1764 wantFormat: "cmppd $22, 123(%rax), %xmm0",
1765 },
1766 {
1767 setup: func(i *instruction) {
1768 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredORD_S), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1769 },
1770 want: "660fc2407b17",
1771 wantFormat: "cmppd $23, 123(%rax), %xmm0",
1772 },
1773 {
1774 setup: func(i *instruction) {
1775 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredEQ_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1776 },
1777 want: "660fc2407b18",
1778 wantFormat: "cmppd $24, 123(%rax), %xmm0",
1779 },
1780 {
1781 setup: func(i *instruction) {
1782 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNGE_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1783 },
1784 want: "660fc2407b19",
1785 wantFormat: "cmppd $25, 123(%rax), %xmm0",
1786 },
1787 {
1788 setup: func(i *instruction) {
1789 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNGT_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1790 },
1791 want: "660fc2407b1a",
1792 wantFormat: "cmppd $26, 123(%rax), %xmm0",
1793 },
1794 {
1795 setup: func(i *instruction) {
1796 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredFALSE_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1797 },
1798 want: "660fc2407b1b",
1799 wantFormat: "cmppd $27, 123(%rax), %xmm0",
1800 },
1801 {
1802 setup: func(i *instruction) {
1803 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredNEQ_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1804 },
1805 want: "660fc2407b1c",
1806 wantFormat: "cmppd $28, 123(%rax), %xmm0",
1807 },
1808 {
1809 setup: func(i *instruction) {
1810 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredGE_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1811 },
1812 want: "660fc2407b1d",
1813 wantFormat: "cmppd $29, 123(%rax), %xmm0",
1814 },
1815 {
1816 setup: func(i *instruction) {
1817 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredGT_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1818 },
1819 want: "660fc2407b1e",
1820 wantFormat: "cmppd $30, 123(%rax), %xmm0",
1821 },
1822 {
1823 setup: func(i *instruction) {
1824 i.asXmmRmRImm(sseOpcodeCmppd, uint8(cmpPredTRUE_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
1825 },
1826 want: "660fc2407b1f",
1827 wantFormat: "cmppd $31, 123(%rax), %xmm0",
1828 },
1829 {
1830 setup: func(i *instruction) {
1831 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredEQ_OQ), newOperandReg(xmm1VReg), xmm0VReg)
1832 },
1833 want: "0fc2c100",
1834 wantFormat: "cmpps $0, %xmm1, %xmm0",
1835 },
1836 {
1837 setup: func(i *instruction) {
1838 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredLT_OS), newOperandReg(xmm1VReg), xmm0VReg)
1839 },
1840 want: "0fc2c101",
1841 wantFormat: "cmpps $1, %xmm1, %xmm0",
1842 },
1843 {
1844 setup: func(i *instruction) {
1845 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredLE_OS), newOperandReg(xmm1VReg), xmm0VReg)
1846 },
1847 want: "0fc2c102",
1848 wantFormat: "cmpps $2, %xmm1, %xmm0",
1849 },
1850 {
1851 setup: func(i *instruction) {
1852 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredUNORD_Q), newOperandReg(xmm1VReg), xmm0VReg)
1853 },
1854 want: "0fc2c103",
1855 wantFormat: "cmpps $3, %xmm1, %xmm0",
1856 },
1857 {
1858 setup: func(i *instruction) {
1859 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNEQ_UQ), newOperandReg(xmm1VReg), xmm0VReg)
1860 },
1861 want: "0fc2c104",
1862 wantFormat: "cmpps $4, %xmm1, %xmm0",
1863 },
1864 {
1865 setup: func(i *instruction) {
1866 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNLT_US), newOperandReg(xmm1VReg), xmm0VReg)
1867 },
1868 want: "0fc2c105",
1869 wantFormat: "cmpps $5, %xmm1, %xmm0",
1870 },
1871 {
1872 setup: func(i *instruction) {
1873 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNLE_US), newOperandReg(xmm1VReg), xmm0VReg)
1874 },
1875 want: "0fc2c106",
1876 wantFormat: "cmpps $6, %xmm1, %xmm0",
1877 },
1878 {
1879 setup: func(i *instruction) {
1880 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredORD_Q), newOperandReg(xmm1VReg), xmm0VReg)
1881 },
1882 want: "0fc2c107",
1883 wantFormat: "cmpps $7, %xmm1, %xmm0",
1884 },
1885 {
1886 setup: func(i *instruction) {
1887 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredEQ_UQ), newOperandReg(xmm1VReg), xmm0VReg)
1888 },
1889 want: "0fc2c108",
1890 wantFormat: "cmpps $8, %xmm1, %xmm0",
1891 },
1892 {
1893 setup: func(i *instruction) {
1894 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNGE_US), newOperandReg(xmm1VReg), xmm0VReg)
1895 },
1896 want: "0fc2c109",
1897 wantFormat: "cmpps $9, %xmm1, %xmm0",
1898 },
1899 {
1900 setup: func(i *instruction) {
1901 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNGT_US), newOperandReg(xmm1VReg), xmm0VReg)
1902 },
1903 want: "0fc2c10a",
1904 wantFormat: "cmpps $10, %xmm1, %xmm0",
1905 },
1906 {
1907 setup: func(i *instruction) {
1908 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredFALSE_OQ), newOperandReg(xmm1VReg), xmm0VReg)
1909 },
1910 want: "0fc2c10b",
1911 wantFormat: "cmpps $11, %xmm1, %xmm0",
1912 },
1913 {
1914 setup: func(i *instruction) {
1915 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNEQ_OQ), newOperandReg(xmm1VReg), xmm0VReg)
1916 },
1917 want: "0fc2c10c",
1918 wantFormat: "cmpps $12, %xmm1, %xmm0",
1919 },
1920 {
1921 setup: func(i *instruction) {
1922 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredGE_OS), newOperandReg(xmm1VReg), xmm0VReg)
1923 },
1924 want: "0fc2c10d",
1925 wantFormat: "cmpps $13, %xmm1, %xmm0",
1926 },
1927 {
1928 setup: func(i *instruction) {
1929 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredGT_OS), newOperandReg(xmm1VReg), xmm0VReg)
1930 },
1931 want: "0fc2c10e",
1932 wantFormat: "cmpps $14, %xmm1, %xmm0",
1933 },
1934 {
1935 setup: func(i *instruction) {
1936 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredTRUE_UQ), newOperandReg(xmm1VReg), xmm0VReg)
1937 },
1938 want: "0fc2c10f",
1939 wantFormat: "cmpps $15, %xmm1, %xmm0",
1940 },
1941 {
1942 setup: func(i *instruction) {
1943 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredEQ_OS), newOperandReg(xmm1VReg), xmm0VReg)
1944 },
1945 want: "0fc2c110",
1946 wantFormat: "cmpps $16, %xmm1, %xmm0",
1947 },
1948 {
1949 setup: func(i *instruction) {
1950 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredLT_OQ), newOperandReg(xmm1VReg), xmm0VReg)
1951 },
1952 want: "0fc2c111",
1953 wantFormat: "cmpps $17, %xmm1, %xmm0",
1954 },
1955 {
1956 setup: func(i *instruction) {
1957 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredLE_OQ), newOperandReg(xmm1VReg), xmm0VReg)
1958 },
1959 want: "0fc2c112",
1960 wantFormat: "cmpps $18, %xmm1, %xmm0",
1961 },
1962 {
1963 setup: func(i *instruction) {
1964 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredUNORD_S), newOperandReg(xmm1VReg), xmm0VReg)
1965 },
1966 want: "0fc2c113",
1967 wantFormat: "cmpps $19, %xmm1, %xmm0",
1968 },
1969 {
1970 setup: func(i *instruction) {
1971 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNEQ_US), newOperandReg(xmm1VReg), xmm0VReg)
1972 },
1973 want: "0fc2c114",
1974 wantFormat: "cmpps $20, %xmm1, %xmm0",
1975 },
1976 {
1977 setup: func(i *instruction) {
1978 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNLT_UQ), newOperandReg(xmm1VReg), xmm0VReg)
1979 },
1980 want: "0fc2c115",
1981 wantFormat: "cmpps $21, %xmm1, %xmm0",
1982 },
1983 {
1984 setup: func(i *instruction) {
1985 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNLE_UQ), newOperandReg(xmm1VReg), xmm0VReg)
1986 },
1987 want: "0fc2c116",
1988 wantFormat: "cmpps $22, %xmm1, %xmm0",
1989 },
1990 {
1991 setup: func(i *instruction) {
1992 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredORD_S), newOperandReg(xmm1VReg), xmm0VReg)
1993 },
1994 want: "0fc2c117",
1995 wantFormat: "cmpps $23, %xmm1, %xmm0",
1996 },
1997 {
1998 setup: func(i *instruction) {
1999 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredEQ_US), newOperandReg(xmm1VReg), xmm0VReg)
2000 },
2001 want: "0fc2c118",
2002 wantFormat: "cmpps $24, %xmm1, %xmm0",
2003 },
2004 {
2005 setup: func(i *instruction) {
2006 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNGE_UQ), newOperandReg(xmm1VReg), xmm0VReg)
2007 },
2008 want: "0fc2c119",
2009 wantFormat: "cmpps $25, %xmm1, %xmm0",
2010 },
2011 {
2012 setup: func(i *instruction) {
2013 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNGT_UQ), newOperandReg(xmm1VReg), xmm0VReg)
2014 },
2015 want: "0fc2c11a",
2016 wantFormat: "cmpps $26, %xmm1, %xmm0",
2017 },
2018 {
2019 setup: func(i *instruction) {
2020 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredFALSE_OS), newOperandReg(xmm1VReg), xmm0VReg)
2021 },
2022 want: "0fc2c11b",
2023 wantFormat: "cmpps $27, %xmm1, %xmm0",
2024 },
2025 {
2026 setup: func(i *instruction) {
2027 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNEQ_OS), newOperandReg(xmm1VReg), xmm0VReg)
2028 },
2029 want: "0fc2c11c",
2030 wantFormat: "cmpps $28, %xmm1, %xmm0",
2031 },
2032 {
2033 setup: func(i *instruction) {
2034 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredGE_OQ), newOperandReg(xmm1VReg), xmm0VReg)
2035 },
2036 want: "0fc2c11d",
2037 wantFormat: "cmpps $29, %xmm1, %xmm0",
2038 },
2039 {
2040 setup: func(i *instruction) {
2041 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredGT_OQ), newOperandReg(xmm1VReg), xmm0VReg)
2042 },
2043 want: "0fc2c11e",
2044 wantFormat: "cmpps $30, %xmm1, %xmm0",
2045 },
2046 {
2047 setup: func(i *instruction) {
2048 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredTRUE_US), newOperandReg(xmm1VReg), xmm0VReg)
2049 },
2050 want: "0fc2c11f",
2051 wantFormat: "cmpps $31, %xmm1, %xmm0",
2052 },
2053 {
2054 setup: func(i *instruction) {
2055 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredEQ_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2056 },
2057 want: "0fc2407b00",
2058 wantFormat: "cmpps $0, 123(%rax), %xmm0",
2059 },
2060 {
2061 setup: func(i *instruction) {
2062 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredLT_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2063 },
2064 want: "0fc2407b01",
2065 wantFormat: "cmpps $1, 123(%rax), %xmm0",
2066 },
2067 {
2068 setup: func(i *instruction) {
2069 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredLE_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2070 },
2071 want: "0fc2407b02",
2072 wantFormat: "cmpps $2, 123(%rax), %xmm0",
2073 },
2074 {
2075 setup: func(i *instruction) {
2076 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredUNORD_Q), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2077 },
2078 want: "0fc2407b03",
2079 wantFormat: "cmpps $3, 123(%rax), %xmm0",
2080 },
2081 {
2082 setup: func(i *instruction) {
2083 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNEQ_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2084 },
2085 want: "0fc2407b04",
2086 wantFormat: "cmpps $4, 123(%rax), %xmm0",
2087 },
2088 {
2089 setup: func(i *instruction) {
2090 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNLT_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2091 },
2092 want: "0fc2407b05",
2093 wantFormat: "cmpps $5, 123(%rax), %xmm0",
2094 },
2095 {
2096 setup: func(i *instruction) {
2097 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNLE_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2098 },
2099 want: "0fc2407b06",
2100 wantFormat: "cmpps $6, 123(%rax), %xmm0",
2101 },
2102 {
2103 setup: func(i *instruction) {
2104 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredORD_Q), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2105 },
2106 want: "0fc2407b07",
2107 wantFormat: "cmpps $7, 123(%rax), %xmm0",
2108 },
2109 {
2110 setup: func(i *instruction) {
2111 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredEQ_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2112 },
2113 want: "0fc2407b08",
2114 wantFormat: "cmpps $8, 123(%rax), %xmm0",
2115 },
2116 {
2117 setup: func(i *instruction) {
2118 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNGE_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2119 },
2120 want: "0fc2407b09",
2121 wantFormat: "cmpps $9, 123(%rax), %xmm0",
2122 },
2123 {
2124 setup: func(i *instruction) {
2125 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNGT_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2126 },
2127 want: "0fc2407b0a",
2128 wantFormat: "cmpps $10, 123(%rax), %xmm0",
2129 },
2130 {
2131 setup: func(i *instruction) {
2132 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredFALSE_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2133 },
2134 want: "0fc2407b0b",
2135 wantFormat: "cmpps $11, 123(%rax), %xmm0",
2136 },
2137 {
2138 setup: func(i *instruction) {
2139 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNEQ_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2140 },
2141 want: "0fc2407b0c",
2142 wantFormat: "cmpps $12, 123(%rax), %xmm0",
2143 },
2144 {
2145 setup: func(i *instruction) {
2146 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredGE_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2147 },
2148 want: "0fc2407b0d",
2149 wantFormat: "cmpps $13, 123(%rax), %xmm0",
2150 },
2151 {
2152 setup: func(i *instruction) {
2153 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredGT_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2154 },
2155 want: "0fc2407b0e",
2156 wantFormat: "cmpps $14, 123(%rax), %xmm0",
2157 },
2158 {
2159 setup: func(i *instruction) {
2160 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredTRUE_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2161 },
2162 want: "0fc2407b0f",
2163 wantFormat: "cmpps $15, 123(%rax), %xmm0",
2164 },
2165 {
2166 setup: func(i *instruction) {
2167 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredEQ_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2168 },
2169 want: "0fc2407b10",
2170 wantFormat: "cmpps $16, 123(%rax), %xmm0",
2171 },
2172 {
2173 setup: func(i *instruction) {
2174 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredLT_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2175 },
2176 want: "0fc2407b11",
2177 wantFormat: "cmpps $17, 123(%rax), %xmm0",
2178 },
2179 {
2180 setup: func(i *instruction) {
2181 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredLE_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2182 },
2183 want: "0fc2407b12",
2184 wantFormat: "cmpps $18, 123(%rax), %xmm0",
2185 },
2186 {
2187 setup: func(i *instruction) {
2188 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredUNORD_S), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2189 },
2190 want: "0fc2407b13",
2191 wantFormat: "cmpps $19, 123(%rax), %xmm0",
2192 },
2193 {
2194 setup: func(i *instruction) {
2195 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNEQ_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2196 },
2197 want: "0fc2407b14",
2198 wantFormat: "cmpps $20, 123(%rax), %xmm0",
2199 },
2200 {
2201 setup: func(i *instruction) {
2202 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNLT_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2203 },
2204 want: "0fc2407b15",
2205 wantFormat: "cmpps $21, 123(%rax), %xmm0",
2206 },
2207 {
2208 setup: func(i *instruction) {
2209 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNLE_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2210 },
2211 want: "0fc2407b16",
2212 wantFormat: "cmpps $22, 123(%rax), %xmm0",
2213 },
2214 {
2215 setup: func(i *instruction) {
2216 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredORD_S), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2217 },
2218 want: "0fc2407b17",
2219 wantFormat: "cmpps $23, 123(%rax), %xmm0",
2220 },
2221 {
2222 setup: func(i *instruction) {
2223 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredEQ_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2224 },
2225 want: "0fc2407b18",
2226 wantFormat: "cmpps $24, 123(%rax), %xmm0",
2227 },
2228 {
2229 setup: func(i *instruction) {
2230 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNGE_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2231 },
2232 want: "0fc2407b19",
2233 wantFormat: "cmpps $25, 123(%rax), %xmm0",
2234 },
2235 {
2236 setup: func(i *instruction) {
2237 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNGT_UQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2238 },
2239 want: "0fc2407b1a",
2240 wantFormat: "cmpps $26, 123(%rax), %xmm0",
2241 },
2242 {
2243 setup: func(i *instruction) {
2244 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredFALSE_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2245 },
2246 want: "0fc2407b1b",
2247 wantFormat: "cmpps $27, 123(%rax), %xmm0",
2248 },
2249 {
2250 setup: func(i *instruction) {
2251 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredNEQ_OS), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2252 },
2253 want: "0fc2407b1c",
2254 wantFormat: "cmpps $28, 123(%rax), %xmm0",
2255 },
2256 {
2257 setup: func(i *instruction) {
2258 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredGE_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2259 },
2260 want: "0fc2407b1d",
2261 wantFormat: "cmpps $29, 123(%rax), %xmm0",
2262 },
2263 {
2264 setup: func(i *instruction) {
2265 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredGT_OQ), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2266 },
2267 want: "0fc2407b1e",
2268 wantFormat: "cmpps $30, 123(%rax), %xmm0",
2269 },
2270 {
2271 setup: func(i *instruction) {
2272 i.asXmmRmRImm(sseOpcodeCmpps, uint8(cmpPredTRUE_US), newOperandMem(newAmodeImmReg(123, raxVReg)), xmm0VReg)
2273 },
2274 want: "0fc2407b1f",
2275 wantFormat: "cmpps $31, 123(%rax), %xmm0",
2276 },
2277 {
2278 setup: func(i *instruction) { i.asPop64(raxVReg) },
2279 want: "58",
2280 wantFormat: "popq %rax",
2281 },
2282 {
2283 setup: func(i *instruction) { i.asPop64(rdiVReg) },
2284 want: "5f",
2285 wantFormat: "popq %rdi",
2286 },
2287 {
2288 setup: func(i *instruction) { i.asPop64(r8VReg) },
2289 want: "4158",
2290 wantFormat: "popq %r8",
2291 },
2292 {
2293 setup: func(i *instruction) { i.asPop64(r15VReg) },
2294 want: "415f",
2295 wantFormat: "popq %r15",
2296 },
2297 {
2298 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(0, rbpVReg, r13VReg, 2))) },
2299 want: "42ff74ad00",
2300 wantFormat: "pushq (%rbp,%r13,4)",
2301 },
2302 {
2303 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(1, rspVReg, r13VReg, 2))) },
2304 want: "42ff74ac01",
2305 wantFormat: "pushq 1(%rsp,%r13,4)",
2306 },
2307 {
2308 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(1<<14, rspVReg, r13VReg, 3))) },
2309 want: "42ffb4ec00400000",
2310 wantFormat: "pushq 16384(%rsp,%r13,8)",
2311 },
2312 {
2313 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(1<<14, rspVReg, rcxVReg, 3))) },
2314 want: "ffb4cc00400000",
2315 wantFormat: "pushq 16384(%rsp,%rcx,8)",
2316 },
2317 {
2318 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(1<<14, rspVReg, rbpVReg, 3))) },
2319 want: "ffb4ec00400000",
2320 wantFormat: "pushq 16384(%rsp,%rbp,8)",
2321 },
2322 {
2323 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(1<<14, rsiVReg, rcxVReg, 3))) },
2324 want: "ffb4ce00400000",
2325 wantFormat: "pushq 16384(%rsi,%rcx,8)",
2326 },
2327 {
2328 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(321, rsiVReg, rcxVReg, 3))) },
2329 want: "ffb4ce41010000",
2330 wantFormat: "pushq 321(%rsi,%rcx,8)",
2331 },
2332 {
2333 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(0, rsiVReg, rcxVReg, 3))) },
2334 want: "ff34ce",
2335 wantFormat: "pushq (%rsi,%rcx,8)",
2336 },
2337 {
2338 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(321, r9VReg, rbxVReg, 2))) },
2339 want: "41ffb49941010000",
2340 wantFormat: "pushq 321(%r9,%rbx,4)",
2341 },
2342 {
2343 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(321, r9VReg, rbpVReg, 2))) },
2344 want: "41ffb4a941010000",
2345 wantFormat: "pushq 321(%r9,%rbp,4)",
2346 },
2347 {
2348 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(321, r9VReg, r13VReg, 2))) },
2349 want: "43ffb4a941010000",
2350 wantFormat: "pushq 321(%r9,%r13,4)",
2351 },
2352 {
2353 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(321, rbpVReg, r13VReg, 2))) },
2354 want: "42ffb4ad41010000",
2355 wantFormat: "pushq 321(%rbp,%r13,4)",
2356 },
2357 {
2358 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(0, r9VReg, r13VReg, 2))) },
2359 want: "43ff34a9",
2360 wantFormat: "pushq (%r9,%r13,4)",
2361 },
2362 {
2363 setup: func(i *instruction) { i.asPush64(newOperandMem(newAmodeRegRegShift(1<<20, r9VReg, r13VReg, 2))) },
2364 want: "43ffb4a900001000",
2365 wantFormat: "pushq 1048576(%r9,%r13,4)",
2366 },
2367 {
2368 setup: func(i *instruction) { i.asPush64(newOperandReg(rdiVReg)) },
2369 want: "57",
2370 wantFormat: "pushq %rdi",
2371 },
2372 {
2373 setup: func(i *instruction) { i.asPush64(newOperandReg(r8VReg)) },
2374 want: "4150",
2375 wantFormat: "pushq %r8",
2376 },
2377 {
2378 setup: func(i *instruction) { i.asPush64(newOperandImm32(128)) },
2379 want: "6880000000",
2380 wantFormat: "pushq $128",
2381 },
2382 {
2383 setup: func(i *instruction) { i.asPush64(newOperandImm32(0x31415927)) },
2384 want: "6827594131",
2385 wantFormat: "pushq $826366247",
2386 },
2387 {
2388 setup: func(i *instruction) {
2389 v := int32(-128)
2390 i.asPush64(newOperandImm32(uint32(v)))
2391 },
2392 want: "6880ffffff",
2393 wantFormat: "pushq $-128",
2394 },
2395 {
2396 setup: func(i *instruction) {
2397 v := int32(-129)
2398 i.asPush64(newOperandImm32(uint32(v)))
2399 },
2400 want: "687fffffff",
2401 wantFormat: "pushq $-129",
2402 },
2403 {
2404 setup: func(i *instruction) {
2405 v := int32(-0x75c4e8a1)
2406 i.asPush64(newOperandImm32(uint32(v)))
2407 },
2408 want: "685f173b8a",
2409 wantFormat: "pushq $-1975838881",
2410 },
2411 {
2412 setup: func(i *instruction) {
2413 i.asAluRmiR(aluRmiROpcodeMul, newOperandMem(newAmodeImmReg(0, rdiVReg)), rdxVReg, true)
2414 },
2415 want: "480faf17",
2416 wantFormat: "imul (%rdi), %rdx",
2417 },
2418 {
2419 setup: func(i *instruction) {
2420 i.asAluRmiR(aluRmiROpcodeMul, newOperandMem(newAmodeImmReg(99, rdiVReg)), rdxVReg, true)
2421 },
2422 want: "480faf5763",
2423 wantFormat: "imul 99(%rdi), %rdx",
2424 },
2425 {
2426 setup: func(i *instruction) {
2427 i.asAluRmiR(aluRmiROpcodeMul, newOperandMem(newAmodeImmReg(1<<21, rdiVReg)), rdxVReg, true)
2428 },
2429 want: "480faf9700002000",
2430 wantFormat: "imul 2097152(%rdi), %rdx",
2431 },
2432 {
2433 setup: func(i *instruction) {
2434 i.asAluRmiR(aluRmiROpcodeMul, newOperandReg(r15VReg), rdxVReg, true)
2435 },
2436 want: "490fafd7",
2437 wantFormat: "imul %r15, %rdx",
2438 },
2439 {
2440 setup: func(i *instruction) {
2441 i.asAluRmiR(aluRmiROpcodeMul, newOperandReg(rcxVReg), r8VReg, false)
2442 },
2443 want: "440fafc1",
2444 wantFormat: "imul %ecx, %r8d",
2445 },
2446 {
2447 setup: func(i *instruction) {
2448 i.asAluRmiR(aluRmiROpcodeMul, newOperandReg(rcxVReg), rsiVReg, false)
2449 },
2450 want: "0faff1",
2451 wantFormat: "imul %ecx, %esi",
2452 },
2453 {
2454 setup: func(i *instruction) {
2455 i.asAluRmiR(aluRmiROpcodeMul, newOperandImm32(76543210), rdxVReg, true)
2456 },
2457 want: "4869d2eaf48f04",
2458 wantFormat: "imul $76543210, %rdx",
2459 },
2460 {
2461 setup: func(i *instruction) {
2462 minusOne := int32(-1)
2463 i.asAluRmiR(aluRmiROpcodeMul, newOperandImm32(uint32(minusOne)), rdxVReg, true)
2464 },
2465 want: "486bd2ff",
2466 wantFormat: "imul $-1, %rdx",
2467 },
2468 {
2469 setup: func(i *instruction) {
2470 i.asAluRmiR(aluRmiROpcodeMul, newOperandImm32(76543210), rdxVReg, false)
2471 },
2472 want: "69d2eaf48f04",
2473 wantFormat: "imul $76543210, %edx",
2474 },
2475 {
2476 setup: func(i *instruction) {
2477 minusOne := int32(-1)
2478 i.asAluRmiR(aluRmiROpcodeMul, newOperandImm32(uint32(minusOne)), rdxVReg, false)
2479 },
2480 want: "6bd2ff",
2481 wantFormat: "imul $-1, %edx",
2482 },
2483 {
2484 setup: func(i *instruction) {
2485 i.asAluRmiR(aluRmiROpcodeAdd, newOperandMem(newAmodeImmReg(0, r12VReg)), rdxVReg, true)
2486 },
2487 want: "49031424",
2488 wantFormat: "add (%r12), %rdx",
2489 },
2490 {
2491 setup: func(i *instruction) {
2492 i.asAluRmiR(aluRmiROpcodeAdd, newOperandMem(newAmodeImmReg(123, r12VReg)), rdxVReg, true)
2493 },
2494 want: "490354247b",
2495 wantFormat: "add 123(%r12), %rdx",
2496 },
2497 {
2498 setup: func(i *instruction) {
2499 i.asAluRmiR(aluRmiROpcodeAdd, newOperandMem(newAmodeImmReg(1<<25, r12VReg)), rdxVReg, true)
2500 },
2501 want: "4903942400000002",
2502 wantFormat: "add 33554432(%r12), %rdx",
2503 },
2504 {
2505 setup: func(i *instruction) {
2506 i.asAluRmiR(aluRmiROpcodeAdd, newOperandImm32(76543210), r15VReg, true)
2507 },
2508 want: "4981c7eaf48f04",
2509 wantFormat: "add $76543210, %r15",
2510 },
2511 {
2512 setup: func(i *instruction) {
2513 minusOne := int32(-1)
2514 i.asAluRmiR(aluRmiROpcodeAdd, newOperandImm32(uint32(minusOne)), r15VReg, true)
2515 },
2516 want: "4983c7ff",
2517 wantFormat: "add $-1, %r15",
2518 },
2519 {
2520 setup: func(i *instruction) {
2521 i.asAluRmiR(aluRmiROpcodeAdd, newOperandImm32(76543210), rsiVReg, true)
2522 },
2523 want: "4881c6eaf48f04",
2524 wantFormat: "add $76543210, %rsi",
2525 },
2526 {
2527 setup: func(i *instruction) {
2528 minusOne := int32(-1)
2529 i.asAluRmiR(aluRmiROpcodeAdd, newOperandImm32(uint32(minusOne)), rsiVReg, true)
2530 },
2531 want: "4883c6ff",
2532 wantFormat: "add $-1, %rsi",
2533 },
2534 {
2535 setup: func(i *instruction) {
2536 i.asAluRmiR(aluRmiROpcodeAdd, newOperandImm32(76543210), r15VReg, false)
2537 },
2538 want: "4181c7eaf48f04",
2539 wantFormat: "add $76543210, %r15d",
2540 },
2541 {
2542 setup: func(i *instruction) {
2543 minusOne := int32(-1)
2544 i.asAluRmiR(aluRmiROpcodeAdd, newOperandImm32(uint32(minusOne)), r15VReg, false)
2545 },
2546 want: "4183c7ff",
2547 wantFormat: "add $-1, %r15d",
2548 },
2549 {
2550 setup: func(i *instruction) {
2551 i.asAluRmiR(aluRmiROpcodeAdd, newOperandImm32(76543210), rsiVReg, false)
2552 },
2553 want: "81c6eaf48f04",
2554 wantFormat: "add $76543210, %esi",
2555 },
2556 {
2557 setup: func(i *instruction) {
2558 minusOne := int32(-1)
2559 i.asAluRmiR(aluRmiROpcodeAdd, newOperandImm32(uint32(minusOne)), rsiVReg, false)
2560 },
2561 want: "83c6ff",
2562 wantFormat: "add $-1, %esi",
2563 },
2564 {
2565 setup: func(i *instruction) { i.asAluRmiR(aluRmiROpcodeAdd, newOperandReg(raxVReg), rdxVReg, true) },
2566 want: "4801c2",
2567 wantFormat: "add %rax, %rdx",
2568 },
2569 {
2570 setup: func(i *instruction) { i.asAluRmiR(aluRmiROpcodeAdd, newOperandReg(raxVReg), r15VReg, true) },
2571 want: "4901c7",
2572 wantFormat: "add %rax, %r15",
2573 },
2574 {
2575 setup: func(i *instruction) { i.asAluRmiR(aluRmiROpcodeAdd, newOperandReg(r11VReg), r15VReg, true) },
2576 want: "4d01df",
2577 wantFormat: "add %r11, %r15",
2578 },
2579 {
2580 setup: func(i *instruction) { i.asAluRmiR(aluRmiROpcodeAdd, newOperandReg(raxVReg), rdxVReg, false) },
2581 want: "01c2",
2582 wantFormat: "add %eax, %edx",
2583 },
2584 {
2585 setup: func(i *instruction) { i.asAluRmiR(aluRmiROpcodeAdd, newOperandReg(raxVReg), r15VReg, false) },
2586 want: "4101c7",
2587 wantFormat: "add %eax, %r15d",
2588 },
2589 {
2590 setup: func(i *instruction) { i.asAluRmiR(aluRmiROpcodeAdd, newOperandReg(r11VReg), r15VReg, false) },
2591 want: "4501df",
2592 wantFormat: "add %r11d, %r15d",
2593 },
2594 {
2595 setup: func(i *instruction) { i.asAluRmiR(aluRmiROpcodeSub, newOperandReg(r11VReg), r15VReg, false) },
2596 want: "4529df",
2597 wantFormat: "sub %r11d, %r15d",
2598 },
2599 {
2600 setup: func(i *instruction) {
2601 i.asAluRmiR(aluRmiROpcodeSub, newOperandMem(newAmodeImmReg(0, r13VReg)), rdxVReg, true)
2602 },
2603 want: "492b5500",
2604 wantFormat: "sub (%r13), %rdx",
2605 },
2606 {
2607 setup: func(i *instruction) {
2608 i.asAluRmiR(aluRmiROpcodeSub, newOperandMem(newAmodeImmReg(123, r13VReg)), rdxVReg, true)
2609 },
2610 want: "492b557b",
2611 wantFormat: "sub 123(%r13), %rdx",
2612 },
2613 {
2614 setup: func(i *instruction) {
2615 i.asAluRmiR(aluRmiROpcodeSub, newOperandMem(newAmodeImmReg(1<<25, r13VReg)), rdxVReg, true)
2616 },
2617 want: "492b9500000002",
2618 wantFormat: "sub 33554432(%r13), %rdx",
2619 },
2620 {
2621 setup: func(i *instruction) { i.asAluRmiR(aluRmiROpcodeAnd, newOperandReg(r11VReg), r15VReg, false) },
2622 want: "4521df",
2623 wantFormat: "and %r11d, %r15d",
2624 },
2625 {
2626 setup: func(i *instruction) { i.asAluRmiR(aluRmiROpcodeOr, newOperandReg(r11VReg), r15VReg, false) },
2627 want: "4509df",
2628 wantFormat: "or %r11d, %r15d",
2629 },
2630 {
2631 setup: func(i *instruction) { i.asAluRmiR(aluRmiROpcodeXor, newOperandReg(r11VReg), r15VReg, false) },
2632 want: "4531df",
2633 wantFormat: "xor %r11d, %r15d",
2634 },
2635 {
2636 setup: func(i *instruction) { i.asLEA(newOperandMem(newAmodeImmReg(0, rdiVReg)), rdxVReg) },
2637 want: "488d17",
2638 wantFormat: "lea (%rdi), %rdx",
2639 },
2640 {
2641 setup: func(i *instruction) { i.asLEA(newOperandMem(newAmodeImmReg(0xffff, rdiVReg)), rdxVReg) },
2642 want: "488d97ffff0000",
2643 wantFormat: "lea 65535(%rdi), %rdx",
2644 },
2645 {
2646 setup: func(i *instruction) {
2647 i.asLEA(newOperandMem(newAmodeRegRegShift(0xffff, rspVReg, r13VReg, 3)), rdxVReg)
2648 },
2649 want: "4a8d94ecffff0000",
2650 wantFormat: "lea 65535(%rsp,%r13,8), %rdx",
2651 },
2652 {
2653 setup: func(i *instruction) {
2654 i.asLEA(newOperandLabel(label(1234)), r11VReg)
2655 },
2656 want: "4c8d1dffffffff",
2657 wantFormat: "lea L1234, %r11",
2658 },
2659 {
2660 setup: func(i *instruction) { i.kind = ud2 },
2661 want: "0f0b",
2662 wantFormat: "ud2",
2663 },
2664 {
2665 setup: func(i *instruction) {
2666 i.asCall(0, nil)
2667 i.u2 = 0xff
2668 },
2669 want: "e8ff000000",
2670 wantFormat: "call f0",
2671 },
2672 {
2673 setup: func(i *instruction) {
2674 i.asCallIndirect(newOperandReg(r12VReg), nil)
2675 },
2676 want: "41ffd4",
2677 wantFormat: "callq *%r12",
2678 },
2679 {
2680 setup: func(i *instruction) {
2681 i.asCallIndirect(newOperandMem(newAmodeImmReg(0, raxVReg)), nil)
2682 },
2683 want: "ff10",
2684 wantFormat: "callq *(%rax)",
2685 },
2686 {
2687 setup: func(i *instruction) {
2688 i.asCallIndirect(newOperandMem(newAmodeImmReg(0xffff_0000, raxVReg)), nil)
2689 },
2690 want: "ff900000ffff",
2691 wantFormat: "callq *-65536(%rax)",
2692 },
2693 {
2694 setup: func(i *instruction) { i.asJmp(newOperandReg(r12VReg)) },
2695 want: "41ffe4",
2696 wantFormat: "jmp %r12",
2697 },
2698 {
2699 setup: func(i *instruction) { i.asJmp(newOperandMem(newAmodeImmReg(0, raxVReg))) },
2700 want: "ff20",
2701 wantFormat: "jmp (%rax)",
2702 },
2703 {
2704 setup: func(i *instruction) { i.asJmp(newOperandImm32(12345)) },
2705 want: "e939300000",
2706 wantFormat: "jmp $12345",
2707 },
2708 {
2709 setup: func(i *instruction) { i.asJmpIf(condO, newOperandImm32(4)) },
2710 want: "0f8004000000",
2711 wantFormat: "jo $4",
2712 },
2713 {
2714 setup: func(i *instruction) { i.asJmpIf(condNO, newOperandImm32(4)) },
2715 want: "0f8104000000",
2716 wantFormat: "jno $4",
2717 },
2718 {
2719 setup: func(i *instruction) { i.asJmpIf(condB, newOperandImm32(4)) },
2720 want: "0f8204000000",
2721 wantFormat: "jb $4",
2722 },
2723 {
2724 setup: func(i *instruction) { i.asJmpIf(condNB, newOperandImm32(4)) },
2725 want: "0f8304000000",
2726 wantFormat: "jnb $4",
2727 },
2728 {
2729 setup: func(i *instruction) { i.asJmpIf(condZ, newOperandImm32(4)) },
2730 want: "0f8404000000",
2731 wantFormat: "jz $4",
2732 },
2733 {
2734 setup: func(i *instruction) { i.asJmpIf(condNZ, newOperandImm32(4)) },
2735 want: "0f8504000000",
2736 wantFormat: "jnz $4",
2737 },
2738 {
2739 setup: func(i *instruction) { i.asJmpIf(condBE, newOperandImm32(4)) },
2740 want: "0f8604000000",
2741 wantFormat: "jbe $4",
2742 },
2743 {
2744 setup: func(i *instruction) { i.asJmpIf(condNBE, newOperandImm32(4)) },
2745 want: "0f8704000000",
2746 wantFormat: "jnbe $4",
2747 },
2748 {
2749 setup: func(i *instruction) { i.asJmpIf(condS, newOperandImm32(4)) },
2750 want: "0f8804000000",
2751 wantFormat: "js $4",
2752 },
2753 {
2754 setup: func(i *instruction) { i.asJmpIf(condNS, newOperandImm32(4)) },
2755 want: "0f8904000000",
2756 wantFormat: "jns $4",
2757 },
2758 {
2759 setup: func(i *instruction) { i.asJmpIf(condL, newOperandImm32(4)) },
2760 want: "0f8c04000000",
2761 wantFormat: "jl $4",
2762 },
2763 {
2764 setup: func(i *instruction) { i.asJmpIf(condNL, newOperandImm32(4)) },
2765 want: "0f8d04000000",
2766 wantFormat: "jnl $4",
2767 },
2768 {
2769 setup: func(i *instruction) { i.asJmpIf(condLE, newOperandImm32(4)) },
2770 want: "0f8e04000000",
2771 wantFormat: "jle $4",
2772 },
2773 {
2774 setup: func(i *instruction) { i.asJmpIf(condNLE, newOperandImm32(4)) },
2775 want: "0f8f04000000",
2776 wantFormat: "jnle $4",
2777 },
2778 {
2779 setup: func(i *instruction) { i.asJmpIf(condP, newOperandImm32(4)) },
2780 want: "0f8a04000000",
2781 wantFormat: "jp $4",
2782 },
2783 {
2784 setup: func(i *instruction) { i.asJmpIf(condNP, newOperandImm32(4)) },
2785 want: "0f8b04000000",
2786 wantFormat: "jnp $4",
2787 },
2788 {
2789 setup: func(i *instruction) {
2790 i.asMov64MR(newOperandMem(
2791 newAmodeImmReg(0, raxVReg),
2792 ), r15VReg)
2793 },
2794 want: "4c8b38",
2795 wantFormat: "movq (%rax), %r15",
2796 },
2797 {
2798 setup: func(i *instruction) {
2799 i.asMov64MR(newOperandMem(
2800 newAmodeImmReg(0, r12VReg),
2801 ), r15VReg)
2802 },
2803 want: "4d8b3c24",
2804 wantFormat: "movq (%r12), %r15",
2805 },
2806 {
2807 setup: func(i *instruction) {
2808 i.asMov64MR(newOperandMem(
2809 newAmodeImmReg(1, r12VReg),
2810 ), r15VReg)
2811 },
2812 want: "4d8b7c2401",
2813 wantFormat: "movq 1(%r12), %r15",
2814 },
2815 {
2816 setup: func(i *instruction) {
2817 i.asMov64MR(newOperandMem(
2818 newAmodeImmReg(1<<20, r12VReg),
2819 ), r15VReg)
2820 },
2821 want: "4d8bbc2400001000",
2822 wantFormat: "movq 1048576(%r12), %r15",
2823 },
2824 {
2825 setup: func(i *instruction) {
2826 i.asMov64MR(newOperandMem(
2827 newAmodeImmReg(1<<20, raxVReg),
2828 ), r15VReg)
2829 },
2830 want: "4c8bb800001000",
2831 wantFormat: "movq 1048576(%rax), %r15",
2832 },
2833 //
2834 {
2835 setup: func(i *instruction) { i.asMovsxRmR(extModeBL, newOperandReg(raxVReg), rdiVReg) },
2836 want: "0fbef8",
2837 wantFormat: "movsx.bl %rax, %rdi",
2838 },
2839 {
2840 setup: func(i *instruction) { i.asMovsxRmR(extModeBL, newOperandReg(rbxVReg), rdiVReg) },
2841 want: "0fbefb",
2842 wantFormat: "movsx.bl %rbx, %rdi",
2843 },
2844 {
2845 setup: func(i *instruction) { i.asMovsxRmR(extModeBQ, newOperandReg(raxVReg), rdiVReg) },
2846 want: "480fbef8",
2847 wantFormat: "movsx.bq %rax, %rdi",
2848 },
2849 {
2850 setup: func(i *instruction) { i.asMovsxRmR(extModeBQ, newOperandReg(r15VReg), rdiVReg) },
2851 want: "490fbeff",
2852 wantFormat: "movsx.bq %r15, %rdi",
2853 },
2854 {
2855 setup: func(i *instruction) { i.asMovsxRmR(extModeWL, newOperandReg(raxVReg), rdiVReg) },
2856 want: "0fbff8",
2857 wantFormat: "movsx.wl %rax, %rdi",
2858 },
2859 {
2860 setup: func(i *instruction) { i.asMovsxRmR(extModeWQ, newOperandReg(raxVReg), rdiVReg) },
2861 want: "480fbff8",
2862 wantFormat: "movsx.wq %rax, %rdi",
2863 },
2864 {
2865 setup: func(i *instruction) { i.asMovsxRmR(extModeLQ, newOperandReg(raxVReg), rdiVReg) },
2866 want: "4863f8",
2867 wantFormat: "movsx.lq %rax, %rdi",
2868 },
2869 {
2870 setup: func(i *instruction) { i.asMovzxRmR(extModeBL, newOperandReg(raxVReg), rdiVReg) },
2871 want: "0fb6f8",
2872 wantFormat: "movzx.bl %rax, %rdi",
2873 },
2874 {
2875 setup: func(i *instruction) { i.asMovzxRmR(extModeBL, newOperandReg(rbxVReg), rdiVReg) },
2876 want: "0fb6fb",
2877 wantFormat: "movzx.bl %rbx, %rdi",
2878 },
2879 {
2880 setup: func(i *instruction) { i.asMovzxRmR(extModeBQ, newOperandReg(raxVReg), rdiVReg) },
2881 want: "480fb6f8",
2882 wantFormat: "movzx.bq %rax, %rdi",
2883 },
2884 {
2885 setup: func(i *instruction) { i.asMovzxRmR(extModeBQ, newOperandReg(r15VReg), rdiVReg) },
2886 want: "490fb6ff",
2887 wantFormat: "movzx.bq %r15, %rdi",
2888 },
2889 {
2890 setup: func(i *instruction) { i.asMovzxRmR(extModeWL, newOperandReg(raxVReg), rdiVReg) },
2891 want: "0fb7f8",
2892 wantFormat: "movzx.wl %rax, %rdi",
2893 },
2894 {
2895 setup: func(i *instruction) { i.asMovzxRmR(extModeWQ, newOperandReg(raxVReg), rdiVReg) },
2896 want: "480fb7f8",
2897 wantFormat: "movzx.wq %rax, %rdi",
2898 },
2899 {
2900 setup: func(i *instruction) { i.asMovzxRmR(extModeLQ, newOperandReg(raxVReg), rdiVReg) },
2901 want: "8bf8",
2902 wantFormat: "movzx.lq %rax, %rdi",
2903 },
2904 {
2905 setup: func(i *instruction) {
2906 a := newOperandMem(newAmodeImmReg(1<<20, raxVReg))
2907 i.asMovsxRmR(extModeBQ, a, rdiVReg)
2908 },
2909 want: "480fbeb800001000",
2910 wantFormat: "movsx.bq 1048576(%rax), %rdi",
2911 },
2912 {
2913 setup: func(i *instruction) {
2914 a := newOperandMem(newAmodeImmReg(1<<20, raxVReg))
2915 i.asMovsxRmR(extModeBL, a, rdiVReg)
2916 },
2917 want: "0fbeb800001000",
2918 wantFormat: "movsx.bl 1048576(%rax), %rdi",
2919 },
2920 {
2921 setup: func(i *instruction) {
2922 a := newOperandMem(newAmodeImmReg(1<<20, raxVReg))
2923 i.asMovsxRmR(extModeWL, a, rdiVReg)
2924 },
2925 want: "0fbfb800001000",
2926 wantFormat: "movsx.wl 1048576(%rax), %rdi",
2927 },
2928 {
2929 setup: func(i *instruction) {
2930 a := newOperandMem(newAmodeImmReg(1<<20, raxVReg))
2931 i.asMovsxRmR(extModeWQ, a, rdiVReg)
2932 },
2933 want: "480fbfb800001000",
2934 wantFormat: "movsx.wq 1048576(%rax), %rdi",
2935 },
2936 {
2937 setup: func(i *instruction) {
2938 a := newOperandMem(newAmodeImmReg(1<<20, raxVReg))
2939 i.asMovsxRmR(extModeLQ, a, rdiVReg)
2940 },
2941 want: "4863b800001000",
2942 wantFormat: "movsx.lq 1048576(%rax), %rdi",
2943 },
2944 {
2945 setup: func(i *instruction) {
2946 a := newOperandMem(newAmodeImmReg(1<<20, raxVReg))
2947 i.asMovzxRmR(extModeLQ, a, rdiVReg)
2948 },
2949 want: "8bb800001000",
2950 wantFormat: "movzx.lq 1048576(%rax), %rdi",
2951 },
2952 {
2953 setup: func(i *instruction) {
2954 a := newOperandMem(newAmodeImmReg(1<<20, raxVReg))
2955 i.asMovRM(rcxVReg, a, 1)
2956 },
2957 want: "888800001000",
2958 wantFormat: "mov.b %rcx, 1048576(%rax)",
2959 },
2960 {
2961 setup: func(i *instruction) {
2962 a := newOperandMem(newAmodeImmReg(1<<20, raxVReg))
2963 i.asMovRM(rdiVReg, a, 1)
2964 },
2965 want: "4088b800001000",
2966 wantFormat: "mov.b %rdi, 1048576(%rax)",
2967 },
2968 {
2969 setup: func(i *instruction) {
2970 a := newOperandMem(newAmodeRegRegShift(1, rcxVReg, rdxVReg, 0))
2971 i.asMovRM(rsiVReg, a, 1)
2972 },
2973 want: "4088741101",
2974 wantFormat: "mov.b %rsi, 1(%rcx,%rdx,1)",
2975 },
2976 {
2977 setup: func(i *instruction) {
2978 a := newOperandMem(newAmodeRegRegShift(1, rcxVReg, rdxVReg, 1))
2979 i.asMovRM(rdiVReg, a, 1)
2980 },
2981 want: "40887c5101",
2982 wantFormat: "mov.b %rdi, 1(%rcx,%rdx,2)",
2983 },
2984 {
2985 setup: func(i *instruction) {
2986 a := newOperandMem(newAmodeRegRegShift(1, rcxVReg, rdxVReg, 1))
2987 i.asMovRM(rdiVReg, a, 2)
2988 },
2989 want: "66897c5101",
2990 wantFormat: "mov.w %rdi, 1(%rcx,%rdx,2)",
2991 },
2992 {
2993 setup: func(i *instruction) {
2994 a := newOperandMem(newAmodeRegRegShift(1<<20, raxVReg, rcxVReg, 3))
2995 i.asMovRM(rdiVReg, a, 2)
2996 },
2997 want: "6689bcc800001000",
2998 wantFormat: "mov.w %rdi, 1048576(%rax,%rcx,8)",
2999 },
3000 {
3001 setup: func(i *instruction) {
3002 a := newOperandMem(newAmodeRegRegShift(1<<20, rcxVReg, rdxVReg, 3))
3003 i.asMovRM(rdiVReg, a, 2)
3004 },
3005 want: "6689bcd100001000",
3006 wantFormat: "mov.w %rdi, 1048576(%rcx,%rdx,8)",
3007 },
3008 {
3009 setup: func(i *instruction) {
3010 a := newOperandMem(newAmodeRegRegShift(123, raxVReg, rcxVReg, 0))
3011 i.asMovRM(rdiVReg, a, 4)
3012 },
3013 want: "897c087b",
3014 wantFormat: "mov.l %rdi, 123(%rax,%rcx,1)",
3015 },
3016 {
3017 setup: func(i *instruction) {
3018 a := newOperandMem(newAmodeRegRegShift(123, raxVReg, rcxVReg, 0))
3019 i.asMovRM(rdiVReg, a, 8)
3020 },
3021 want: "48897c087b",
3022 wantFormat: "mov.q %rdi, 123(%rax,%rcx,1)",
3023 },
3024 {
3025 setup: func(i *instruction) {
3026 a := newOperandMem(newAmodeRegRegShift(123, raxVReg, rcxVReg, 0))
3027 i.asXmmMovRM(sseOpcodeMovaps, xmm1VReg, a)
3028 },
3029 want: "0f294c087b",
3030 wantFormat: "movaps %xmm1, 123(%rax,%rcx,1)",
3031 },
3032 {
3033 setup: func(i *instruction) {
3034 a := newOperandMem(newAmodeImmReg(123, rcxVReg))
3035 i.asXmmMovRM(sseOpcodeMovaps, xmm15VReg, a)
3036 },
3037 want: "440f29797b",
3038 wantFormat: "movaps %xmm15, 123(%rcx)",
3039 },
3040 {
3041 setup: func(i *instruction) {
3042 a := newOperandMem(newAmodeImmReg(123, rcxVReg))
3043 i.asXmmMovRM(sseOpcodeMovapd, xmm15VReg, a)
3044 },
3045 want: "66440f29797b",
3046 wantFormat: "movapd %xmm15, 123(%rcx)",
3047 },
3048 {
3049 setup: func(i *instruction) {
3050 a := newOperandMem(newAmodeImmReg(123, rcxVReg))
3051 i.asXmmMovRM(sseOpcodeMovdqa, xmm15VReg, a)
3052 },
3053 want: "66440f7f797b",
3054 wantFormat: "movdqa %xmm15, 123(%rcx)",
3055 },
3056 {
3057 setup: func(i *instruction) {
3058 a := newOperandMem(newAmodeImmReg(123, rcxVReg))
3059 i.asXmmMovRM(sseOpcodeMovdqu, xmm15VReg, a)
3060 },
3061 want: "f3440f7f797b",
3062 wantFormat: "movdqu %xmm15, 123(%rcx)",
3063 },
3064 {
3065 setup: func(i *instruction) {
3066 a := newOperandMem(newAmodeImmReg(123, rcxVReg))
3067 i.asXmmMovRM(sseOpcodeMovss, xmm15VReg, a)
3068 },
3069 want: "f3440f11797b",
3070 wantFormat: "movss %xmm15, 123(%rcx)",
3071 },
3072 {
3073 setup: func(i *instruction) {
3074 a := newOperandMem(newAmodeImmReg(123, rcxVReg))
3075 i.asXmmMovRM(sseOpcodeMovsd, xmm15VReg, a)
3076 },
3077 want: "f2440f11797b",
3078 wantFormat: "movsd %xmm15, 123(%rcx)",
3079 },
3080 {
3081 setup: func(i *instruction) {
3082 a := newOperandMem(newAmodeImmReg(123, rcxVReg))
3083 i.asXmmMovRM(sseOpcodeMovups, xmm15VReg, a)
3084 },
3085 want: "440f11797b",
3086 wantFormat: "movups %xmm15, 123(%rcx)",
3087 },
3088 {
3089 setup: func(i *instruction) {
3090 a := newOperandMem(newAmodeImmReg(123, rcxVReg))
3091 i.asXmmMovRM(sseOpcodeMovupd, xmm15VReg, a)
3092 },
3093 want: "66440f11797b",
3094 wantFormat: "movupd %xmm15, 123(%rcx)",
3095 },
3096 {
3097 setup: func(i *instruction) {
3098 i.asShiftR(shiftROpRotateLeft, newOperandReg(rcxVReg), rdiVReg, false)
3099 },
3100 want: "d3c7",
3101 wantFormat: "roll %ecx, %edi",
3102 },
3103 {
3104 setup: func(i *instruction) {
3105 i.asShiftR(shiftROpRotateLeft, newOperandImm32(128), rdiVReg, false)
3106 },
3107 want: "c1c780",
3108 wantFormat: "roll $128, %edi",
3109 },
3110 {
3111 setup: func(i *instruction) {
3112 i.asShiftR(shiftROpRotateLeft, newOperandReg(rcxVReg), rdiVReg, true)
3113 },
3114 want: "48d3c7",
3115 wantFormat: "rolq %ecx, %rdi",
3116 },
3117 {
3118 setup: func(i *instruction) {
3119 i.asShiftR(shiftROpRotateLeft, newOperandImm32(128), rdiVReg, true)
3120 },
3121 want: "48c1c780",
3122 wantFormat: "rolq $128, %rdi",
3123 },
3124 {
3125 setup: func(i *instruction) {
3126 i.asShiftR(shiftROpRotateRight, newOperandReg(rcxVReg), rdiVReg, false)
3127 },
3128 want: "d3cf",
3129 wantFormat: "rorl %ecx, %edi",
3130 },
3131 {
3132 setup: func(i *instruction) {
3133 i.asShiftR(shiftROpRotateRight, newOperandImm32(128), rdiVReg, false)
3134 },
3135 want: "c1cf80",
3136 wantFormat: "rorl $128, %edi",
3137 },
3138 {
3139 setup: func(i *instruction) {
3140 i.asShiftR(shiftROpRotateRight, newOperandReg(rcxVReg), rdiVReg, true)
3141 },
3142 want: "48d3cf",
3143 wantFormat: "rorq %ecx, %rdi",
3144 },
3145 {
3146 setup: func(i *instruction) {
3147 i.asShiftR(shiftROpRotateRight, newOperandImm32(128), rdiVReg, true)
3148 },
3149 want: "48c1cf80",
3150 wantFormat: "rorq $128, %rdi",
3151 },
3152 {
3153 setup: func(i *instruction) {
3154 i.asShiftR(shiftROpShiftLeft, newOperandReg(rcxVReg), rdiVReg, false)
3155 },
3156 want: "d3e7",
3157 wantFormat: "shll %ecx, %edi",
3158 },
3159 {
3160 setup: func(i *instruction) {
3161 i.asShiftR(shiftROpShiftLeft, newOperandImm32(128), rdiVReg, false)
3162 },
3163 want: "c1e780",
3164 wantFormat: "shll $128, %edi",
3165 },
3166 {
3167 setup: func(i *instruction) {
3168 i.asShiftR(shiftROpShiftLeft, newOperandReg(rcxVReg), rdiVReg, true)
3169 },
3170 want: "48d3e7",
3171 wantFormat: "shlq %ecx, %rdi",
3172 },
3173 {
3174 setup: func(i *instruction) {
3175 i.asShiftR(shiftROpShiftLeft, newOperandImm32(128), rdiVReg, true)
3176 },
3177 want: "48c1e780",
3178 wantFormat: "shlq $128, %rdi",
3179 },
3180 {
3181 setup: func(i *instruction) {
3182 i.asShiftR(shiftROpShiftRightLogical, newOperandReg(rcxVReg), rdiVReg, false)
3183 },
3184 want: "d3ef",
3185 wantFormat: "shrl %ecx, %edi",
3186 },
3187 {
3188 setup: func(i *instruction) {
3189 i.asShiftR(shiftROpShiftRightLogical, newOperandImm32(128), rdiVReg, false)
3190 },
3191 want: "c1ef80",
3192 wantFormat: "shrl $128, %edi",
3193 },
3194 {
3195 setup: func(i *instruction) {
3196 i.asShiftR(shiftROpShiftRightLogical, newOperandReg(rcxVReg), rdiVReg, true)
3197 },
3198 want: "48d3ef",
3199 wantFormat: "shrq %ecx, %rdi",
3200 },
3201 {
3202 setup: func(i *instruction) {
3203 i.asShiftR(shiftROpShiftRightLogical, newOperandImm32(128), rdiVReg, true)
3204 },
3205 want: "48c1ef80",
3206 wantFormat: "shrq $128, %rdi",
3207 },
3208 {
3209 setup: func(i *instruction) {
3210 i.asShiftR(shiftROpShiftRightArithmetic, newOperandReg(rcxVReg), rdiVReg, false)
3211 },
3212 want: "d3ff",
3213 wantFormat: "sarl %ecx, %edi",
3214 },
3215 {
3216 setup: func(i *instruction) {
3217 i.asShiftR(shiftROpShiftRightArithmetic, newOperandImm32(128), rdiVReg, false)
3218 },
3219 want: "c1ff80",
3220 wantFormat: "sarl $128, %edi",
3221 },
3222 {
3223 setup: func(i *instruction) {
3224 i.asShiftR(shiftROpShiftRightArithmetic, newOperandReg(rcxVReg), rdiVReg, true)
3225 },
3226 want: "48d3ff",
3227 wantFormat: "sarq %ecx, %rdi",
3228 },
3229 {
3230 setup: func(i *instruction) {
3231 i.asShiftR(shiftROpShiftRightArithmetic, newOperandImm32(128), rdiVReg, true)
3232 },
3233 want: "48c1ff80",
3234 wantFormat: "sarq $128, %rdi",
3235 },
3236 {
3237 setup: func(i *instruction) {
3238 i.asXmmRmiReg(sseOpcodePsllw, newOperandImm32(128), xmm11VReg)
3239 },
3240 want: "66410f71f380",
3241 wantFormat: "psllw $128, %xmm11",
3242 },
3243 {
3244 setup: func(i *instruction) {
3245 i.asXmmRmiReg(sseOpcodePslld, newOperandImm32(128), xmm11VReg)
3246 },
3247 want: "66410f72f380",
3248 wantFormat: "pslld $128, %xmm11",
3249 },
3250 {
3251 setup: func(i *instruction) {
3252 i.asXmmRmiReg(sseOpcodePsllq, newOperandImm32(128), xmm11VReg)
3253 },
3254 want: "66410f73f380",
3255 wantFormat: "psllq $128, %xmm11",
3256 },
3257 {
3258 setup: func(i *instruction) {
3259 i.asXmmRmiReg(sseOpcodePsraw, newOperandImm32(128), xmm11VReg)
3260 },
3261 want: "66410f71e380",
3262 wantFormat: "psraw $128, %xmm11",
3263 },
3264 {
3265 setup: func(i *instruction) {
3266 i.asXmmRmiReg(sseOpcodePsrad, newOperandImm32(128), xmm11VReg)
3267 },
3268 want: "66410f72e380",
3269 wantFormat: "psrad $128, %xmm11",
3270 },
3271 {
3272 setup: func(i *instruction) {
3273 i.asXmmRmiReg(sseOpcodePsrlw, newOperandImm32(128), xmm11VReg)
3274 },
3275 want: "66410f71d380",
3276 wantFormat: "psrlw $128, %xmm11",
3277 },
3278 {
3279 setup: func(i *instruction) {
3280 i.asXmmRmiReg(sseOpcodePsrld, newOperandImm32(128), xmm11VReg)
3281 },
3282 want: "66410f72d380",
3283 wantFormat: "psrld $128, %xmm11",
3284 },
3285 {
3286 setup: func(i *instruction) {
3287 i.asXmmRmiReg(sseOpcodePsrlq, newOperandImm32(128), xmm11VReg)
3288 },
3289 want: "66410f73d380",
3290 wantFormat: "psrlq $128, %xmm11",
3291 },
3292 {
3293 setup: func(i *instruction) {
3294 i.asXmmRmiReg(sseOpcodePsllw, newOperandReg(xmm13VReg), xmm11VReg)
3295 },
3296 want: "66450ff1dd",
3297 wantFormat: "psllw %xmm13, %xmm11",
3298 },
3299 {
3300 setup: func(i *instruction) {
3301 i.asXmmRmiReg(sseOpcodePslld, newOperandReg(xmm13VReg), xmm11VReg)
3302 },
3303 want: "66450ff2dd",
3304 wantFormat: "pslld %xmm13, %xmm11",
3305 },
3306 {
3307 setup: func(i *instruction) {
3308 i.asXmmRmiReg(sseOpcodePsllq, newOperandReg(xmm13VReg), xmm11VReg)
3309 },
3310 want: "66450ff3dd",
3311 wantFormat: "psllq %xmm13, %xmm11",
3312 },
3313 {
3314 setup: func(i *instruction) {
3315 i.asXmmRmiReg(sseOpcodePsraw, newOperandReg(xmm13VReg), xmm11VReg)
3316 },
3317 want: "66450fe1dd",
3318 wantFormat: "psraw %xmm13, %xmm11",
3319 },
3320 {
3321 setup: func(i *instruction) {
3322 i.asXmmRmiReg(sseOpcodePsrad, newOperandReg(xmm13VReg), xmm11VReg)
3323 },
3324 want: "66450fe2dd",
3325 wantFormat: "psrad %xmm13, %xmm11",
3326 },
3327 {
3328 setup: func(i *instruction) {
3329 i.asXmmRmiReg(sseOpcodePsrlw, newOperandReg(xmm13VReg), xmm11VReg)
3330 },
3331 want: "66450fd1dd",
3332 wantFormat: "psrlw %xmm13, %xmm11",
3333 },
3334 {
3335 setup: func(i *instruction) {
3336 i.asXmmRmiReg(sseOpcodePsrld, newOperandReg(xmm13VReg), xmm11VReg)
3337 },
3338 want: "66450fd2dd",
3339 wantFormat: "psrld %xmm13, %xmm11",
3340 },
3341 {
3342 setup: func(i *instruction) {
3343 i.asXmmRmiReg(sseOpcodePsrlq, newOperandReg(xmm13VReg), xmm11VReg)
3344 },
3345 want: "66450fd3dd",
3346 wantFormat: "psrlq %xmm13, %xmm11",
3347 },
3348 {
3349 setup: func(i *instruction) {
3350 i.asXmmRmiReg(sseOpcodePsllw, newOperandMem(newAmodeImmReg(128, r13VReg)), xmm11VReg)
3351 },
3352 want: "66450ff19d80000000",
3353 wantFormat: "psllw 128(%r13), %xmm11",
3354 },
3355 {
3356 setup: func(i *instruction) {
3357 i.asXmmRmiReg(sseOpcodePslld, newOperandMem(newAmodeImmReg(128, r13VReg)), xmm11VReg)
3358 },
3359 want: "66450ff29d80000000",
3360 wantFormat: "pslld 128(%r13), %xmm11",
3361 },
3362 {
3363 setup: func(i *instruction) {
3364 i.asXmmRmiReg(sseOpcodePsllq, newOperandMem(newAmodeImmReg(128, r13VReg)), xmm11VReg)
3365 },
3366 want: "66450ff39d80000000",
3367 wantFormat: "psllq 128(%r13), %xmm11",
3368 },
3369 {
3370 setup: func(i *instruction) {
3371 i.asXmmRmiReg(sseOpcodePsraw, newOperandMem(newAmodeImmReg(128, r13VReg)), xmm11VReg)
3372 },
3373 want: "66450fe19d80000000",
3374 wantFormat: "psraw 128(%r13), %xmm11",
3375 },
3376 {
3377 setup: func(i *instruction) {
3378 i.asXmmRmiReg(sseOpcodePsrad, newOperandMem(newAmodeImmReg(128, r13VReg)), xmm11VReg)
3379 },
3380 want: "66450fe29d80000000",
3381 wantFormat: "psrad 128(%r13), %xmm11",
3382 },
3383 {
3384 setup: func(i *instruction) {
3385 i.asXmmRmiReg(sseOpcodePsrlw, newOperandMem(newAmodeImmReg(128, r13VReg)), xmm11VReg)
3386 },
3387 want: "66450fd19d80000000",
3388 wantFormat: "psrlw 128(%r13), %xmm11",
3389 },
3390 {
3391 setup: func(i *instruction) {
3392 i.asXmmRmiReg(sseOpcodePsrld, newOperandMem(newAmodeImmReg(128, r13VReg)), xmm11VReg)
3393 },
3394 want: "66450fd29d80000000",
3395 wantFormat: "psrld 128(%r13), %xmm11",
3396 },
3397 {
3398 setup: func(i *instruction) {
3399 i.asXmmRmiReg(sseOpcodePsrlq, newOperandMem(newAmodeImmReg(128, r13VReg)), xmm11VReg)
3400 },
3401 want: "66450fd39d80000000",
3402 wantFormat: "psrlq 128(%r13), %xmm11",
3403 },
3404 {
3405 setup: func(i *instruction) {
3406 i.asCmpRmiR(true, newOperandReg(r13VReg), rdiVReg, true)
3407 },
3408 want: "4c39ef",
3409 wantFormat: "cmpq %r13, %rdi",
3410 },
3411 {
3412 setup: func(i *instruction) {
3413 i.asCmpRmiR(false, newOperandReg(r13VReg), rdiVReg, true)
3414 },
3415 want: "4c85ef",
3416 wantFormat: "testq %r13, %rdi",
3417 },
3418 {
3419 setup: func(i *instruction) {
3420 i.asCmpRmiR(true, newOperandReg(r13VReg), rdiVReg, false)
3421 },
3422 want: "4439ef",
3423 wantFormat: "cmpl %r13d, %edi",
3424 },
3425 {
3426 setup: func(i *instruction) {
3427 i.asCmpRmiR(false, newOperandReg(r13VReg), rdiVReg, false)
3428 },
3429 want: "4485ef",
3430 wantFormat: "testl %r13d, %edi",
3431 },
3432 {
3433 setup: func(i *instruction) {
3434 i.asCmpRmiR(true, newOperandMem(newAmodeImmReg(128, r13VReg)), rdiVReg, true)
3435 },
3436 want: "493bbd80000000",
3437 wantFormat: "cmpq 128(%r13), %rdi",
3438 },
3439 {
3440 setup: func(i *instruction) {
3441 i.asCmpRmiR(false, newOperandMem(newAmodeImmReg(128, r13VReg)), rdiVReg, true)
3442 },
3443 want: "4985bd80000000",
3444 wantFormat: "testq %rdi, 128(%r13)",
3445 },
3446 {
3447 setup: func(i *instruction) {
3448 i.asCmpRmiR(true, newOperandMem(newAmodeImmReg(128, r13VReg)), rdiVReg, false)
3449 },
3450 want: "413bbd80000000",
3451 wantFormat: "cmpl 128(%r13), %edi",
3452 },
3453 {
3454 setup: func(i *instruction) {
3455 i.asCmpRmiR(false, newOperandMem(newAmodeImmReg(128, r13VReg)), rdiVReg, false)
3456 },
3457 want: "4185bd80000000",
3458 wantFormat: "testl %edi, 128(%r13)",
3459 },
3460 {
3461 setup: func(i *instruction) {
3462 i.asCmpRmiR(true, newOperandImm32(128), rdiVReg, true)
3463 },
3464 want: "4881ff80000000",
3465 wantFormat: "cmpq $128, %rdi",
3466 },
3467 {
3468 setup: func(i *instruction) {
3469 i.asCmpRmiR(false, newOperandImm32(128), rdiVReg, true)
3470 },
3471 want: "48f7c780000000",
3472 wantFormat: "testq $128, %rdi",
3473 },
3474 {
3475 setup: func(i *instruction) {
3476 i.asCmpRmiR(true, newOperandImm32(128), rdiVReg, false)
3477 },
3478 want: "81ff80000000",
3479 wantFormat: "cmpl $128, %edi",
3480 },
3481 {
3482 setup: func(i *instruction) {
3483 i.asCmpRmiR(false, newOperandImm32(128), rdiVReg, false)
3484 },
3485 want: "f7c780000000",
3486 wantFormat: "testl $128, %edi",
3487 },
3488 {
3489 setup: func(i *instruction) { i.asSetcc(condO, rsiVReg) },
3490 want: "400f90c6",
3491 wantFormat: "seto %rsi",
3492 },
3493 {
3494 setup: func(i *instruction) { i.asSetcc(condNO, rsiVReg) },
3495 want: "400f91c6",
3496 wantFormat: "setno %rsi",
3497 },
3498 {
3499 setup: func(i *instruction) { i.asSetcc(condB, rsiVReg) },
3500 want: "400f92c6",
3501 wantFormat: "setb %rsi",
3502 },
3503 {
3504 setup: func(i *instruction) { i.asSetcc(condNB, rsiVReg) },
3505 want: "400f93c6",
3506 wantFormat: "setnb %rsi",
3507 },
3508 {
3509 setup: func(i *instruction) { i.asSetcc(condZ, rsiVReg) },
3510 want: "400f94c6",
3511 wantFormat: "setz %rsi",
3512 },
3513 {
3514 setup: func(i *instruction) { i.asSetcc(condNZ, rsiVReg) },
3515 want: "400f95c6",
3516 wantFormat: "setnz %rsi",
3517 },
3518 {
3519 setup: func(i *instruction) { i.asSetcc(condBE, rsiVReg) },
3520 want: "400f96c6",
3521 wantFormat: "setbe %rsi",
3522 },
3523 {
3524 setup: func(i *instruction) { i.asSetcc(condNBE, rsiVReg) },
3525 want: "400f97c6",
3526 wantFormat: "setnbe %rsi",
3527 },
3528 {
3529 setup: func(i *instruction) { i.asSetcc(condS, rsiVReg) },
3530 want: "400f98c6",
3531 wantFormat: "sets %rsi",
3532 },
3533 {
3534 setup: func(i *instruction) { i.asSetcc(condNS, rsiVReg) },
3535 want: "400f99c6",
3536 wantFormat: "setns %rsi",
3537 },
3538 {
3539 setup: func(i *instruction) { i.asSetcc(condP, rsiVReg) },
3540 want: "400f9ac6",
3541 wantFormat: "setp %rsi",
3542 },
3543 {
3544 setup: func(i *instruction) { i.asSetcc(condNP, rsiVReg) },
3545 want: "400f9bc6",
3546 wantFormat: "setnp %rsi",
3547 },
3548 {
3549 setup: func(i *instruction) { i.asSetcc(condL, rsiVReg) },
3550 want: "400f9cc6",
3551 wantFormat: "setl %rsi",
3552 },
3553 {
3554 setup: func(i *instruction) { i.asSetcc(condNL, rsiVReg) },
3555 want: "400f9dc6",
3556 wantFormat: "setnl %rsi",
3557 },
3558 {
3559 setup: func(i *instruction) { i.asSetcc(condLE, rsiVReg) },
3560 want: "400f9ec6",
3561 wantFormat: "setle %rsi",
3562 },
3563 {
3564 setup: func(i *instruction) { i.asSetcc(condNLE, rsiVReg) },
3565 want: "400f9fc6",
3566 wantFormat: "setnle %rsi",
3567 },
3568 {
3569 setup: func(i *instruction) { i.asCmove(condO, newOperandReg(rdiVReg), rsiVReg, true) },
3570 want: "480f40f7",
3571 wantFormat: "cmovoq %rdi, %rsi",
3572 },
3573 {
3574 setup: func(i *instruction) { i.asCmove(condNO, newOperandReg(rdiVReg), rsiVReg, true) },
3575 want: "480f41f7",
3576 wantFormat: "cmovnoq %rdi, %rsi",
3577 },
3578 {
3579 setup: func(i *instruction) { i.asCmove(condB, newOperandReg(rdiVReg), rsiVReg, true) },
3580 want: "480f42f7",
3581 wantFormat: "cmovbq %rdi, %rsi",
3582 },
3583 {
3584 setup: func(i *instruction) { i.asCmove(condNB, newOperandReg(rdiVReg), rsiVReg, true) },
3585 want: "480f43f7",
3586 wantFormat: "cmovnbq %rdi, %rsi",
3587 },
3588 {
3589 setup: func(i *instruction) { i.asCmove(condZ, newOperandReg(rdiVReg), rsiVReg, true) },
3590 want: "480f44f7",
3591 wantFormat: "cmovzq %rdi, %rsi",
3592 },
3593 {
3594 setup: func(i *instruction) { i.asCmove(condNZ, newOperandReg(rdiVReg), rsiVReg, true) },
3595 want: "480f45f7",
3596 wantFormat: "cmovnzq %rdi, %rsi",
3597 },
3598 {
3599 setup: func(i *instruction) { i.asCmove(condBE, newOperandReg(rdiVReg), rsiVReg, true) },
3600 want: "480f46f7",
3601 wantFormat: "cmovbeq %rdi, %rsi",
3602 },
3603 {
3604 setup: func(i *instruction) { i.asCmove(condNBE, newOperandReg(rdiVReg), rsiVReg, true) },
3605 want: "480f47f7",
3606 wantFormat: "cmovnbeq %rdi, %rsi",
3607 },
3608 {
3609 setup: func(i *instruction) { i.asCmove(condS, newOperandReg(rdiVReg), rsiVReg, true) },
3610 want: "480f48f7",
3611 wantFormat: "cmovsq %rdi, %rsi",
3612 },
3613 {
3614 setup: func(i *instruction) { i.asCmove(condNS, newOperandReg(rdiVReg), rsiVReg, true) },
3615 want: "480f49f7",
3616 wantFormat: "cmovnsq %rdi, %rsi",
3617 },
3618 {
3619 setup: func(i *instruction) { i.asCmove(condP, newOperandReg(rdiVReg), rsiVReg, true) },
3620 want: "480f4af7",
3621 wantFormat: "cmovpq %rdi, %rsi",
3622 },
3623 {
3624 setup: func(i *instruction) { i.asCmove(condNP, newOperandReg(rdiVReg), rsiVReg, true) },
3625 want: "480f4bf7",
3626 wantFormat: "cmovnpq %rdi, %rsi",
3627 },
3628 {
3629 setup: func(i *instruction) { i.asCmove(condL, newOperandReg(rdiVReg), rsiVReg, true) },
3630 want: "480f4cf7",
3631 wantFormat: "cmovlq %rdi, %rsi",
3632 },
3633 {
3634 setup: func(i *instruction) { i.asCmove(condNL, newOperandReg(rdiVReg), rsiVReg, true) },
3635 want: "480f4df7",
3636 wantFormat: "cmovnlq %rdi, %rsi",
3637 },
3638 {
3639 setup: func(i *instruction) { i.asCmove(condLE, newOperandReg(rdiVReg), rsiVReg, true) },
3640 want: "480f4ef7",
3641 wantFormat: "cmovleq %rdi, %rsi",
3642 },
3643 {
3644 setup: func(i *instruction) { i.asCmove(condNLE, newOperandReg(rdiVReg), rsiVReg, true) },
3645 want: "480f4ff7",
3646 wantFormat: "cmovnleq %rdi, %rsi",
3647 },
3648 {
3649 setup: func(i *instruction) { i.asCmove(condO, newOperandReg(rdiVReg), rsiVReg, false) },
3650 want: "0f40f7",
3651 wantFormat: "cmovol %edi, %esi",
3652 },
3653 {
3654 setup: func(i *instruction) { i.asCmove(condNO, newOperandReg(rdiVReg), rsiVReg, false) },
3655 want: "0f41f7",
3656 wantFormat: "cmovnol %edi, %esi",
3657 },
3658 {
3659 setup: func(i *instruction) { i.asCmove(condB, newOperandReg(rdiVReg), rsiVReg, false) },
3660 want: "0f42f7",
3661 wantFormat: "cmovbl %edi, %esi",
3662 },
3663 {
3664 setup: func(i *instruction) { i.asCmove(condNB, newOperandReg(rdiVReg), rsiVReg, false) },
3665 want: "0f43f7",
3666 wantFormat: "cmovnbl %edi, %esi",
3667 },
3668 {
3669 setup: func(i *instruction) { i.asCmove(condZ, newOperandReg(rdiVReg), rsiVReg, false) },
3670 want: "0f44f7",
3671 wantFormat: "cmovzl %edi, %esi",
3672 },
3673 {
3674 setup: func(i *instruction) { i.asCmove(condNZ, newOperandReg(rdiVReg), rsiVReg, false) },
3675 want: "0f45f7",
3676 wantFormat: "cmovnzl %edi, %esi",
3677 },
3678 {
3679 setup: func(i *instruction) { i.asCmove(condBE, newOperandReg(rdiVReg), rsiVReg, false) },
3680 want: "0f46f7",
3681 wantFormat: "cmovbel %edi, %esi",
3682 },
3683 {
3684 setup: func(i *instruction) { i.asCmove(condNBE, newOperandReg(rdiVReg), rsiVReg, false) },
3685 want: "0f47f7",
3686 wantFormat: "cmovnbel %edi, %esi",
3687 },
3688 {
3689 setup: func(i *instruction) { i.asCmove(condS, newOperandReg(rdiVReg), rsiVReg, false) },
3690 want: "0f48f7",
3691 wantFormat: "cmovsl %edi, %esi",
3692 },
3693 {
3694 setup: func(i *instruction) { i.asCmove(condNS, newOperandReg(rdiVReg), rsiVReg, false) },
3695 want: "0f49f7",
3696 wantFormat: "cmovnsl %edi, %esi",
3697 },
3698 {
3699 setup: func(i *instruction) { i.asCmove(condP, newOperandReg(rdiVReg), rsiVReg, false) },
3700 want: "0f4af7",
3701 wantFormat: "cmovpl %edi, %esi",
3702 },
3703 {
3704 setup: func(i *instruction) { i.asCmove(condNP, newOperandReg(rdiVReg), rsiVReg, false) },
3705 want: "0f4bf7",
3706 wantFormat: "cmovnpl %edi, %esi",
3707 },
3708 {
3709 setup: func(i *instruction) { i.asCmove(condL, newOperandReg(rdiVReg), rsiVReg, false) },
3710 want: "0f4cf7",
3711 wantFormat: "cmovll %edi, %esi",
3712 },
3713 {
3714 setup: func(i *instruction) { i.asCmove(condNL, newOperandReg(rdiVReg), rsiVReg, false) },
3715 want: "0f4df7",
3716 wantFormat: "cmovnll %edi, %esi",
3717 },
3718 {
3719 setup: func(i *instruction) { i.asCmove(condLE, newOperandReg(rdiVReg), rsiVReg, false) },
3720 want: "0f4ef7",
3721 wantFormat: "cmovlel %edi, %esi",
3722 },
3723 {
3724 setup: func(i *instruction) { i.asCmove(condNLE, newOperandReg(rdiVReg), rsiVReg, false) },
3725 want: "0f4ff7",
3726 wantFormat: "cmovnlel %edi, %esi",
3727 },
3728 {
3729 setup: func(i *instruction) { i.asCmove(condO, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3730 want: "480f40707b",
3731 wantFormat: "cmovoq 123(%rax), %rsi",
3732 },
3733 {
3734 setup: func(i *instruction) { i.asCmove(condNO, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3735 want: "480f41707b",
3736 wantFormat: "cmovnoq 123(%rax), %rsi",
3737 },
3738 {
3739 setup: func(i *instruction) { i.asCmove(condB, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3740 want: "480f42707b",
3741 wantFormat: "cmovbq 123(%rax), %rsi",
3742 },
3743 {
3744 setup: func(i *instruction) { i.asCmove(condNB, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3745 want: "480f43707b",
3746 wantFormat: "cmovnbq 123(%rax), %rsi",
3747 },
3748 {
3749 setup: func(i *instruction) { i.asCmove(condZ, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3750 want: "480f44707b",
3751 wantFormat: "cmovzq 123(%rax), %rsi",
3752 },
3753 {
3754 setup: func(i *instruction) { i.asCmove(condNZ, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3755 want: "480f45707b",
3756 wantFormat: "cmovnzq 123(%rax), %rsi",
3757 },
3758 {
3759 setup: func(i *instruction) { i.asCmove(condBE, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3760 want: "480f46707b",
3761 wantFormat: "cmovbeq 123(%rax), %rsi",
3762 },
3763 {
3764 setup: func(i *instruction) { i.asCmove(condNBE, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3765 want: "480f47707b",
3766 wantFormat: "cmovnbeq 123(%rax), %rsi",
3767 },
3768 {
3769 setup: func(i *instruction) { i.asCmove(condS, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3770 want: "480f48707b",
3771 wantFormat: "cmovsq 123(%rax), %rsi",
3772 },
3773 {
3774 setup: func(i *instruction) { i.asCmove(condNS, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3775 want: "480f49707b",
3776 wantFormat: "cmovnsq 123(%rax), %rsi",
3777 },
3778 {
3779 setup: func(i *instruction) { i.asCmove(condP, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3780 want: "480f4a707b",
3781 wantFormat: "cmovpq 123(%rax), %rsi",
3782 },
3783 {
3784 setup: func(i *instruction) { i.asCmove(condNP, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3785 want: "480f4b707b",
3786 wantFormat: "cmovnpq 123(%rax), %rsi",
3787 },
3788 {
3789 setup: func(i *instruction) { i.asCmove(condL, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3790 want: "480f4c707b",
3791 wantFormat: "cmovlq 123(%rax), %rsi",
3792 },
3793 {
3794 setup: func(i *instruction) { i.asCmove(condNL, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3795 want: "480f4d707b",
3796 wantFormat: "cmovnlq 123(%rax), %rsi",
3797 },
3798 {
3799 setup: func(i *instruction) { i.asCmove(condLE, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3800 want: "480f4e707b",
3801 wantFormat: "cmovleq 123(%rax), %rsi",
3802 },
3803 {
3804 setup: func(i *instruction) { i.asCmove(condNLE, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, true) },
3805 want: "480f4f707b",
3806 wantFormat: "cmovnleq 123(%rax), %rsi",
3807 },
3808 {
3809 setup: func(i *instruction) { i.asCmove(condO, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3810 want: "0f40707b",
3811 wantFormat: "cmovol 123(%rax), %esi",
3812 },
3813 {
3814 setup: func(i *instruction) { i.asCmove(condNO, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3815 want: "0f41707b",
3816 wantFormat: "cmovnol 123(%rax), %esi",
3817 },
3818 {
3819 setup: func(i *instruction) { i.asCmove(condB, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3820 want: "0f42707b",
3821 wantFormat: "cmovbl 123(%rax), %esi",
3822 },
3823 {
3824 setup: func(i *instruction) { i.asCmove(condNB, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3825 want: "0f43707b",
3826 wantFormat: "cmovnbl 123(%rax), %esi",
3827 },
3828 {
3829 setup: func(i *instruction) { i.asCmove(condZ, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3830 want: "0f44707b",
3831 wantFormat: "cmovzl 123(%rax), %esi",
3832 },
3833 {
3834 setup: func(i *instruction) { i.asCmove(condNZ, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3835 want: "0f45707b",
3836 wantFormat: "cmovnzl 123(%rax), %esi",
3837 },
3838 {
3839 setup: func(i *instruction) { i.asCmove(condBE, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3840 want: "0f46707b",
3841 wantFormat: "cmovbel 123(%rax), %esi",
3842 },
3843 {
3844 setup: func(i *instruction) { i.asCmove(condNBE, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3845 want: "0f47707b",
3846 wantFormat: "cmovnbel 123(%rax), %esi",
3847 },
3848 {
3849 setup: func(i *instruction) { i.asCmove(condS, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3850 want: "0f48707b",
3851 wantFormat: "cmovsl 123(%rax), %esi",
3852 },
3853 {
3854 setup: func(i *instruction) { i.asCmove(condNS, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3855 want: "0f49707b",
3856 wantFormat: "cmovnsl 123(%rax), %esi",
3857 },
3858 {
3859 setup: func(i *instruction) { i.asCmove(condP, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3860 want: "0f4a707b",
3861 wantFormat: "cmovpl 123(%rax), %esi",
3862 },
3863 {
3864 setup: func(i *instruction) { i.asCmove(condNP, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3865 want: "0f4b707b",
3866 wantFormat: "cmovnpl 123(%rax), %esi",
3867 },
3868 {
3869 setup: func(i *instruction) { i.asCmove(condL, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3870 want: "0f4c707b",
3871 wantFormat: "cmovll 123(%rax), %esi",
3872 },
3873 {
3874 setup: func(i *instruction) { i.asCmove(condNL, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3875 want: "0f4d707b",
3876 wantFormat: "cmovnll 123(%rax), %esi",
3877 },
3878 {
3879 setup: func(i *instruction) { i.asCmove(condLE, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3880 want: "0f4e707b",
3881 wantFormat: "cmovlel 123(%rax), %esi",
3882 },
3883 {
3884 setup: func(i *instruction) { i.asCmove(condNLE, newOperandMem(newAmodeImmReg(123, raxVReg)), rsiVReg, false) },
3885 want: "0f4f707b",
3886 wantFormat: "cmovnlel 123(%rax), %esi",
3887 },
3888 {
3889 setup: func(i *instruction) { *i = *allocateExitSeq(r15VReg) },
3890 // movq 0x10(%r15), %rbp
3891 // movq 0x18(%r15), %rsp
3892 // retq
3893 want: "498b6f10498b6718c3",
3894 wantFormat: "exit_sequence %r15",
3895 },
3896 {
3897 setup: func(i *instruction) { i.asXCHG(r11VReg, newOperandReg(r14VReg), 8) },
3898 want: "4d87de",
3899 wantFormat: "xchg.q %r11, %r14",
3900 },
3901 {
3902 setup: func(i *instruction) { i.asXCHG(r11VReg, newOperandMem(newAmodeImmReg(123, raxVReg)), 8) },
3903 want: "4c87587b",
3904 wantFormat: "xchg.q %r11, 123(%rax)",
3905 },
3906 {
3907 setup: func(i *instruction) { i.asXCHG(r15VReg, newOperandReg(raxVReg), 8) },
3908 want: "4c87f8",
3909 wantFormat: "xchg.q %r15, %rax",
3910 },
3911 {
3912 setup: func(i *instruction) { i.asXCHG(rbxVReg, newOperandReg(rsiVReg), 8) },
3913 want: "4887de",
3914 wantFormat: "xchg.q %rbx, %rsi",
3915 },
3916 {
3917 setup: func(i *instruction) { i.asXCHG(r11VReg, newOperandReg(r14VReg), 4) },
3918 want: "4587de",
3919 wantFormat: "xchg.l %r11, %r14",
3920 },
3921 {
3922 setup: func(i *instruction) { i.asXCHG(r15VReg, newOperandReg(raxVReg), 4) },
3923 want: "4487f8",
3924 wantFormat: "xchg.l %r15, %rax",
3925 },
3926 {
3927 setup: func(i *instruction) { i.asXCHG(rbxVReg, newOperandReg(rsiVReg), 4) },
3928 want: "87de",
3929 wantFormat: "xchg.l %rbx, %rsi",
3930 },
3931 {
3932 setup: func(i *instruction) { i.asXCHG(r11VReg, newOperandMem(newAmodeImmReg(123, raxVReg)), 4) },
3933 want: "4487587b",
3934 wantFormat: "xchg.l %r11, 123(%rax)",
3935 },
3936 {
3937 setup: func(i *instruction) { i.asXCHG(r11VReg, newOperandReg(r14VReg), 2) },
3938 want: "664587de",
3939 wantFormat: "xchg.w %r11, %r14",
3940 },
3941 {
3942 setup: func(i *instruction) { i.asXCHG(r15VReg, newOperandReg(raxVReg), 2) },
3943 want: "664487f8",
3944 wantFormat: "xchg.w %r15, %rax",
3945 },
3946 {
3947 setup: func(i *instruction) { i.asXCHG(rbxVReg, newOperandReg(rsiVReg), 2) },
3948 want: "6687de",
3949 wantFormat: "xchg.w %rbx, %rsi",
3950 },
3951 {
3952 setup: func(i *instruction) { i.asXCHG(r11VReg, newOperandMem(newAmodeImmReg(123, raxVReg)), 2) },
3953 want: "664487587b",
3954 wantFormat: "xchg.w %r11, 123(%rax)",
3955 },
3956 {
3957 setup: func(i *instruction) { i.asXCHG(r11VReg, newOperandMem(newAmodeImmReg(123, raxVReg)), 1) },
3958 want: "4486587b",
3959 wantFormat: "xchg.b %r11, 123(%rax)",
3960 },
3961 {
3962 setup: func(i *instruction) { i.asXCHG(r11VReg, newOperandMem(newAmodeImmReg(123, rdiVReg)), 1) },
3963 want: "44865f7b",
3964 wantFormat: "xchg.b %r11, 123(%rdi)",
3965 },
3966 {
3967 setup: func(i *instruction) { i.asXCHG(rsiVReg, newOperandMem(newAmodeImmReg(123, raxVReg)), 1) },
3968 want: "4086707b",
3969 wantFormat: "xchg.b %rsi, 123(%rax)",
3970 },
3971 {
3972 setup: func(i *instruction) { i.asXCHG(rdiVReg, newOperandMem(newAmodeImmReg(123, raxVReg)), 1) },
3973 want: "4086787b",
3974 wantFormat: "xchg.b %rdi, 123(%rax)",
3975 },
3976 {
3977 setup: func(i *instruction) { i.asXCHG(rdiVReg, newOperandMem(newAmodeImmReg(123, rsiVReg)), 1) },
3978 want: "40867e7b",
3979 wantFormat: "xchg.b %rdi, 123(%rsi)",
3980 },
3981 {
3982 setup: func(i *instruction) { i.asZeros(rbxVReg) },
3983 want: "4831db",
3984 wantFormat: "xor %rbx, %rbx",
3985 },
3986 {
3987 setup: func(i *instruction) { i.asZeros(r14VReg) },
3988 want: "4d31f6",
3989 wantFormat: "xor %r14, %r14",
3990 },
3991 {
3992 setup: func(i *instruction) { i.asZeros(xmm1VReg) },
3993 want: "660fefc9",
3994 wantFormat: "xor %xmm1, %xmm1",
3995 },
3996 {
3997 setup: func(i *instruction) { i.asZeros(xmm12VReg) },
3998 want: "66450fefe4",
3999 wantFormat: "xor %xmm12, %xmm12",
4000 },
4001 {
4002 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodeCmpss, uint8(25), newOperandReg(xmm1VReg), xmm0VReg) },
4003 want: "f30fc2c119",
4004 wantFormat: "cmpss $25, %xmm1, %xmm0",
4005 },
4006 {
4007 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodeCmpsd, uint8(25), newOperandReg(xmm1VReg), xmm0VReg) },
4008 want: "f20fc2c119",
4009 wantFormat: "cmpsd $25, %xmm1, %xmm0",
4010 },
4011 {
4012 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodeInsertps, uint8(25), newOperandReg(xmm1VReg), xmm0VReg) },
4013 want: "660f3a21c119",
4014 wantFormat: "insertps $25, %xmm1, %xmm0",
4015 },
4016 {
4017 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodePalignr, uint8(25), newOperandReg(xmm1VReg), xmm0VReg) },
4018 want: "660f3a0fc119",
4019 wantFormat: "palignr $25, %xmm1, %xmm0",
4020 },
4021 {
4022 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodePinsrb, uint8(25), newOperandReg(r14VReg), xmm1VReg) },
4023 want: "66410f3a20ce19",
4024 wantFormat: "pinsrb $25, %r14d, %xmm1",
4025 },
4026 {
4027 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodePinsrw, uint8(25), newOperandReg(r14VReg), xmm1VReg) },
4028 want: "66410fc4ce19",
4029 wantFormat: "pinsrw $25, %r14d, %xmm1",
4030 },
4031 {
4032 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodePinsrd, uint8(25), newOperandReg(r14VReg), xmm1VReg) },
4033 want: "66410f3a22ce19",
4034 wantFormat: "pinsrd $25, %r14d, %xmm1",
4035 },
4036 {
4037 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodePinsrq, uint8(25), newOperandReg(r14VReg), xmm1VReg) },
4038 want: "66490f3a22ce19",
4039 wantFormat: "pinsrq $25, %r14, %xmm1",
4040 },
4041 {
4042 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodePextrb, uint8(25), newOperandReg(xmm1VReg), r14VReg) },
4043 want: "66410f3a14ce19",
4044 wantFormat: "pextrb $25, %xmm1, %r14d",
4045 },
4046 {
4047 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodePextrw, uint8(25), newOperandReg(xmm1VReg), r14VReg) },
4048 want: "66440fc5f119",
4049 wantFormat: "pextrw $25, %xmm1, %r14d",
4050 },
4051 {
4052 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodePextrd, uint8(25), newOperandReg(xmm1VReg), rbxVReg) },
4053 want: "660f3a16cb19",
4054 wantFormat: "pextrd $25, %xmm1, %ebx",
4055 },
4056 {
4057 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodePextrq, uint8(25), newOperandReg(xmm1VReg), rdxVReg) },
4058 want: "66480f3a16ca19",
4059 wantFormat: "pextrq $25, %xmm1, %rdx",
4060 },
4061 {
4062 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodePshufd, uint8(25), newOperandReg(xmm1VReg), xmm0VReg) },
4063 want: "660f70c119",
4064 wantFormat: "pshufd $25, %xmm1, %xmm0",
4065 },
4066 {
4067 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodeRoundps, uint8(25), newOperandReg(xmm1VReg), xmm0VReg) },
4068 want: "660f3a08c119",
4069 wantFormat: "roundps $25, %xmm1, %xmm0",
4070 },
4071 {
4072 setup: func(i *instruction) { i.asXmmRmRImm(sseOpcodeRoundpd, uint8(25), newOperandReg(xmm1VReg), xmm0VReg) },
4073 want: "660f3a09c119",
4074 wantFormat: "roundpd $25, %xmm1, %xmm0",
4075 },
4076 {
4077 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePmulhrsw, newOperandReg(xmm1VReg), xmm0VReg) },
4078 want: "660f380bc1",
4079 wantFormat: "pmulhrsw %xmm1, %xmm0",
4080 },
4081 {
4082 setup: func(i *instruction) { i.asXmmRmR(sseOpcodeUnpcklps, newOperandReg(xmm1VReg), xmm0VReg) },
4083 want: "0f14c1",
4084 wantFormat: "unpcklps %xmm1, %xmm0",
4085 },
4086 {
4087 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeCvtps2pd, newOperandReg(xmm1VReg), xmm0VReg) },
4088 want: "0f5ac1",
4089 wantFormat: "cvtps2pd %xmm1, %xmm0",
4090 },
4091 {
4092 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeCvtpd2ps, newOperandReg(xmm15VReg), xmm0VReg) },
4093 want: "66410f5ac7",
4094 wantFormat: "cvtpd2ps %xmm15, %xmm0",
4095 },
4096 {
4097 setup: func(i *instruction) { i.asXmmUnaryRmR(sseOpcodeCvttpd2dq, newOperandReg(xmm15VReg), xmm11VReg) },
4098 want: "66450fe6df",
4099 wantFormat: "cvttpd2dq %xmm15, %xmm11",
4100 },
4101 {
4102 setup: func(i *instruction) {
4103 i.asXmmRmRImm(sseOpcodeShufps, 0b00_00_10_00, newOperandReg(xmm15VReg), xmm11VReg)
4104 },
4105 want: "450fc6df08",
4106 wantFormat: "shufps $8, %xmm15, %xmm11",
4107 },
4108 {
4109 setup: func(i *instruction) { i.asXmmRmR(sseOpcodePmaddubsw, newOperandReg(xmm1VReg), xmm0VReg) },
4110 want: "660f3804c1",
4111 wantFormat: "pmaddubsw %xmm1, %xmm0",
4112 },
4113 {
4114 setup: func(i *instruction) { i.asBlendvpd(newOperandReg(xmm1VReg), xmm15VReg) },
4115 want: "66440f3815f9",
4116 wantFormat: "blendvpd %xmm1, %xmm15, %xmm0",
4117 },
4118 {
4119 setup: func(i *instruction) { i.asMFence() },
4120 want: "0faef0",
4121 wantFormat: "mfence",
4122 },
4123 {
4124 setup: func(i *instruction) { i.asLockCmpXCHG(rsiVReg, newAmodeImmReg(123, raxVReg), 8) },
4125 want: "f0480fb1707b",
4126 wantFormat: "lock cmpxchg.q %rsi, 123(%rax)",
4127 },
4128 {
4129 setup: func(i *instruction) { i.asLockCmpXCHG(r11VReg, newAmodeImmReg(123, raxVReg), 8) },
4130 want: "f04c0fb1587b",
4131 wantFormat: "lock cmpxchg.q %r11, 123(%rax)",
4132 },
4133 {
4134 setup: func(i *instruction) { i.asLockCmpXCHG(rsiVReg, newAmodeImmReg(123, raxVReg), 4) },
4135 want: "f00fb1707b",
4136 wantFormat: "lock cmpxchg.l %rsi, 123(%rax)",
4137 },
4138 {
4139 setup: func(i *instruction) { i.asLockCmpXCHG(r11VReg, newAmodeImmReg(123, raxVReg), 4) },
4140 want: "f0440fb1587b",
4141 wantFormat: "lock cmpxchg.l %r11, 123(%rax)",
4142 },
4143 {
4144 setup: func(i *instruction) { i.asLockCmpXCHG(r11VReg, newAmodeImmReg(123, raxVReg), 2) },
4145 want: "66f0440fb1587b",
4146 wantFormat: "lock cmpxchg.w %r11, 123(%rax)",
4147 },
4148 {
4149 setup: func(i *instruction) { i.asLockCmpXCHG(rsiVReg, newAmodeImmReg(123, raxVReg), 2) },
4150 want: "66f00fb1707b",
4151 wantFormat: "lock cmpxchg.w %rsi, 123(%rax)",
4152 },
4153 {
4154 setup: func(i *instruction) { i.asLockCmpXCHG(r11VReg, newAmodeImmReg(123, raxVReg), 1) },
4155 want: "f0440fb0587b",
4156 wantFormat: "lock cmpxchg.b %r11, 123(%rax)",
4157 },
4158 {
4159 setup: func(i *instruction) { i.asLockCmpXCHG(r11VReg, newAmodeImmReg(123, rdiVReg), 1) },
4160 want: "f0440fb05f7b",
4161 wantFormat: "lock cmpxchg.b %r11, 123(%rdi)",
4162 },
4163 {
4164 setup: func(i *instruction) { i.asLockCmpXCHG(rsiVReg, newAmodeImmReg(123, raxVReg), 1) },
4165 want: "f0400fb0707b",
4166 wantFormat: "lock cmpxchg.b %rsi, 123(%rax)",
4167 },
4168 {
4169 setup: func(i *instruction) { i.asLockCmpXCHG(rdiVReg, newAmodeImmReg(123, raxVReg), 1) },
4170 want: "f0400fb0787b",
4171 wantFormat: "lock cmpxchg.b %rdi, 123(%rax)",
4172 },
4173 {
4174 setup: func(i *instruction) { i.asLockCmpXCHG(rdiVReg, newAmodeImmReg(123, rsiVReg), 1) },
4175 want: "f0400fb07e7b",
4176 wantFormat: "lock cmpxchg.b %rdi, 123(%rsi)",
4177 },
4178 {
4179 setup: func(i *instruction) { i.asLockXAdd(rsiVReg, newAmodeImmReg(123, raxVReg), 8) },
4180 want: "f0480fc1707b",
4181 wantFormat: "lock xadd.q %rsi, 123(%rax)",
4182 },
4183 {
4184 setup: func(i *instruction) { i.asLockXAdd(r11VReg, newAmodeImmReg(123, raxVReg), 8) },
4185 want: "f04c0fc1587b",
4186 wantFormat: "lock xadd.q %r11, 123(%rax)",
4187 },
4188 {
4189 setup: func(i *instruction) { i.asLockXAdd(rsiVReg, newAmodeImmReg(123, raxVReg), 4) },
4190 want: "f00fc1707b",
4191 wantFormat: "lock xadd.l %rsi, 123(%rax)",
4192 },
4193 {
4194 setup: func(i *instruction) { i.asLockXAdd(r11VReg, newAmodeImmReg(123, raxVReg), 4) },
4195 want: "f0440fc1587b",
4196 wantFormat: "lock xadd.l %r11, 123(%rax)",
4197 },
4198 {
4199 setup: func(i *instruction) { i.asLockXAdd(r11VReg, newAmodeImmReg(123, raxVReg), 2) },
4200 want: "66f0440fc1587b",
4201 wantFormat: "lock xadd.w %r11, 123(%rax)",
4202 },
4203 {
4204 setup: func(i *instruction) { i.asLockXAdd(rsiVReg, newAmodeImmReg(123, raxVReg), 2) },
4205 want: "66f00fc1707b",
4206 wantFormat: "lock xadd.w %rsi, 123(%rax)",
4207 },
4208 {
4209 setup: func(i *instruction) { i.asLockXAdd(r11VReg, newAmodeImmReg(123, raxVReg), 1) },
4210 want: "f0440fc0587b",
4211 wantFormat: "lock xadd.b %r11, 123(%rax)",
4212 },
4213 {
4214 setup: func(i *instruction) { i.asLockXAdd(r11VReg, newAmodeImmReg(123, rdiVReg), 1) },
4215 want: "f0440fc05f7b",
4216 wantFormat: "lock xadd.b %r11, 123(%rdi)",
4217 },
4218 {
4219 setup: func(i *instruction) { i.asLockXAdd(rsiVReg, newAmodeImmReg(123, raxVReg), 1) },
4220 want: "f0400fc0707b",
4221 wantFormat: "lock xadd.b %rsi, 123(%rax)",
4222 },
4223 {
4224 setup: func(i *instruction) { i.asLockXAdd(rdiVReg, newAmodeImmReg(123, raxVReg), 1) },
4225 want: "f0400fc0787b",
4226 wantFormat: "lock xadd.b %rdi, 123(%rax)",
4227 },
4228 {
4229 setup: func(i *instruction) { i.asLockXAdd(rdiVReg, newAmodeImmReg(123, rsiVReg), 1) },
4230 want: "f0400fc07e7b",
4231 wantFormat: "lock xadd.b %rdi, 123(%rsi)",
4232 },
4233 } {
4234 tc := tc
4235 t.Run(tc.wantFormat, func(t *testing.T) {
4236 i := &instruction{}
4237 tc.setup(i)
4238
4239 require.Equal(t, tc.wantFormat, i.String())
4240
4241 mc := &mockCompiler{}
4242 m := &machine{c: mc}
4243 i.encode(m.c)
4244 require.Equal(t, tc.want, hex.EncodeToString(mc.buf))
4245 })
4246 }
4247 }