1 //! Tests for the emitter
2 //!
3 //! See comments at the top of `fn x64_emit` for advice on how to create reliable test cases.
4 //!
5 //! to see stdout: cargo test -- --nocapture
6 //!
7 //! for this specific case, as of 24 Aug 2020:
8 //!
9 //! cd to the top of your wasmtime tree, then:
10 //! RUST_BACKTRACE=1 cargo test --features test-programs/test_programs \
11 //! --features experimental_x64 --all --exclude peepmatic --exclude lightbeam \
12 //! --exclude wasmtime-lightbeam --exclude peepmatic-automata --exclude peepmatic-fuzzing \
13 //! --exclude peepmatic-macro --exclude wasmtime-wasi-nn -- isa::x64::inst::emit_tests::test_x64_emit
14
15 use super::*;
16 use crate::isa::test_utils;
17 use crate::isa::x64;
18 use alloc::vec::Vec;
19
20 #[test]
test_x64_emit()21 fn test_x64_emit() {
22 let rax = regs::rax();
23 let rbx = regs::rbx();
24 let rcx = regs::rcx();
25 let rdx = regs::rdx();
26 let rsi = regs::rsi();
27 let rdi = regs::rdi();
28 let rsp = regs::rsp();
29 let rbp = regs::rbp();
30 let r8 = regs::r8();
31 let r9 = regs::r9();
32 let r10 = regs::r10();
33 let r11 = regs::r11();
34 let r12 = regs::r12();
35 let r13 = regs::r13();
36 let r14 = regs::r14();
37 let r15 = regs::r15();
38
39 let xmm0 = regs::xmm0();
40 let xmm1 = regs::xmm1();
41 let xmm2 = regs::xmm2();
42 let xmm3 = regs::xmm3();
43 let xmm4 = regs::xmm4();
44 let xmm5 = regs::xmm5();
45 let xmm6 = regs::xmm6();
46 let xmm7 = regs::xmm7();
47 let xmm8 = regs::xmm8();
48 let xmm9 = regs::xmm9();
49 let xmm10 = regs::xmm10();
50 let xmm11 = regs::xmm11();
51 let xmm12 = regs::xmm12();
52 let xmm13 = regs::xmm13();
53 let xmm14 = regs::xmm14();
54 let xmm15 = regs::xmm15();
55
56 // And Writable<> versions of the same:
57 let w_rax = Writable::<Reg>::from_reg(rax);
58 let w_rbx = Writable::<Reg>::from_reg(rbx);
59 let w_rcx = Writable::<Reg>::from_reg(rcx);
60 let w_rdx = Writable::<Reg>::from_reg(rdx);
61 let w_rsi = Writable::<Reg>::from_reg(rsi);
62 let w_rdi = Writable::<Reg>::from_reg(rdi);
63 let _w_rsp = Writable::<Reg>::from_reg(rsp);
64 let _w_rbp = Writable::<Reg>::from_reg(rbp);
65 let w_r8 = Writable::<Reg>::from_reg(r8);
66 let w_r9 = Writable::<Reg>::from_reg(r9);
67 let _w_r10 = Writable::<Reg>::from_reg(r10);
68 let w_r11 = Writable::<Reg>::from_reg(r11);
69 let w_r12 = Writable::<Reg>::from_reg(r12);
70 let w_r13 = Writable::<Reg>::from_reg(r13);
71 let w_r14 = Writable::<Reg>::from_reg(r14);
72 let w_r15 = Writable::<Reg>::from_reg(r15);
73
74 let w_xmm0 = Writable::<Reg>::from_reg(xmm0);
75 let w_xmm1 = Writable::<Reg>::from_reg(xmm1);
76 let w_xmm2 = Writable::<Reg>::from_reg(xmm2);
77 let w_xmm3 = Writable::<Reg>::from_reg(xmm3);
78 let w_xmm4 = Writable::<Reg>::from_reg(xmm4);
79 let w_xmm5 = Writable::<Reg>::from_reg(xmm5);
80 let w_xmm6 = Writable::<Reg>::from_reg(xmm6);
81 let w_xmm7 = Writable::<Reg>::from_reg(xmm7);
82 let w_xmm8 = Writable::<Reg>::from_reg(xmm8);
83 let w_xmm9 = Writable::<Reg>::from_reg(xmm9);
84 let w_xmm10 = Writable::<Reg>::from_reg(xmm10);
85 let w_xmm11 = Writable::<Reg>::from_reg(xmm11);
86 let w_xmm12 = Writable::<Reg>::from_reg(xmm12);
87 let w_xmm13 = Writable::<Reg>::from_reg(xmm13);
88 let w_xmm14 = Writable::<Reg>::from_reg(xmm14);
89 let w_xmm15 = Writable::<Reg>::from_reg(xmm15);
90
91 let mut insns = Vec::<(Inst, &str, &str)>::new();
92
93 // ========================================================
94 // Cases aimed at checking Addr-esses: IR (Imm + Reg)
95 //
96 // These are just a bunch of loads with all supported (by the emitter)
97 // permutations of address formats.
98 //
99 // Addr_IR, offset zero
100 insns.push((
101 Inst::mov64_m_r(Amode::imm_reg(0, rax), w_rdi),
102 "488B38",
103 "movq 0(%rax), %rdi",
104 ));
105 insns.push((
106 Inst::mov64_m_r(Amode::imm_reg(0, rbx), w_rdi),
107 "488B3B",
108 "movq 0(%rbx), %rdi",
109 ));
110 insns.push((
111 Inst::mov64_m_r(Amode::imm_reg(0, rcx), w_rdi),
112 "488B39",
113 "movq 0(%rcx), %rdi",
114 ));
115 insns.push((
116 Inst::mov64_m_r(Amode::imm_reg(0, rdx), w_rdi),
117 "488B3A",
118 "movq 0(%rdx), %rdi",
119 ));
120 insns.push((
121 Inst::mov64_m_r(Amode::imm_reg(0, rbp), w_rdi),
122 "488B7D00",
123 "movq 0(%rbp), %rdi",
124 ));
125 insns.push((
126 Inst::mov64_m_r(Amode::imm_reg(0, rsp), w_rdi),
127 "488B3C24",
128 "movq 0(%rsp), %rdi",
129 ));
130 insns.push((
131 Inst::mov64_m_r(Amode::imm_reg(0, rsi), w_rdi),
132 "488B3E",
133 "movq 0(%rsi), %rdi",
134 ));
135 insns.push((
136 Inst::mov64_m_r(Amode::imm_reg(0, rdi), w_rdi),
137 "488B3F",
138 "movq 0(%rdi), %rdi",
139 ));
140 insns.push((
141 Inst::mov64_m_r(Amode::imm_reg(0, r8), w_rdi),
142 "498B38",
143 "movq 0(%r8), %rdi",
144 ));
145 insns.push((
146 Inst::mov64_m_r(Amode::imm_reg(0, r9), w_rdi),
147 "498B39",
148 "movq 0(%r9), %rdi",
149 ));
150 insns.push((
151 Inst::mov64_m_r(Amode::imm_reg(0, r10), w_rdi),
152 "498B3A",
153 "movq 0(%r10), %rdi",
154 ));
155 insns.push((
156 Inst::mov64_m_r(Amode::imm_reg(0, r11), w_rdi),
157 "498B3B",
158 "movq 0(%r11), %rdi",
159 ));
160 insns.push((
161 Inst::mov64_m_r(Amode::imm_reg(0, r12), w_rdi),
162 "498B3C24",
163 "movq 0(%r12), %rdi",
164 ));
165 insns.push((
166 Inst::mov64_m_r(Amode::imm_reg(0, r13), w_rdi),
167 "498B7D00",
168 "movq 0(%r13), %rdi",
169 ));
170 insns.push((
171 Inst::mov64_m_r(Amode::imm_reg(0, r14), w_rdi),
172 "498B3E",
173 "movq 0(%r14), %rdi",
174 ));
175 insns.push((
176 Inst::mov64_m_r(Amode::imm_reg(0, r15), w_rdi),
177 "498B3F",
178 "movq 0(%r15), %rdi",
179 ));
180
181 // ========================================================
182 // Addr_IR, offset max simm8
183 insns.push((
184 Inst::mov64_m_r(Amode::imm_reg(127, rax), w_rdi),
185 "488B787F",
186 "movq 127(%rax), %rdi",
187 ));
188 insns.push((
189 Inst::mov64_m_r(Amode::imm_reg(127, rbx), w_rdi),
190 "488B7B7F",
191 "movq 127(%rbx), %rdi",
192 ));
193 insns.push((
194 Inst::mov64_m_r(Amode::imm_reg(127, rcx), w_rdi),
195 "488B797F",
196 "movq 127(%rcx), %rdi",
197 ));
198 insns.push((
199 Inst::mov64_m_r(Amode::imm_reg(127, rdx), w_rdi),
200 "488B7A7F",
201 "movq 127(%rdx), %rdi",
202 ));
203 insns.push((
204 Inst::mov64_m_r(Amode::imm_reg(127, rbp), w_rdi),
205 "488B7D7F",
206 "movq 127(%rbp), %rdi",
207 ));
208 insns.push((
209 Inst::mov64_m_r(Amode::imm_reg(127, rsp), w_rdi),
210 "488B7C247F",
211 "movq 127(%rsp), %rdi",
212 ));
213 insns.push((
214 Inst::mov64_m_r(Amode::imm_reg(127, rsi), w_rdi),
215 "488B7E7F",
216 "movq 127(%rsi), %rdi",
217 ));
218 insns.push((
219 Inst::mov64_m_r(Amode::imm_reg(127, rdi), w_rdi),
220 "488B7F7F",
221 "movq 127(%rdi), %rdi",
222 ));
223 insns.push((
224 Inst::mov64_m_r(Amode::imm_reg(127, r8), w_rdi),
225 "498B787F",
226 "movq 127(%r8), %rdi",
227 ));
228 insns.push((
229 Inst::mov64_m_r(Amode::imm_reg(127, r9), w_rdi),
230 "498B797F",
231 "movq 127(%r9), %rdi",
232 ));
233 insns.push((
234 Inst::mov64_m_r(Amode::imm_reg(127, r10), w_rdi),
235 "498B7A7F",
236 "movq 127(%r10), %rdi",
237 ));
238 insns.push((
239 Inst::mov64_m_r(Amode::imm_reg(127, r11), w_rdi),
240 "498B7B7F",
241 "movq 127(%r11), %rdi",
242 ));
243 insns.push((
244 Inst::mov64_m_r(Amode::imm_reg(127, r12), w_rdi),
245 "498B7C247F",
246 "movq 127(%r12), %rdi",
247 ));
248 insns.push((
249 Inst::mov64_m_r(Amode::imm_reg(127, r13), w_rdi),
250 "498B7D7F",
251 "movq 127(%r13), %rdi",
252 ));
253 insns.push((
254 Inst::mov64_m_r(Amode::imm_reg(127, r14), w_rdi),
255 "498B7E7F",
256 "movq 127(%r14), %rdi",
257 ));
258 insns.push((
259 Inst::mov64_m_r(Amode::imm_reg(127, r15), w_rdi),
260 "498B7F7F",
261 "movq 127(%r15), %rdi",
262 ));
263
264 // ========================================================
265 // Addr_IR, offset min simm8
266 insns.push((
267 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, rax), w_rdi),
268 "488B7880",
269 "movq -128(%rax), %rdi",
270 ));
271 insns.push((
272 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, rbx), w_rdi),
273 "488B7B80",
274 "movq -128(%rbx), %rdi",
275 ));
276 insns.push((
277 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, rcx), w_rdi),
278 "488B7980",
279 "movq -128(%rcx), %rdi",
280 ));
281 insns.push((
282 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, rdx), w_rdi),
283 "488B7A80",
284 "movq -128(%rdx), %rdi",
285 ));
286 insns.push((
287 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, rbp), w_rdi),
288 "488B7D80",
289 "movq -128(%rbp), %rdi",
290 ));
291 insns.push((
292 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, rsp), w_rdi),
293 "488B7C2480",
294 "movq -128(%rsp), %rdi",
295 ));
296 insns.push((
297 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, rsi), w_rdi),
298 "488B7E80",
299 "movq -128(%rsi), %rdi",
300 ));
301 insns.push((
302 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, rdi), w_rdi),
303 "488B7F80",
304 "movq -128(%rdi), %rdi",
305 ));
306 insns.push((
307 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, r8), w_rdi),
308 "498B7880",
309 "movq -128(%r8), %rdi",
310 ));
311 insns.push((
312 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, r9), w_rdi),
313 "498B7980",
314 "movq -128(%r9), %rdi",
315 ));
316 insns.push((
317 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, r10), w_rdi),
318 "498B7A80",
319 "movq -128(%r10), %rdi",
320 ));
321 insns.push((
322 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, r11), w_rdi),
323 "498B7B80",
324 "movq -128(%r11), %rdi",
325 ));
326 insns.push((
327 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, r12), w_rdi),
328 "498B7C2480",
329 "movq -128(%r12), %rdi",
330 ));
331 insns.push((
332 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, r13), w_rdi),
333 "498B7D80",
334 "movq -128(%r13), %rdi",
335 ));
336 insns.push((
337 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, r14), w_rdi),
338 "498B7E80",
339 "movq -128(%r14), %rdi",
340 ));
341 insns.push((
342 Inst::mov64_m_r(Amode::imm_reg(-128i32 as u32, r15), w_rdi),
343 "498B7F80",
344 "movq -128(%r15), %rdi",
345 ));
346
347 // ========================================================
348 // Addr_IR, offset smallest positive simm32
349 insns.push((
350 Inst::mov64_m_r(Amode::imm_reg(128, rax), w_rdi),
351 "488BB880000000",
352 "movq 128(%rax), %rdi",
353 ));
354 insns.push((
355 Inst::mov64_m_r(Amode::imm_reg(128, rbx), w_rdi),
356 "488BBB80000000",
357 "movq 128(%rbx), %rdi",
358 ));
359 insns.push((
360 Inst::mov64_m_r(Amode::imm_reg(128, rcx), w_rdi),
361 "488BB980000000",
362 "movq 128(%rcx), %rdi",
363 ));
364 insns.push((
365 Inst::mov64_m_r(Amode::imm_reg(128, rdx), w_rdi),
366 "488BBA80000000",
367 "movq 128(%rdx), %rdi",
368 ));
369 insns.push((
370 Inst::mov64_m_r(Amode::imm_reg(128, rbp), w_rdi),
371 "488BBD80000000",
372 "movq 128(%rbp), %rdi",
373 ));
374 insns.push((
375 Inst::mov64_m_r(Amode::imm_reg(128, rsp), w_rdi),
376 "488BBC2480000000",
377 "movq 128(%rsp), %rdi",
378 ));
379 insns.push((
380 Inst::mov64_m_r(Amode::imm_reg(128, rsi), w_rdi),
381 "488BBE80000000",
382 "movq 128(%rsi), %rdi",
383 ));
384 insns.push((
385 Inst::mov64_m_r(Amode::imm_reg(128, rdi), w_rdi),
386 "488BBF80000000",
387 "movq 128(%rdi), %rdi",
388 ));
389 insns.push((
390 Inst::mov64_m_r(Amode::imm_reg(128, r8), w_rdi),
391 "498BB880000000",
392 "movq 128(%r8), %rdi",
393 ));
394 insns.push((
395 Inst::mov64_m_r(Amode::imm_reg(128, r9), w_rdi),
396 "498BB980000000",
397 "movq 128(%r9), %rdi",
398 ));
399 insns.push((
400 Inst::mov64_m_r(Amode::imm_reg(128, r10), w_rdi),
401 "498BBA80000000",
402 "movq 128(%r10), %rdi",
403 ));
404 insns.push((
405 Inst::mov64_m_r(Amode::imm_reg(128, r11), w_rdi),
406 "498BBB80000000",
407 "movq 128(%r11), %rdi",
408 ));
409 insns.push((
410 Inst::mov64_m_r(Amode::imm_reg(128, r12), w_rdi),
411 "498BBC2480000000",
412 "movq 128(%r12), %rdi",
413 ));
414 insns.push((
415 Inst::mov64_m_r(Amode::imm_reg(128, r13), w_rdi),
416 "498BBD80000000",
417 "movq 128(%r13), %rdi",
418 ));
419 insns.push((
420 Inst::mov64_m_r(Amode::imm_reg(128, r14), w_rdi),
421 "498BBE80000000",
422 "movq 128(%r14), %rdi",
423 ));
424 insns.push((
425 Inst::mov64_m_r(Amode::imm_reg(128, r15), w_rdi),
426 "498BBF80000000",
427 "movq 128(%r15), %rdi",
428 ));
429
430 // ========================================================
431 // Addr_IR, offset smallest negative simm32
432 insns.push((
433 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, rax), w_rdi),
434 "488BB87FFFFFFF",
435 "movq -129(%rax), %rdi",
436 ));
437 insns.push((
438 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, rbx), w_rdi),
439 "488BBB7FFFFFFF",
440 "movq -129(%rbx), %rdi",
441 ));
442 insns.push((
443 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, rcx), w_rdi),
444 "488BB97FFFFFFF",
445 "movq -129(%rcx), %rdi",
446 ));
447 insns.push((
448 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, rdx), w_rdi),
449 "488BBA7FFFFFFF",
450 "movq -129(%rdx), %rdi",
451 ));
452 insns.push((
453 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, rbp), w_rdi),
454 "488BBD7FFFFFFF",
455 "movq -129(%rbp), %rdi",
456 ));
457 insns.push((
458 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, rsp), w_rdi),
459 "488BBC247FFFFFFF",
460 "movq -129(%rsp), %rdi",
461 ));
462 insns.push((
463 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, rsi), w_rdi),
464 "488BBE7FFFFFFF",
465 "movq -129(%rsi), %rdi",
466 ));
467 insns.push((
468 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, rdi), w_rdi),
469 "488BBF7FFFFFFF",
470 "movq -129(%rdi), %rdi",
471 ));
472 insns.push((
473 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, r8), w_rdi),
474 "498BB87FFFFFFF",
475 "movq -129(%r8), %rdi",
476 ));
477 insns.push((
478 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, r9), w_rdi),
479 "498BB97FFFFFFF",
480 "movq -129(%r9), %rdi",
481 ));
482 insns.push((
483 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, r10), w_rdi),
484 "498BBA7FFFFFFF",
485 "movq -129(%r10), %rdi",
486 ));
487 insns.push((
488 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, r11), w_rdi),
489 "498BBB7FFFFFFF",
490 "movq -129(%r11), %rdi",
491 ));
492 insns.push((
493 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, r12), w_rdi),
494 "498BBC247FFFFFFF",
495 "movq -129(%r12), %rdi",
496 ));
497 insns.push((
498 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, r13), w_rdi),
499 "498BBD7FFFFFFF",
500 "movq -129(%r13), %rdi",
501 ));
502 insns.push((
503 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, r14), w_rdi),
504 "498BBE7FFFFFFF",
505 "movq -129(%r14), %rdi",
506 ));
507 insns.push((
508 Inst::mov64_m_r(Amode::imm_reg(-129i32 as u32, r15), w_rdi),
509 "498BBF7FFFFFFF",
510 "movq -129(%r15), %rdi",
511 ));
512
513 // ========================================================
514 // Addr_IR, offset large positive simm32
515 insns.push((
516 Inst::mov64_m_r(Amode::imm_reg(0x17732077, rax), w_rdi),
517 "488BB877207317",
518 "movq 393420919(%rax), %rdi",
519 ));
520 insns.push((
521 Inst::mov64_m_r(Amode::imm_reg(0x17732077, rbx), w_rdi),
522 "488BBB77207317",
523 "movq 393420919(%rbx), %rdi",
524 ));
525 insns.push((
526 Inst::mov64_m_r(Amode::imm_reg(0x17732077, rcx), w_rdi),
527 "488BB977207317",
528 "movq 393420919(%rcx), %rdi",
529 ));
530 insns.push((
531 Inst::mov64_m_r(Amode::imm_reg(0x17732077, rdx), w_rdi),
532 "488BBA77207317",
533 "movq 393420919(%rdx), %rdi",
534 ));
535 insns.push((
536 Inst::mov64_m_r(Amode::imm_reg(0x17732077, rbp), w_rdi),
537 "488BBD77207317",
538 "movq 393420919(%rbp), %rdi",
539 ));
540 insns.push((
541 Inst::mov64_m_r(Amode::imm_reg(0x17732077, rsp), w_rdi),
542 "488BBC2477207317",
543 "movq 393420919(%rsp), %rdi",
544 ));
545 insns.push((
546 Inst::mov64_m_r(Amode::imm_reg(0x17732077, rsi), w_rdi),
547 "488BBE77207317",
548 "movq 393420919(%rsi), %rdi",
549 ));
550 insns.push((
551 Inst::mov64_m_r(Amode::imm_reg(0x17732077, rdi), w_rdi),
552 "488BBF77207317",
553 "movq 393420919(%rdi), %rdi",
554 ));
555 insns.push((
556 Inst::mov64_m_r(Amode::imm_reg(0x17732077, r8), w_rdi),
557 "498BB877207317",
558 "movq 393420919(%r8), %rdi",
559 ));
560 insns.push((
561 Inst::mov64_m_r(Amode::imm_reg(0x17732077, r9), w_rdi),
562 "498BB977207317",
563 "movq 393420919(%r9), %rdi",
564 ));
565 insns.push((
566 Inst::mov64_m_r(Amode::imm_reg(0x17732077, r10), w_rdi),
567 "498BBA77207317",
568 "movq 393420919(%r10), %rdi",
569 ));
570 insns.push((
571 Inst::mov64_m_r(Amode::imm_reg(0x17732077, r11), w_rdi),
572 "498BBB77207317",
573 "movq 393420919(%r11), %rdi",
574 ));
575 insns.push((
576 Inst::mov64_m_r(Amode::imm_reg(0x17732077, r12), w_rdi),
577 "498BBC2477207317",
578 "movq 393420919(%r12), %rdi",
579 ));
580 insns.push((
581 Inst::mov64_m_r(Amode::imm_reg(0x17732077, r13), w_rdi),
582 "498BBD77207317",
583 "movq 393420919(%r13), %rdi",
584 ));
585 insns.push((
586 Inst::mov64_m_r(Amode::imm_reg(0x17732077, r14), w_rdi),
587 "498BBE77207317",
588 "movq 393420919(%r14), %rdi",
589 ));
590 insns.push((
591 Inst::mov64_m_r(Amode::imm_reg(0x17732077, r15), w_rdi),
592 "498BBF77207317",
593 "movq 393420919(%r15), %rdi",
594 ));
595
596 // ========================================================
597 // Addr_IR, offset large negative simm32
598 insns.push((
599 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, rax), w_rdi),
600 "488BB8D9A6BECE",
601 "movq -826366247(%rax), %rdi",
602 ));
603 insns.push((
604 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, rbx), w_rdi),
605 "488BBBD9A6BECE",
606 "movq -826366247(%rbx), %rdi",
607 ));
608 insns.push((
609 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, rcx), w_rdi),
610 "488BB9D9A6BECE",
611 "movq -826366247(%rcx), %rdi",
612 ));
613 insns.push((
614 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, rdx), w_rdi),
615 "488BBAD9A6BECE",
616 "movq -826366247(%rdx), %rdi",
617 ));
618 insns.push((
619 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, rbp), w_rdi),
620 "488BBDD9A6BECE",
621 "movq -826366247(%rbp), %rdi",
622 ));
623 insns.push((
624 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, rsp), w_rdi),
625 "488BBC24D9A6BECE",
626 "movq -826366247(%rsp), %rdi",
627 ));
628 insns.push((
629 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, rsi), w_rdi),
630 "488BBED9A6BECE",
631 "movq -826366247(%rsi), %rdi",
632 ));
633 insns.push((
634 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, rdi), w_rdi),
635 "488BBFD9A6BECE",
636 "movq -826366247(%rdi), %rdi",
637 ));
638 insns.push((
639 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, r8), w_rdi),
640 "498BB8D9A6BECE",
641 "movq -826366247(%r8), %rdi",
642 ));
643 insns.push((
644 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, r9), w_rdi),
645 "498BB9D9A6BECE",
646 "movq -826366247(%r9), %rdi",
647 ));
648 insns.push((
649 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, r10), w_rdi),
650 "498BBAD9A6BECE",
651 "movq -826366247(%r10), %rdi",
652 ));
653 insns.push((
654 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, r11), w_rdi),
655 "498BBBD9A6BECE",
656 "movq -826366247(%r11), %rdi",
657 ));
658 insns.push((
659 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, r12), w_rdi),
660 "498BBC24D9A6BECE",
661 "movq -826366247(%r12), %rdi",
662 ));
663 insns.push((
664 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, r13), w_rdi),
665 "498BBDD9A6BECE",
666 "movq -826366247(%r13), %rdi",
667 ));
668 insns.push((
669 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, r14), w_rdi),
670 "498BBED9A6BECE",
671 "movq -826366247(%r14), %rdi",
672 ));
673 insns.push((
674 Inst::mov64_m_r(Amode::imm_reg(-0x31415927i32 as u32, r15), w_rdi),
675 "498BBFD9A6BECE",
676 "movq -826366247(%r15), %rdi",
677 ));
678
679 // ========================================================
680 // Cases aimed at checking Addr-esses: IRRS (Imm + Reg + (Reg << Shift))
681 // Note these don't check the case where the index reg is RSP, since we
682 // don't encode any of those.
683 //
684 // Addr_IRRS, offset max simm8
685 insns.push((
686 Inst::mov64_m_r(Amode::imm_reg_reg_shift(127, rax, rax, 0), w_r11),
687 "4C8B5C007F",
688 "movq 127(%rax,%rax,1), %r11",
689 ));
690 insns.push((
691 Inst::mov64_m_r(Amode::imm_reg_reg_shift(127, rdi, rax, 1), w_r11),
692 "4C8B5C477F",
693 "movq 127(%rdi,%rax,2), %r11",
694 ));
695 insns.push((
696 Inst::mov64_m_r(Amode::imm_reg_reg_shift(127, r8, rax, 2), w_r11),
697 "4D8B5C807F",
698 "movq 127(%r8,%rax,4), %r11",
699 ));
700 insns.push((
701 Inst::mov64_m_r(Amode::imm_reg_reg_shift(127, r15, rax, 3), w_r11),
702 "4D8B5CC77F",
703 "movq 127(%r15,%rax,8), %r11",
704 ));
705 insns.push((
706 Inst::mov64_m_r(Amode::imm_reg_reg_shift(127, rax, rdi, 3), w_r11),
707 "4C8B5CF87F",
708 "movq 127(%rax,%rdi,8), %r11",
709 ));
710 insns.push((
711 Inst::mov64_m_r(Amode::imm_reg_reg_shift(127, rdi, rdi, 2), w_r11),
712 "4C8B5CBF7F",
713 "movq 127(%rdi,%rdi,4), %r11",
714 ));
715 insns.push((
716 Inst::mov64_m_r(Amode::imm_reg_reg_shift(127, r8, rdi, 1), w_r11),
717 "4D8B5C787F",
718 "movq 127(%r8,%rdi,2), %r11",
719 ));
720 insns.push((
721 Inst::mov64_m_r(Amode::imm_reg_reg_shift(127, r15, rdi, 0), w_r11),
722 "4D8B5C3F7F",
723 "movq 127(%r15,%rdi,1), %r11",
724 ));
725
726 // ========================================================
727 // Addr_IRRS, offset min simm8
728 insns.push((
729 Inst::mov64_m_r(Amode::imm_reg_reg_shift(-128i32 as u32, rax, r8, 2), w_r11),
730 "4E8B5C8080",
731 "movq -128(%rax,%r8,4), %r11",
732 ));
733 insns.push((
734 Inst::mov64_m_r(Amode::imm_reg_reg_shift(-128i32 as u32, rdi, r8, 3), w_r11),
735 "4E8B5CC780",
736 "movq -128(%rdi,%r8,8), %r11",
737 ));
738 insns.push((
739 Inst::mov64_m_r(Amode::imm_reg_reg_shift(-128i32 as u32, r8, r8, 0), w_r11),
740 "4F8B5C0080",
741 "movq -128(%r8,%r8,1), %r11",
742 ));
743 insns.push((
744 Inst::mov64_m_r(Amode::imm_reg_reg_shift(-128i32 as u32, r15, r8, 1), w_r11),
745 "4F8B5C4780",
746 "movq -128(%r15,%r8,2), %r11",
747 ));
748 insns.push((
749 Inst::mov64_m_r(Amode::imm_reg_reg_shift(-128i32 as u32, rax, r15, 1), w_r11),
750 "4E8B5C7880",
751 "movq -128(%rax,%r15,2), %r11",
752 ));
753 insns.push((
754 Inst::mov64_m_r(Amode::imm_reg_reg_shift(-128i32 as u32, rdi, r15, 0), w_r11),
755 "4E8B5C3F80",
756 "movq -128(%rdi,%r15,1), %r11",
757 ));
758 insns.push((
759 Inst::mov64_m_r(Amode::imm_reg_reg_shift(-128i32 as u32, r8, r15, 3), w_r11),
760 "4F8B5CF880",
761 "movq -128(%r8,%r15,8), %r11",
762 ));
763 insns.push((
764 Inst::mov64_m_r(Amode::imm_reg_reg_shift(-128i32 as u32, r15, r15, 2), w_r11),
765 "4F8B5CBF80",
766 "movq -128(%r15,%r15,4), %r11",
767 ));
768
769 // ========================================================
770 // Addr_IRRS, offset large positive simm32
771 insns.push((
772 Inst::mov64_m_r(Amode::imm_reg_reg_shift(0x4f6625be, rax, rax, 0), w_r11),
773 "4C8B9C00BE25664F",
774 "movq 1332094398(%rax,%rax,1), %r11",
775 ));
776 insns.push((
777 Inst::mov64_m_r(Amode::imm_reg_reg_shift(0x4f6625be, rdi, rax, 1), w_r11),
778 "4C8B9C47BE25664F",
779 "movq 1332094398(%rdi,%rax,2), %r11",
780 ));
781 insns.push((
782 Inst::mov64_m_r(Amode::imm_reg_reg_shift(0x4f6625be, r8, rax, 2), w_r11),
783 "4D8B9C80BE25664F",
784 "movq 1332094398(%r8,%rax,4), %r11",
785 ));
786 insns.push((
787 Inst::mov64_m_r(Amode::imm_reg_reg_shift(0x4f6625be, r15, rax, 3), w_r11),
788 "4D8B9CC7BE25664F",
789 "movq 1332094398(%r15,%rax,8), %r11",
790 ));
791 insns.push((
792 Inst::mov64_m_r(Amode::imm_reg_reg_shift(0x4f6625be, rax, rdi, 3), w_r11),
793 "4C8B9CF8BE25664F",
794 "movq 1332094398(%rax,%rdi,8), %r11",
795 ));
796 insns.push((
797 Inst::mov64_m_r(Amode::imm_reg_reg_shift(0x4f6625be, rdi, rdi, 2), w_r11),
798 "4C8B9CBFBE25664F",
799 "movq 1332094398(%rdi,%rdi,4), %r11",
800 ));
801 insns.push((
802 Inst::mov64_m_r(Amode::imm_reg_reg_shift(0x4f6625be, r8, rdi, 1), w_r11),
803 "4D8B9C78BE25664F",
804 "movq 1332094398(%r8,%rdi,2), %r11",
805 ));
806 insns.push((
807 Inst::mov64_m_r(Amode::imm_reg_reg_shift(0x4f6625be, r15, rdi, 0), w_r11),
808 "4D8B9C3FBE25664F",
809 "movq 1332094398(%r15,%rdi,1), %r11",
810 ));
811
812 // ========================================================
813 // Addr_IRRS, offset large negative simm32
814 insns.push((
815 Inst::mov64_m_r(
816 Amode::imm_reg_reg_shift(-0x264d1690i32 as u32, rax, r8, 2),
817 w_r11,
818 ),
819 "4E8B9C8070E9B2D9",
820 "movq -642586256(%rax,%r8,4), %r11",
821 ));
822 insns.push((
823 Inst::mov64_m_r(
824 Amode::imm_reg_reg_shift(-0x264d1690i32 as u32, rdi, r8, 3),
825 w_r11,
826 ),
827 "4E8B9CC770E9B2D9",
828 "movq -642586256(%rdi,%r8,8), %r11",
829 ));
830 insns.push((
831 Inst::mov64_m_r(
832 Amode::imm_reg_reg_shift(-0x264d1690i32 as u32, r8, r8, 0),
833 w_r11,
834 ),
835 "4F8B9C0070E9B2D9",
836 "movq -642586256(%r8,%r8,1), %r11",
837 ));
838 insns.push((
839 Inst::mov64_m_r(
840 Amode::imm_reg_reg_shift(-0x264d1690i32 as u32, r15, r8, 1),
841 w_r11,
842 ),
843 "4F8B9C4770E9B2D9",
844 "movq -642586256(%r15,%r8,2), %r11",
845 ));
846 insns.push((
847 Inst::mov64_m_r(
848 Amode::imm_reg_reg_shift(-0x264d1690i32 as u32, rax, r15, 1),
849 w_r11,
850 ),
851 "4E8B9C7870E9B2D9",
852 "movq -642586256(%rax,%r15,2), %r11",
853 ));
854 insns.push((
855 Inst::mov64_m_r(
856 Amode::imm_reg_reg_shift(-0x264d1690i32 as u32, rdi, r15, 0),
857 w_r11,
858 ),
859 "4E8B9C3F70E9B2D9",
860 "movq -642586256(%rdi,%r15,1), %r11",
861 ));
862 insns.push((
863 Inst::mov64_m_r(
864 Amode::imm_reg_reg_shift(-0x264d1690i32 as u32, r8, r15, 3),
865 w_r11,
866 ),
867 "4F8B9CF870E9B2D9",
868 "movq -642586256(%r8,%r15,8), %r11",
869 ));
870 insns.push((
871 Inst::mov64_m_r(
872 Amode::imm_reg_reg_shift(-0x264d1690i32 as u32, r15, r15, 2),
873 w_r11,
874 ),
875 "4F8B9CBF70E9B2D9",
876 "movq -642586256(%r15,%r15,4), %r11",
877 ));
878
879 // End of test cases for Addr
880 // ========================================================
881
882 // ========================================================
883 // General tests for each insn. Don't forget to follow the
884 // guidelines commented just prior to `fn x64_emit`.
885 //
886 // Alu_RMI_R
887 insns.push((
888 Inst::alu_rmi_r(
889 OperandSize::Size64,
890 AluRmiROpcode::Add,
891 RegMemImm::reg(r15),
892 w_rdx,
893 ),
894 "4C01FA",
895 "addq %r15, %rdx",
896 ));
897 insns.push((
898 Inst::alu_rmi_r(
899 OperandSize::Size32,
900 AluRmiROpcode::Add,
901 RegMemImm::reg(rcx),
902 w_r8,
903 ),
904 "4101C8",
905 "addl %ecx, %r8d",
906 ));
907 insns.push((
908 Inst::alu_rmi_r(
909 OperandSize::Size32,
910 AluRmiROpcode::Add,
911 RegMemImm::reg(rcx),
912 w_rsi,
913 ),
914 "01CE",
915 "addl %ecx, %esi",
916 ));
917 insns.push((
918 Inst::alu_rmi_r(
919 OperandSize::Size64,
920 AluRmiROpcode::Add,
921 RegMemImm::mem(Amode::imm_reg(99, rdi)),
922 w_rdx,
923 ),
924 "48035763",
925 "addq 99(%rdi), %rdx",
926 ));
927 insns.push((
928 Inst::alu_rmi_r(
929 OperandSize::Size32,
930 AluRmiROpcode::Add,
931 RegMemImm::mem(Amode::imm_reg(99, rdi)),
932 w_r8,
933 ),
934 "44034763",
935 "addl 99(%rdi), %r8d",
936 ));
937 insns.push((
938 Inst::alu_rmi_r(
939 OperandSize::Size32,
940 AluRmiROpcode::Add,
941 RegMemImm::mem(Amode::imm_reg(99, rdi)),
942 w_rsi,
943 ),
944 "037763",
945 "addl 99(%rdi), %esi",
946 ));
947 insns.push((
948 Inst::alu_rmi_r(
949 OperandSize::Size64,
950 AluRmiROpcode::Add,
951 RegMemImm::imm(-127i32 as u32),
952 w_rdx,
953 ),
954 "4883C281",
955 "addq $-127, %rdx",
956 ));
957 insns.push((
958 Inst::alu_rmi_r(
959 OperandSize::Size64,
960 AluRmiROpcode::Add,
961 RegMemImm::imm(-129i32 as u32),
962 w_rdx,
963 ),
964 "4881C27FFFFFFF",
965 "addq $-129, %rdx",
966 ));
967 insns.push((
968 Inst::alu_rmi_r(
969 OperandSize::Size64,
970 AluRmiROpcode::Add,
971 RegMemImm::imm(76543210),
972 w_rdx,
973 ),
974 "4881C2EAF48F04",
975 "addq $76543210, %rdx",
976 ));
977 insns.push((
978 Inst::alu_rmi_r(
979 OperandSize::Size32,
980 AluRmiROpcode::Add,
981 RegMemImm::imm(-127i32 as u32),
982 w_r8,
983 ),
984 "4183C081",
985 "addl $-127, %r8d",
986 ));
987 insns.push((
988 Inst::alu_rmi_r(
989 OperandSize::Size32,
990 AluRmiROpcode::Add,
991 RegMemImm::imm(-129i32 as u32),
992 w_r8,
993 ),
994 "4181C07FFFFFFF",
995 "addl $-129, %r8d",
996 ));
997 insns.push((
998 Inst::alu_rmi_r(
999 OperandSize::Size32,
1000 AluRmiROpcode::Add,
1001 RegMemImm::imm(-76543210i32 as u32),
1002 w_r8,
1003 ),
1004 "4181C0160B70FB",
1005 "addl $-76543210, %r8d",
1006 ));
1007 insns.push((
1008 Inst::alu_rmi_r(
1009 OperandSize::Size32,
1010 AluRmiROpcode::Add,
1011 RegMemImm::imm(-127i32 as u32),
1012 w_rsi,
1013 ),
1014 "83C681",
1015 "addl $-127, %esi",
1016 ));
1017 insns.push((
1018 Inst::alu_rmi_r(
1019 OperandSize::Size32,
1020 AluRmiROpcode::Add,
1021 RegMemImm::imm(-129i32 as u32),
1022 w_rsi,
1023 ),
1024 "81C67FFFFFFF",
1025 "addl $-129, %esi",
1026 ));
1027 insns.push((
1028 Inst::alu_rmi_r(
1029 OperandSize::Size32,
1030 AluRmiROpcode::Add,
1031 RegMemImm::imm(76543210),
1032 w_rsi,
1033 ),
1034 "81C6EAF48F04",
1035 "addl $76543210, %esi",
1036 ));
1037 // This is pretty feeble
1038 insns.push((
1039 Inst::alu_rmi_r(
1040 OperandSize::Size64,
1041 AluRmiROpcode::Sub,
1042 RegMemImm::reg(r15),
1043 w_rdx,
1044 ),
1045 "4C29FA",
1046 "subq %r15, %rdx",
1047 ));
1048 insns.push((
1049 Inst::alu_rmi_r(
1050 OperandSize::Size64,
1051 AluRmiROpcode::And,
1052 RegMemImm::reg(r15),
1053 w_rdx,
1054 ),
1055 "4C21FA",
1056 "andq %r15, %rdx",
1057 ));
1058 insns.push((
1059 Inst::alu_rmi_r(
1060 OperandSize::Size64,
1061 AluRmiROpcode::Or,
1062 RegMemImm::reg(r15),
1063 w_rdx,
1064 ),
1065 "4C09FA",
1066 "orq %r15, %rdx",
1067 ));
1068 insns.push((
1069 Inst::alu_rmi_r(
1070 OperandSize::Size32,
1071 AluRmiROpcode::And8,
1072 RegMemImm::reg(r15),
1073 w_rdx,
1074 ),
1075 "4420FA",
1076 "andb %r15b, %dl",
1077 ));
1078 insns.push((
1079 Inst::alu_rmi_r(
1080 OperandSize::Size32,
1081 AluRmiROpcode::And8,
1082 RegMemImm::reg(rax),
1083 w_rsi,
1084 ),
1085 "4020C6",
1086 "andb %al, %sil",
1087 ));
1088 insns.push((
1089 Inst::alu_rmi_r(
1090 OperandSize::Size32,
1091 AluRmiROpcode::And8,
1092 RegMemImm::reg(rax),
1093 w_rbx,
1094 ),
1095 "20C3",
1096 "andb %al, %bl",
1097 ));
1098 insns.push((
1099 Inst::alu_rmi_r(
1100 OperandSize::Size32,
1101 AluRmiROpcode::And8,
1102 RegMemImm::mem(Amode::imm_reg(0, rax)),
1103 w_rbx,
1104 ),
1105 "2218",
1106 "andb 0(%rax), %bl",
1107 ));
1108 insns.push((
1109 Inst::alu_rmi_r(
1110 OperandSize::Size32,
1111 AluRmiROpcode::Or8,
1112 RegMemImm::reg(r15),
1113 w_rdx,
1114 ),
1115 "4408FA",
1116 "orb %r15b, %dl",
1117 ));
1118 insns.push((
1119 Inst::alu_rmi_r(
1120 OperandSize::Size32,
1121 AluRmiROpcode::Or8,
1122 RegMemImm::reg(rax),
1123 w_rsi,
1124 ),
1125 "4008C6",
1126 "orb %al, %sil",
1127 ));
1128 insns.push((
1129 Inst::alu_rmi_r(
1130 OperandSize::Size32,
1131 AluRmiROpcode::Or8,
1132 RegMemImm::reg(rax),
1133 w_rbx,
1134 ),
1135 "08C3",
1136 "orb %al, %bl",
1137 ));
1138 insns.push((
1139 Inst::alu_rmi_r(
1140 OperandSize::Size32,
1141 AluRmiROpcode::Or8,
1142 RegMemImm::mem(Amode::imm_reg(0, rax)),
1143 w_rbx,
1144 ),
1145 "0A18",
1146 "orb 0(%rax), %bl",
1147 ));
1148 insns.push((
1149 Inst::alu_rmi_r(
1150 OperandSize::Size64,
1151 AluRmiROpcode::Xor,
1152 RegMemImm::reg(r15),
1153 w_rdx,
1154 ),
1155 "4C31FA",
1156 "xorq %r15, %rdx",
1157 ));
1158 // Test all mul cases, though
1159 insns.push((
1160 Inst::alu_rmi_r(
1161 OperandSize::Size64,
1162 AluRmiROpcode::Mul,
1163 RegMemImm::reg(r15),
1164 w_rdx,
1165 ),
1166 "490FAFD7",
1167 "imulq %r15, %rdx",
1168 ));
1169 insns.push((
1170 Inst::alu_rmi_r(
1171 OperandSize::Size32,
1172 AluRmiROpcode::Mul,
1173 RegMemImm::reg(rcx),
1174 w_r8,
1175 ),
1176 "440FAFC1",
1177 "imull %ecx, %r8d",
1178 ));
1179 insns.push((
1180 Inst::alu_rmi_r(
1181 OperandSize::Size32,
1182 AluRmiROpcode::Mul,
1183 RegMemImm::reg(rcx),
1184 w_rsi,
1185 ),
1186 "0FAFF1",
1187 "imull %ecx, %esi",
1188 ));
1189 insns.push((
1190 Inst::alu_rmi_r(
1191 OperandSize::Size64,
1192 AluRmiROpcode::Mul,
1193 RegMemImm::mem(Amode::imm_reg(99, rdi)),
1194 w_rdx,
1195 ),
1196 "480FAF5763",
1197 "imulq 99(%rdi), %rdx",
1198 ));
1199 insns.push((
1200 Inst::alu_rmi_r(
1201 OperandSize::Size32,
1202 AluRmiROpcode::Mul,
1203 RegMemImm::mem(Amode::imm_reg(99, rdi)),
1204 w_r8,
1205 ),
1206 "440FAF4763",
1207 "imull 99(%rdi), %r8d",
1208 ));
1209 insns.push((
1210 Inst::alu_rmi_r(
1211 OperandSize::Size32,
1212 AluRmiROpcode::Mul,
1213 RegMemImm::mem(Amode::imm_reg(99, rdi)),
1214 w_rsi,
1215 ),
1216 "0FAF7763",
1217 "imull 99(%rdi), %esi",
1218 ));
1219 insns.push((
1220 Inst::alu_rmi_r(
1221 OperandSize::Size64,
1222 AluRmiROpcode::Mul,
1223 RegMemImm::imm(-127i32 as u32),
1224 w_rdx,
1225 ),
1226 "486BD281",
1227 "imulq $-127, %rdx",
1228 ));
1229 insns.push((
1230 Inst::alu_rmi_r(
1231 OperandSize::Size64,
1232 AluRmiROpcode::Mul,
1233 RegMemImm::imm(-129i32 as u32),
1234 w_rdx,
1235 ),
1236 "4869D27FFFFFFF",
1237 "imulq $-129, %rdx",
1238 ));
1239 insns.push((
1240 Inst::alu_rmi_r(
1241 OperandSize::Size64,
1242 AluRmiROpcode::Mul,
1243 RegMemImm::imm(76543210),
1244 w_rdx,
1245 ),
1246 "4869D2EAF48F04",
1247 "imulq $76543210, %rdx",
1248 ));
1249 insns.push((
1250 Inst::alu_rmi_r(
1251 OperandSize::Size32,
1252 AluRmiROpcode::Mul,
1253 RegMemImm::imm(-127i32 as u32),
1254 w_r8,
1255 ),
1256 "456BC081",
1257 "imull $-127, %r8d",
1258 ));
1259 insns.push((
1260 Inst::alu_rmi_r(
1261 OperandSize::Size32,
1262 AluRmiROpcode::Mul,
1263 RegMemImm::imm(-129i32 as u32),
1264 w_r8,
1265 ),
1266 "4569C07FFFFFFF",
1267 "imull $-129, %r8d",
1268 ));
1269 insns.push((
1270 Inst::alu_rmi_r(
1271 OperandSize::Size32,
1272 AluRmiROpcode::Mul,
1273 RegMemImm::imm(-76543210i32 as u32),
1274 w_r8,
1275 ),
1276 "4569C0160B70FB",
1277 "imull $-76543210, %r8d",
1278 ));
1279 insns.push((
1280 Inst::alu_rmi_r(
1281 OperandSize::Size32,
1282 AluRmiROpcode::Mul,
1283 RegMemImm::imm(-127i32 as u32),
1284 w_rsi,
1285 ),
1286 "6BF681",
1287 "imull $-127, %esi",
1288 ));
1289 insns.push((
1290 Inst::alu_rmi_r(
1291 OperandSize::Size32,
1292 AluRmiROpcode::Mul,
1293 RegMemImm::imm(-129i32 as u32),
1294 w_rsi,
1295 ),
1296 "69F67FFFFFFF",
1297 "imull $-129, %esi",
1298 ));
1299 insns.push((
1300 Inst::alu_rmi_r(
1301 OperandSize::Size32,
1302 AluRmiROpcode::Mul,
1303 RegMemImm::imm(76543210),
1304 w_rsi,
1305 ),
1306 "69F6EAF48F04",
1307 "imull $76543210, %esi",
1308 ));
1309
1310 // ========================================================
1311 // UnaryRmR
1312
1313 insns.push((
1314 Inst::unary_rm_r(
1315 OperandSize::Size32,
1316 UnaryRmROpcode::Bsr,
1317 RegMem::reg(rsi),
1318 w_rdi,
1319 ),
1320 "0FBDFE",
1321 "bsrl %esi, %edi",
1322 ));
1323 insns.push((
1324 Inst::unary_rm_r(
1325 OperandSize::Size64,
1326 UnaryRmROpcode::Bsr,
1327 RegMem::reg(r15),
1328 w_rax,
1329 ),
1330 "490FBDC7",
1331 "bsrq %r15, %rax",
1332 ));
1333
1334 // ========================================================
1335 // Not
1336 insns.push((
1337 Inst::not(OperandSize::Size32, Writable::from_reg(regs::rsi())),
1338 "F7D6",
1339 "notl %esi",
1340 ));
1341 insns.push((
1342 Inst::not(OperandSize::Size64, Writable::from_reg(regs::r15())),
1343 "49F7D7",
1344 "notq %r15",
1345 ));
1346 insns.push((
1347 Inst::not(OperandSize::Size32, Writable::from_reg(regs::r14())),
1348 "41F7D6",
1349 "notl %r14d",
1350 ));
1351 insns.push((
1352 Inst::not(OperandSize::Size16, Writable::from_reg(regs::rdi())),
1353 "66F7D7",
1354 "notw %di",
1355 ));
1356 insns.push((
1357 Inst::not(OperandSize::Size8, Writable::from_reg(regs::rdi())),
1358 "40F6D7",
1359 "notb %dil",
1360 ));
1361 insns.push((
1362 Inst::not(OperandSize::Size8, Writable::from_reg(regs::rax())),
1363 "F6D0",
1364 "notb %al",
1365 ));
1366
1367 // ========================================================
1368 // Neg
1369 insns.push((
1370 Inst::neg(OperandSize::Size32, Writable::from_reg(regs::rsi())),
1371 "F7DE",
1372 "negl %esi",
1373 ));
1374 insns.push((
1375 Inst::neg(OperandSize::Size64, Writable::from_reg(regs::r15())),
1376 "49F7DF",
1377 "negq %r15",
1378 ));
1379 insns.push((
1380 Inst::neg(OperandSize::Size32, Writable::from_reg(regs::r14())),
1381 "41F7DE",
1382 "negl %r14d",
1383 ));
1384 insns.push((
1385 Inst::neg(OperandSize::Size16, Writable::from_reg(regs::rdi())),
1386 "66F7DF",
1387 "negw %di",
1388 ));
1389 insns.push((
1390 Inst::neg(OperandSize::Size8, Writable::from_reg(regs::rdi())),
1391 "40F6DF",
1392 "negb %dil",
1393 ));
1394 insns.push((
1395 Inst::neg(OperandSize::Size8, Writable::from_reg(regs::rax())),
1396 "F6D8",
1397 "negb %al",
1398 ));
1399
1400 // ========================================================
1401 // Div
1402 insns.push((
1403 Inst::div(
1404 OperandSize::Size32,
1405 true, /*signed*/
1406 RegMem::reg(regs::rsi()),
1407 ),
1408 "F7FE",
1409 "idiv %esi",
1410 ));
1411 insns.push((
1412 Inst::div(
1413 OperandSize::Size64,
1414 true, /*signed*/
1415 RegMem::reg(regs::r15()),
1416 ),
1417 "49F7FF",
1418 "idiv %r15",
1419 ));
1420 insns.push((
1421 Inst::div(
1422 OperandSize::Size32,
1423 false, /*signed*/
1424 RegMem::reg(regs::r14()),
1425 ),
1426 "41F7F6",
1427 "div %r14d",
1428 ));
1429 insns.push((
1430 Inst::div(
1431 OperandSize::Size64,
1432 false, /*signed*/
1433 RegMem::reg(regs::rdi()),
1434 ),
1435 "48F7F7",
1436 "div %rdi",
1437 ));
1438 insns.push((
1439 Inst::div(OperandSize::Size8, false, RegMem::reg(regs::rax())),
1440 "F6F0",
1441 "div %al",
1442 ));
1443 insns.push((
1444 Inst::div(OperandSize::Size8, false, RegMem::reg(regs::rsi())),
1445 "40F6F6",
1446 "div %sil",
1447 ));
1448
1449 // ========================================================
1450 // MulHi
1451 insns.push((
1452 Inst::mul_hi(
1453 OperandSize::Size32,
1454 true, /*signed*/
1455 RegMem::reg(regs::rsi()),
1456 ),
1457 "F7EE",
1458 "imul %esi",
1459 ));
1460 insns.push((
1461 Inst::mul_hi(
1462 OperandSize::Size64,
1463 true, /*signed*/
1464 RegMem::reg(regs::r15()),
1465 ),
1466 "49F7EF",
1467 "imul %r15",
1468 ));
1469 insns.push((
1470 Inst::mul_hi(
1471 OperandSize::Size32,
1472 false, /*signed*/
1473 RegMem::reg(regs::r14()),
1474 ),
1475 "41F7E6",
1476 "mul %r14d",
1477 ));
1478 insns.push((
1479 Inst::mul_hi(
1480 OperandSize::Size64,
1481 false, /*signed*/
1482 RegMem::reg(regs::rdi()),
1483 ),
1484 "48F7E7",
1485 "mul %rdi",
1486 ));
1487
1488 // ========================================================
1489 // cbw
1490 insns.push((Inst::sign_extend_data(OperandSize::Size8), "6698", "cbw"));
1491
1492 // ========================================================
1493 // cdq family: SignExtendRaxRdx
1494 insns.push((Inst::sign_extend_data(OperandSize::Size16), "6699", "cwd"));
1495 insns.push((Inst::sign_extend_data(OperandSize::Size32), "99", "cdq"));
1496 insns.push((Inst::sign_extend_data(OperandSize::Size64), "4899", "cqo"));
1497
1498 // ========================================================
1499 // Imm_R
1500 //
1501 insns.push((
1502 Inst::imm(OperandSize::Size32, 1234567, w_r14),
1503 "41BE87D61200",
1504 "movl $1234567, %r14d",
1505 ));
1506 insns.push((
1507 Inst::imm(OperandSize::Size32, -126i64 as u64, w_r14),
1508 "41BE82FFFFFF",
1509 "movl $-126, %r14d",
1510 ));
1511 insns.push((
1512 Inst::imm(OperandSize::Size64, 1234567898765, w_r14),
1513 "49BE8D26FB711F010000",
1514 "movabsq $1234567898765, %r14",
1515 ));
1516 insns.push((
1517 Inst::imm(OperandSize::Size64, -126i64 as u64, w_r14),
1518 "49C7C682FFFFFF",
1519 "movabsq $-126, %r14",
1520 ));
1521 insns.push((
1522 Inst::imm(OperandSize::Size32, 1234567, w_rcx),
1523 "B987D61200",
1524 "movl $1234567, %ecx",
1525 ));
1526 insns.push((
1527 Inst::imm(OperandSize::Size32, -126i64 as u64, w_rcx),
1528 "B982FFFFFF",
1529 "movl $-126, %ecx",
1530 ));
1531 insns.push((
1532 Inst::imm(OperandSize::Size64, 1234567898765, w_rsi),
1533 "48BE8D26FB711F010000",
1534 "movabsq $1234567898765, %rsi",
1535 ));
1536 insns.push((
1537 Inst::imm(OperandSize::Size64, -126i64 as u64, w_rbx),
1538 "48C7C382FFFFFF",
1539 "movabsq $-126, %rbx",
1540 ));
1541
1542 // ========================================================
1543 // Mov_R_R
1544 insns.push((
1545 Inst::mov_r_r(OperandSize::Size32, rbx, w_rsi),
1546 "89DE",
1547 "movl %ebx, %esi",
1548 ));
1549 insns.push((
1550 Inst::mov_r_r(OperandSize::Size32, rbx, w_r9),
1551 "4189D9",
1552 "movl %ebx, %r9d",
1553 ));
1554 insns.push((
1555 Inst::mov_r_r(OperandSize::Size32, r11, w_rsi),
1556 "4489DE",
1557 "movl %r11d, %esi",
1558 ));
1559 insns.push((
1560 Inst::mov_r_r(OperandSize::Size32, r12, w_r9),
1561 "4589E1",
1562 "movl %r12d, %r9d",
1563 ));
1564 insns.push((
1565 Inst::mov_r_r(OperandSize::Size64, rbx, w_rsi),
1566 "4889DE",
1567 "movq %rbx, %rsi",
1568 ));
1569 insns.push((
1570 Inst::mov_r_r(OperandSize::Size64, rbx, w_r9),
1571 "4989D9",
1572 "movq %rbx, %r9",
1573 ));
1574 insns.push((
1575 Inst::mov_r_r(OperandSize::Size64, r11, w_rsi),
1576 "4C89DE",
1577 "movq %r11, %rsi",
1578 ));
1579 insns.push((
1580 Inst::mov_r_r(OperandSize::Size64, r12, w_r9),
1581 "4D89E1",
1582 "movq %r12, %r9",
1583 ));
1584
1585 // ========================================================
1586 // MovZX_RM_R
1587 insns.push((
1588 Inst::movzx_rm_r(ExtMode::BL, RegMem::reg(rdi), w_rdi),
1589 "400FB6FF",
1590 "movzbl %dil, %edi",
1591 ));
1592 insns.push((
1593 Inst::movzx_rm_r(ExtMode::BL, RegMem::reg(rax), w_rsi),
1594 "0FB6F0",
1595 "movzbl %al, %esi",
1596 ));
1597 insns.push((
1598 Inst::movzx_rm_r(ExtMode::BL, RegMem::reg(r15), w_rsi),
1599 "410FB6F7",
1600 "movzbl %r15b, %esi",
1601 ));
1602 insns.push((
1603 Inst::movzx_rm_r(
1604 ExtMode::BL,
1605 RegMem::mem(Amode::imm_reg(-7i32 as u32, rcx)),
1606 w_rsi,
1607 ),
1608 "0FB671F9",
1609 "movzbl -7(%rcx), %esi",
1610 ));
1611 insns.push((
1612 Inst::movzx_rm_r(
1613 ExtMode::BL,
1614 RegMem::mem(Amode::imm_reg(-7i32 as u32, r8)),
1615 w_rbx,
1616 ),
1617 "410FB658F9",
1618 "movzbl -7(%r8), %ebx",
1619 ));
1620 insns.push((
1621 Inst::movzx_rm_r(
1622 ExtMode::BL,
1623 RegMem::mem(Amode::imm_reg(-7i32 as u32, r10)),
1624 w_r9,
1625 ),
1626 "450FB64AF9",
1627 "movzbl -7(%r10), %r9d",
1628 ));
1629 insns.push((
1630 Inst::movzx_rm_r(
1631 ExtMode::BL,
1632 RegMem::mem(Amode::imm_reg(-7i32 as u32, r11)),
1633 w_rdx,
1634 ),
1635 "410FB653F9",
1636 "movzbl -7(%r11), %edx",
1637 ));
1638 insns.push((
1639 Inst::movzx_rm_r(ExtMode::BQ, RegMem::reg(rax), w_rsi),
1640 "480FB6F0",
1641 "movzbq %al, %rsi",
1642 ));
1643 insns.push((
1644 Inst::movzx_rm_r(ExtMode::BQ, RegMem::reg(r10), w_rsi),
1645 "490FB6F2",
1646 "movzbq %r10b, %rsi",
1647 ));
1648 insns.push((
1649 Inst::movzx_rm_r(
1650 ExtMode::BQ,
1651 RegMem::mem(Amode::imm_reg(-7i32 as u32, rcx)),
1652 w_rsi,
1653 ),
1654 "480FB671F9",
1655 "movzbq -7(%rcx), %rsi",
1656 ));
1657 insns.push((
1658 Inst::movzx_rm_r(
1659 ExtMode::BQ,
1660 RegMem::mem(Amode::imm_reg(-7i32 as u32, r8)),
1661 w_rbx,
1662 ),
1663 "490FB658F9",
1664 "movzbq -7(%r8), %rbx",
1665 ));
1666 insns.push((
1667 Inst::movzx_rm_r(
1668 ExtMode::BQ,
1669 RegMem::mem(Amode::imm_reg(-7i32 as u32, r10)),
1670 w_r9,
1671 ),
1672 "4D0FB64AF9",
1673 "movzbq -7(%r10), %r9",
1674 ));
1675 insns.push((
1676 Inst::movzx_rm_r(
1677 ExtMode::BQ,
1678 RegMem::mem(Amode::imm_reg(-7i32 as u32, r11)),
1679 w_rdx,
1680 ),
1681 "490FB653F9",
1682 "movzbq -7(%r11), %rdx",
1683 ));
1684 insns.push((
1685 Inst::movzx_rm_r(ExtMode::WL, RegMem::reg(rcx), w_rsi),
1686 "0FB7F1",
1687 "movzwl %cx, %esi",
1688 ));
1689 insns.push((
1690 Inst::movzx_rm_r(ExtMode::WL, RegMem::reg(r10), w_rsi),
1691 "410FB7F2",
1692 "movzwl %r10w, %esi",
1693 ));
1694 insns.push((
1695 Inst::movzx_rm_r(
1696 ExtMode::WL,
1697 RegMem::mem(Amode::imm_reg(-7i32 as u32, rcx)),
1698 w_rsi,
1699 ),
1700 "0FB771F9",
1701 "movzwl -7(%rcx), %esi",
1702 ));
1703 insns.push((
1704 Inst::movzx_rm_r(
1705 ExtMode::WL,
1706 RegMem::mem(Amode::imm_reg(-7i32 as u32, r8)),
1707 w_rbx,
1708 ),
1709 "410FB758F9",
1710 "movzwl -7(%r8), %ebx",
1711 ));
1712 insns.push((
1713 Inst::movzx_rm_r(
1714 ExtMode::WL,
1715 RegMem::mem(Amode::imm_reg(-7i32 as u32, r10)),
1716 w_r9,
1717 ),
1718 "450FB74AF9",
1719 "movzwl -7(%r10), %r9d",
1720 ));
1721 insns.push((
1722 Inst::movzx_rm_r(
1723 ExtMode::WL,
1724 RegMem::mem(Amode::imm_reg(-7i32 as u32, r11)),
1725 w_rdx,
1726 ),
1727 "410FB753F9",
1728 "movzwl -7(%r11), %edx",
1729 ));
1730 insns.push((
1731 Inst::movzx_rm_r(ExtMode::WQ, RegMem::reg(rcx), w_rsi),
1732 "480FB7F1",
1733 "movzwq %cx, %rsi",
1734 ));
1735 insns.push((
1736 Inst::movzx_rm_r(ExtMode::WQ, RegMem::reg(r11), w_rsi),
1737 "490FB7F3",
1738 "movzwq %r11w, %rsi",
1739 ));
1740 insns.push((
1741 Inst::movzx_rm_r(
1742 ExtMode::WQ,
1743 RegMem::mem(Amode::imm_reg(-7i32 as u32, rcx)),
1744 w_rsi,
1745 ),
1746 "480FB771F9",
1747 "movzwq -7(%rcx), %rsi",
1748 ));
1749 insns.push((
1750 Inst::movzx_rm_r(
1751 ExtMode::WQ,
1752 RegMem::mem(Amode::imm_reg(-7i32 as u32, r8)),
1753 w_rbx,
1754 ),
1755 "490FB758F9",
1756 "movzwq -7(%r8), %rbx",
1757 ));
1758 insns.push((
1759 Inst::movzx_rm_r(
1760 ExtMode::WQ,
1761 RegMem::mem(Amode::imm_reg(-7i32 as u32, r10)),
1762 w_r9,
1763 ),
1764 "4D0FB74AF9",
1765 "movzwq -7(%r10), %r9",
1766 ));
1767 insns.push((
1768 Inst::movzx_rm_r(
1769 ExtMode::WQ,
1770 RegMem::mem(Amode::imm_reg(-7i32 as u32, r11)),
1771 w_rdx,
1772 ),
1773 "490FB753F9",
1774 "movzwq -7(%r11), %rdx",
1775 ));
1776 insns.push((
1777 Inst::movzx_rm_r(ExtMode::LQ, RegMem::reg(rcx), w_rsi),
1778 "8BF1",
1779 "movl %ecx, %esi",
1780 ));
1781 insns.push((
1782 Inst::movzx_rm_r(
1783 ExtMode::LQ,
1784 RegMem::mem(Amode::imm_reg(-7i32 as u32, rcx)),
1785 w_rsi,
1786 ),
1787 "8B71F9",
1788 "movl -7(%rcx), %esi",
1789 ));
1790 insns.push((
1791 Inst::movzx_rm_r(
1792 ExtMode::LQ,
1793 RegMem::mem(Amode::imm_reg(-7i32 as u32, r8)),
1794 w_rbx,
1795 ),
1796 "418B58F9",
1797 "movl -7(%r8), %ebx",
1798 ));
1799 insns.push((
1800 Inst::movzx_rm_r(
1801 ExtMode::LQ,
1802 RegMem::mem(Amode::imm_reg(-7i32 as u32, r10)),
1803 w_r9,
1804 ),
1805 "458B4AF9",
1806 "movl -7(%r10), %r9d",
1807 ));
1808 insns.push((
1809 Inst::movzx_rm_r(
1810 ExtMode::LQ,
1811 RegMem::mem(Amode::imm_reg(-7i32 as u32, r11)),
1812 w_rdx,
1813 ),
1814 "418B53F9",
1815 "movl -7(%r11), %edx",
1816 ));
1817
1818 // ========================================================
1819 // Mov64_M_R
1820 insns.push((
1821 Inst::mov64_m_r(Amode::imm_reg_reg_shift(179, rax, rbx, 0), w_rcx),
1822 "488B8C18B3000000",
1823 "movq 179(%rax,%rbx,1), %rcx",
1824 ));
1825 insns.push((
1826 Inst::mov64_m_r(Amode::imm_reg_reg_shift(179, rax, rbx, 0), w_r8),
1827 "4C8B8418B3000000",
1828 "movq 179(%rax,%rbx,1), %r8",
1829 ));
1830 insns.push((
1831 Inst::mov64_m_r(Amode::imm_reg_reg_shift(179, rax, r9, 0), w_rcx),
1832 "4A8B8C08B3000000",
1833 "movq 179(%rax,%r9,1), %rcx",
1834 ));
1835 insns.push((
1836 Inst::mov64_m_r(Amode::imm_reg_reg_shift(179, rax, r9, 0), w_r8),
1837 "4E8B8408B3000000",
1838 "movq 179(%rax,%r9,1), %r8",
1839 ));
1840 insns.push((
1841 Inst::mov64_m_r(Amode::imm_reg_reg_shift(179, r10, rbx, 0), w_rcx),
1842 "498B8C1AB3000000",
1843 "movq 179(%r10,%rbx,1), %rcx",
1844 ));
1845 insns.push((
1846 Inst::mov64_m_r(Amode::imm_reg_reg_shift(179, r10, rbx, 0), w_r8),
1847 "4D8B841AB3000000",
1848 "movq 179(%r10,%rbx,1), %r8",
1849 ));
1850 insns.push((
1851 Inst::mov64_m_r(Amode::imm_reg_reg_shift(179, r10, r9, 0), w_rcx),
1852 "4B8B8C0AB3000000",
1853 "movq 179(%r10,%r9,1), %rcx",
1854 ));
1855 insns.push((
1856 Inst::mov64_m_r(Amode::imm_reg_reg_shift(179, r10, r9, 0), w_r8),
1857 "4F8B840AB3000000",
1858 "movq 179(%r10,%r9,1), %r8",
1859 ));
1860
1861 // ========================================================
1862 // LoadEffectiveAddress
1863 insns.push((
1864 Inst::lea(Amode::imm_reg(42, r10), w_r8),
1865 "4D8D422A",
1866 "lea 42(%r10), %r8",
1867 ));
1868 insns.push((
1869 Inst::lea(Amode::imm_reg(42, r10), w_r15),
1870 "4D8D7A2A",
1871 "lea 42(%r10), %r15",
1872 ));
1873 insns.push((
1874 Inst::lea(Amode::imm_reg_reg_shift(179, r10, r9, 0), w_r8),
1875 "4F8D840AB3000000",
1876 "lea 179(%r10,%r9,1), %r8",
1877 ));
1878 insns.push((
1879 Inst::lea(Amode::rip_relative(MachLabel::from_block(0)), w_rdi),
1880 "488D3D00000000",
1881 "lea label0(%rip), %rdi",
1882 ));
1883
1884 // ========================================================
1885 // MovSX_RM_R
1886 insns.push((
1887 Inst::movsx_rm_r(ExtMode::BL, RegMem::reg(rdi), w_rdi),
1888 "400FBEFF",
1889 "movsbl %dil, %edi",
1890 ));
1891 insns.push((
1892 Inst::movsx_rm_r(ExtMode::BL, RegMem::reg(rcx), w_rsi),
1893 "0FBEF1",
1894 "movsbl %cl, %esi",
1895 ));
1896 insns.push((
1897 Inst::movsx_rm_r(ExtMode::BL, RegMem::reg(r14), w_rsi),
1898 "410FBEF6",
1899 "movsbl %r14b, %esi",
1900 ));
1901 insns.push((
1902 Inst::movsx_rm_r(
1903 ExtMode::BL,
1904 RegMem::mem(Amode::imm_reg(-7i32 as u32, rcx)),
1905 w_rsi,
1906 ),
1907 "0FBE71F9",
1908 "movsbl -7(%rcx), %esi",
1909 ));
1910 insns.push((
1911 Inst::movsx_rm_r(
1912 ExtMode::BL,
1913 RegMem::mem(Amode::imm_reg(-7i32 as u32, r8)),
1914 w_rbx,
1915 ),
1916 "410FBE58F9",
1917 "movsbl -7(%r8), %ebx",
1918 ));
1919 insns.push((
1920 Inst::movsx_rm_r(
1921 ExtMode::BL,
1922 RegMem::mem(Amode::imm_reg(-7i32 as u32, r10)),
1923 w_r9,
1924 ),
1925 "450FBE4AF9",
1926 "movsbl -7(%r10), %r9d",
1927 ));
1928 insns.push((
1929 Inst::movsx_rm_r(
1930 ExtMode::BL,
1931 RegMem::mem(Amode::imm_reg(-7i32 as u32, r11)),
1932 w_rdx,
1933 ),
1934 "410FBE53F9",
1935 "movsbl -7(%r11), %edx",
1936 ));
1937 insns.push((
1938 Inst::movsx_rm_r(ExtMode::BQ, RegMem::reg(rcx), w_rsi),
1939 "480FBEF1",
1940 "movsbq %cl, %rsi",
1941 ));
1942 insns.push((
1943 Inst::movsx_rm_r(ExtMode::BQ, RegMem::reg(r15), w_rsi),
1944 "490FBEF7",
1945 "movsbq %r15b, %rsi",
1946 ));
1947 insns.push((
1948 Inst::movsx_rm_r(
1949 ExtMode::BQ,
1950 RegMem::mem(Amode::imm_reg(-7i32 as u32, rcx)),
1951 w_rsi,
1952 ),
1953 "480FBE71F9",
1954 "movsbq -7(%rcx), %rsi",
1955 ));
1956 insns.push((
1957 Inst::movsx_rm_r(
1958 ExtMode::BQ,
1959 RegMem::mem(Amode::imm_reg(-7i32 as u32, r8)),
1960 w_rbx,
1961 ),
1962 "490FBE58F9",
1963 "movsbq -7(%r8), %rbx",
1964 ));
1965 insns.push((
1966 Inst::movsx_rm_r(
1967 ExtMode::BQ,
1968 RegMem::mem(Amode::imm_reg(-7i32 as u32, r10)),
1969 w_r9,
1970 ),
1971 "4D0FBE4AF9",
1972 "movsbq -7(%r10), %r9",
1973 ));
1974 insns.push((
1975 Inst::movsx_rm_r(
1976 ExtMode::BQ,
1977 RegMem::mem(Amode::imm_reg(-7i32 as u32, r11)),
1978 w_rdx,
1979 ),
1980 "490FBE53F9",
1981 "movsbq -7(%r11), %rdx",
1982 ));
1983 insns.push((
1984 Inst::movsx_rm_r(ExtMode::WL, RegMem::reg(rcx), w_rsi),
1985 "0FBFF1",
1986 "movswl %cx, %esi",
1987 ));
1988 insns.push((
1989 Inst::movsx_rm_r(ExtMode::WL, RegMem::reg(r14), w_rsi),
1990 "410FBFF6",
1991 "movswl %r14w, %esi",
1992 ));
1993 insns.push((
1994 Inst::movsx_rm_r(
1995 ExtMode::WL,
1996 RegMem::mem(Amode::imm_reg(-7i32 as u32, rcx)),
1997 w_rsi,
1998 ),
1999 "0FBF71F9",
2000 "movswl -7(%rcx), %esi",
2001 ));
2002 insns.push((
2003 Inst::movsx_rm_r(
2004 ExtMode::WL,
2005 RegMem::mem(Amode::imm_reg(-7i32 as u32, r8)),
2006 w_rbx,
2007 ),
2008 "410FBF58F9",
2009 "movswl -7(%r8), %ebx",
2010 ));
2011 insns.push((
2012 Inst::movsx_rm_r(
2013 ExtMode::WL,
2014 RegMem::mem(Amode::imm_reg(-7i32 as u32, r10)),
2015 w_r9,
2016 ),
2017 "450FBF4AF9",
2018 "movswl -7(%r10), %r9d",
2019 ));
2020 insns.push((
2021 Inst::movsx_rm_r(
2022 ExtMode::WL,
2023 RegMem::mem(Amode::imm_reg(-7i32 as u32, r11)),
2024 w_rdx,
2025 ),
2026 "410FBF53F9",
2027 "movswl -7(%r11), %edx",
2028 ));
2029 insns.push((
2030 Inst::movsx_rm_r(ExtMode::WQ, RegMem::reg(rcx), w_rsi),
2031 "480FBFF1",
2032 "movswq %cx, %rsi",
2033 ));
2034 insns.push((
2035 Inst::movsx_rm_r(ExtMode::WQ, RegMem::reg(r13), w_rsi),
2036 "490FBFF5",
2037 "movswq %r13w, %rsi",
2038 ));
2039 insns.push((
2040 Inst::movsx_rm_r(
2041 ExtMode::WQ,
2042 RegMem::mem(Amode::imm_reg(-7i32 as u32, rcx)),
2043 w_rsi,
2044 ),
2045 "480FBF71F9",
2046 "movswq -7(%rcx), %rsi",
2047 ));
2048 insns.push((
2049 Inst::movsx_rm_r(
2050 ExtMode::WQ,
2051 RegMem::mem(Amode::imm_reg(-7i32 as u32, r8)),
2052 w_rbx,
2053 ),
2054 "490FBF58F9",
2055 "movswq -7(%r8), %rbx",
2056 ));
2057 insns.push((
2058 Inst::movsx_rm_r(
2059 ExtMode::WQ,
2060 RegMem::mem(Amode::imm_reg(-7i32 as u32, r10)),
2061 w_r9,
2062 ),
2063 "4D0FBF4AF9",
2064 "movswq -7(%r10), %r9",
2065 ));
2066 insns.push((
2067 Inst::movsx_rm_r(
2068 ExtMode::WQ,
2069 RegMem::mem(Amode::imm_reg(-7i32 as u32, r11)),
2070 w_rdx,
2071 ),
2072 "490FBF53F9",
2073 "movswq -7(%r11), %rdx",
2074 ));
2075 insns.push((
2076 Inst::movsx_rm_r(ExtMode::LQ, RegMem::reg(rcx), w_rsi),
2077 "4863F1",
2078 "movslq %ecx, %rsi",
2079 ));
2080 insns.push((
2081 Inst::movsx_rm_r(ExtMode::LQ, RegMem::reg(r15), w_rsi),
2082 "4963F7",
2083 "movslq %r15d, %rsi",
2084 ));
2085 insns.push((
2086 Inst::movsx_rm_r(
2087 ExtMode::LQ,
2088 RegMem::mem(Amode::imm_reg(-7i32 as u32, rcx)),
2089 w_rsi,
2090 ),
2091 "486371F9",
2092 "movslq -7(%rcx), %rsi",
2093 ));
2094 insns.push((
2095 Inst::movsx_rm_r(
2096 ExtMode::LQ,
2097 RegMem::mem(Amode::imm_reg(-7i32 as u32, r8)),
2098 w_rbx,
2099 ),
2100 "496358F9",
2101 "movslq -7(%r8), %rbx",
2102 ));
2103 insns.push((
2104 Inst::movsx_rm_r(
2105 ExtMode::LQ,
2106 RegMem::mem(Amode::imm_reg(-7i32 as u32, r10)),
2107 w_r9,
2108 ),
2109 "4D634AF9",
2110 "movslq -7(%r10), %r9",
2111 ));
2112 insns.push((
2113 Inst::movsx_rm_r(
2114 ExtMode::LQ,
2115 RegMem::mem(Amode::imm_reg(-7i32 as u32, r11)),
2116 w_rdx,
2117 ),
2118 "496353F9",
2119 "movslq -7(%r11), %rdx",
2120 ));
2121
2122 // ========================================================
2123 // Mov_R_M. Byte stores are tricky. Check everything carefully.
2124 insns.push((
2125 Inst::mov_r_m(OperandSize::Size64, rax, Amode::imm_reg(99, rdi)),
2126 "48894763",
2127 "movq %rax, 99(%rdi)",
2128 ));
2129 insns.push((
2130 Inst::mov_r_m(OperandSize::Size64, rbx, Amode::imm_reg(99, r8)),
2131 "49895863",
2132 "movq %rbx, 99(%r8)",
2133 ));
2134 insns.push((
2135 Inst::mov_r_m(OperandSize::Size64, rcx, Amode::imm_reg(99, rsi)),
2136 "48894E63",
2137 "movq %rcx, 99(%rsi)",
2138 ));
2139 insns.push((
2140 Inst::mov_r_m(OperandSize::Size64, rdx, Amode::imm_reg(99, r9)),
2141 "49895163",
2142 "movq %rdx, 99(%r9)",
2143 ));
2144 insns.push((
2145 Inst::mov_r_m(OperandSize::Size64, rsi, Amode::imm_reg(99, rax)),
2146 "48897063",
2147 "movq %rsi, 99(%rax)",
2148 ));
2149 insns.push((
2150 Inst::mov_r_m(OperandSize::Size64, rdi, Amode::imm_reg(99, r15)),
2151 "49897F63",
2152 "movq %rdi, 99(%r15)",
2153 ));
2154 insns.push((
2155 Inst::mov_r_m(OperandSize::Size64, rsp, Amode::imm_reg(99, rcx)),
2156 "48896163",
2157 "movq %rsp, 99(%rcx)",
2158 ));
2159 insns.push((
2160 Inst::mov_r_m(OperandSize::Size64, rbp, Amode::imm_reg(99, r14)),
2161 "49896E63",
2162 "movq %rbp, 99(%r14)",
2163 ));
2164 insns.push((
2165 Inst::mov_r_m(OperandSize::Size64, r8, Amode::imm_reg(99, rdi)),
2166 "4C894763",
2167 "movq %r8, 99(%rdi)",
2168 ));
2169 insns.push((
2170 Inst::mov_r_m(OperandSize::Size64, r9, Amode::imm_reg(99, r8)),
2171 "4D894863",
2172 "movq %r9, 99(%r8)",
2173 ));
2174 insns.push((
2175 Inst::mov_r_m(OperandSize::Size64, r10, Amode::imm_reg(99, rsi)),
2176 "4C895663",
2177 "movq %r10, 99(%rsi)",
2178 ));
2179 insns.push((
2180 Inst::mov_r_m(OperandSize::Size64, r11, Amode::imm_reg(99, r9)),
2181 "4D895963",
2182 "movq %r11, 99(%r9)",
2183 ));
2184 insns.push((
2185 Inst::mov_r_m(OperandSize::Size64, r12, Amode::imm_reg(99, rax)),
2186 "4C896063",
2187 "movq %r12, 99(%rax)",
2188 ));
2189 insns.push((
2190 Inst::mov_r_m(OperandSize::Size64, r13, Amode::imm_reg(99, r15)),
2191 "4D896F63",
2192 "movq %r13, 99(%r15)",
2193 ));
2194 insns.push((
2195 Inst::mov_r_m(OperandSize::Size64, r14, Amode::imm_reg(99, rcx)),
2196 "4C897163",
2197 "movq %r14, 99(%rcx)",
2198 ));
2199 insns.push((
2200 Inst::mov_r_m(OperandSize::Size64, r15, Amode::imm_reg(99, r14)),
2201 "4D897E63",
2202 "movq %r15, 99(%r14)",
2203 ));
2204 //
2205 insns.push((
2206 Inst::mov_r_m(OperandSize::Size32, rax, Amode::imm_reg(99, rdi)),
2207 "894763",
2208 "movl %eax, 99(%rdi)",
2209 ));
2210 insns.push((
2211 Inst::mov_r_m(OperandSize::Size32, rbx, Amode::imm_reg(99, r8)),
2212 "41895863",
2213 "movl %ebx, 99(%r8)",
2214 ));
2215 insns.push((
2216 Inst::mov_r_m(OperandSize::Size32, rcx, Amode::imm_reg(99, rsi)),
2217 "894E63",
2218 "movl %ecx, 99(%rsi)",
2219 ));
2220 insns.push((
2221 Inst::mov_r_m(OperandSize::Size32, rdx, Amode::imm_reg(99, r9)),
2222 "41895163",
2223 "movl %edx, 99(%r9)",
2224 ));
2225 insns.push((
2226 Inst::mov_r_m(OperandSize::Size32, rsi, Amode::imm_reg(99, rax)),
2227 "897063",
2228 "movl %esi, 99(%rax)",
2229 ));
2230 insns.push((
2231 Inst::mov_r_m(OperandSize::Size32, rdi, Amode::imm_reg(99, r15)),
2232 "41897F63",
2233 "movl %edi, 99(%r15)",
2234 ));
2235 insns.push((
2236 Inst::mov_r_m(OperandSize::Size32, rsp, Amode::imm_reg(99, rcx)),
2237 "896163",
2238 "movl %esp, 99(%rcx)",
2239 ));
2240 insns.push((
2241 Inst::mov_r_m(OperandSize::Size32, rbp, Amode::imm_reg(99, r14)),
2242 "41896E63",
2243 "movl %ebp, 99(%r14)",
2244 ));
2245 insns.push((
2246 Inst::mov_r_m(OperandSize::Size32, r8, Amode::imm_reg(99, rdi)),
2247 "44894763",
2248 "movl %r8d, 99(%rdi)",
2249 ));
2250 insns.push((
2251 Inst::mov_r_m(OperandSize::Size32, r9, Amode::imm_reg(99, r8)),
2252 "45894863",
2253 "movl %r9d, 99(%r8)",
2254 ));
2255 insns.push((
2256 Inst::mov_r_m(OperandSize::Size32, r10, Amode::imm_reg(99, rsi)),
2257 "44895663",
2258 "movl %r10d, 99(%rsi)",
2259 ));
2260 insns.push((
2261 Inst::mov_r_m(OperandSize::Size32, r11, Amode::imm_reg(99, r9)),
2262 "45895963",
2263 "movl %r11d, 99(%r9)",
2264 ));
2265 insns.push((
2266 Inst::mov_r_m(OperandSize::Size32, r12, Amode::imm_reg(99, rax)),
2267 "44896063",
2268 "movl %r12d, 99(%rax)",
2269 ));
2270 insns.push((
2271 Inst::mov_r_m(OperandSize::Size32, r13, Amode::imm_reg(99, r15)),
2272 "45896F63",
2273 "movl %r13d, 99(%r15)",
2274 ));
2275 insns.push((
2276 Inst::mov_r_m(OperandSize::Size32, r14, Amode::imm_reg(99, rcx)),
2277 "44897163",
2278 "movl %r14d, 99(%rcx)",
2279 ));
2280 insns.push((
2281 Inst::mov_r_m(OperandSize::Size32, r15, Amode::imm_reg(99, r14)),
2282 "45897E63",
2283 "movl %r15d, 99(%r14)",
2284 ));
2285 //
2286 insns.push((
2287 Inst::mov_r_m(OperandSize::Size16, rax, Amode::imm_reg(99, rdi)),
2288 "66894763",
2289 "movw %ax, 99(%rdi)",
2290 ));
2291 insns.push((
2292 Inst::mov_r_m(OperandSize::Size16, rbx, Amode::imm_reg(99, r8)),
2293 "6641895863",
2294 "movw %bx, 99(%r8)",
2295 ));
2296 insns.push((
2297 Inst::mov_r_m(OperandSize::Size16, rcx, Amode::imm_reg(99, rsi)),
2298 "66894E63",
2299 "movw %cx, 99(%rsi)",
2300 ));
2301 insns.push((
2302 Inst::mov_r_m(OperandSize::Size16, rdx, Amode::imm_reg(99, r9)),
2303 "6641895163",
2304 "movw %dx, 99(%r9)",
2305 ));
2306 insns.push((
2307 Inst::mov_r_m(OperandSize::Size16, rsi, Amode::imm_reg(99, rax)),
2308 "66897063",
2309 "movw %si, 99(%rax)",
2310 ));
2311 insns.push((
2312 Inst::mov_r_m(OperandSize::Size16, rdi, Amode::imm_reg(99, r15)),
2313 "6641897F63",
2314 "movw %di, 99(%r15)",
2315 ));
2316 insns.push((
2317 Inst::mov_r_m(OperandSize::Size16, rsp, Amode::imm_reg(99, rcx)),
2318 "66896163",
2319 "movw %sp, 99(%rcx)",
2320 ));
2321 insns.push((
2322 Inst::mov_r_m(OperandSize::Size16, rbp, Amode::imm_reg(99, r14)),
2323 "6641896E63",
2324 "movw %bp, 99(%r14)",
2325 ));
2326 insns.push((
2327 Inst::mov_r_m(OperandSize::Size16, r8, Amode::imm_reg(99, rdi)),
2328 "6644894763",
2329 "movw %r8w, 99(%rdi)",
2330 ));
2331 insns.push((
2332 Inst::mov_r_m(OperandSize::Size16, r9, Amode::imm_reg(99, r8)),
2333 "6645894863",
2334 "movw %r9w, 99(%r8)",
2335 ));
2336 insns.push((
2337 Inst::mov_r_m(OperandSize::Size16, r10, Amode::imm_reg(99, rsi)),
2338 "6644895663",
2339 "movw %r10w, 99(%rsi)",
2340 ));
2341 insns.push((
2342 Inst::mov_r_m(OperandSize::Size16, r11, Amode::imm_reg(99, r9)),
2343 "6645895963",
2344 "movw %r11w, 99(%r9)",
2345 ));
2346 insns.push((
2347 Inst::mov_r_m(OperandSize::Size16, r12, Amode::imm_reg(99, rax)),
2348 "6644896063",
2349 "movw %r12w, 99(%rax)",
2350 ));
2351 insns.push((
2352 Inst::mov_r_m(OperandSize::Size16, r13, Amode::imm_reg(99, r15)),
2353 "6645896F63",
2354 "movw %r13w, 99(%r15)",
2355 ));
2356 insns.push((
2357 Inst::mov_r_m(OperandSize::Size16, r14, Amode::imm_reg(99, rcx)),
2358 "6644897163",
2359 "movw %r14w, 99(%rcx)",
2360 ));
2361 insns.push((
2362 Inst::mov_r_m(OperandSize::Size16, r15, Amode::imm_reg(99, r14)),
2363 "6645897E63",
2364 "movw %r15w, 99(%r14)",
2365 ));
2366 //
2367 insns.push((
2368 Inst::mov_r_m(OperandSize::Size8, rax, Amode::imm_reg(99, rdi)),
2369 "884763",
2370 "movb %al, 99(%rdi)",
2371 ));
2372 insns.push((
2373 Inst::mov_r_m(OperandSize::Size8, rbx, Amode::imm_reg(99, r8)),
2374 "41885863",
2375 "movb %bl, 99(%r8)",
2376 ));
2377 insns.push((
2378 Inst::mov_r_m(OperandSize::Size8, rcx, Amode::imm_reg(99, rsi)),
2379 "884E63",
2380 "movb %cl, 99(%rsi)",
2381 ));
2382 insns.push((
2383 Inst::mov_r_m(OperandSize::Size8, rdx, Amode::imm_reg(99, r9)),
2384 "41885163",
2385 "movb %dl, 99(%r9)",
2386 ));
2387 insns.push((
2388 Inst::mov_r_m(OperandSize::Size8, rsi, Amode::imm_reg(99, rax)),
2389 "40887063",
2390 "movb %sil, 99(%rax)",
2391 ));
2392 insns.push((
2393 Inst::mov_r_m(OperandSize::Size8, rdi, Amode::imm_reg(99, r15)),
2394 "41887F63",
2395 "movb %dil, 99(%r15)",
2396 ));
2397 insns.push((
2398 Inst::mov_r_m(OperandSize::Size8, rsp, Amode::imm_reg(99, rcx)),
2399 "40886163",
2400 "movb %spl, 99(%rcx)",
2401 ));
2402 insns.push((
2403 Inst::mov_r_m(OperandSize::Size8, rbp, Amode::imm_reg(99, r14)),
2404 "41886E63",
2405 "movb %bpl, 99(%r14)",
2406 ));
2407 insns.push((
2408 Inst::mov_r_m(OperandSize::Size8, r8, Amode::imm_reg(99, rdi)),
2409 "44884763",
2410 "movb %r8b, 99(%rdi)",
2411 ));
2412 insns.push((
2413 Inst::mov_r_m(OperandSize::Size8, r9, Amode::imm_reg(99, r8)),
2414 "45884863",
2415 "movb %r9b, 99(%r8)",
2416 ));
2417 insns.push((
2418 Inst::mov_r_m(OperandSize::Size8, r10, Amode::imm_reg(99, rsi)),
2419 "44885663",
2420 "movb %r10b, 99(%rsi)",
2421 ));
2422 insns.push((
2423 Inst::mov_r_m(OperandSize::Size8, r11, Amode::imm_reg(99, r9)),
2424 "45885963",
2425 "movb %r11b, 99(%r9)",
2426 ));
2427 insns.push((
2428 Inst::mov_r_m(OperandSize::Size8, r12, Amode::imm_reg(99, rax)),
2429 "44886063",
2430 "movb %r12b, 99(%rax)",
2431 ));
2432 insns.push((
2433 Inst::mov_r_m(OperandSize::Size8, r13, Amode::imm_reg(99, r15)),
2434 "45886F63",
2435 "movb %r13b, 99(%r15)",
2436 ));
2437 insns.push((
2438 Inst::mov_r_m(OperandSize::Size8, r14, Amode::imm_reg(99, rcx)),
2439 "44887163",
2440 "movb %r14b, 99(%rcx)",
2441 ));
2442 insns.push((
2443 Inst::mov_r_m(OperandSize::Size8, r15, Amode::imm_reg(99, r14)),
2444 "45887E63",
2445 "movb %r15b, 99(%r14)",
2446 ));
2447
2448 // ========================================================
2449 // Shift_R
2450 insns.push((
2451 Inst::shift_r(OperandSize::Size32, ShiftKind::ShiftLeft, None, w_rdi),
2452 "D3E7",
2453 "shll %cl, %edi",
2454 ));
2455 insns.push((
2456 Inst::shift_r(OperandSize::Size32, ShiftKind::ShiftLeft, None, w_r12),
2457 "41D3E4",
2458 "shll %cl, %r12d",
2459 ));
2460 insns.push((
2461 Inst::shift_r(OperandSize::Size32, ShiftKind::ShiftLeft, Some(2), w_r8),
2462 "41C1E002",
2463 "shll $2, %r8d",
2464 ));
2465 insns.push((
2466 Inst::shift_r(OperandSize::Size32, ShiftKind::ShiftLeft, Some(31), w_r13),
2467 "41C1E51F",
2468 "shll $31, %r13d",
2469 ));
2470 insns.push((
2471 Inst::shift_r(OperandSize::Size64, ShiftKind::ShiftLeft, None, w_r13),
2472 "49D3E5",
2473 "shlq %cl, %r13",
2474 ));
2475 insns.push((
2476 Inst::shift_r(OperandSize::Size64, ShiftKind::ShiftLeft, None, w_rdi),
2477 "48D3E7",
2478 "shlq %cl, %rdi",
2479 ));
2480 insns.push((
2481 Inst::shift_r(OperandSize::Size64, ShiftKind::ShiftLeft, Some(2), w_r8),
2482 "49C1E002",
2483 "shlq $2, %r8",
2484 ));
2485 insns.push((
2486 Inst::shift_r(OperandSize::Size64, ShiftKind::ShiftLeft, Some(3), w_rbx),
2487 "48C1E303",
2488 "shlq $3, %rbx",
2489 ));
2490 insns.push((
2491 Inst::shift_r(OperandSize::Size64, ShiftKind::ShiftLeft, Some(63), w_r13),
2492 "49C1E53F",
2493 "shlq $63, %r13",
2494 ));
2495 insns.push((
2496 Inst::shift_r(
2497 OperandSize::Size32,
2498 ShiftKind::ShiftRightLogical,
2499 None,
2500 w_rdi,
2501 ),
2502 "D3EF",
2503 "shrl %cl, %edi",
2504 ));
2505 insns.push((
2506 Inst::shift_r(
2507 OperandSize::Size32,
2508 ShiftKind::ShiftRightLogical,
2509 Some(2),
2510 w_r8,
2511 ),
2512 "41C1E802",
2513 "shrl $2, %r8d",
2514 ));
2515 insns.push((
2516 Inst::shift_r(
2517 OperandSize::Size32,
2518 ShiftKind::ShiftRightLogical,
2519 Some(31),
2520 w_r13,
2521 ),
2522 "41C1ED1F",
2523 "shrl $31, %r13d",
2524 ));
2525 insns.push((
2526 Inst::shift_r(
2527 OperandSize::Size64,
2528 ShiftKind::ShiftRightLogical,
2529 None,
2530 w_rdi,
2531 ),
2532 "48D3EF",
2533 "shrq %cl, %rdi",
2534 ));
2535 insns.push((
2536 Inst::shift_r(
2537 OperandSize::Size64,
2538 ShiftKind::ShiftRightLogical,
2539 Some(2),
2540 w_r8,
2541 ),
2542 "49C1E802",
2543 "shrq $2, %r8",
2544 ));
2545 insns.push((
2546 Inst::shift_r(
2547 OperandSize::Size64,
2548 ShiftKind::ShiftRightLogical,
2549 Some(63),
2550 w_r13,
2551 ),
2552 "49C1ED3F",
2553 "shrq $63, %r13",
2554 ));
2555 insns.push((
2556 Inst::shift_r(
2557 OperandSize::Size32,
2558 ShiftKind::ShiftRightArithmetic,
2559 None,
2560 w_rdi,
2561 ),
2562 "D3FF",
2563 "sarl %cl, %edi",
2564 ));
2565 insns.push((
2566 Inst::shift_r(
2567 OperandSize::Size32,
2568 ShiftKind::ShiftRightArithmetic,
2569 Some(2),
2570 w_r8,
2571 ),
2572 "41C1F802",
2573 "sarl $2, %r8d",
2574 ));
2575 insns.push((
2576 Inst::shift_r(
2577 OperandSize::Size32,
2578 ShiftKind::ShiftRightArithmetic,
2579 Some(31),
2580 w_r13,
2581 ),
2582 "41C1FD1F",
2583 "sarl $31, %r13d",
2584 ));
2585 insns.push((
2586 Inst::shift_r(
2587 OperandSize::Size64,
2588 ShiftKind::ShiftRightArithmetic,
2589 None,
2590 w_rdi,
2591 ),
2592 "48D3FF",
2593 "sarq %cl, %rdi",
2594 ));
2595 insns.push((
2596 Inst::shift_r(
2597 OperandSize::Size64,
2598 ShiftKind::ShiftRightArithmetic,
2599 Some(2),
2600 w_r8,
2601 ),
2602 "49C1F802",
2603 "sarq $2, %r8",
2604 ));
2605 insns.push((
2606 Inst::shift_r(
2607 OperandSize::Size64,
2608 ShiftKind::ShiftRightArithmetic,
2609 Some(63),
2610 w_r13,
2611 ),
2612 "49C1FD3F",
2613 "sarq $63, %r13",
2614 ));
2615 insns.push((
2616 Inst::shift_r(OperandSize::Size64, ShiftKind::RotateLeft, None, w_r8),
2617 "49D3C0",
2618 "rolq %cl, %r8",
2619 ));
2620 insns.push((
2621 Inst::shift_r(OperandSize::Size32, ShiftKind::RotateLeft, Some(3), w_r9),
2622 "41C1C103",
2623 "roll $3, %r9d",
2624 ));
2625 insns.push((
2626 Inst::shift_r(OperandSize::Size32, ShiftKind::RotateRight, None, w_rsi),
2627 "D3CE",
2628 "rorl %cl, %esi",
2629 ));
2630 insns.push((
2631 Inst::shift_r(OperandSize::Size64, ShiftKind::RotateRight, Some(5), w_r15),
2632 "49C1CF05",
2633 "rorq $5, %r15",
2634 ));
2635 insns.push((
2636 Inst::shift_r(OperandSize::Size8, ShiftKind::RotateRight, None, w_rsi),
2637 "40D2CE",
2638 "rorb %cl, %sil",
2639 ));
2640 insns.push((
2641 Inst::shift_r(OperandSize::Size8, ShiftKind::RotateRight, None, w_rax),
2642 "D2C8",
2643 "rorb %cl, %al",
2644 ));
2645 insns.push((
2646 Inst::shift_r(OperandSize::Size8, ShiftKind::RotateRight, Some(5), w_r15),
2647 "41C0CF05",
2648 "rorb $5, %r15b",
2649 ));
2650 insns.push((
2651 Inst::shift_r(OperandSize::Size16, ShiftKind::RotateRight, None, w_rsi),
2652 "66D3CE",
2653 "rorw %cl, %si",
2654 ));
2655 insns.push((
2656 Inst::shift_r(OperandSize::Size16, ShiftKind::RotateRight, Some(5), w_r15),
2657 "6641C1CF05",
2658 "rorw $5, %r15w",
2659 ));
2660
2661 // ========================================================
2662 // CmpRMIR
2663 insns.push((
2664 Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::reg(r15), rdx),
2665 "4C39FA",
2666 "cmpq %r15, %rdx",
2667 ));
2668 insns.push((
2669 Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::reg(rcx), r8),
2670 "4939C8",
2671 "cmpq %rcx, %r8",
2672 ));
2673 insns.push((
2674 Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::reg(rcx), rsi),
2675 "4839CE",
2676 "cmpq %rcx, %rsi",
2677 ));
2678 insns.push((
2679 Inst::cmp_rmi_r(
2680 OperandSize::Size64,
2681 RegMemImm::mem(Amode::imm_reg(99, rdi)),
2682 rdx,
2683 ),
2684 "483B5763",
2685 "cmpq 99(%rdi), %rdx",
2686 ));
2687 insns.push((
2688 Inst::cmp_rmi_r(
2689 OperandSize::Size64,
2690 RegMemImm::mem(Amode::imm_reg(99, rdi)),
2691 r8,
2692 ),
2693 "4C3B4763",
2694 "cmpq 99(%rdi), %r8",
2695 ));
2696 insns.push((
2697 Inst::cmp_rmi_r(
2698 OperandSize::Size64,
2699 RegMemImm::mem(Amode::imm_reg(99, rdi)),
2700 rsi,
2701 ),
2702 "483B7763",
2703 "cmpq 99(%rdi), %rsi",
2704 ));
2705 insns.push((
2706 Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::imm(76543210), rdx),
2707 "4881FAEAF48F04",
2708 "cmpq $76543210, %rdx",
2709 ));
2710 insns.push((
2711 Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::imm(-76543210i32 as u32), r8),
2712 "4981F8160B70FB",
2713 "cmpq $-76543210, %r8",
2714 ));
2715 insns.push((
2716 Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::imm(76543210), rsi),
2717 "4881FEEAF48F04",
2718 "cmpq $76543210, %rsi",
2719 ));
2720 //
2721 insns.push((
2722 Inst::cmp_rmi_r(OperandSize::Size32, RegMemImm::reg(r15), rdx),
2723 "4439FA",
2724 "cmpl %r15d, %edx",
2725 ));
2726 insns.push((
2727 Inst::cmp_rmi_r(OperandSize::Size32, RegMemImm::reg(rcx), r8),
2728 "4139C8",
2729 "cmpl %ecx, %r8d",
2730 ));
2731 insns.push((
2732 Inst::cmp_rmi_r(OperandSize::Size32, RegMemImm::reg(rcx), rsi),
2733 "39CE",
2734 "cmpl %ecx, %esi",
2735 ));
2736 insns.push((
2737 Inst::cmp_rmi_r(
2738 OperandSize::Size32,
2739 RegMemImm::mem(Amode::imm_reg(99, rdi)),
2740 rdx,
2741 ),
2742 "3B5763",
2743 "cmpl 99(%rdi), %edx",
2744 ));
2745 insns.push((
2746 Inst::cmp_rmi_r(
2747 OperandSize::Size32,
2748 RegMemImm::mem(Amode::imm_reg(99, rdi)),
2749 r8,
2750 ),
2751 "443B4763",
2752 "cmpl 99(%rdi), %r8d",
2753 ));
2754 insns.push((
2755 Inst::cmp_rmi_r(
2756 OperandSize::Size32,
2757 RegMemImm::mem(Amode::imm_reg(99, rdi)),
2758 rsi,
2759 ),
2760 "3B7763",
2761 "cmpl 99(%rdi), %esi",
2762 ));
2763 insns.push((
2764 Inst::cmp_rmi_r(OperandSize::Size32, RegMemImm::imm(76543210), rdx),
2765 "81FAEAF48F04",
2766 "cmpl $76543210, %edx",
2767 ));
2768 insns.push((
2769 Inst::cmp_rmi_r(OperandSize::Size32, RegMemImm::imm(-76543210i32 as u32), r8),
2770 "4181F8160B70FB",
2771 "cmpl $-76543210, %r8d",
2772 ));
2773 insns.push((
2774 Inst::cmp_rmi_r(OperandSize::Size32, RegMemImm::imm(76543210), rsi),
2775 "81FEEAF48F04",
2776 "cmpl $76543210, %esi",
2777 ));
2778 //
2779 insns.push((
2780 Inst::cmp_rmi_r(OperandSize::Size16, RegMemImm::reg(r15), rdx),
2781 "664439FA",
2782 "cmpw %r15w, %dx",
2783 ));
2784 insns.push((
2785 Inst::cmp_rmi_r(OperandSize::Size16, RegMemImm::reg(rcx), r8),
2786 "664139C8",
2787 "cmpw %cx, %r8w",
2788 ));
2789 insns.push((
2790 Inst::cmp_rmi_r(OperandSize::Size16, RegMemImm::reg(rcx), rsi),
2791 "6639CE",
2792 "cmpw %cx, %si",
2793 ));
2794 insns.push((
2795 Inst::cmp_rmi_r(
2796 OperandSize::Size16,
2797 RegMemImm::mem(Amode::imm_reg(99, rdi)),
2798 rdx,
2799 ),
2800 "663B5763",
2801 "cmpw 99(%rdi), %dx",
2802 ));
2803 insns.push((
2804 Inst::cmp_rmi_r(
2805 OperandSize::Size16,
2806 RegMemImm::mem(Amode::imm_reg(99, rdi)),
2807 r8,
2808 ),
2809 "66443B4763",
2810 "cmpw 99(%rdi), %r8w",
2811 ));
2812 insns.push((
2813 Inst::cmp_rmi_r(
2814 OperandSize::Size16,
2815 RegMemImm::mem(Amode::imm_reg(99, rdi)),
2816 rsi,
2817 ),
2818 "663B7763",
2819 "cmpw 99(%rdi), %si",
2820 ));
2821 insns.push((
2822 Inst::cmp_rmi_r(OperandSize::Size16, RegMemImm::imm(23210), rdx),
2823 "6681FAAA5A",
2824 "cmpw $23210, %dx",
2825 ));
2826 insns.push((
2827 Inst::cmp_rmi_r(OperandSize::Size16, RegMemImm::imm(-7654i32 as u32), r8),
2828 "664181F81AE2",
2829 "cmpw $-7654, %r8w",
2830 ));
2831 insns.push((
2832 Inst::cmp_rmi_r(OperandSize::Size16, RegMemImm::imm(7654), rsi),
2833 "6681FEE61D",
2834 "cmpw $7654, %si",
2835 ));
2836 //
2837 insns.push((
2838 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r15), rdx),
2839 "4438FA",
2840 "cmpb %r15b, %dl",
2841 ));
2842 insns.push((
2843 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), r8),
2844 "4138C8",
2845 "cmpb %cl, %r8b",
2846 ));
2847 insns.push((
2848 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), rsi),
2849 "4038CE",
2850 "cmpb %cl, %sil",
2851 ));
2852 insns.push((
2853 Inst::cmp_rmi_r(
2854 OperandSize::Size8,
2855 RegMemImm::mem(Amode::imm_reg(99, rdi)),
2856 rdx,
2857 ),
2858 "3A5763",
2859 "cmpb 99(%rdi), %dl",
2860 ));
2861 insns.push((
2862 Inst::cmp_rmi_r(
2863 OperandSize::Size8,
2864 RegMemImm::mem(Amode::imm_reg(99, rdi)),
2865 r8,
2866 ),
2867 "443A4763",
2868 "cmpb 99(%rdi), %r8b",
2869 ));
2870 insns.push((
2871 Inst::cmp_rmi_r(
2872 OperandSize::Size8,
2873 RegMemImm::mem(Amode::imm_reg(99, rdi)),
2874 rsi,
2875 ),
2876 "403A7763",
2877 "cmpb 99(%rdi), %sil",
2878 ));
2879 insns.push((
2880 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::imm(70), rdx),
2881 "80FA46",
2882 "cmpb $70, %dl",
2883 ));
2884 insns.push((
2885 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::imm(-76i32 as u32), r8),
2886 "4180F8B4",
2887 "cmpb $-76, %r8b",
2888 ));
2889 insns.push((
2890 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::imm(76), rsi),
2891 "4080FE4C",
2892 "cmpb $76, %sil",
2893 ));
2894 // Extra byte-cases (paranoia!) for cmp_rmi_r for first operand = R
2895 insns.push((
2896 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rax), rbx),
2897 "38C3",
2898 "cmpb %al, %bl",
2899 ));
2900 insns.push((
2901 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rbx), rax),
2902 "38D8",
2903 "cmpb %bl, %al",
2904 ));
2905 insns.push((
2906 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), rdx),
2907 "38CA",
2908 "cmpb %cl, %dl",
2909 ));
2910 insns.push((
2911 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), rsi),
2912 "4038CE",
2913 "cmpb %cl, %sil",
2914 ));
2915 insns.push((
2916 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), r10),
2917 "4138CA",
2918 "cmpb %cl, %r10b",
2919 ));
2920 insns.push((
2921 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), r14),
2922 "4138CE",
2923 "cmpb %cl, %r14b",
2924 ));
2925 insns.push((
2926 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rbp), rdx),
2927 "4038EA",
2928 "cmpb %bpl, %dl",
2929 ));
2930 insns.push((
2931 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rbp), rsi),
2932 "4038EE",
2933 "cmpb %bpl, %sil",
2934 ));
2935 insns.push((
2936 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rbp), r10),
2937 "4138EA",
2938 "cmpb %bpl, %r10b",
2939 ));
2940 insns.push((
2941 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rbp), r14),
2942 "4138EE",
2943 "cmpb %bpl, %r14b",
2944 ));
2945 insns.push((
2946 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r9), rdx),
2947 "4438CA",
2948 "cmpb %r9b, %dl",
2949 ));
2950 insns.push((
2951 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r9), rsi),
2952 "4438CE",
2953 "cmpb %r9b, %sil",
2954 ));
2955 insns.push((
2956 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r9), r10),
2957 "4538CA",
2958 "cmpb %r9b, %r10b",
2959 ));
2960 insns.push((
2961 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r9), r14),
2962 "4538CE",
2963 "cmpb %r9b, %r14b",
2964 ));
2965 insns.push((
2966 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r13), rdx),
2967 "4438EA",
2968 "cmpb %r13b, %dl",
2969 ));
2970 insns.push((
2971 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r13), rsi),
2972 "4438EE",
2973 "cmpb %r13b, %sil",
2974 ));
2975 insns.push((
2976 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r13), r10),
2977 "4538EA",
2978 "cmpb %r13b, %r10b",
2979 ));
2980 insns.push((
2981 Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r13), r14),
2982 "4538EE",
2983 "cmpb %r13b, %r14b",
2984 ));
2985
2986 // ========================================================
2987 // TestRmiR
2988 insns.push((
2989 Inst::test_rmi_r(OperandSize::Size64, RegMemImm::reg(r15), rdx),
2990 "4C85FA",
2991 "testq %r15, %rdx",
2992 ));
2993 insns.push((
2994 Inst::test_rmi_r(
2995 OperandSize::Size64,
2996 RegMemImm::mem(Amode::imm_reg(99, rdi)),
2997 rdx,
2998 ),
2999 "48855763",
3000 "testq 99(%rdi), %rdx",
3001 ));
3002 insns.push((
3003 Inst::test_rmi_r(OperandSize::Size64, RegMemImm::imm(127), rdx),
3004 "48F7C27F000000",
3005 "testq $127, %rdx",
3006 ));
3007 insns.push((
3008 Inst::test_rmi_r(OperandSize::Size64, RegMemImm::imm(76543210), rdx),
3009 "48F7C2EAF48F04",
3010 "testq $76543210, %rdx",
3011 ));
3012 //
3013 insns.push((
3014 Inst::test_rmi_r(OperandSize::Size32, RegMemImm::reg(r15), rdx),
3015 "4485FA",
3016 "testl %r15d, %edx",
3017 ));
3018 insns.push((
3019 Inst::test_rmi_r(
3020 OperandSize::Size32,
3021 RegMemImm::mem(Amode::imm_reg(99, rdi)),
3022 rdx,
3023 ),
3024 "855763",
3025 "testl 99(%rdi), %edx",
3026 ));
3027 insns.push((
3028 Inst::test_rmi_r(OperandSize::Size32, RegMemImm::imm(76543210), rdx),
3029 "F7C2EAF48F04",
3030 "testl $76543210, %edx",
3031 ));
3032 //
3033 insns.push((
3034 Inst::test_rmi_r(OperandSize::Size16, RegMemImm::reg(r15), rdx),
3035 "664485FA",
3036 "testw %r15w, %dx",
3037 ));
3038 insns.push((
3039 Inst::test_rmi_r(
3040 OperandSize::Size16,
3041 RegMemImm::mem(Amode::imm_reg(99, rdi)),
3042 rdx,
3043 ),
3044 "66855763",
3045 "testw 99(%rdi), %dx",
3046 ));
3047 insns.push((
3048 Inst::test_rmi_r(OperandSize::Size16, RegMemImm::imm(23210), rdx),
3049 "66F7C2AA5A",
3050 "testw $23210, %dx",
3051 ));
3052 //
3053 insns.push((
3054 Inst::test_rmi_r(OperandSize::Size8, RegMemImm::reg(r15), rdx),
3055 "4484FA",
3056 "testb %r15b, %dl",
3057 ));
3058 insns.push((
3059 Inst::test_rmi_r(
3060 OperandSize::Size8,
3061 RegMemImm::mem(Amode::imm_reg(99, rdi)),
3062 rdx,
3063 ),
3064 "845763",
3065 "testb 99(%rdi), %dl",
3066 ));
3067 insns.push((
3068 Inst::test_rmi_r(OperandSize::Size8, RegMemImm::imm(70), rdx),
3069 "F6C246",
3070 "testb $70, %dl",
3071 ));
3072 // Extra byte-cases (paranoia!) for test_rmi_r for first operand = R
3073 insns.push((
3074 Inst::test_rmi_r(OperandSize::Size8, RegMemImm::reg(rax), rbx),
3075 "84C3",
3076 "testb %al, %bl",
3077 ));
3078 insns.push((
3079 Inst::test_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), rsi),
3080 "4084CE",
3081 "testb %cl, %sil",
3082 ));
3083 insns.push((
3084 Inst::test_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), r10),
3085 "4184CA",
3086 "testb %cl, %r10b",
3087 ));
3088
3089 // ========================================================
3090 // SetCC
3091 insns.push((Inst::setcc(CC::O, w_rsi), "400F90C6", "seto %sil"));
3092 insns.push((Inst::setcc(CC::NLE, w_rsi), "400F9FC6", "setnle %sil"));
3093 insns.push((Inst::setcc(CC::Z, w_r14), "410F94C6", "setz %r14b"));
3094 insns.push((Inst::setcc(CC::LE, w_r14), "410F9EC6", "setle %r14b"));
3095 insns.push((Inst::setcc(CC::P, w_r9), "410F9AC1", "setp %r9b"));
3096 insns.push((Inst::setcc(CC::NP, w_r8), "410F9BC0", "setnp %r8b"));
3097 // ========================================================
3098 // Cmove
3099 insns.push((
3100 Inst::cmove(OperandSize::Size16, CC::O, RegMem::reg(rdi), w_rsi),
3101 "660F40F7",
3102 "cmovow %di, %si",
3103 ));
3104 insns.push((
3105 Inst::cmove(
3106 OperandSize::Size16,
3107 CC::NO,
3108 RegMem::mem(Amode::imm_reg_reg_shift(37, rdi, rsi, 2)),
3109 w_r15,
3110 ),
3111 "66440F417CB725",
3112 "cmovnow 37(%rdi,%rsi,4), %r15w",
3113 ));
3114 insns.push((
3115 Inst::cmove(OperandSize::Size32, CC::LE, RegMem::reg(rdi), w_rsi),
3116 "0F4EF7",
3117 "cmovlel %edi, %esi",
3118 ));
3119 insns.push((
3120 Inst::cmove(
3121 OperandSize::Size32,
3122 CC::NLE,
3123 RegMem::mem(Amode::imm_reg(0, r15)),
3124 w_rsi,
3125 ),
3126 "410F4F37",
3127 "cmovnlel 0(%r15), %esi",
3128 ));
3129 insns.push((
3130 Inst::cmove(OperandSize::Size64, CC::Z, RegMem::reg(rdi), w_r14),
3131 "4C0F44F7",
3132 "cmovzq %rdi, %r14",
3133 ));
3134 insns.push((
3135 Inst::cmove(
3136 OperandSize::Size64,
3137 CC::NZ,
3138 RegMem::mem(Amode::imm_reg(13, rdi)),
3139 w_r14,
3140 ),
3141 "4C0F45770D",
3142 "cmovnzq 13(%rdi), %r14",
3143 ));
3144
3145 // ========================================================
3146 // Push64
3147 insns.push((Inst::push64(RegMemImm::reg(rdi)), "57", "pushq %rdi"));
3148 insns.push((Inst::push64(RegMemImm::reg(r8)), "4150", "pushq %r8"));
3149 insns.push((
3150 Inst::push64(RegMemImm::mem(Amode::imm_reg_reg_shift(321, rsi, rcx, 3))),
3151 "FFB4CE41010000",
3152 "pushq 321(%rsi,%rcx,8)",
3153 ));
3154 insns.push((
3155 Inst::push64(RegMemImm::mem(Amode::imm_reg_reg_shift(321, r9, rbx, 2))),
3156 "41FFB49941010000",
3157 "pushq 321(%r9,%rbx,4)",
3158 ));
3159 insns.push((Inst::push64(RegMemImm::imm(0)), "6A00", "pushq $0"));
3160 insns.push((Inst::push64(RegMemImm::imm(127)), "6A7F", "pushq $127"));
3161 insns.push((
3162 Inst::push64(RegMemImm::imm(128)),
3163 "6880000000",
3164 "pushq $128",
3165 ));
3166 insns.push((
3167 Inst::push64(RegMemImm::imm(0x31415927)),
3168 "6827594131",
3169 "pushq $826366247",
3170 ));
3171 insns.push((
3172 Inst::push64(RegMemImm::imm(-128i32 as u32)),
3173 "6A80",
3174 "pushq $-128",
3175 ));
3176 insns.push((
3177 Inst::push64(RegMemImm::imm(-129i32 as u32)),
3178 "687FFFFFFF",
3179 "pushq $-129",
3180 ));
3181 insns.push((
3182 Inst::push64(RegMemImm::imm(-0x75c4e8a1i32 as u32)),
3183 "685F173B8A",
3184 "pushq $-1975838881",
3185 ));
3186
3187 // ========================================================
3188 // Pop64
3189 insns.push((Inst::pop64(w_rax), "58", "popq %rax"));
3190 insns.push((Inst::pop64(w_rdi), "5F", "popq %rdi"));
3191 insns.push((Inst::pop64(w_r8), "4158", "popq %r8"));
3192 insns.push((Inst::pop64(w_r15), "415F", "popq %r15"));
3193
3194 // ========================================================
3195 // CallKnown
3196 insns.push((
3197 Inst::call_known(
3198 ExternalName::User {
3199 namespace: 0,
3200 index: 0,
3201 },
3202 Vec::new(),
3203 Vec::new(),
3204 Opcode::Call,
3205 ),
3206 "E800000000",
3207 "call User { namespace: 0, index: 0 }",
3208 ));
3209
3210 // ========================================================
3211 // CallUnknown
3212 fn call_unknown(rm: RegMem) -> Inst {
3213 Inst::call_unknown(rm, Vec::new(), Vec::new(), Opcode::CallIndirect)
3214 }
3215
3216 insns.push((call_unknown(RegMem::reg(rbp)), "FFD5", "call *%rbp"));
3217 insns.push((call_unknown(RegMem::reg(r11)), "41FFD3", "call *%r11"));
3218 insns.push((
3219 call_unknown(RegMem::mem(Amode::imm_reg_reg_shift(321, rsi, rcx, 3))),
3220 "FF94CE41010000",
3221 "call *321(%rsi,%rcx,8)",
3222 ));
3223 insns.push((
3224 call_unknown(RegMem::mem(Amode::imm_reg_reg_shift(321, r10, rdx, 2))),
3225 "41FF949241010000",
3226 "call *321(%r10,%rdx,4)",
3227 ));
3228
3229 // ========================================================
3230 // LoadExtName
3231 // N.B.: test harness below sets is_pic.
3232 insns.push((
3233 Inst::LoadExtName {
3234 dst: Writable::from_reg(r11),
3235 name: Box::new(ExternalName::User {
3236 namespace: 0,
3237 index: 0,
3238 }),
3239 offset: 0,
3240 },
3241 "4C8B1D00000000",
3242 "load_ext_name u0:0+0, %r11",
3243 ));
3244 insns.push((
3245 Inst::LoadExtName {
3246 dst: Writable::from_reg(r11),
3247 name: Box::new(ExternalName::User {
3248 namespace: 0,
3249 index: 0,
3250 }),
3251 offset: 0x12345678,
3252 },
3253 "4C8B1D000000004981C378563412",
3254 "load_ext_name u0:0+305419896, %r11",
3255 ));
3256 insns.push((
3257 Inst::LoadExtName {
3258 dst: Writable::from_reg(r11),
3259 name: Box::new(ExternalName::User {
3260 namespace: 0,
3261 index: 0,
3262 }),
3263 offset: -0x12345678,
3264 },
3265 "4C8B1D000000004981EB78563412",
3266 "load_ext_name u0:0+-305419896, %r11",
3267 ));
3268
3269 // ========================================================
3270 // Ret
3271 insns.push((Inst::ret(), "C3", "ret"));
3272
3273 // ========================================================
3274 // JmpKnown skipped for now
3275
3276 // ========================================================
3277 // JmpCondSymm isn't a real instruction
3278
3279 // ========================================================
3280 // JmpCond skipped for now
3281
3282 // ========================================================
3283 // JmpCondCompound isn't a real instruction
3284
3285 // ========================================================
3286 // JmpUnknown
3287 insns.push((Inst::jmp_unknown(RegMem::reg(rbp)), "FFE5", "jmp *%rbp"));
3288 insns.push((
3289 Inst::jmp_unknown(RegMem::reg(r11)),
3290 "41FFE3",
3291 "jmp *%r11",
3292 ));
3293 insns.push((
3294 Inst::jmp_unknown(RegMem::mem(Amode::imm_reg_reg_shift(321, rsi, rcx, 3))),
3295 "FFA4CE41010000",
3296 "jmp *321(%rsi,%rcx,8)",
3297 ));
3298 insns.push((
3299 Inst::jmp_unknown(RegMem::mem(Amode::imm_reg_reg_shift(321, r10, rdx, 2))),
3300 "41FFA49241010000",
3301 "jmp *321(%r10,%rdx,4)",
3302 ));
3303
3304 // ========================================================
3305 // XMM_CMP_RM_R
3306
3307 insns.push((
3308 Inst::xmm_cmp_rm_r(SseOpcode::Ucomiss, RegMem::reg(xmm1), xmm2),
3309 "0F2ED1",
3310 "ucomiss %xmm1, %xmm2",
3311 ));
3312
3313 insns.push((
3314 Inst::xmm_cmp_rm_r(SseOpcode::Ucomiss, RegMem::reg(xmm0), xmm9),
3315 "440F2EC8",
3316 "ucomiss %xmm0, %xmm9",
3317 ));
3318
3319 insns.push((
3320 Inst::xmm_cmp_rm_r(SseOpcode::Ucomisd, RegMem::reg(xmm13), xmm4),
3321 "66410F2EE5",
3322 "ucomisd %xmm13, %xmm4",
3323 ));
3324
3325 insns.push((
3326 Inst::xmm_cmp_rm_r(SseOpcode::Ucomisd, RegMem::reg(xmm11), xmm12),
3327 "66450F2EE3",
3328 "ucomisd %xmm11, %xmm12",
3329 ));
3330
3331 // ========================================================
3332 // XMM_RM_R: float binary ops
3333
3334 insns.push((
3335 Inst::xmm_rm_r(SseOpcode::Addss, RegMem::reg(xmm1), w_xmm0),
3336 "F30F58C1",
3337 "addss %xmm1, %xmm0",
3338 ));
3339 insns.push((
3340 Inst::xmm_rm_r(SseOpcode::Addss, RegMem::reg(xmm11), w_xmm13),
3341 "F3450F58EB",
3342 "addss %xmm11, %xmm13",
3343 ));
3344 insns.push((
3345 Inst::xmm_rm_r(
3346 SseOpcode::Addss,
3347 RegMem::mem(Amode::imm_reg_reg_shift(123, r10, rdx, 2)),
3348 w_xmm0,
3349 ),
3350 "F3410F5844927B",
3351 "addss 123(%r10,%rdx,4), %xmm0",
3352 ));
3353 insns.push((
3354 Inst::xmm_rm_r(SseOpcode::Addsd, RegMem::reg(xmm15), w_xmm4),
3355 "F2410F58E7",
3356 "addsd %xmm15, %xmm4",
3357 ));
3358
3359 insns.push((
3360 Inst::xmm_rm_r(SseOpcode::Subss, RegMem::reg(xmm0), w_xmm1),
3361 "F30F5CC8",
3362 "subss %xmm0, %xmm1",
3363 ));
3364 insns.push((
3365 Inst::xmm_rm_r(SseOpcode::Subss, RegMem::reg(xmm12), w_xmm1),
3366 "F3410F5CCC",
3367 "subss %xmm12, %xmm1",
3368 ));
3369 insns.push((
3370 Inst::xmm_rm_r(
3371 SseOpcode::Subss,
3372 RegMem::mem(Amode::imm_reg_reg_shift(321, r10, rax, 3)),
3373 w_xmm10,
3374 ),
3375 "F3450F5C94C241010000",
3376 "subss 321(%r10,%rax,8), %xmm10",
3377 ));
3378 insns.push((
3379 Inst::xmm_rm_r(SseOpcode::Subsd, RegMem::reg(xmm5), w_xmm14),
3380 "F2440F5CF5",
3381 "subsd %xmm5, %xmm14",
3382 ));
3383
3384 insns.push((
3385 Inst::xmm_rm_r(SseOpcode::Mulss, RegMem::reg(xmm5), w_xmm4),
3386 "F30F59E5",
3387 "mulss %xmm5, %xmm4",
3388 ));
3389 insns.push((
3390 Inst::xmm_rm_r(SseOpcode::Mulsd, RegMem::reg(xmm5), w_xmm4),
3391 "F20F59E5",
3392 "mulsd %xmm5, %xmm4",
3393 ));
3394
3395 insns.push((
3396 Inst::xmm_rm_r(SseOpcode::Divss, RegMem::reg(xmm8), w_xmm7),
3397 "F3410F5EF8",
3398 "divss %xmm8, %xmm7",
3399 ));
3400 insns.push((
3401 Inst::xmm_rm_r(SseOpcode::Divsd, RegMem::reg(xmm5), w_xmm4),
3402 "F20F5EE5",
3403 "divsd %xmm5, %xmm4",
3404 ));
3405
3406 insns.push((
3407 Inst::xmm_rm_r(SseOpcode::Andps, RegMem::reg(xmm3), w_xmm12),
3408 "440F54E3",
3409 "andps %xmm3, %xmm12",
3410 ));
3411
3412 insns.push((
3413 Inst::xmm_rm_r(SseOpcode::Andnps, RegMem::reg(xmm4), w_xmm11),
3414 "440F55DC",
3415 "andnps %xmm4, %xmm11",
3416 ));
3417
3418 insns.push((
3419 Inst::xmm_rm_r(SseOpcode::Orps, RegMem::reg(xmm1), w_xmm15),
3420 "440F56F9",
3421 "orps %xmm1, %xmm15",
3422 ));
3423 insns.push((
3424 Inst::xmm_rm_r(SseOpcode::Orps, RegMem::reg(xmm5), w_xmm4),
3425 "0F56E5",
3426 "orps %xmm5, %xmm4",
3427 ));
3428
3429 insns.push((
3430 Inst::xmm_rm_r(SseOpcode::Blendvpd, RegMem::reg(xmm15), w_xmm4),
3431 "66410F3815E7",
3432 "blendvpd %xmm15, %xmm4",
3433 ));
3434
3435 insns.push((
3436 Inst::xmm_rm_r(SseOpcode::Blendvps, RegMem::reg(xmm2), w_xmm3),
3437 "660F3814DA",
3438 "blendvps %xmm2, %xmm3",
3439 ));
3440
3441 insns.push((
3442 Inst::xmm_rm_r(SseOpcode::Pblendvb, RegMem::reg(xmm12), w_xmm13),
3443 "66450F3810EC",
3444 "pblendvb %xmm12, %xmm13",
3445 ));
3446
3447 // ========================================================
3448 // XMM_RM_R: Integer Packed
3449
3450 insns.push((
3451 Inst::xmm_rm_r(SseOpcode::Paddb, RegMem::reg(xmm9), w_xmm5),
3452 "66410FFCE9",
3453 "paddb %xmm9, %xmm5",
3454 ));
3455
3456 insns.push((
3457 Inst::xmm_rm_r(SseOpcode::Paddw, RegMem::reg(xmm7), w_xmm6),
3458 "660FFDF7",
3459 "paddw %xmm7, %xmm6",
3460 ));
3461
3462 insns.push((
3463 Inst::xmm_rm_r(SseOpcode::Paddd, RegMem::reg(xmm12), w_xmm13),
3464 "66450FFEEC",
3465 "paddd %xmm12, %xmm13",
3466 ));
3467
3468 insns.push((
3469 Inst::xmm_rm_r(SseOpcode::Paddq, RegMem::reg(xmm1), w_xmm8),
3470 "66440FD4C1",
3471 "paddq %xmm1, %xmm8",
3472 ));
3473
3474 insns.push((
3475 Inst::xmm_rm_r(SseOpcode::Paddsb, RegMem::reg(xmm9), w_xmm5),
3476 "66410FECE9",
3477 "paddsb %xmm9, %xmm5",
3478 ));
3479
3480 insns.push((
3481 Inst::xmm_rm_r(SseOpcode::Paddsw, RegMem::reg(xmm7), w_xmm6),
3482 "660FEDF7",
3483 "paddsw %xmm7, %xmm6",
3484 ));
3485
3486 insns.push((
3487 Inst::xmm_rm_r(SseOpcode::Paddusb, RegMem::reg(xmm12), w_xmm13),
3488 "66450FDCEC",
3489 "paddusb %xmm12, %xmm13",
3490 ));
3491
3492 insns.push((
3493 Inst::xmm_rm_r(SseOpcode::Paddusw, RegMem::reg(xmm1), w_xmm8),
3494 "66440FDDC1",
3495 "paddusw %xmm1, %xmm8",
3496 ));
3497
3498 insns.push((
3499 Inst::xmm_rm_r(SseOpcode::Psubsb, RegMem::reg(xmm9), w_xmm5),
3500 "66410FE8E9",
3501 "psubsb %xmm9, %xmm5",
3502 ));
3503
3504 insns.push((
3505 Inst::xmm_rm_r(SseOpcode::Psubsw, RegMem::reg(xmm7), w_xmm6),
3506 "660FE9F7",
3507 "psubsw %xmm7, %xmm6",
3508 ));
3509
3510 insns.push((
3511 Inst::xmm_rm_r(SseOpcode::Psubusb, RegMem::reg(xmm12), w_xmm13),
3512 "66450FD8EC",
3513 "psubusb %xmm12, %xmm13",
3514 ));
3515
3516 insns.push((
3517 Inst::xmm_rm_r(SseOpcode::Psubusw, RegMem::reg(xmm1), w_xmm8),
3518 "66440FD9C1",
3519 "psubusw %xmm1, %xmm8",
3520 ));
3521
3522 insns.push((
3523 Inst::xmm_rm_r(SseOpcode::Pavgb, RegMem::reg(xmm12), w_xmm13),
3524 "66450FE0EC",
3525 "pavgb %xmm12, %xmm13",
3526 ));
3527
3528 insns.push((
3529 Inst::xmm_rm_r(SseOpcode::Pavgw, RegMem::reg(xmm1), w_xmm8),
3530 "66440FE3C1",
3531 "pavgw %xmm1, %xmm8",
3532 ));
3533
3534 insns.push((
3535 Inst::xmm_rm_r(SseOpcode::Psubb, RegMem::reg(xmm5), w_xmm9),
3536 "66440FF8CD",
3537 "psubb %xmm5, %xmm9",
3538 ));
3539
3540 insns.push((
3541 Inst::xmm_rm_r(SseOpcode::Psubw, RegMem::reg(xmm6), w_xmm7),
3542 "660FF9FE",
3543 "psubw %xmm6, %xmm7",
3544 ));
3545
3546 insns.push((
3547 Inst::xmm_rm_r(SseOpcode::Psubd, RegMem::reg(xmm13), w_xmm12),
3548 "66450FFAE5",
3549 "psubd %xmm13, %xmm12",
3550 ));
3551
3552 insns.push((
3553 Inst::xmm_rm_r(SseOpcode::Psubq, RegMem::reg(xmm8), w_xmm1),
3554 "66410FFBC8",
3555 "psubq %xmm8, %xmm1",
3556 ));
3557
3558 insns.push((
3559 Inst::xmm_rm_r(SseOpcode::Pmuldq, RegMem::reg(xmm4), w_xmm15),
3560 "66440F3828FC",
3561 "pmuldq %xmm4, %xmm15",
3562 ));
3563
3564 insns.push((
3565 Inst::xmm_rm_r(SseOpcode::Pmulhw, RegMem::reg(xmm9), w_xmm1),
3566 "66410FE5C9",
3567 "pmulhw %xmm9, %xmm1",
3568 ));
3569
3570 insns.push((
3571 Inst::xmm_rm_r(SseOpcode::Pmulhuw, RegMem::reg(xmm7), w_xmm9),
3572 "66440FE4CF",
3573 "pmulhuw %xmm7, %xmm9",
3574 ));
3575
3576 insns.push((
3577 Inst::xmm_rm_r(SseOpcode::Pmulld, RegMem::reg(xmm15), w_xmm6),
3578 "66410F3840F7",
3579 "pmulld %xmm15, %xmm6",
3580 ));
3581
3582 insns.push((
3583 Inst::xmm_rm_r(SseOpcode::Pmullw, RegMem::reg(xmm14), w_xmm1),
3584 "66410FD5CE",
3585 "pmullw %xmm14, %xmm1",
3586 ));
3587
3588 insns.push((
3589 Inst::xmm_rm_r_evex(Avx512Opcode::Vpmullq, RegMem::reg(xmm14), xmm10, w_xmm1),
3590 "62D2AD0840CE",
3591 "vpmullq %xmm14, %xmm10, %xmm1",
3592 ));
3593
3594 insns.push((
3595 Inst::xmm_rm_r_evex(Avx512Opcode::Vpermi2b, RegMem::reg(xmm14), xmm10, w_xmm1),
3596 "62D22D0875CE",
3597 "vpermi2b %xmm14, %xmm10, %xmm1",
3598 ));
3599
3600 insns.push((
3601 Inst::xmm_rm_r_evex(Avx512Opcode::Vpermi2b, RegMem::reg(xmm1), xmm0, w_xmm2),
3602 "62F27D0875D1",
3603 "vpermi2b %xmm1, %xmm0, %xmm2",
3604 ));
3605
3606 insns.push((
3607 Inst::xmm_rm_r(SseOpcode::Pmuludq, RegMem::reg(xmm8), w_xmm9),
3608 "66450FF4C8",
3609 "pmuludq %xmm8, %xmm9",
3610 ));
3611
3612 insns.push((
3613 Inst::xmm_rm_r(SseOpcode::Pmaddwd, RegMem::reg(xmm8), w_xmm1),
3614 "66410FF5C8",
3615 "pmaddwd %xmm8, %xmm1",
3616 ));
3617
3618 insns.push((
3619 Inst::xmm_rm_r(SseOpcode::Pmaxsb, RegMem::reg(xmm15), w_xmm6),
3620 "66410F383CF7",
3621 "pmaxsb %xmm15, %xmm6",
3622 ));
3623
3624 insns.push((
3625 Inst::xmm_rm_r(SseOpcode::Pmaxsw, RegMem::reg(xmm15), w_xmm6),
3626 "66410FEEF7",
3627 "pmaxsw %xmm15, %xmm6",
3628 ));
3629
3630 insns.push((
3631 Inst::xmm_rm_r(SseOpcode::Pmaxsd, RegMem::reg(xmm15), w_xmm6),
3632 "66410F383DF7",
3633 "pmaxsd %xmm15, %xmm6",
3634 ));
3635
3636 insns.push((
3637 Inst::xmm_rm_r(SseOpcode::Pmaxub, RegMem::reg(xmm14), w_xmm1),
3638 "66410FDECE",
3639 "pmaxub %xmm14, %xmm1",
3640 ));
3641
3642 insns.push((
3643 Inst::xmm_rm_r(SseOpcode::Pmaxuw, RegMem::reg(xmm14), w_xmm1),
3644 "66410F383ECE",
3645 "pmaxuw %xmm14, %xmm1",
3646 ));
3647
3648 insns.push((
3649 Inst::xmm_rm_r(SseOpcode::Pmaxud, RegMem::reg(xmm14), w_xmm1),
3650 "66410F383FCE",
3651 "pmaxud %xmm14, %xmm1",
3652 ));
3653
3654 insns.push((
3655 Inst::xmm_rm_r(SseOpcode::Pminsb, RegMem::reg(xmm8), w_xmm9),
3656 "66450F3838C8",
3657 "pminsb %xmm8, %xmm9",
3658 ));
3659
3660 insns.push((
3661 Inst::xmm_rm_r(SseOpcode::Pminsw, RegMem::reg(xmm8), w_xmm9),
3662 "66450FEAC8",
3663 "pminsw %xmm8, %xmm9",
3664 ));
3665
3666 insns.push((
3667 Inst::xmm_rm_r(SseOpcode::Pminsd, RegMem::reg(xmm8), w_xmm9),
3668 "66450F3839C8",
3669 "pminsd %xmm8, %xmm9",
3670 ));
3671
3672 insns.push((
3673 Inst::xmm_rm_r(SseOpcode::Pminub, RegMem::reg(xmm3), w_xmm2),
3674 "660FDAD3",
3675 "pminub %xmm3, %xmm2",
3676 ));
3677
3678 insns.push((
3679 Inst::xmm_rm_r(SseOpcode::Pminuw, RegMem::reg(xmm3), w_xmm2),
3680 "660F383AD3",
3681 "pminuw %xmm3, %xmm2",
3682 ));
3683
3684 insns.push((
3685 Inst::xmm_rm_r(SseOpcode::Pminud, RegMem::reg(xmm3), w_xmm2),
3686 "660F383BD3",
3687 "pminud %xmm3, %xmm2",
3688 ));
3689
3690 insns.push((
3691 Inst::xmm_rm_r(SseOpcode::Pxor, RegMem::reg(xmm11), w_xmm2),
3692 "66410FEFD3",
3693 "pxor %xmm11, %xmm2",
3694 ));
3695
3696 insns.push((
3697 Inst::xmm_rm_r(SseOpcode::Pshufb, RegMem::reg(xmm11), w_xmm2),
3698 "66410F3800D3",
3699 "pshufb %xmm11, %xmm2",
3700 ));
3701
3702 insns.push((
3703 Inst::xmm_rm_r(SseOpcode::Packssdw, RegMem::reg(xmm11), w_xmm12),
3704 "66450F6BE3",
3705 "packssdw %xmm11, %xmm12",
3706 ));
3707
3708 insns.push((
3709 Inst::xmm_rm_r(SseOpcode::Packsswb, RegMem::reg(xmm11), w_xmm2),
3710 "66410F63D3",
3711 "packsswb %xmm11, %xmm2",
3712 ));
3713
3714 insns.push((
3715 Inst::xmm_rm_r(SseOpcode::Packusdw, RegMem::reg(xmm13), w_xmm6),
3716 "66410F382BF5",
3717 "packusdw %xmm13, %xmm6",
3718 ));
3719
3720 insns.push((
3721 Inst::xmm_rm_r(SseOpcode::Packuswb, RegMem::reg(xmm9), w_xmm4),
3722 "66410F67E1",
3723 "packuswb %xmm9, %xmm4",
3724 ));
3725
3726 insns.push((
3727 Inst::xmm_rm_r(SseOpcode::Punpckhbw, RegMem::reg(xmm3), w_xmm2),
3728 "660F68D3",
3729 "punpckhbw %xmm3, %xmm2",
3730 ));
3731
3732 insns.push((
3733 Inst::xmm_rm_r(SseOpcode::Punpckhwd, RegMem::reg(xmm13), w_xmm2),
3734 "66410F69D5",
3735 "punpckhwd %xmm13, %xmm2",
3736 ));
3737
3738 insns.push((
3739 Inst::xmm_rm_r(SseOpcode::Punpcklbw, RegMem::reg(xmm1), w_xmm8),
3740 "66440F60C1",
3741 "punpcklbw %xmm1, %xmm8",
3742 ));
3743
3744 insns.push((
3745 Inst::xmm_rm_r(SseOpcode::Punpcklwd, RegMem::reg(xmm11), w_xmm8),
3746 "66450F61C3",
3747 "punpcklwd %xmm11, %xmm8",
3748 ));
3749
3750 insns.push((
3751 Inst::xmm_rm_r(SseOpcode::Unpcklps, RegMem::reg(xmm11), w_xmm2),
3752 "410F14D3",
3753 "unpcklps %xmm11, %xmm2",
3754 ));
3755
3756 // ========================================================
3757 // XMM_RM_R: Integer Conversion
3758 insns.push((
3759 Inst::xmm_rm_r(SseOpcode::Cvtdq2ps, RegMem::reg(xmm1), w_xmm8),
3760 "440F5BC1",
3761 "cvtdq2ps %xmm1, %xmm8",
3762 ));
3763
3764 insns.push((
3765 Inst::xmm_rm_r(SseOpcode::Cvttpd2dq, RegMem::reg(xmm15), w_xmm7),
3766 "66410FE6FF",
3767 "cvttpd2dq %xmm15, %xmm7",
3768 ));
3769
3770 insns.push((
3771 Inst::xmm_rm_r(SseOpcode::Cvttps2dq, RegMem::reg(xmm9), w_xmm8),
3772 "F3450F5BC1",
3773 "cvttps2dq %xmm9, %xmm8",
3774 ));
3775
3776 // XMM_Mov_R_M: float stores
3777 insns.push((
3778 Inst::xmm_mov_r_m(SseOpcode::Movss, xmm15, Amode::imm_reg(128, r12)),
3779 "F3450F11BC2480000000",
3780 "movss %xmm15, 128(%r12)",
3781 ));
3782 insns.push((
3783 Inst::xmm_mov_r_m(SseOpcode::Movsd, xmm1, Amode::imm_reg(0, rsi)),
3784 "F20F110E",
3785 "movsd %xmm1, 0(%rsi)",
3786 ));
3787
3788 // ========================================================
3789 // XMM_MOV: Packed Move
3790
3791 insns.push((
3792 Inst::xmm_mov(SseOpcode::Pmovsxbd, RegMem::reg(xmm6), w_xmm8),
3793 "66440F3821C6",
3794 "pmovsxbd %xmm6, %xmm8",
3795 ));
3796
3797 insns.push((
3798 Inst::xmm_mov(SseOpcode::Pmovsxbw, RegMem::reg(xmm9), w_xmm10),
3799 "66450F3820D1",
3800 "pmovsxbw %xmm9, %xmm10",
3801 ));
3802
3803 insns.push((
3804 Inst::xmm_mov(SseOpcode::Pmovsxbq, RegMem::reg(xmm1), w_xmm1),
3805 "660F3822C9",
3806 "pmovsxbq %xmm1, %xmm1",
3807 ));
3808
3809 insns.push((
3810 Inst::xmm_mov(SseOpcode::Pmovsxwd, RegMem::reg(xmm13), w_xmm10),
3811 "66450F3823D5",
3812 "pmovsxwd %xmm13, %xmm10",
3813 ));
3814
3815 insns.push((
3816 Inst::xmm_mov(SseOpcode::Pmovsxwq, RegMem::reg(xmm12), w_xmm12),
3817 "66450F3824E4",
3818 "pmovsxwq %xmm12, %xmm12",
3819 ));
3820
3821 insns.push((
3822 Inst::xmm_mov(SseOpcode::Pmovsxdq, RegMem::reg(xmm10), w_xmm8),
3823 "66450F3825C2",
3824 "pmovsxdq %xmm10, %xmm8",
3825 ));
3826
3827 insns.push((
3828 Inst::xmm_mov(SseOpcode::Pmovzxbd, RegMem::reg(xmm5), w_xmm6),
3829 "660F3831F5",
3830 "pmovzxbd %xmm5, %xmm6",
3831 ));
3832
3833 insns.push((
3834 Inst::xmm_mov(SseOpcode::Pmovzxbw, RegMem::reg(xmm5), w_xmm13),
3835 "66440F3830ED",
3836 "pmovzxbw %xmm5, %xmm13",
3837 ));
3838
3839 insns.push((
3840 Inst::xmm_mov(SseOpcode::Pmovzxbq, RegMem::reg(xmm10), w_xmm11),
3841 "66450F3832DA",
3842 "pmovzxbq %xmm10, %xmm11",
3843 ));
3844
3845 insns.push((
3846 Inst::xmm_mov(SseOpcode::Pmovzxwd, RegMem::reg(xmm2), w_xmm10),
3847 "66440F3833D2",
3848 "pmovzxwd %xmm2, %xmm10",
3849 ));
3850
3851 insns.push((
3852 Inst::xmm_mov(SseOpcode::Pmovzxwq, RegMem::reg(xmm7), w_xmm4),
3853 "660F3834E7",
3854 "pmovzxwq %xmm7, %xmm4",
3855 ));
3856
3857 insns.push((
3858 Inst::xmm_mov(SseOpcode::Pmovzxdq, RegMem::reg(xmm3), w_xmm4),
3859 "660F3835E3",
3860 "pmovzxdq %xmm3, %xmm4",
3861 ));
3862
3863 // XmmUnary: moves and unary float ops
3864 insns.push((
3865 Inst::xmm_unary_rm_r(SseOpcode::Movss, RegMem::reg(xmm13), w_xmm2),
3866 "F3410F10D5",
3867 "movss %xmm13, %xmm2",
3868 ));
3869
3870 insns.push((
3871 Inst::xmm_unary_rm_r(SseOpcode::Movsd, RegMem::reg(xmm0), w_xmm1),
3872 "F20F10C8",
3873 "movsd %xmm0, %xmm1",
3874 ));
3875 insns.push((
3876 Inst::xmm_unary_rm_r(
3877 SseOpcode::Movsd,
3878 RegMem::mem(Amode::imm_reg(0, rsi)),
3879 w_xmm2,
3880 ),
3881 "F20F1016",
3882 "movsd 0(%rsi), %xmm2",
3883 ));
3884 insns.push((
3885 Inst::xmm_unary_rm_r(SseOpcode::Movsd, RegMem::reg(xmm14), w_xmm3),
3886 "F2410F10DE",
3887 "movsd %xmm14, %xmm3",
3888 ));
3889
3890 insns.push((
3891 Inst::xmm_unary_rm_r(SseOpcode::Movaps, RegMem::reg(xmm5), w_xmm14),
3892 "440F28F5",
3893 "movaps %xmm5, %xmm14",
3894 ));
3895
3896 insns.push((
3897 Inst::xmm_unary_rm_r(SseOpcode::Sqrtss, RegMem::reg(xmm7), w_xmm8),
3898 "F3440F51C7",
3899 "sqrtss %xmm7, %xmm8",
3900 ));
3901 insns.push((
3902 Inst::xmm_unary_rm_r(SseOpcode::Sqrtsd, RegMem::reg(xmm1), w_xmm2),
3903 "F20F51D1",
3904 "sqrtsd %xmm1, %xmm2",
3905 ));
3906
3907 insns.push((
3908 Inst::xmm_unary_rm_r(SseOpcode::Cvtss2sd, RegMem::reg(xmm0), w_xmm1),
3909 "F30F5AC8",
3910 "cvtss2sd %xmm0, %xmm1",
3911 ));
3912 insns.push((
3913 Inst::xmm_unary_rm_r(SseOpcode::Cvtsd2ss, RegMem::reg(xmm1), w_xmm0),
3914 "F20F5AC1",
3915 "cvtsd2ss %xmm1, %xmm0",
3916 ));
3917
3918 insns.push((
3919 Inst::xmm_unary_rm_r(SseOpcode::Pabsb, RegMem::reg(xmm2), w_xmm1),
3920 "660F381CCA",
3921 "pabsb %xmm2, %xmm1",
3922 ));
3923 insns.push((
3924 Inst::xmm_unary_rm_r(SseOpcode::Pabsw, RegMem::reg(xmm0), w_xmm0),
3925 "660F381DC0",
3926 "pabsw %xmm0, %xmm0",
3927 ));
3928 insns.push((
3929 Inst::xmm_unary_rm_r(SseOpcode::Pabsd, RegMem::reg(xmm10), w_xmm11),
3930 "66450F381EDA",
3931 "pabsd %xmm10, %xmm11",
3932 ));
3933
3934 insns.push((
3935 Inst::xmm_unary_rm_r(SseOpcode::Cvtdq2pd, RegMem::reg(xmm2), w_xmm8),
3936 "F3440FE6C2",
3937 "cvtdq2pd %xmm2, %xmm8",
3938 ));
3939
3940 insns.push((
3941 Inst::xmm_unary_rm_r_evex(Avx512Opcode::Vpabsq, RegMem::reg(xmm2), w_xmm8),
3942 "6272FD081FC2",
3943 "vpabsq %xmm2, %xmm8",
3944 ));
3945
3946 insns.push((
3947 Inst::xmm_unary_rm_r_evex(Avx512Opcode::Vcvtudq2ps, RegMem::reg(xmm2), w_xmm8),
3948 "62717F087AC2",
3949 "vcvtudq2ps %xmm2, %xmm8",
3950 ));
3951
3952 insns.push((
3953 Inst::xmm_unary_rm_r_evex(Avx512Opcode::Vpopcntb, RegMem::reg(xmm2), w_xmm8),
3954 "62727D0854C2",
3955 "vpopcntb %xmm2, %xmm8",
3956 ));
3957
3958 insns.push((
3959 Inst::xmm_unary_rm_r(SseOpcode::Cvtpd2ps, RegMem::reg(xmm7), w_xmm7),
3960 "660F5AFF",
3961 "cvtpd2ps %xmm7, %xmm7",
3962 ));
3963
3964 insns.push((
3965 Inst::xmm_unary_rm_r(SseOpcode::Cvtps2pd, RegMem::reg(xmm11), w_xmm9),
3966 "450F5ACB",
3967 "cvtps2pd %xmm11, %xmm9",
3968 ));
3969
3970 // Xmm to int conversions, and conversely.
3971
3972 insns.push((
3973 Inst::xmm_to_gpr(SseOpcode::Movd, xmm0, w_rsi, OperandSize::Size32),
3974 "660F7EC6",
3975 "movd %xmm0, %esi",
3976 ));
3977 insns.push((
3978 Inst::xmm_to_gpr(SseOpcode::Movq, xmm2, w_rdi, OperandSize::Size64),
3979 "66480F7ED7",
3980 "movq %xmm2, %rdi",
3981 ));
3982 insns.push((
3983 Inst::xmm_to_gpr(SseOpcode::Cvttss2si, xmm0, w_rsi, OperandSize::Size32),
3984 "F30F2CF0",
3985 "cvttss2si %xmm0, %esi",
3986 ));
3987 insns.push((
3988 Inst::xmm_to_gpr(SseOpcode::Cvttss2si, xmm0, w_rdi, OperandSize::Size64),
3989 "F3480F2CF8",
3990 "cvttss2si %xmm0, %rdi",
3991 ));
3992 insns.push((
3993 Inst::xmm_to_gpr(SseOpcode::Cvttsd2si, xmm0, w_rax, OperandSize::Size32),
3994 "F20F2CC0",
3995 "cvttsd2si %xmm0, %eax",
3996 ));
3997 insns.push((
3998 Inst::xmm_to_gpr(SseOpcode::Cvttsd2si, xmm0, w_r15, OperandSize::Size64),
3999 "F24C0F2CF8",
4000 "cvttsd2si %xmm0, %r15",
4001 ));
4002
4003 insns.push((
4004 Inst::xmm_to_gpr(SseOpcode::Pmovmskb, xmm10, w_rax, OperandSize::Size32),
4005 "66410FD7C2",
4006 "pmovmskb %xmm10, %eax",
4007 ));
4008 insns.push((
4009 Inst::xmm_to_gpr(SseOpcode::Movmskps, xmm2, w_rax, OperandSize::Size32),
4010 "0F50C2",
4011 "movmskps %xmm2, %eax",
4012 ));
4013 insns.push((
4014 Inst::xmm_to_gpr(SseOpcode::Movmskpd, xmm0, w_rcx, OperandSize::Size32),
4015 "660F50C8",
4016 "movmskpd %xmm0, %ecx",
4017 ));
4018
4019 insns.push((
4020 Inst::gpr_to_xmm(
4021 SseOpcode::Movd,
4022 RegMem::reg(rax),
4023 OperandSize::Size32,
4024 w_xmm15,
4025 ),
4026 "66440F6EF8",
4027 "movd %eax, %xmm15",
4028 ));
4029 insns.push((
4030 Inst::gpr_to_xmm(
4031 SseOpcode::Movd,
4032 RegMem::mem(Amode::imm_reg(2, r10)),
4033 OperandSize::Size32,
4034 w_xmm9,
4035 ),
4036 "66450F6E4A02",
4037 "movd 2(%r10), %xmm9",
4038 ));
4039 insns.push((
4040 Inst::gpr_to_xmm(
4041 SseOpcode::Movd,
4042 RegMem::reg(rsi),
4043 OperandSize::Size32,
4044 w_xmm1,
4045 ),
4046 "660F6ECE",
4047 "movd %esi, %xmm1",
4048 ));
4049 insns.push((
4050 Inst::gpr_to_xmm(
4051 SseOpcode::Movq,
4052 RegMem::reg(rdi),
4053 OperandSize::Size64,
4054 w_xmm15,
4055 ),
4056 "664C0F6EFF",
4057 "movq %rdi, %xmm15",
4058 ));
4059 insns.push((
4060 Inst::gpr_to_xmm(
4061 SseOpcode::Cvtsi2ss,
4062 RegMem::reg(rdi),
4063 OperandSize::Size32,
4064 w_xmm15,
4065 ),
4066 "F3440F2AFF",
4067 "cvtsi2ss %edi, %xmm15",
4068 ));
4069 insns.push((
4070 Inst::gpr_to_xmm(
4071 SseOpcode::Cvtsi2sd,
4072 RegMem::reg(rsi),
4073 OperandSize::Size64,
4074 w_xmm1,
4075 ),
4076 "F2480F2ACE",
4077 "cvtsi2sd %rsi, %xmm1",
4078 ));
4079
4080 // ========================================================
4081 // XmmRmi
4082 insns.push((
4083 Inst::xmm_rmi_reg(SseOpcode::Psraw, RegMemImm::reg(xmm10), w_xmm1),
4084 "66410FE1CA",
4085 "psraw %xmm10, %xmm1",
4086 ));
4087 insns.push((
4088 Inst::xmm_rmi_reg(SseOpcode::Pslld, RegMemImm::imm(31), w_xmm1),
4089 "660F72F11F",
4090 "pslld $31, %xmm1",
4091 ));
4092 insns.push((
4093 Inst::xmm_rmi_reg(SseOpcode::Psrlq, RegMemImm::imm(1), w_xmm3),
4094 "660F73D301",
4095 "psrlq $1, %xmm3",
4096 ));
4097
4098 // ========================================================
4099 // XmmRmRImm
4100 insns.push((
4101 Inst::xmm_rm_r_imm(
4102 SseOpcode::Cmppd,
4103 RegMem::reg(xmm5),
4104 w_xmm1,
4105 2,
4106 OperandSize::Size32,
4107 ),
4108 "660FC2CD02",
4109 "cmppd $2, %xmm5, %xmm1",
4110 ));
4111 insns.push((
4112 Inst::xmm_rm_r_imm(
4113 SseOpcode::Cmpps,
4114 RegMem::reg(xmm15),
4115 w_xmm7,
4116 0,
4117 OperandSize::Size32,
4118 ),
4119 "410FC2FF00",
4120 "cmpps $0, %xmm15, %xmm7",
4121 ));
4122 insns.push((
4123 Inst::xmm_rm_r_imm(
4124 SseOpcode::Palignr,
4125 RegMem::reg(xmm1),
4126 w_xmm9,
4127 3,
4128 OperandSize::Size32,
4129 ),
4130 "66440F3A0FC903",
4131 "palignr $3, %xmm1, %xmm9",
4132 ));
4133
4134 insns.push((
4135 Inst::xmm_rm_r_imm(
4136 SseOpcode::Shufps,
4137 RegMem::reg(xmm1),
4138 w_xmm10,
4139 136,
4140 OperandSize::Size32,
4141 ),
4142 "440FC6D188",
4143 "shufps $136, %xmm1, %xmm10",
4144 ));
4145
4146 insns.push((
4147 Inst::xmm_rm_r_imm(
4148 SseOpcode::Roundps,
4149 RegMem::reg(xmm7),
4150 w_xmm8,
4151 3,
4152 OperandSize::Size32,
4153 ),
4154 "66440F3A08C703",
4155 "roundps $3, %xmm7, %xmm8",
4156 ));
4157 insns.push((
4158 Inst::xmm_rm_r_imm(
4159 SseOpcode::Roundpd,
4160 RegMem::reg(xmm10),
4161 w_xmm7,
4162 2,
4163 OperandSize::Size32,
4164 ),
4165 "66410F3A09FA02",
4166 "roundpd $2, %xmm10, %xmm7",
4167 ));
4168 insns.push((
4169 Inst::xmm_rm_r_imm(
4170 SseOpcode::Roundps,
4171 RegMem::reg(xmm4),
4172 w_xmm8,
4173 1,
4174 OperandSize::Size32,
4175 ),
4176 "66440F3A08C401",
4177 "roundps $1, %xmm4, %xmm8",
4178 ));
4179 insns.push((
4180 Inst::xmm_rm_r_imm(
4181 SseOpcode::Roundpd,
4182 RegMem::reg(xmm15),
4183 w_xmm15,
4184 0,
4185 OperandSize::Size32,
4186 ),
4187 "66450F3A09FF00",
4188 "roundpd $0, %xmm15, %xmm15",
4189 ));
4190
4191 // ========================================================
4192 // Pertaining to atomics.
4193 let am1: SyntheticAmode = Amode::imm_reg_reg_shift(321, r10, rdx, 2).into();
4194 // `am2` doesn't contribute any 1 bits to the rex prefix, so we must use it when testing
4195 // for retention of the apparently-redundant rex prefix in the 8-bit case.
4196 let am2: SyntheticAmode = Amode::imm_reg_reg_shift(-12345i32 as u32, rcx, rsi, 3).into();
4197
4198 // A general 8-bit case.
4199 insns.push((
4200 Inst::LockCmpxchg {
4201 ty: types::I8,
4202 src: rbx,
4203 dst: am1,
4204 },
4205 "F0410FB09C9241010000",
4206 "lock cmpxchgb %bl, 321(%r10,%rdx,4)",
4207 ));
4208 // Check redundant rex retention in 8-bit cases.
4209 insns.push((
4210 Inst::LockCmpxchg {
4211 ty: types::I8,
4212 src: rdx,
4213 dst: am2.clone(),
4214 },
4215 "F00FB094F1C7CFFFFF",
4216 "lock cmpxchgb %dl, -12345(%rcx,%rsi,8)",
4217 ));
4218 insns.push((
4219 Inst::LockCmpxchg {
4220 ty: types::I8,
4221 src: rsi,
4222 dst: am2.clone(),
4223 },
4224 "F0400FB0B4F1C7CFFFFF",
4225 "lock cmpxchgb %sil, -12345(%rcx,%rsi,8)",
4226 ));
4227 insns.push((
4228 Inst::LockCmpxchg {
4229 ty: types::I8,
4230 src: r10,
4231 dst: am2.clone(),
4232 },
4233 "F0440FB094F1C7CFFFFF",
4234 "lock cmpxchgb %r10b, -12345(%rcx,%rsi,8)",
4235 ));
4236 insns.push((
4237 Inst::LockCmpxchg {
4238 ty: types::I8,
4239 src: r15,
4240 dst: am2.clone(),
4241 },
4242 "F0440FB0BCF1C7CFFFFF",
4243 "lock cmpxchgb %r15b, -12345(%rcx,%rsi,8)",
4244 ));
4245 // 16 bit cases
4246 insns.push((
4247 Inst::LockCmpxchg {
4248 ty: types::I16,
4249 src: rsi,
4250 dst: am2.clone(),
4251 },
4252 "66F00FB1B4F1C7CFFFFF",
4253 "lock cmpxchgw %si, -12345(%rcx,%rsi,8)",
4254 ));
4255 insns.push((
4256 Inst::LockCmpxchg {
4257 ty: types::I16,
4258 src: r10,
4259 dst: am2.clone(),
4260 },
4261 "66F0440FB194F1C7CFFFFF",
4262 "lock cmpxchgw %r10w, -12345(%rcx,%rsi,8)",
4263 ));
4264 // 32 bit cases
4265 insns.push((
4266 Inst::LockCmpxchg {
4267 ty: types::I32,
4268 src: rsi,
4269 dst: am2.clone(),
4270 },
4271 "F00FB1B4F1C7CFFFFF",
4272 "lock cmpxchgl %esi, -12345(%rcx,%rsi,8)",
4273 ));
4274 insns.push((
4275 Inst::LockCmpxchg {
4276 ty: types::I32,
4277 src: r10,
4278 dst: am2.clone(),
4279 },
4280 "F0440FB194F1C7CFFFFF",
4281 "lock cmpxchgl %r10d, -12345(%rcx,%rsi,8)",
4282 ));
4283 // 64 bit cases
4284 insns.push((
4285 Inst::LockCmpxchg {
4286 ty: types::I64,
4287 src: rsi,
4288 dst: am2.clone(),
4289 },
4290 "F0480FB1B4F1C7CFFFFF",
4291 "lock cmpxchgq %rsi, -12345(%rcx,%rsi,8)",
4292 ));
4293 insns.push((
4294 Inst::LockCmpxchg {
4295 ty: types::I64,
4296 src: r10,
4297 dst: am2.clone(),
4298 },
4299 "F04C0FB194F1C7CFFFFF",
4300 "lock cmpxchgq %r10, -12345(%rcx,%rsi,8)",
4301 ));
4302
4303 // AtomicRmwSeq
4304 insns.push((
4305 Inst::AtomicRmwSeq { ty: types::I8, op: inst_common::AtomicRmwOp::Or, },
4306 "490FB6014989C34D09D3F0450FB0190F85EFFFFFFF",
4307 "atomically { 8_bits_at_[%r9]) Or= %r10; %rax = old_value_at_[%r9]; %r11, %rflags = trash }"
4308 ));
4309 insns.push((
4310 Inst::AtomicRmwSeq { ty: types::I16, op: inst_common::AtomicRmwOp::And, },
4311 "490FB7014989C34D21D366F0450FB1190F85EEFFFFFF",
4312 "atomically { 16_bits_at_[%r9]) And= %r10; %rax = old_value_at_[%r9]; %r11, %rflags = trash }"
4313 ));
4314 insns.push((
4315 Inst::AtomicRmwSeq { ty: types::I32, op: inst_common::AtomicRmwOp::Xchg, },
4316 "418B014989C34D89D3F0450FB1190F85EFFFFFFF",
4317 "atomically { 32_bits_at_[%r9]) Xchg= %r10; %rax = old_value_at_[%r9]; %r11, %rflags = trash }"
4318 ));
4319 insns.push((
4320 Inst::AtomicRmwSeq { ty: types::I32, op: inst_common::AtomicRmwOp::Umin, },
4321 "418B014989C34539DA4D0F46DAF0450FB1190F85EBFFFFFF",
4322 "atomically { 32_bits_at_[%r9]) Umin= %r10; %rax = old_value_at_[%r9]; %r11, %rflags = trash }"
4323 ));
4324 insns.push((
4325 Inst::AtomicRmwSeq { ty: types::I64, op: inst_common::AtomicRmwOp::Add, },
4326 "498B014989C34D01D3F04D0FB1190F85EFFFFFFF",
4327 "atomically { 64_bits_at_[%r9]) Add= %r10; %rax = old_value_at_[%r9]; %r11, %rflags = trash }"
4328 ));
4329
4330 // Fence
4331 insns.push((
4332 Inst::Fence {
4333 kind: FenceKind::MFence,
4334 },
4335 "0FAEF0",
4336 "mfence",
4337 ));
4338 insns.push((
4339 Inst::Fence {
4340 kind: FenceKind::LFence,
4341 },
4342 "0FAEE8",
4343 "lfence",
4344 ));
4345 insns.push((
4346 Inst::Fence {
4347 kind: FenceKind::SFence,
4348 },
4349 "0FAEF8",
4350 "sfence",
4351 ));
4352
4353 // ========================================================
4354 // Misc instructions.
4355
4356 insns.push((Inst::Hlt, "CC", "hlt"));
4357
4358 let trap_code = TrapCode::UnreachableCodeReached;
4359 insns.push((Inst::Ud2 { trap_code }, "0F0B", "ud2 unreachable"));
4360
4361 insns.push((
4362 Inst::ElfTlsGetAddr {
4363 symbol: ExternalName::User {
4364 namespace: 0,
4365 index: 0,
4366 },
4367 },
4368 "66488D3D00000000666648E800000000",
4369 "elf_tls_get_addr User { namespace: 0, index: 0 }",
4370 ));
4371
4372 insns.push((
4373 Inst::MachOTlsGetAddr {
4374 symbol: ExternalName::User {
4375 namespace: 0,
4376 index: 0,
4377 },
4378 },
4379 "488B3D00000000FF17",
4380 "macho_tls_get_addr User { namespace: 0, index: 0 }",
4381 ));
4382
4383 // ========================================================
4384 // Actually run the tests!
4385 let mut flag_builder = settings::builder();
4386 flag_builder.enable("is_pic").unwrap();
4387 let flags = settings::Flags::new(flag_builder);
4388
4389 use crate::settings::Configurable;
4390 let mut isa_flag_builder = x64::settings::builder();
4391 isa_flag_builder.enable("has_ssse3").unwrap();
4392 isa_flag_builder.enable("has_sse41").unwrap();
4393 isa_flag_builder.enable("has_avx512bitalg").unwrap();
4394 isa_flag_builder.enable("has_avx512dq").unwrap();
4395 isa_flag_builder.enable("has_avx512f").unwrap();
4396 isa_flag_builder.enable("has_avx512vbmi").unwrap();
4397 isa_flag_builder.enable("has_avx512vl").unwrap();
4398 let isa_flags = x64::settings::Flags::new(&flags, isa_flag_builder);
4399
4400 let rru = regs::create_reg_universe_systemv(&flags);
4401 let emit_info = EmitInfo::new(flags, isa_flags);
4402 for (insn, expected_encoding, expected_printing) in insns {
4403 // Check the printed text is as expected.
4404 let actual_printing = insn.show_rru(Some(&rru));
4405 assert_eq!(expected_printing, actual_printing);
4406 let mut sink = test_utils::TestCodeSink::new();
4407 let mut buffer = MachBuffer::new();
4408
4409 insn.emit(&mut buffer, &emit_info, &mut Default::default());
4410
4411 // Allow one label just after the instruction (so the offset is 0).
4412 let label = buffer.get_label();
4413 buffer.bind_label(label);
4414
4415 let buffer = buffer.finish();
4416 buffer.emit(&mut sink);
4417 let actual_encoding = &sink.stringify();
4418 assert_eq!(expected_encoding, actual_encoding, "{}", expected_printing);
4419 }
4420 }
4421