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:
8 //!
9 //! (cd cranelift/codegen && \
10 //! RUST_BACKTRACE=1 cargo test isa::x64::inst::test_x64_insn_encoding_and_printing -- --nocapture)
11
12 use alloc::vec::Vec;
13
14 use super::*;
15 use crate::isa::test_utils;
16
17 #[test]
test_x64_emit()18 fn test_x64_emit() {
19 let rax = regs::rax();
20 let rbx = regs::rbx();
21 let rcx = regs::rcx();
22 let rdx = regs::rdx();
23 let rsi = regs::rsi();
24 let rdi = regs::rdi();
25 let rsp = regs::rsp();
26 let rbp = regs::rbp();
27 let r8 = regs::r8();
28 let r9 = regs::r9();
29 let r10 = regs::r10();
30 let r11 = regs::r11();
31 let r12 = regs::r12();
32 let r13 = regs::r13();
33 let r14 = regs::r14();
34 let r15 = regs::r15();
35
36 // And Writable<> versions of the same:
37 let w_rax = Writable::<Reg>::from_reg(rax);
38 let w_rbx = Writable::<Reg>::from_reg(rbx);
39 let w_rcx = Writable::<Reg>::from_reg(rcx);
40 let w_rdx = Writable::<Reg>::from_reg(rdx);
41 let w_rsi = Writable::<Reg>::from_reg(rsi);
42 let w_rdi = Writable::<Reg>::from_reg(rdi);
43 let _w_rsp = Writable::<Reg>::from_reg(rsp);
44 let _w_rbp = Writable::<Reg>::from_reg(rbp);
45 let w_r8 = Writable::<Reg>::from_reg(r8);
46 let w_r9 = Writable::<Reg>::from_reg(r9);
47 let _w_r10 = Writable::<Reg>::from_reg(r10);
48 let w_r11 = Writable::<Reg>::from_reg(r11);
49 let w_r12 = Writable::<Reg>::from_reg(r12);
50 let w_r13 = Writable::<Reg>::from_reg(r13);
51 let w_r14 = Writable::<Reg>::from_reg(r14);
52 let w_r15 = Writable::<Reg>::from_reg(r15);
53
54 let mut insns = Vec::<(Inst, &str, &str)>::new();
55
56 // ========================================================
57 // Cases aimed at checking Addr-esses: IR (Imm + Reg)
58 //
59 // These are just a bunch of loads with all supported (by the emitter)
60 // permutations of address formats.
61 //
62 // Addr_IR, offset zero
63 insns.push((
64 Inst::mov64_m_r(Addr::imm_reg(0, rax), w_rdi),
65 "488B38",
66 "movq 0(%rax), %rdi",
67 ));
68 insns.push((
69 Inst::mov64_m_r(Addr::imm_reg(0, rbx), w_rdi),
70 "488B3B",
71 "movq 0(%rbx), %rdi",
72 ));
73 insns.push((
74 Inst::mov64_m_r(Addr::imm_reg(0, rcx), w_rdi),
75 "488B39",
76 "movq 0(%rcx), %rdi",
77 ));
78 insns.push((
79 Inst::mov64_m_r(Addr::imm_reg(0, rdx), w_rdi),
80 "488B3A",
81 "movq 0(%rdx), %rdi",
82 ));
83 insns.push((
84 Inst::mov64_m_r(Addr::imm_reg(0, rbp), w_rdi),
85 "488B7D00",
86 "movq 0(%rbp), %rdi",
87 ));
88 insns.push((
89 Inst::mov64_m_r(Addr::imm_reg(0, rsp), w_rdi),
90 "488B3C24",
91 "movq 0(%rsp), %rdi",
92 ));
93 insns.push((
94 Inst::mov64_m_r(Addr::imm_reg(0, rsi), w_rdi),
95 "488B3E",
96 "movq 0(%rsi), %rdi",
97 ));
98 insns.push((
99 Inst::mov64_m_r(Addr::imm_reg(0, rdi), w_rdi),
100 "488B3F",
101 "movq 0(%rdi), %rdi",
102 ));
103 insns.push((
104 Inst::mov64_m_r(Addr::imm_reg(0, r8), w_rdi),
105 "498B38",
106 "movq 0(%r8), %rdi",
107 ));
108 insns.push((
109 Inst::mov64_m_r(Addr::imm_reg(0, r9), w_rdi),
110 "498B39",
111 "movq 0(%r9), %rdi",
112 ));
113 insns.push((
114 Inst::mov64_m_r(Addr::imm_reg(0, r10), w_rdi),
115 "498B3A",
116 "movq 0(%r10), %rdi",
117 ));
118 insns.push((
119 Inst::mov64_m_r(Addr::imm_reg(0, r11), w_rdi),
120 "498B3B",
121 "movq 0(%r11), %rdi",
122 ));
123 insns.push((
124 Inst::mov64_m_r(Addr::imm_reg(0, r12), w_rdi),
125 "498B3C24",
126 "movq 0(%r12), %rdi",
127 ));
128 insns.push((
129 Inst::mov64_m_r(Addr::imm_reg(0, r13), w_rdi),
130 "498B7D00",
131 "movq 0(%r13), %rdi",
132 ));
133 insns.push((
134 Inst::mov64_m_r(Addr::imm_reg(0, r14), w_rdi),
135 "498B3E",
136 "movq 0(%r14), %rdi",
137 ));
138 insns.push((
139 Inst::mov64_m_r(Addr::imm_reg(0, r15), w_rdi),
140 "498B3F",
141 "movq 0(%r15), %rdi",
142 ));
143
144 // ========================================================
145 // Addr_IR, offset max simm8
146 insns.push((
147 Inst::mov64_m_r(Addr::imm_reg(127, rax), w_rdi),
148 "488B787F",
149 "movq 127(%rax), %rdi",
150 ));
151 insns.push((
152 Inst::mov64_m_r(Addr::imm_reg(127, rbx), w_rdi),
153 "488B7B7F",
154 "movq 127(%rbx), %rdi",
155 ));
156 insns.push((
157 Inst::mov64_m_r(Addr::imm_reg(127, rcx), w_rdi),
158 "488B797F",
159 "movq 127(%rcx), %rdi",
160 ));
161 insns.push((
162 Inst::mov64_m_r(Addr::imm_reg(127, rdx), w_rdi),
163 "488B7A7F",
164 "movq 127(%rdx), %rdi",
165 ));
166 insns.push((
167 Inst::mov64_m_r(Addr::imm_reg(127, rbp), w_rdi),
168 "488B7D7F",
169 "movq 127(%rbp), %rdi",
170 ));
171 insns.push((
172 Inst::mov64_m_r(Addr::imm_reg(127, rsp), w_rdi),
173 "488B7C247F",
174 "movq 127(%rsp), %rdi",
175 ));
176 insns.push((
177 Inst::mov64_m_r(Addr::imm_reg(127, rsi), w_rdi),
178 "488B7E7F",
179 "movq 127(%rsi), %rdi",
180 ));
181 insns.push((
182 Inst::mov64_m_r(Addr::imm_reg(127, rdi), w_rdi),
183 "488B7F7F",
184 "movq 127(%rdi), %rdi",
185 ));
186 insns.push((
187 Inst::mov64_m_r(Addr::imm_reg(127, r8), w_rdi),
188 "498B787F",
189 "movq 127(%r8), %rdi",
190 ));
191 insns.push((
192 Inst::mov64_m_r(Addr::imm_reg(127, r9), w_rdi),
193 "498B797F",
194 "movq 127(%r9), %rdi",
195 ));
196 insns.push((
197 Inst::mov64_m_r(Addr::imm_reg(127, r10), w_rdi),
198 "498B7A7F",
199 "movq 127(%r10), %rdi",
200 ));
201 insns.push((
202 Inst::mov64_m_r(Addr::imm_reg(127, r11), w_rdi),
203 "498B7B7F",
204 "movq 127(%r11), %rdi",
205 ));
206 insns.push((
207 Inst::mov64_m_r(Addr::imm_reg(127, r12), w_rdi),
208 "498B7C247F",
209 "movq 127(%r12), %rdi",
210 ));
211 insns.push((
212 Inst::mov64_m_r(Addr::imm_reg(127, r13), w_rdi),
213 "498B7D7F",
214 "movq 127(%r13), %rdi",
215 ));
216 insns.push((
217 Inst::mov64_m_r(Addr::imm_reg(127, r14), w_rdi),
218 "498B7E7F",
219 "movq 127(%r14), %rdi",
220 ));
221 insns.push((
222 Inst::mov64_m_r(Addr::imm_reg(127, r15), w_rdi),
223 "498B7F7F",
224 "movq 127(%r15), %rdi",
225 ));
226
227 // ========================================================
228 // Addr_IR, offset min simm8
229 insns.push((
230 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, rax), w_rdi),
231 "488B7880",
232 "movq -128(%rax), %rdi",
233 ));
234 insns.push((
235 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, rbx), w_rdi),
236 "488B7B80",
237 "movq -128(%rbx), %rdi",
238 ));
239 insns.push((
240 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, rcx), w_rdi),
241 "488B7980",
242 "movq -128(%rcx), %rdi",
243 ));
244 insns.push((
245 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, rdx), w_rdi),
246 "488B7A80",
247 "movq -128(%rdx), %rdi",
248 ));
249 insns.push((
250 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, rbp), w_rdi),
251 "488B7D80",
252 "movq -128(%rbp), %rdi",
253 ));
254 insns.push((
255 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, rsp), w_rdi),
256 "488B7C2480",
257 "movq -128(%rsp), %rdi",
258 ));
259 insns.push((
260 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, rsi), w_rdi),
261 "488B7E80",
262 "movq -128(%rsi), %rdi",
263 ));
264 insns.push((
265 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, rdi), w_rdi),
266 "488B7F80",
267 "movq -128(%rdi), %rdi",
268 ));
269 insns.push((
270 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, r8), w_rdi),
271 "498B7880",
272 "movq -128(%r8), %rdi",
273 ));
274 insns.push((
275 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, r9), w_rdi),
276 "498B7980",
277 "movq -128(%r9), %rdi",
278 ));
279 insns.push((
280 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, r10), w_rdi),
281 "498B7A80",
282 "movq -128(%r10), %rdi",
283 ));
284 insns.push((
285 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, r11), w_rdi),
286 "498B7B80",
287 "movq -128(%r11), %rdi",
288 ));
289 insns.push((
290 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, r12), w_rdi),
291 "498B7C2480",
292 "movq -128(%r12), %rdi",
293 ));
294 insns.push((
295 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, r13), w_rdi),
296 "498B7D80",
297 "movq -128(%r13), %rdi",
298 ));
299 insns.push((
300 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, r14), w_rdi),
301 "498B7E80",
302 "movq -128(%r14), %rdi",
303 ));
304 insns.push((
305 Inst::mov64_m_r(Addr::imm_reg(-128i32 as u32, r15), w_rdi),
306 "498B7F80",
307 "movq -128(%r15), %rdi",
308 ));
309
310 // ========================================================
311 // Addr_IR, offset smallest positive simm32
312 insns.push((
313 Inst::mov64_m_r(Addr::imm_reg(128, rax), w_rdi),
314 "488BB880000000",
315 "movq 128(%rax), %rdi",
316 ));
317 insns.push((
318 Inst::mov64_m_r(Addr::imm_reg(128, rbx), w_rdi),
319 "488BBB80000000",
320 "movq 128(%rbx), %rdi",
321 ));
322 insns.push((
323 Inst::mov64_m_r(Addr::imm_reg(128, rcx), w_rdi),
324 "488BB980000000",
325 "movq 128(%rcx), %rdi",
326 ));
327 insns.push((
328 Inst::mov64_m_r(Addr::imm_reg(128, rdx), w_rdi),
329 "488BBA80000000",
330 "movq 128(%rdx), %rdi",
331 ));
332 insns.push((
333 Inst::mov64_m_r(Addr::imm_reg(128, rbp), w_rdi),
334 "488BBD80000000",
335 "movq 128(%rbp), %rdi",
336 ));
337 insns.push((
338 Inst::mov64_m_r(Addr::imm_reg(128, rsp), w_rdi),
339 "488BBC2480000000",
340 "movq 128(%rsp), %rdi",
341 ));
342 insns.push((
343 Inst::mov64_m_r(Addr::imm_reg(128, rsi), w_rdi),
344 "488BBE80000000",
345 "movq 128(%rsi), %rdi",
346 ));
347 insns.push((
348 Inst::mov64_m_r(Addr::imm_reg(128, rdi), w_rdi),
349 "488BBF80000000",
350 "movq 128(%rdi), %rdi",
351 ));
352 insns.push((
353 Inst::mov64_m_r(Addr::imm_reg(128, r8), w_rdi),
354 "498BB880000000",
355 "movq 128(%r8), %rdi",
356 ));
357 insns.push((
358 Inst::mov64_m_r(Addr::imm_reg(128, r9), w_rdi),
359 "498BB980000000",
360 "movq 128(%r9), %rdi",
361 ));
362 insns.push((
363 Inst::mov64_m_r(Addr::imm_reg(128, r10), w_rdi),
364 "498BBA80000000",
365 "movq 128(%r10), %rdi",
366 ));
367 insns.push((
368 Inst::mov64_m_r(Addr::imm_reg(128, r11), w_rdi),
369 "498BBB80000000",
370 "movq 128(%r11), %rdi",
371 ));
372 insns.push((
373 Inst::mov64_m_r(Addr::imm_reg(128, r12), w_rdi),
374 "498BBC2480000000",
375 "movq 128(%r12), %rdi",
376 ));
377 insns.push((
378 Inst::mov64_m_r(Addr::imm_reg(128, r13), w_rdi),
379 "498BBD80000000",
380 "movq 128(%r13), %rdi",
381 ));
382 insns.push((
383 Inst::mov64_m_r(Addr::imm_reg(128, r14), w_rdi),
384 "498BBE80000000",
385 "movq 128(%r14), %rdi",
386 ));
387 insns.push((
388 Inst::mov64_m_r(Addr::imm_reg(128, r15), w_rdi),
389 "498BBF80000000",
390 "movq 128(%r15), %rdi",
391 ));
392
393 // ========================================================
394 // Addr_IR, offset smallest negative simm32
395 insns.push((
396 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, rax), w_rdi),
397 "488BB87FFFFFFF",
398 "movq -129(%rax), %rdi",
399 ));
400 insns.push((
401 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, rbx), w_rdi),
402 "488BBB7FFFFFFF",
403 "movq -129(%rbx), %rdi",
404 ));
405 insns.push((
406 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, rcx), w_rdi),
407 "488BB97FFFFFFF",
408 "movq -129(%rcx), %rdi",
409 ));
410 insns.push((
411 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, rdx), w_rdi),
412 "488BBA7FFFFFFF",
413 "movq -129(%rdx), %rdi",
414 ));
415 insns.push((
416 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, rbp), w_rdi),
417 "488BBD7FFFFFFF",
418 "movq -129(%rbp), %rdi",
419 ));
420 insns.push((
421 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, rsp), w_rdi),
422 "488BBC247FFFFFFF",
423 "movq -129(%rsp), %rdi",
424 ));
425 insns.push((
426 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, rsi), w_rdi),
427 "488BBE7FFFFFFF",
428 "movq -129(%rsi), %rdi",
429 ));
430 insns.push((
431 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, rdi), w_rdi),
432 "488BBF7FFFFFFF",
433 "movq -129(%rdi), %rdi",
434 ));
435 insns.push((
436 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, r8), w_rdi),
437 "498BB87FFFFFFF",
438 "movq -129(%r8), %rdi",
439 ));
440 insns.push((
441 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, r9), w_rdi),
442 "498BB97FFFFFFF",
443 "movq -129(%r9), %rdi",
444 ));
445 insns.push((
446 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, r10), w_rdi),
447 "498BBA7FFFFFFF",
448 "movq -129(%r10), %rdi",
449 ));
450 insns.push((
451 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, r11), w_rdi),
452 "498BBB7FFFFFFF",
453 "movq -129(%r11), %rdi",
454 ));
455 insns.push((
456 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, r12), w_rdi),
457 "498BBC247FFFFFFF",
458 "movq -129(%r12), %rdi",
459 ));
460 insns.push((
461 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, r13), w_rdi),
462 "498BBD7FFFFFFF",
463 "movq -129(%r13), %rdi",
464 ));
465 insns.push((
466 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, r14), w_rdi),
467 "498BBE7FFFFFFF",
468 "movq -129(%r14), %rdi",
469 ));
470 insns.push((
471 Inst::mov64_m_r(Addr::imm_reg(-129i32 as u32, r15), w_rdi),
472 "498BBF7FFFFFFF",
473 "movq -129(%r15), %rdi",
474 ));
475
476 // ========================================================
477 // Addr_IR, offset large positive simm32
478 insns.push((
479 Inst::mov64_m_r(Addr::imm_reg(0x17732077, rax), w_rdi),
480 "488BB877207317",
481 "movq 393420919(%rax), %rdi",
482 ));
483 insns.push((
484 Inst::mov64_m_r(Addr::imm_reg(0x17732077, rbx), w_rdi),
485 "488BBB77207317",
486 "movq 393420919(%rbx), %rdi",
487 ));
488 insns.push((
489 Inst::mov64_m_r(Addr::imm_reg(0x17732077, rcx), w_rdi),
490 "488BB977207317",
491 "movq 393420919(%rcx), %rdi",
492 ));
493 insns.push((
494 Inst::mov64_m_r(Addr::imm_reg(0x17732077, rdx), w_rdi),
495 "488BBA77207317",
496 "movq 393420919(%rdx), %rdi",
497 ));
498 insns.push((
499 Inst::mov64_m_r(Addr::imm_reg(0x17732077, rbp), w_rdi),
500 "488BBD77207317",
501 "movq 393420919(%rbp), %rdi",
502 ));
503 insns.push((
504 Inst::mov64_m_r(Addr::imm_reg(0x17732077, rsp), w_rdi),
505 "488BBC2477207317",
506 "movq 393420919(%rsp), %rdi",
507 ));
508 insns.push((
509 Inst::mov64_m_r(Addr::imm_reg(0x17732077, rsi), w_rdi),
510 "488BBE77207317",
511 "movq 393420919(%rsi), %rdi",
512 ));
513 insns.push((
514 Inst::mov64_m_r(Addr::imm_reg(0x17732077, rdi), w_rdi),
515 "488BBF77207317",
516 "movq 393420919(%rdi), %rdi",
517 ));
518 insns.push((
519 Inst::mov64_m_r(Addr::imm_reg(0x17732077, r8), w_rdi),
520 "498BB877207317",
521 "movq 393420919(%r8), %rdi",
522 ));
523 insns.push((
524 Inst::mov64_m_r(Addr::imm_reg(0x17732077, r9), w_rdi),
525 "498BB977207317",
526 "movq 393420919(%r9), %rdi",
527 ));
528 insns.push((
529 Inst::mov64_m_r(Addr::imm_reg(0x17732077, r10), w_rdi),
530 "498BBA77207317",
531 "movq 393420919(%r10), %rdi",
532 ));
533 insns.push((
534 Inst::mov64_m_r(Addr::imm_reg(0x17732077, r11), w_rdi),
535 "498BBB77207317",
536 "movq 393420919(%r11), %rdi",
537 ));
538 insns.push((
539 Inst::mov64_m_r(Addr::imm_reg(0x17732077, r12), w_rdi),
540 "498BBC2477207317",
541 "movq 393420919(%r12), %rdi",
542 ));
543 insns.push((
544 Inst::mov64_m_r(Addr::imm_reg(0x17732077, r13), w_rdi),
545 "498BBD77207317",
546 "movq 393420919(%r13), %rdi",
547 ));
548 insns.push((
549 Inst::mov64_m_r(Addr::imm_reg(0x17732077, r14), w_rdi),
550 "498BBE77207317",
551 "movq 393420919(%r14), %rdi",
552 ));
553 insns.push((
554 Inst::mov64_m_r(Addr::imm_reg(0x17732077, r15), w_rdi),
555 "498BBF77207317",
556 "movq 393420919(%r15), %rdi",
557 ));
558
559 // ========================================================
560 // Addr_IR, offset large negative simm32
561 insns.push((
562 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, rax), w_rdi),
563 "488BB8D9A6BECE",
564 "movq -826366247(%rax), %rdi",
565 ));
566 insns.push((
567 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, rbx), w_rdi),
568 "488BBBD9A6BECE",
569 "movq -826366247(%rbx), %rdi",
570 ));
571 insns.push((
572 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, rcx), w_rdi),
573 "488BB9D9A6BECE",
574 "movq -826366247(%rcx), %rdi",
575 ));
576 insns.push((
577 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, rdx), w_rdi),
578 "488BBAD9A6BECE",
579 "movq -826366247(%rdx), %rdi",
580 ));
581 insns.push((
582 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, rbp), w_rdi),
583 "488BBDD9A6BECE",
584 "movq -826366247(%rbp), %rdi",
585 ));
586 insns.push((
587 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, rsp), w_rdi),
588 "488BBC24D9A6BECE",
589 "movq -826366247(%rsp), %rdi",
590 ));
591 insns.push((
592 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, rsi), w_rdi),
593 "488BBED9A6BECE",
594 "movq -826366247(%rsi), %rdi",
595 ));
596 insns.push((
597 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, rdi), w_rdi),
598 "488BBFD9A6BECE",
599 "movq -826366247(%rdi), %rdi",
600 ));
601 insns.push((
602 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, r8), w_rdi),
603 "498BB8D9A6BECE",
604 "movq -826366247(%r8), %rdi",
605 ));
606 insns.push((
607 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, r9), w_rdi),
608 "498BB9D9A6BECE",
609 "movq -826366247(%r9), %rdi",
610 ));
611 insns.push((
612 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, r10), w_rdi),
613 "498BBAD9A6BECE",
614 "movq -826366247(%r10), %rdi",
615 ));
616 insns.push((
617 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, r11), w_rdi),
618 "498BBBD9A6BECE",
619 "movq -826366247(%r11), %rdi",
620 ));
621 insns.push((
622 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, r12), w_rdi),
623 "498BBC24D9A6BECE",
624 "movq -826366247(%r12), %rdi",
625 ));
626 insns.push((
627 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, r13), w_rdi),
628 "498BBDD9A6BECE",
629 "movq -826366247(%r13), %rdi",
630 ));
631 insns.push((
632 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, r14), w_rdi),
633 "498BBED9A6BECE",
634 "movq -826366247(%r14), %rdi",
635 ));
636 insns.push((
637 Inst::mov64_m_r(Addr::imm_reg(-0x31415927i32 as u32, r15), w_rdi),
638 "498BBFD9A6BECE",
639 "movq -826366247(%r15), %rdi",
640 ));
641
642 // ========================================================
643 // Cases aimed at checking Addr-esses: IRRS (Imm + Reg + (Reg << Shift))
644 // Note these don't check the case where the index reg is RSP, since we
645 // don't encode any of those.
646 //
647 // Addr_IRRS, offset max simm8
648 insns.push((
649 Inst::mov64_m_r(Addr::imm_reg_reg_shift(127, rax, rax, 0), w_r11),
650 "4C8B5C007F",
651 "movq 127(%rax,%rax,1), %r11",
652 ));
653 insns.push((
654 Inst::mov64_m_r(Addr::imm_reg_reg_shift(127, rdi, rax, 1), w_r11),
655 "4C8B5C477F",
656 "movq 127(%rdi,%rax,2), %r11",
657 ));
658 insns.push((
659 Inst::mov64_m_r(Addr::imm_reg_reg_shift(127, r8, rax, 2), w_r11),
660 "4D8B5C807F",
661 "movq 127(%r8,%rax,4), %r11",
662 ));
663 insns.push((
664 Inst::mov64_m_r(Addr::imm_reg_reg_shift(127, r15, rax, 3), w_r11),
665 "4D8B5CC77F",
666 "movq 127(%r15,%rax,8), %r11",
667 ));
668 insns.push((
669 Inst::mov64_m_r(Addr::imm_reg_reg_shift(127, rax, rdi, 3), w_r11),
670 "4C8B5CF87F",
671 "movq 127(%rax,%rdi,8), %r11",
672 ));
673 insns.push((
674 Inst::mov64_m_r(Addr::imm_reg_reg_shift(127, rdi, rdi, 2), w_r11),
675 "4C8B5CBF7F",
676 "movq 127(%rdi,%rdi,4), %r11",
677 ));
678 insns.push((
679 Inst::mov64_m_r(Addr::imm_reg_reg_shift(127, r8, rdi, 1), w_r11),
680 "4D8B5C787F",
681 "movq 127(%r8,%rdi,2), %r11",
682 ));
683 insns.push((
684 Inst::mov64_m_r(Addr::imm_reg_reg_shift(127, r15, rdi, 0), w_r11),
685 "4D8B5C3F7F",
686 "movq 127(%r15,%rdi,1), %r11",
687 ));
688
689 // ========================================================
690 // Addr_IRRS, offset min simm8
691 insns.push((
692 Inst::mov64_m_r(Addr::imm_reg_reg_shift(-128i32 as u32, rax, r8, 2), w_r11),
693 "4E8B5C8080",
694 "movq -128(%rax,%r8,4), %r11",
695 ));
696 insns.push((
697 Inst::mov64_m_r(Addr::imm_reg_reg_shift(-128i32 as u32, rdi, r8, 3), w_r11),
698 "4E8B5CC780",
699 "movq -128(%rdi,%r8,8), %r11",
700 ));
701 insns.push((
702 Inst::mov64_m_r(Addr::imm_reg_reg_shift(-128i32 as u32, r8, r8, 0), w_r11),
703 "4F8B5C0080",
704 "movq -128(%r8,%r8,1), %r11",
705 ));
706 insns.push((
707 Inst::mov64_m_r(Addr::imm_reg_reg_shift(-128i32 as u32, r15, r8, 1), w_r11),
708 "4F8B5C4780",
709 "movq -128(%r15,%r8,2), %r11",
710 ));
711 insns.push((
712 Inst::mov64_m_r(Addr::imm_reg_reg_shift(-128i32 as u32, rax, r15, 1), w_r11),
713 "4E8B5C7880",
714 "movq -128(%rax,%r15,2), %r11",
715 ));
716 insns.push((
717 Inst::mov64_m_r(Addr::imm_reg_reg_shift(-128i32 as u32, rdi, r15, 0), w_r11),
718 "4E8B5C3F80",
719 "movq -128(%rdi,%r15,1), %r11",
720 ));
721 insns.push((
722 Inst::mov64_m_r(Addr::imm_reg_reg_shift(-128i32 as u32, r8, r15, 3), w_r11),
723 "4F8B5CF880",
724 "movq -128(%r8,%r15,8), %r11",
725 ));
726 insns.push((
727 Inst::mov64_m_r(Addr::imm_reg_reg_shift(-128i32 as u32, r15, r15, 2), w_r11),
728 "4F8B5CBF80",
729 "movq -128(%r15,%r15,4), %r11",
730 ));
731
732 // ========================================================
733 // Addr_IRRS, offset large positive simm32
734 insns.push((
735 Inst::mov64_m_r(Addr::imm_reg_reg_shift(0x4f6625be, rax, rax, 0), w_r11),
736 "4C8B9C00BE25664F",
737 "movq 1332094398(%rax,%rax,1), %r11",
738 ));
739 insns.push((
740 Inst::mov64_m_r(Addr::imm_reg_reg_shift(0x4f6625be, rdi, rax, 1), w_r11),
741 "4C8B9C47BE25664F",
742 "movq 1332094398(%rdi,%rax,2), %r11",
743 ));
744 insns.push((
745 Inst::mov64_m_r(Addr::imm_reg_reg_shift(0x4f6625be, r8, rax, 2), w_r11),
746 "4D8B9C80BE25664F",
747 "movq 1332094398(%r8,%rax,4), %r11",
748 ));
749 insns.push((
750 Inst::mov64_m_r(Addr::imm_reg_reg_shift(0x4f6625be, r15, rax, 3), w_r11),
751 "4D8B9CC7BE25664F",
752 "movq 1332094398(%r15,%rax,8), %r11",
753 ));
754 insns.push((
755 Inst::mov64_m_r(Addr::imm_reg_reg_shift(0x4f6625be, rax, rdi, 3), w_r11),
756 "4C8B9CF8BE25664F",
757 "movq 1332094398(%rax,%rdi,8), %r11",
758 ));
759 insns.push((
760 Inst::mov64_m_r(Addr::imm_reg_reg_shift(0x4f6625be, rdi, rdi, 2), w_r11),
761 "4C8B9CBFBE25664F",
762 "movq 1332094398(%rdi,%rdi,4), %r11",
763 ));
764 insns.push((
765 Inst::mov64_m_r(Addr::imm_reg_reg_shift(0x4f6625be, r8, rdi, 1), w_r11),
766 "4D8B9C78BE25664F",
767 "movq 1332094398(%r8,%rdi,2), %r11",
768 ));
769 insns.push((
770 Inst::mov64_m_r(Addr::imm_reg_reg_shift(0x4f6625be, r15, rdi, 0), w_r11),
771 "4D8B9C3FBE25664F",
772 "movq 1332094398(%r15,%rdi,1), %r11",
773 ));
774
775 // ========================================================
776 // Addr_IRRS, offset large negative simm32
777 insns.push((
778 Inst::mov64_m_r(
779 Addr::imm_reg_reg_shift(-0x264d1690i32 as u32, rax, r8, 2),
780 w_r11,
781 ),
782 "4E8B9C8070E9B2D9",
783 "movq -642586256(%rax,%r8,4), %r11",
784 ));
785 insns.push((
786 Inst::mov64_m_r(
787 Addr::imm_reg_reg_shift(-0x264d1690i32 as u32, rdi, r8, 3),
788 w_r11,
789 ),
790 "4E8B9CC770E9B2D9",
791 "movq -642586256(%rdi,%r8,8), %r11",
792 ));
793 insns.push((
794 Inst::mov64_m_r(
795 Addr::imm_reg_reg_shift(-0x264d1690i32 as u32, r8, r8, 0),
796 w_r11,
797 ),
798 "4F8B9C0070E9B2D9",
799 "movq -642586256(%r8,%r8,1), %r11",
800 ));
801 insns.push((
802 Inst::mov64_m_r(
803 Addr::imm_reg_reg_shift(-0x264d1690i32 as u32, r15, r8, 1),
804 w_r11,
805 ),
806 "4F8B9C4770E9B2D9",
807 "movq -642586256(%r15,%r8,2), %r11",
808 ));
809 insns.push((
810 Inst::mov64_m_r(
811 Addr::imm_reg_reg_shift(-0x264d1690i32 as u32, rax, r15, 1),
812 w_r11,
813 ),
814 "4E8B9C7870E9B2D9",
815 "movq -642586256(%rax,%r15,2), %r11",
816 ));
817 insns.push((
818 Inst::mov64_m_r(
819 Addr::imm_reg_reg_shift(-0x264d1690i32 as u32, rdi, r15, 0),
820 w_r11,
821 ),
822 "4E8B9C3F70E9B2D9",
823 "movq -642586256(%rdi,%r15,1), %r11",
824 ));
825 insns.push((
826 Inst::mov64_m_r(
827 Addr::imm_reg_reg_shift(-0x264d1690i32 as u32, r8, r15, 3),
828 w_r11,
829 ),
830 "4F8B9CF870E9B2D9",
831 "movq -642586256(%r8,%r15,8), %r11",
832 ));
833 insns.push((
834 Inst::mov64_m_r(
835 Addr::imm_reg_reg_shift(-0x264d1690i32 as u32, r15, r15, 2),
836 w_r11,
837 ),
838 "4F8B9CBF70E9B2D9",
839 "movq -642586256(%r15,%r15,4), %r11",
840 ));
841
842 // End of test cases for Addr
843 // ========================================================
844
845 // ========================================================
846 // General tests for each insn. Don't forget to follow the
847 // guidelines commented just prior to `fn x64_emit`.
848 //
849 // Alu_RMI_R
850 insns.push((
851 Inst::alu_rmi_r(true, RMI_R_Op::Add, RMI::reg(r15), w_rdx),
852 "4C01FA",
853 "addq %r15, %rdx",
854 ));
855 insns.push((
856 Inst::alu_rmi_r(false, RMI_R_Op::Add, RMI::reg(rcx), w_r8),
857 "4101C8",
858 "addl %ecx, %r8d",
859 ));
860 insns.push((
861 Inst::alu_rmi_r(false, RMI_R_Op::Add, RMI::reg(rcx), w_rsi),
862 "01CE",
863 "addl %ecx, %esi",
864 ));
865 insns.push((
866 Inst::alu_rmi_r(true, RMI_R_Op::Add, RMI::mem(Addr::imm_reg(99, rdi)), w_rdx),
867 "48035763",
868 "addq 99(%rdi), %rdx",
869 ));
870 insns.push((
871 Inst::alu_rmi_r(false, RMI_R_Op::Add, RMI::mem(Addr::imm_reg(99, rdi)), w_r8),
872 "44034763",
873 "addl 99(%rdi), %r8d",
874 ));
875 insns.push((
876 Inst::alu_rmi_r(
877 false,
878 RMI_R_Op::Add,
879 RMI::mem(Addr::imm_reg(99, rdi)),
880 w_rsi,
881 ),
882 "037763",
883 "addl 99(%rdi), %esi",
884 ));
885 insns.push((
886 Inst::alu_rmi_r(true, RMI_R_Op::Add, RMI::imm(-127i32 as u32), w_rdx),
887 "4883C281",
888 "addq $-127, %rdx",
889 ));
890 insns.push((
891 Inst::alu_rmi_r(true, RMI_R_Op::Add, RMI::imm(-129i32 as u32), w_rdx),
892 "4881C27FFFFFFF",
893 "addq $-129, %rdx",
894 ));
895 insns.push((
896 Inst::alu_rmi_r(true, RMI_R_Op::Add, RMI::imm(76543210), w_rdx),
897 "4881C2EAF48F04",
898 "addq $76543210, %rdx",
899 ));
900 insns.push((
901 Inst::alu_rmi_r(false, RMI_R_Op::Add, RMI::imm(-127i32 as u32), w_r8),
902 "4183C081",
903 "addl $-127, %r8d",
904 ));
905 insns.push((
906 Inst::alu_rmi_r(false, RMI_R_Op::Add, RMI::imm(-129i32 as u32), w_r8),
907 "4181C07FFFFFFF",
908 "addl $-129, %r8d",
909 ));
910 insns.push((
911 Inst::alu_rmi_r(false, RMI_R_Op::Add, RMI::imm(-76543210i32 as u32), w_r8),
912 "4181C0160B70FB",
913 "addl $-76543210, %r8d",
914 ));
915 insns.push((
916 Inst::alu_rmi_r(false, RMI_R_Op::Add, RMI::imm(-127i32 as u32), w_rsi),
917 "83C681",
918 "addl $-127, %esi",
919 ));
920 insns.push((
921 Inst::alu_rmi_r(false, RMI_R_Op::Add, RMI::imm(-129i32 as u32), w_rsi),
922 "81C67FFFFFFF",
923 "addl $-129, %esi",
924 ));
925 insns.push((
926 Inst::alu_rmi_r(false, RMI_R_Op::Add, RMI::imm(76543210), w_rsi),
927 "81C6EAF48F04",
928 "addl $76543210, %esi",
929 ));
930 // This is pretty feeble
931 insns.push((
932 Inst::alu_rmi_r(true, RMI_R_Op::Sub, RMI::reg(r15), w_rdx),
933 "4C29FA",
934 "subq %r15, %rdx",
935 ));
936 insns.push((
937 Inst::alu_rmi_r(true, RMI_R_Op::And, RMI::reg(r15), w_rdx),
938 "4C21FA",
939 "andq %r15, %rdx",
940 ));
941 insns.push((
942 Inst::alu_rmi_r(true, RMI_R_Op::Or, RMI::reg(r15), w_rdx),
943 "4C09FA",
944 "orq %r15, %rdx",
945 ));
946 insns.push((
947 Inst::alu_rmi_r(true, RMI_R_Op::Xor, RMI::reg(r15), w_rdx),
948 "4C31FA",
949 "xorq %r15, %rdx",
950 ));
951 // Test all mul cases, though
952 insns.push((
953 Inst::alu_rmi_r(true, RMI_R_Op::Mul, RMI::reg(r15), w_rdx),
954 "490FAFD7",
955 "imulq %r15, %rdx",
956 ));
957 insns.push((
958 Inst::alu_rmi_r(false, RMI_R_Op::Mul, RMI::reg(rcx), w_r8),
959 "440FAFC1",
960 "imull %ecx, %r8d",
961 ));
962 insns.push((
963 Inst::alu_rmi_r(false, RMI_R_Op::Mul, RMI::reg(rcx), w_rsi),
964 "0FAFF1",
965 "imull %ecx, %esi",
966 ));
967 insns.push((
968 Inst::alu_rmi_r(true, RMI_R_Op::Mul, RMI::mem(Addr::imm_reg(99, rdi)), w_rdx),
969 "480FAF5763",
970 "imulq 99(%rdi), %rdx",
971 ));
972 insns.push((
973 Inst::alu_rmi_r(false, RMI_R_Op::Mul, RMI::mem(Addr::imm_reg(99, rdi)), w_r8),
974 "440FAF4763",
975 "imull 99(%rdi), %r8d",
976 ));
977 insns.push((
978 Inst::alu_rmi_r(
979 false,
980 RMI_R_Op::Mul,
981 RMI::mem(Addr::imm_reg(99, rdi)),
982 w_rsi,
983 ),
984 "0FAF7763",
985 "imull 99(%rdi), %esi",
986 ));
987 insns.push((
988 Inst::alu_rmi_r(true, RMI_R_Op::Mul, RMI::imm(-127i32 as u32), w_rdx),
989 "486BD281",
990 "imulq $-127, %rdx",
991 ));
992 insns.push((
993 Inst::alu_rmi_r(true, RMI_R_Op::Mul, RMI::imm(-129i32 as u32), w_rdx),
994 "4869D27FFFFFFF",
995 "imulq $-129, %rdx",
996 ));
997 insns.push((
998 Inst::alu_rmi_r(true, RMI_R_Op::Mul, RMI::imm(76543210), w_rdx),
999 "4869D2EAF48F04",
1000 "imulq $76543210, %rdx",
1001 ));
1002 insns.push((
1003 Inst::alu_rmi_r(false, RMI_R_Op::Mul, RMI::imm(-127i32 as u32), w_r8),
1004 "456BC081",
1005 "imull $-127, %r8d",
1006 ));
1007 insns.push((
1008 Inst::alu_rmi_r(false, RMI_R_Op::Mul, RMI::imm(-129i32 as u32), w_r8),
1009 "4569C07FFFFFFF",
1010 "imull $-129, %r8d",
1011 ));
1012 insns.push((
1013 Inst::alu_rmi_r(false, RMI_R_Op::Mul, RMI::imm(-76543210i32 as u32), w_r8),
1014 "4569C0160B70FB",
1015 "imull $-76543210, %r8d",
1016 ));
1017 insns.push((
1018 Inst::alu_rmi_r(false, RMI_R_Op::Mul, RMI::imm(-127i32 as u32), w_rsi),
1019 "6BF681",
1020 "imull $-127, %esi",
1021 ));
1022 insns.push((
1023 Inst::alu_rmi_r(false, RMI_R_Op::Mul, RMI::imm(-129i32 as u32), w_rsi),
1024 "69F67FFFFFFF",
1025 "imull $-129, %esi",
1026 ));
1027 insns.push((
1028 Inst::alu_rmi_r(false, RMI_R_Op::Mul, RMI::imm(76543210), w_rsi),
1029 "69F6EAF48F04",
1030 "imull $76543210, %esi",
1031 ));
1032
1033 // ========================================================
1034 // Imm_R
1035 //
1036 insns.push((
1037 Inst::imm_r(false, 1234567, w_r14),
1038 "41BE87D61200",
1039 "movl $1234567, %r14d",
1040 ));
1041 insns.push((
1042 Inst::imm_r(false, -126i64 as u64, w_r14),
1043 "41BE82FFFFFF",
1044 "movl $-126, %r14d",
1045 ));
1046 insns.push((
1047 Inst::imm_r(true, 1234567898765, w_r14),
1048 "49BE8D26FB711F010000",
1049 "movabsq $1234567898765, %r14",
1050 ));
1051 insns.push((
1052 Inst::imm_r(true, -126i64 as u64, w_r14),
1053 "49BE82FFFFFFFFFFFFFF",
1054 "movabsq $-126, %r14",
1055 ));
1056 insns.push((
1057 Inst::imm_r(false, 1234567, w_rcx),
1058 "B987D61200",
1059 "movl $1234567, %ecx",
1060 ));
1061 insns.push((
1062 Inst::imm_r(false, -126i64 as u64, w_rcx),
1063 "B982FFFFFF",
1064 "movl $-126, %ecx",
1065 ));
1066 insns.push((
1067 Inst::imm_r(true, 1234567898765, w_rsi),
1068 "48BE8D26FB711F010000",
1069 "movabsq $1234567898765, %rsi",
1070 ));
1071 insns.push((
1072 Inst::imm_r(true, -126i64 as u64, w_rbx),
1073 "48BB82FFFFFFFFFFFFFF",
1074 "movabsq $-126, %rbx",
1075 ));
1076
1077 // ========================================================
1078 // Mov_R_R
1079 insns.push((
1080 Inst::mov_r_r(false, rbx, w_rsi),
1081 "89DE",
1082 "movl %ebx, %esi",
1083 ));
1084 insns.push((
1085 Inst::mov_r_r(false, rbx, w_r9),
1086 "4189D9",
1087 "movl %ebx, %r9d",
1088 ));
1089 insns.push((
1090 Inst::mov_r_r(false, r11, w_rsi),
1091 "4489DE",
1092 "movl %r11d, %esi",
1093 ));
1094 insns.push((
1095 Inst::mov_r_r(false, r12, w_r9),
1096 "4589E1",
1097 "movl %r12d, %r9d",
1098 ));
1099 insns.push((
1100 Inst::mov_r_r(true, rbx, w_rsi),
1101 "4889DE",
1102 "movq %rbx, %rsi",
1103 ));
1104 insns.push((
1105 Inst::mov_r_r(true, rbx, w_r9),
1106 "4989D9",
1107 "movq %rbx, %r9",
1108 ));
1109 insns.push((
1110 Inst::mov_r_r(true, r11, w_rsi),
1111 "4C89DE",
1112 "movq %r11, %rsi",
1113 ));
1114 insns.push((
1115 Inst::mov_r_r(true, r12, w_r9),
1116 "4D89E1",
1117 "movq %r12, %r9",
1118 ));
1119
1120 // ========================================================
1121 // MovZX_M_R
1122 insns.push((
1123 Inst::movzx_m_r(ExtMode::BL, Addr::imm_reg(-7i32 as u32, rcx), w_rsi),
1124 "0FB671F9",
1125 "movzbl -7(%rcx), %esi",
1126 ));
1127 insns.push((
1128 Inst::movzx_m_r(ExtMode::BL, Addr::imm_reg(-7i32 as u32, r8), w_rbx),
1129 "410FB658F9",
1130 "movzbl -7(%r8), %ebx",
1131 ));
1132 insns.push((
1133 Inst::movzx_m_r(ExtMode::BL, Addr::imm_reg(-7i32 as u32, r10), w_r9),
1134 "450FB64AF9",
1135 "movzbl -7(%r10), %r9d",
1136 ));
1137 insns.push((
1138 Inst::movzx_m_r(ExtMode::BL, Addr::imm_reg(-7i32 as u32, r11), w_rdx),
1139 "410FB653F9",
1140 "movzbl -7(%r11), %edx",
1141 ));
1142 insns.push((
1143 Inst::movzx_m_r(ExtMode::BQ, Addr::imm_reg(-7i32 as u32, rcx), w_rsi),
1144 "480FB671F9",
1145 "movzbq -7(%rcx), %rsi",
1146 ));
1147 insns.push((
1148 Inst::movzx_m_r(ExtMode::BQ, Addr::imm_reg(-7i32 as u32, r8), w_rbx),
1149 "490FB658F9",
1150 "movzbq -7(%r8), %rbx",
1151 ));
1152 insns.push((
1153 Inst::movzx_m_r(ExtMode::BQ, Addr::imm_reg(-7i32 as u32, r10), w_r9),
1154 "4D0FB64AF9",
1155 "movzbq -7(%r10), %r9",
1156 ));
1157 insns.push((
1158 Inst::movzx_m_r(ExtMode::BQ, Addr::imm_reg(-7i32 as u32, r11), w_rdx),
1159 "490FB653F9",
1160 "movzbq -7(%r11), %rdx",
1161 ));
1162 insns.push((
1163 Inst::movzx_m_r(ExtMode::WL, Addr::imm_reg(-7i32 as u32, rcx), w_rsi),
1164 "0FB771F9",
1165 "movzwl -7(%rcx), %esi",
1166 ));
1167 insns.push((
1168 Inst::movzx_m_r(ExtMode::WL, Addr::imm_reg(-7i32 as u32, r8), w_rbx),
1169 "410FB758F9",
1170 "movzwl -7(%r8), %ebx",
1171 ));
1172 insns.push((
1173 Inst::movzx_m_r(ExtMode::WL, Addr::imm_reg(-7i32 as u32, r10), w_r9),
1174 "450FB74AF9",
1175 "movzwl -7(%r10), %r9d",
1176 ));
1177 insns.push((
1178 Inst::movzx_m_r(ExtMode::WL, Addr::imm_reg(-7i32 as u32, r11), w_rdx),
1179 "410FB753F9",
1180 "movzwl -7(%r11), %edx",
1181 ));
1182 insns.push((
1183 Inst::movzx_m_r(ExtMode::WQ, Addr::imm_reg(-7i32 as u32, rcx), w_rsi),
1184 "480FB771F9",
1185 "movzwq -7(%rcx), %rsi",
1186 ));
1187 insns.push((
1188 Inst::movzx_m_r(ExtMode::WQ, Addr::imm_reg(-7i32 as u32, r8), w_rbx),
1189 "490FB758F9",
1190 "movzwq -7(%r8), %rbx",
1191 ));
1192 insns.push((
1193 Inst::movzx_m_r(ExtMode::WQ, Addr::imm_reg(-7i32 as u32, r10), w_r9),
1194 "4D0FB74AF9",
1195 "movzwq -7(%r10), %r9",
1196 ));
1197 insns.push((
1198 Inst::movzx_m_r(ExtMode::WQ, Addr::imm_reg(-7i32 as u32, r11), w_rdx),
1199 "490FB753F9",
1200 "movzwq -7(%r11), %rdx",
1201 ));
1202 insns.push((
1203 Inst::movzx_m_r(ExtMode::LQ, Addr::imm_reg(-7i32 as u32, rcx), w_rsi),
1204 "8B71F9",
1205 "movl -7(%rcx), %esi",
1206 ));
1207 insns.push((
1208 Inst::movzx_m_r(ExtMode::LQ, Addr::imm_reg(-7i32 as u32, r8), w_rbx),
1209 "418B58F9",
1210 "movl -7(%r8), %ebx",
1211 ));
1212 insns.push((
1213 Inst::movzx_m_r(ExtMode::LQ, Addr::imm_reg(-7i32 as u32, r10), w_r9),
1214 "458B4AF9",
1215 "movl -7(%r10), %r9d",
1216 ));
1217 insns.push((
1218 Inst::movzx_m_r(ExtMode::LQ, Addr::imm_reg(-7i32 as u32, r11), w_rdx),
1219 "418B53F9",
1220 "movl -7(%r11), %edx",
1221 ));
1222
1223 // ========================================================
1224 // Mov64_M_R
1225 insns.push((
1226 Inst::mov64_m_r(Addr::imm_reg_reg_shift(179, rax, rbx, 0), w_rcx),
1227 "488B8C18B3000000",
1228 "movq 179(%rax,%rbx,1), %rcx",
1229 ));
1230 insns.push((
1231 Inst::mov64_m_r(Addr::imm_reg_reg_shift(179, rax, rbx, 0), w_r8),
1232 "4C8B8418B3000000",
1233 "movq 179(%rax,%rbx,1), %r8",
1234 ));
1235 insns.push((
1236 Inst::mov64_m_r(Addr::imm_reg_reg_shift(179, rax, r9, 0), w_rcx),
1237 "4A8B8C08B3000000",
1238 "movq 179(%rax,%r9,1), %rcx",
1239 ));
1240 insns.push((
1241 Inst::mov64_m_r(Addr::imm_reg_reg_shift(179, rax, r9, 0), w_r8),
1242 "4E8B8408B3000000",
1243 "movq 179(%rax,%r9,1), %r8",
1244 ));
1245 insns.push((
1246 Inst::mov64_m_r(Addr::imm_reg_reg_shift(179, r10, rbx, 0), w_rcx),
1247 "498B8C1AB3000000",
1248 "movq 179(%r10,%rbx,1), %rcx",
1249 ));
1250 insns.push((
1251 Inst::mov64_m_r(Addr::imm_reg_reg_shift(179, r10, rbx, 0), w_r8),
1252 "4D8B841AB3000000",
1253 "movq 179(%r10,%rbx,1), %r8",
1254 ));
1255 insns.push((
1256 Inst::mov64_m_r(Addr::imm_reg_reg_shift(179, r10, r9, 0), w_rcx),
1257 "4B8B8C0AB3000000",
1258 "movq 179(%r10,%r9,1), %rcx",
1259 ));
1260 insns.push((
1261 Inst::mov64_m_r(Addr::imm_reg_reg_shift(179, r10, r9, 0), w_r8),
1262 "4F8B840AB3000000",
1263 "movq 179(%r10,%r9,1), %r8",
1264 ));
1265
1266 // ========================================================
1267 // MovSX_M_R
1268 insns.push((
1269 Inst::movsx_m_r(ExtMode::BL, Addr::imm_reg(-7i32 as u32, rcx), w_rsi),
1270 "0FBE71F9",
1271 "movsbl -7(%rcx), %esi",
1272 ));
1273 insns.push((
1274 Inst::movsx_m_r(ExtMode::BL, Addr::imm_reg(-7i32 as u32, r8), w_rbx),
1275 "410FBE58F9",
1276 "movsbl -7(%r8), %ebx",
1277 ));
1278 insns.push((
1279 Inst::movsx_m_r(ExtMode::BL, Addr::imm_reg(-7i32 as u32, r10), w_r9),
1280 "450FBE4AF9",
1281 "movsbl -7(%r10), %r9d",
1282 ));
1283 insns.push((
1284 Inst::movsx_m_r(ExtMode::BL, Addr::imm_reg(-7i32 as u32, r11), w_rdx),
1285 "410FBE53F9",
1286 "movsbl -7(%r11), %edx",
1287 ));
1288 insns.push((
1289 Inst::movsx_m_r(ExtMode::BQ, Addr::imm_reg(-7i32 as u32, rcx), w_rsi),
1290 "480FBE71F9",
1291 "movsbq -7(%rcx), %rsi",
1292 ));
1293 insns.push((
1294 Inst::movsx_m_r(ExtMode::BQ, Addr::imm_reg(-7i32 as u32, r8), w_rbx),
1295 "490FBE58F9",
1296 "movsbq -7(%r8), %rbx",
1297 ));
1298 insns.push((
1299 Inst::movsx_m_r(ExtMode::BQ, Addr::imm_reg(-7i32 as u32, r10), w_r9),
1300 "4D0FBE4AF9",
1301 "movsbq -7(%r10), %r9",
1302 ));
1303 insns.push((
1304 Inst::movsx_m_r(ExtMode::BQ, Addr::imm_reg(-7i32 as u32, r11), w_rdx),
1305 "490FBE53F9",
1306 "movsbq -7(%r11), %rdx",
1307 ));
1308 insns.push((
1309 Inst::movsx_m_r(ExtMode::WL, Addr::imm_reg(-7i32 as u32, rcx), w_rsi),
1310 "0FBF71F9",
1311 "movswl -7(%rcx), %esi",
1312 ));
1313 insns.push((
1314 Inst::movsx_m_r(ExtMode::WL, Addr::imm_reg(-7i32 as u32, r8), w_rbx),
1315 "410FBF58F9",
1316 "movswl -7(%r8), %ebx",
1317 ));
1318 insns.push((
1319 Inst::movsx_m_r(ExtMode::WL, Addr::imm_reg(-7i32 as u32, r10), w_r9),
1320 "450FBF4AF9",
1321 "movswl -7(%r10), %r9d",
1322 ));
1323 insns.push((
1324 Inst::movsx_m_r(ExtMode::WL, Addr::imm_reg(-7i32 as u32, r11), w_rdx),
1325 "410FBF53F9",
1326 "movswl -7(%r11), %edx",
1327 ));
1328 insns.push((
1329 Inst::movsx_m_r(ExtMode::WQ, Addr::imm_reg(-7i32 as u32, rcx), w_rsi),
1330 "480FBF71F9",
1331 "movswq -7(%rcx), %rsi",
1332 ));
1333 insns.push((
1334 Inst::movsx_m_r(ExtMode::WQ, Addr::imm_reg(-7i32 as u32, r8), w_rbx),
1335 "490FBF58F9",
1336 "movswq -7(%r8), %rbx",
1337 ));
1338 insns.push((
1339 Inst::movsx_m_r(ExtMode::WQ, Addr::imm_reg(-7i32 as u32, r10), w_r9),
1340 "4D0FBF4AF9",
1341 "movswq -7(%r10), %r9",
1342 ));
1343 insns.push((
1344 Inst::movsx_m_r(ExtMode::WQ, Addr::imm_reg(-7i32 as u32, r11), w_rdx),
1345 "490FBF53F9",
1346 "movswq -7(%r11), %rdx",
1347 ));
1348 insns.push((
1349 Inst::movsx_m_r(ExtMode::LQ, Addr::imm_reg(-7i32 as u32, rcx), w_rsi),
1350 "486371F9",
1351 "movslq -7(%rcx), %rsi",
1352 ));
1353 insns.push((
1354 Inst::movsx_m_r(ExtMode::LQ, Addr::imm_reg(-7i32 as u32, r8), w_rbx),
1355 "496358F9",
1356 "movslq -7(%r8), %rbx",
1357 ));
1358 insns.push((
1359 Inst::movsx_m_r(ExtMode::LQ, Addr::imm_reg(-7i32 as u32, r10), w_r9),
1360 "4D634AF9",
1361 "movslq -7(%r10), %r9",
1362 ));
1363 insns.push((
1364 Inst::movsx_m_r(ExtMode::LQ, Addr::imm_reg(-7i32 as u32, r11), w_rdx),
1365 "496353F9",
1366 "movslq -7(%r11), %rdx",
1367 ));
1368
1369 // ========================================================
1370 // Mov_R_M. Byte stores are tricky. Check everything carefully.
1371 insns.push((
1372 Inst::mov_r_m(8, rax, Addr::imm_reg(99, rdi)),
1373 "48894763",
1374 "movq %rax, 99(%rdi)",
1375 ));
1376 insns.push((
1377 Inst::mov_r_m(8, rbx, Addr::imm_reg(99, r8)),
1378 "49895863",
1379 "movq %rbx, 99(%r8)",
1380 ));
1381 insns.push((
1382 Inst::mov_r_m(8, rcx, Addr::imm_reg(99, rsi)),
1383 "48894E63",
1384 "movq %rcx, 99(%rsi)",
1385 ));
1386 insns.push((
1387 Inst::mov_r_m(8, rdx, Addr::imm_reg(99, r9)),
1388 "49895163",
1389 "movq %rdx, 99(%r9)",
1390 ));
1391 insns.push((
1392 Inst::mov_r_m(8, rsi, Addr::imm_reg(99, rax)),
1393 "48897063",
1394 "movq %rsi, 99(%rax)",
1395 ));
1396 insns.push((
1397 Inst::mov_r_m(8, rdi, Addr::imm_reg(99, r15)),
1398 "49897F63",
1399 "movq %rdi, 99(%r15)",
1400 ));
1401 insns.push((
1402 Inst::mov_r_m(8, rsp, Addr::imm_reg(99, rcx)),
1403 "48896163",
1404 "movq %rsp, 99(%rcx)",
1405 ));
1406 insns.push((
1407 Inst::mov_r_m(8, rbp, Addr::imm_reg(99, r14)),
1408 "49896E63",
1409 "movq %rbp, 99(%r14)",
1410 ));
1411 insns.push((
1412 Inst::mov_r_m(8, r8, Addr::imm_reg(99, rdi)),
1413 "4C894763",
1414 "movq %r8, 99(%rdi)",
1415 ));
1416 insns.push((
1417 Inst::mov_r_m(8, r9, Addr::imm_reg(99, r8)),
1418 "4D894863",
1419 "movq %r9, 99(%r8)",
1420 ));
1421 insns.push((
1422 Inst::mov_r_m(8, r10, Addr::imm_reg(99, rsi)),
1423 "4C895663",
1424 "movq %r10, 99(%rsi)",
1425 ));
1426 insns.push((
1427 Inst::mov_r_m(8, r11, Addr::imm_reg(99, r9)),
1428 "4D895963",
1429 "movq %r11, 99(%r9)",
1430 ));
1431 insns.push((
1432 Inst::mov_r_m(8, r12, Addr::imm_reg(99, rax)),
1433 "4C896063",
1434 "movq %r12, 99(%rax)",
1435 ));
1436 insns.push((
1437 Inst::mov_r_m(8, r13, Addr::imm_reg(99, r15)),
1438 "4D896F63",
1439 "movq %r13, 99(%r15)",
1440 ));
1441 insns.push((
1442 Inst::mov_r_m(8, r14, Addr::imm_reg(99, rcx)),
1443 "4C897163",
1444 "movq %r14, 99(%rcx)",
1445 ));
1446 insns.push((
1447 Inst::mov_r_m(8, r15, Addr::imm_reg(99, r14)),
1448 "4D897E63",
1449 "movq %r15, 99(%r14)",
1450 ));
1451 //
1452 insns.push((
1453 Inst::mov_r_m(4, rax, Addr::imm_reg(99, rdi)),
1454 "894763",
1455 "movl %eax, 99(%rdi)",
1456 ));
1457 insns.push((
1458 Inst::mov_r_m(4, rbx, Addr::imm_reg(99, r8)),
1459 "41895863",
1460 "movl %ebx, 99(%r8)",
1461 ));
1462 insns.push((
1463 Inst::mov_r_m(4, rcx, Addr::imm_reg(99, rsi)),
1464 "894E63",
1465 "movl %ecx, 99(%rsi)",
1466 ));
1467 insns.push((
1468 Inst::mov_r_m(4, rdx, Addr::imm_reg(99, r9)),
1469 "41895163",
1470 "movl %edx, 99(%r9)",
1471 ));
1472 insns.push((
1473 Inst::mov_r_m(4, rsi, Addr::imm_reg(99, rax)),
1474 "897063",
1475 "movl %esi, 99(%rax)",
1476 ));
1477 insns.push((
1478 Inst::mov_r_m(4, rdi, Addr::imm_reg(99, r15)),
1479 "41897F63",
1480 "movl %edi, 99(%r15)",
1481 ));
1482 insns.push((
1483 Inst::mov_r_m(4, rsp, Addr::imm_reg(99, rcx)),
1484 "896163",
1485 "movl %esp, 99(%rcx)",
1486 ));
1487 insns.push((
1488 Inst::mov_r_m(4, rbp, Addr::imm_reg(99, r14)),
1489 "41896E63",
1490 "movl %ebp, 99(%r14)",
1491 ));
1492 insns.push((
1493 Inst::mov_r_m(4, r8, Addr::imm_reg(99, rdi)),
1494 "44894763",
1495 "movl %r8d, 99(%rdi)",
1496 ));
1497 insns.push((
1498 Inst::mov_r_m(4, r9, Addr::imm_reg(99, r8)),
1499 "45894863",
1500 "movl %r9d, 99(%r8)",
1501 ));
1502 insns.push((
1503 Inst::mov_r_m(4, r10, Addr::imm_reg(99, rsi)),
1504 "44895663",
1505 "movl %r10d, 99(%rsi)",
1506 ));
1507 insns.push((
1508 Inst::mov_r_m(4, r11, Addr::imm_reg(99, r9)),
1509 "45895963",
1510 "movl %r11d, 99(%r9)",
1511 ));
1512 insns.push((
1513 Inst::mov_r_m(4, r12, Addr::imm_reg(99, rax)),
1514 "44896063",
1515 "movl %r12d, 99(%rax)",
1516 ));
1517 insns.push((
1518 Inst::mov_r_m(4, r13, Addr::imm_reg(99, r15)),
1519 "45896F63",
1520 "movl %r13d, 99(%r15)",
1521 ));
1522 insns.push((
1523 Inst::mov_r_m(4, r14, Addr::imm_reg(99, rcx)),
1524 "44897163",
1525 "movl %r14d, 99(%rcx)",
1526 ));
1527 insns.push((
1528 Inst::mov_r_m(4, r15, Addr::imm_reg(99, r14)),
1529 "45897E63",
1530 "movl %r15d, 99(%r14)",
1531 ));
1532 //
1533 insns.push((
1534 Inst::mov_r_m(2, rax, Addr::imm_reg(99, rdi)),
1535 "66894763",
1536 "movw %ax, 99(%rdi)",
1537 ));
1538 insns.push((
1539 Inst::mov_r_m(2, rbx, Addr::imm_reg(99, r8)),
1540 "6641895863",
1541 "movw %bx, 99(%r8)",
1542 ));
1543 insns.push((
1544 Inst::mov_r_m(2, rcx, Addr::imm_reg(99, rsi)),
1545 "66894E63",
1546 "movw %cx, 99(%rsi)",
1547 ));
1548 insns.push((
1549 Inst::mov_r_m(2, rdx, Addr::imm_reg(99, r9)),
1550 "6641895163",
1551 "movw %dx, 99(%r9)",
1552 ));
1553 insns.push((
1554 Inst::mov_r_m(2, rsi, Addr::imm_reg(99, rax)),
1555 "66897063",
1556 "movw %si, 99(%rax)",
1557 ));
1558 insns.push((
1559 Inst::mov_r_m(2, rdi, Addr::imm_reg(99, r15)),
1560 "6641897F63",
1561 "movw %di, 99(%r15)",
1562 ));
1563 insns.push((
1564 Inst::mov_r_m(2, rsp, Addr::imm_reg(99, rcx)),
1565 "66896163",
1566 "movw %sp, 99(%rcx)",
1567 ));
1568 insns.push((
1569 Inst::mov_r_m(2, rbp, Addr::imm_reg(99, r14)),
1570 "6641896E63",
1571 "movw %bp, 99(%r14)",
1572 ));
1573 insns.push((
1574 Inst::mov_r_m(2, r8, Addr::imm_reg(99, rdi)),
1575 "6644894763",
1576 "movw %r8w, 99(%rdi)",
1577 ));
1578 insns.push((
1579 Inst::mov_r_m(2, r9, Addr::imm_reg(99, r8)),
1580 "6645894863",
1581 "movw %r9w, 99(%r8)",
1582 ));
1583 insns.push((
1584 Inst::mov_r_m(2, r10, Addr::imm_reg(99, rsi)),
1585 "6644895663",
1586 "movw %r10w, 99(%rsi)",
1587 ));
1588 insns.push((
1589 Inst::mov_r_m(2, r11, Addr::imm_reg(99, r9)),
1590 "6645895963",
1591 "movw %r11w, 99(%r9)",
1592 ));
1593 insns.push((
1594 Inst::mov_r_m(2, r12, Addr::imm_reg(99, rax)),
1595 "6644896063",
1596 "movw %r12w, 99(%rax)",
1597 ));
1598 insns.push((
1599 Inst::mov_r_m(2, r13, Addr::imm_reg(99, r15)),
1600 "6645896F63",
1601 "movw %r13w, 99(%r15)",
1602 ));
1603 insns.push((
1604 Inst::mov_r_m(2, r14, Addr::imm_reg(99, rcx)),
1605 "6644897163",
1606 "movw %r14w, 99(%rcx)",
1607 ));
1608 insns.push((
1609 Inst::mov_r_m(2, r15, Addr::imm_reg(99, r14)),
1610 "6645897E63",
1611 "movw %r15w, 99(%r14)",
1612 ));
1613 //
1614 insns.push((
1615 Inst::mov_r_m(1, rax, Addr::imm_reg(99, rdi)),
1616 "884763",
1617 "movb %al, 99(%rdi)",
1618 ));
1619 insns.push((
1620 Inst::mov_r_m(1, rbx, Addr::imm_reg(99, r8)),
1621 "41885863",
1622 "movb %bl, 99(%r8)",
1623 ));
1624 insns.push((
1625 Inst::mov_r_m(1, rcx, Addr::imm_reg(99, rsi)),
1626 "884E63",
1627 "movb %cl, 99(%rsi)",
1628 ));
1629 insns.push((
1630 Inst::mov_r_m(1, rdx, Addr::imm_reg(99, r9)),
1631 "41885163",
1632 "movb %dl, 99(%r9)",
1633 ));
1634 insns.push((
1635 Inst::mov_r_m(1, rsi, Addr::imm_reg(99, rax)),
1636 "40887063",
1637 "movb %sil, 99(%rax)",
1638 ));
1639 insns.push((
1640 Inst::mov_r_m(1, rdi, Addr::imm_reg(99, r15)),
1641 "41887F63",
1642 "movb %dil, 99(%r15)",
1643 ));
1644 insns.push((
1645 Inst::mov_r_m(1, rsp, Addr::imm_reg(99, rcx)),
1646 "40886163",
1647 "movb %spl, 99(%rcx)",
1648 ));
1649 insns.push((
1650 Inst::mov_r_m(1, rbp, Addr::imm_reg(99, r14)),
1651 "41886E63",
1652 "movb %bpl, 99(%r14)",
1653 ));
1654 insns.push((
1655 Inst::mov_r_m(1, r8, Addr::imm_reg(99, rdi)),
1656 "44884763",
1657 "movb %r8b, 99(%rdi)",
1658 ));
1659 insns.push((
1660 Inst::mov_r_m(1, r9, Addr::imm_reg(99, r8)),
1661 "45884863",
1662 "movb %r9b, 99(%r8)",
1663 ));
1664 insns.push((
1665 Inst::mov_r_m(1, r10, Addr::imm_reg(99, rsi)),
1666 "44885663",
1667 "movb %r10b, 99(%rsi)",
1668 ));
1669 insns.push((
1670 Inst::mov_r_m(1, r11, Addr::imm_reg(99, r9)),
1671 "45885963",
1672 "movb %r11b, 99(%r9)",
1673 ));
1674 insns.push((
1675 Inst::mov_r_m(1, r12, Addr::imm_reg(99, rax)),
1676 "44886063",
1677 "movb %r12b, 99(%rax)",
1678 ));
1679 insns.push((
1680 Inst::mov_r_m(1, r13, Addr::imm_reg(99, r15)),
1681 "45886F63",
1682 "movb %r13b, 99(%r15)",
1683 ));
1684 insns.push((
1685 Inst::mov_r_m(1, r14, Addr::imm_reg(99, rcx)),
1686 "44887163",
1687 "movb %r14b, 99(%rcx)",
1688 ));
1689 insns.push((
1690 Inst::mov_r_m(1, r15, Addr::imm_reg(99, r14)),
1691 "45887E63",
1692 "movb %r15b, 99(%r14)",
1693 ));
1694
1695 // ========================================================
1696 // Shift_R
1697 insns.push((
1698 Inst::shift_r(false, ShiftKind::Left, None, w_rdi),
1699 "D3E7",
1700 "shll %cl, %edi",
1701 ));
1702 insns.push((
1703 Inst::shift_r(false, ShiftKind::Left, None, w_r12),
1704 "41D3E4",
1705 "shll %cl, %r12d",
1706 ));
1707 insns.push((
1708 Inst::shift_r(false, ShiftKind::Left, Some(2), w_r8),
1709 "41C1E002",
1710 "shll $2, %r8d",
1711 ));
1712 insns.push((
1713 Inst::shift_r(false, ShiftKind::Left, Some(31), w_r13),
1714 "41C1E51F",
1715 "shll $31, %r13d",
1716 ));
1717 insns.push((
1718 Inst::shift_r(true, ShiftKind::Left, None, w_r13),
1719 "49D3E5",
1720 "shlq %cl, %r13",
1721 ));
1722 insns.push((
1723 Inst::shift_r(true, ShiftKind::Left, None, w_rdi),
1724 "48D3E7",
1725 "shlq %cl, %rdi",
1726 ));
1727 insns.push((
1728 Inst::shift_r(true, ShiftKind::Left, Some(2), w_r8),
1729 "49C1E002",
1730 "shlq $2, %r8",
1731 ));
1732 insns.push((
1733 Inst::shift_r(true, ShiftKind::Left, Some(3), w_rbx),
1734 "48C1E303",
1735 "shlq $3, %rbx",
1736 ));
1737 insns.push((
1738 Inst::shift_r(true, ShiftKind::Left, Some(63), w_r13),
1739 "49C1E53F",
1740 "shlq $63, %r13",
1741 ));
1742 insns.push((
1743 Inst::shift_r(false, ShiftKind::RightZ, None, w_rdi),
1744 "D3EF",
1745 "shrl %cl, %edi",
1746 ));
1747 insns.push((
1748 Inst::shift_r(false, ShiftKind::RightZ, Some(2), w_r8),
1749 "41C1E802",
1750 "shrl $2, %r8d",
1751 ));
1752 insns.push((
1753 Inst::shift_r(false, ShiftKind::RightZ, Some(31), w_r13),
1754 "41C1ED1F",
1755 "shrl $31, %r13d",
1756 ));
1757 insns.push((
1758 Inst::shift_r(true, ShiftKind::RightZ, None, w_rdi),
1759 "48D3EF",
1760 "shrq %cl, %rdi",
1761 ));
1762 insns.push((
1763 Inst::shift_r(true, ShiftKind::RightZ, Some(2), w_r8),
1764 "49C1E802",
1765 "shrq $2, %r8",
1766 ));
1767 insns.push((
1768 Inst::shift_r(true, ShiftKind::RightZ, Some(63), w_r13),
1769 "49C1ED3F",
1770 "shrq $63, %r13",
1771 ));
1772 insns.push((
1773 Inst::shift_r(false, ShiftKind::RightS, None, w_rdi),
1774 "D3FF",
1775 "sarl %cl, %edi",
1776 ));
1777 insns.push((
1778 Inst::shift_r(false, ShiftKind::RightS, Some(2), w_r8),
1779 "41C1F802",
1780 "sarl $2, %r8d",
1781 ));
1782 insns.push((
1783 Inst::shift_r(false, ShiftKind::RightS, Some(31), w_r13),
1784 "41C1FD1F",
1785 "sarl $31, %r13d",
1786 ));
1787 insns.push((
1788 Inst::shift_r(true, ShiftKind::RightS, None, w_rdi),
1789 "48D3FF",
1790 "sarq %cl, %rdi",
1791 ));
1792 insns.push((
1793 Inst::shift_r(true, ShiftKind::RightS, Some(2), w_r8),
1794 "49C1F802",
1795 "sarq $2, %r8",
1796 ));
1797 insns.push((
1798 Inst::shift_r(true, ShiftKind::RightS, Some(63), w_r13),
1799 "49C1FD3F",
1800 "sarq $63, %r13",
1801 ));
1802
1803 // ========================================================
1804 // CmpRMIR
1805 insns.push((
1806 Inst::cmp_rmi_r(8, RMI::reg(r15), rdx),
1807 "4C39FA",
1808 "cmpq %r15, %rdx",
1809 ));
1810 insns.push((
1811 Inst::cmp_rmi_r(8, RMI::reg(rcx), r8),
1812 "4939C8",
1813 "cmpq %rcx, %r8",
1814 ));
1815 insns.push((
1816 Inst::cmp_rmi_r(8, RMI::reg(rcx), rsi),
1817 "4839CE",
1818 "cmpq %rcx, %rsi",
1819 ));
1820 insns.push((
1821 Inst::cmp_rmi_r(8, RMI::mem(Addr::imm_reg(99, rdi)), rdx),
1822 "483B5763",
1823 "cmpq 99(%rdi), %rdx",
1824 ));
1825 insns.push((
1826 Inst::cmp_rmi_r(8, RMI::mem(Addr::imm_reg(99, rdi)), r8),
1827 "4C3B4763",
1828 "cmpq 99(%rdi), %r8",
1829 ));
1830 insns.push((
1831 Inst::cmp_rmi_r(8, RMI::mem(Addr::imm_reg(99, rdi)), rsi),
1832 "483B7763",
1833 "cmpq 99(%rdi), %rsi",
1834 ));
1835 insns.push((
1836 Inst::cmp_rmi_r(8, RMI::imm(76543210), rdx),
1837 "4881FAEAF48F04",
1838 "cmpq $76543210, %rdx",
1839 ));
1840 insns.push((
1841 Inst::cmp_rmi_r(8, RMI::imm(-76543210i32 as u32), r8),
1842 "4981F8160B70FB",
1843 "cmpq $-76543210, %r8",
1844 ));
1845 insns.push((
1846 Inst::cmp_rmi_r(8, RMI::imm(76543210), rsi),
1847 "4881FEEAF48F04",
1848 "cmpq $76543210, %rsi",
1849 ));
1850 //
1851 insns.push((
1852 Inst::cmp_rmi_r(4, RMI::reg(r15), rdx),
1853 "4439FA",
1854 "cmpl %r15d, %edx",
1855 ));
1856 insns.push((
1857 Inst::cmp_rmi_r(4, RMI::reg(rcx), r8),
1858 "4139C8",
1859 "cmpl %ecx, %r8d",
1860 ));
1861 insns.push((
1862 Inst::cmp_rmi_r(4, RMI::reg(rcx), rsi),
1863 "39CE",
1864 "cmpl %ecx, %esi",
1865 ));
1866 insns.push((
1867 Inst::cmp_rmi_r(4, RMI::mem(Addr::imm_reg(99, rdi)), rdx),
1868 "3B5763",
1869 "cmpl 99(%rdi), %edx",
1870 ));
1871 insns.push((
1872 Inst::cmp_rmi_r(4, RMI::mem(Addr::imm_reg(99, rdi)), r8),
1873 "443B4763",
1874 "cmpl 99(%rdi), %r8d",
1875 ));
1876 insns.push((
1877 Inst::cmp_rmi_r(4, RMI::mem(Addr::imm_reg(99, rdi)), rsi),
1878 "3B7763",
1879 "cmpl 99(%rdi), %esi",
1880 ));
1881 insns.push((
1882 Inst::cmp_rmi_r(4, RMI::imm(76543210), rdx),
1883 "81FAEAF48F04",
1884 "cmpl $76543210, %edx",
1885 ));
1886 insns.push((
1887 Inst::cmp_rmi_r(4, RMI::imm(-76543210i32 as u32), r8),
1888 "4181F8160B70FB",
1889 "cmpl $-76543210, %r8d",
1890 ));
1891 insns.push((
1892 Inst::cmp_rmi_r(4, RMI::imm(76543210), rsi),
1893 "81FEEAF48F04",
1894 "cmpl $76543210, %esi",
1895 ));
1896 //
1897 insns.push((
1898 Inst::cmp_rmi_r(2, RMI::reg(r15), rdx),
1899 "664439FA",
1900 "cmpw %r15w, %dx",
1901 ));
1902 insns.push((
1903 Inst::cmp_rmi_r(2, RMI::reg(rcx), r8),
1904 "664139C8",
1905 "cmpw %cx, %r8w",
1906 ));
1907 insns.push((
1908 Inst::cmp_rmi_r(2, RMI::reg(rcx), rsi),
1909 "6639CE",
1910 "cmpw %cx, %si",
1911 ));
1912 insns.push((
1913 Inst::cmp_rmi_r(2, RMI::mem(Addr::imm_reg(99, rdi)), rdx),
1914 "663B5763",
1915 "cmpw 99(%rdi), %dx",
1916 ));
1917 insns.push((
1918 Inst::cmp_rmi_r(2, RMI::mem(Addr::imm_reg(99, rdi)), r8),
1919 "66443B4763",
1920 "cmpw 99(%rdi), %r8w",
1921 ));
1922 insns.push((
1923 Inst::cmp_rmi_r(2, RMI::mem(Addr::imm_reg(99, rdi)), rsi),
1924 "663B7763",
1925 "cmpw 99(%rdi), %si",
1926 ));
1927 insns.push((
1928 Inst::cmp_rmi_r(2, RMI::imm(23210), rdx),
1929 "6681FAAA5A",
1930 "cmpw $23210, %dx",
1931 ));
1932 insns.push((
1933 Inst::cmp_rmi_r(2, RMI::imm(-7654i32 as u32), r8),
1934 "664181F81AE2",
1935 "cmpw $-7654, %r8w",
1936 ));
1937 insns.push((
1938 Inst::cmp_rmi_r(2, RMI::imm(7654), rsi),
1939 "6681FEE61D",
1940 "cmpw $7654, %si",
1941 ));
1942 //
1943 insns.push((
1944 Inst::cmp_rmi_r(1, RMI::reg(r15), rdx),
1945 "4438FA",
1946 "cmpb %r15b, %dl",
1947 ));
1948 insns.push((
1949 Inst::cmp_rmi_r(1, RMI::reg(rcx), r8),
1950 "4138C8",
1951 "cmpb %cl, %r8b",
1952 ));
1953 insns.push((
1954 Inst::cmp_rmi_r(1, RMI::reg(rcx), rsi),
1955 "4038CE",
1956 "cmpb %cl, %sil",
1957 ));
1958 insns.push((
1959 Inst::cmp_rmi_r(1, RMI::mem(Addr::imm_reg(99, rdi)), rdx),
1960 "3A5763",
1961 "cmpb 99(%rdi), %dl",
1962 ));
1963 insns.push((
1964 Inst::cmp_rmi_r(1, RMI::mem(Addr::imm_reg(99, rdi)), r8),
1965 "443A4763",
1966 "cmpb 99(%rdi), %r8b",
1967 ));
1968 insns.push((
1969 Inst::cmp_rmi_r(1, RMI::mem(Addr::imm_reg(99, rdi)), rsi),
1970 "403A7763",
1971 "cmpb 99(%rdi), %sil",
1972 ));
1973 insns.push((
1974 Inst::cmp_rmi_r(1, RMI::imm(70), rdx),
1975 "80FA46",
1976 "cmpb $70, %dl",
1977 ));
1978 insns.push((
1979 Inst::cmp_rmi_r(1, RMI::imm(-76i32 as u32), r8),
1980 "4180F8B4",
1981 "cmpb $-76, %r8b",
1982 ));
1983 insns.push((
1984 Inst::cmp_rmi_r(1, RMI::imm(76), rsi),
1985 "4080FE4C",
1986 "cmpb $76, %sil",
1987 ));
1988 // Extra byte-cases (paranoia!) for cmp_rmi_r for first operand = R
1989 insns.push((
1990 Inst::cmp_rmi_r(1, RMI::reg(rax), rbx),
1991 "38C3",
1992 "cmpb %al, %bl",
1993 ));
1994 insns.push((
1995 Inst::cmp_rmi_r(1, RMI::reg(rbx), rax),
1996 "38D8",
1997 "cmpb %bl, %al",
1998 ));
1999 insns.push((
2000 Inst::cmp_rmi_r(1, RMI::reg(rcx), rdx),
2001 "38CA",
2002 "cmpb %cl, %dl",
2003 ));
2004 insns.push((
2005 Inst::cmp_rmi_r(1, RMI::reg(rcx), rsi),
2006 "4038CE",
2007 "cmpb %cl, %sil",
2008 ));
2009 insns.push((
2010 Inst::cmp_rmi_r(1, RMI::reg(rcx), r10),
2011 "4138CA",
2012 "cmpb %cl, %r10b",
2013 ));
2014 insns.push((
2015 Inst::cmp_rmi_r(1, RMI::reg(rcx), r14),
2016 "4138CE",
2017 "cmpb %cl, %r14b",
2018 ));
2019 insns.push((
2020 Inst::cmp_rmi_r(1, RMI::reg(rbp), rdx),
2021 "4038EA",
2022 "cmpb %bpl, %dl",
2023 ));
2024 insns.push((
2025 Inst::cmp_rmi_r(1, RMI::reg(rbp), rsi),
2026 "4038EE",
2027 "cmpb %bpl, %sil",
2028 ));
2029 insns.push((
2030 Inst::cmp_rmi_r(1, RMI::reg(rbp), r10),
2031 "4138EA",
2032 "cmpb %bpl, %r10b",
2033 ));
2034 insns.push((
2035 Inst::cmp_rmi_r(1, RMI::reg(rbp), r14),
2036 "4138EE",
2037 "cmpb %bpl, %r14b",
2038 ));
2039 insns.push((
2040 Inst::cmp_rmi_r(1, RMI::reg(r9), rdx),
2041 "4438CA",
2042 "cmpb %r9b, %dl",
2043 ));
2044 insns.push((
2045 Inst::cmp_rmi_r(1, RMI::reg(r9), rsi),
2046 "4438CE",
2047 "cmpb %r9b, %sil",
2048 ));
2049 insns.push((
2050 Inst::cmp_rmi_r(1, RMI::reg(r9), r10),
2051 "4538CA",
2052 "cmpb %r9b, %r10b",
2053 ));
2054 insns.push((
2055 Inst::cmp_rmi_r(1, RMI::reg(r9), r14),
2056 "4538CE",
2057 "cmpb %r9b, %r14b",
2058 ));
2059 insns.push((
2060 Inst::cmp_rmi_r(1, RMI::reg(r13), rdx),
2061 "4438EA",
2062 "cmpb %r13b, %dl",
2063 ));
2064 insns.push((
2065 Inst::cmp_rmi_r(1, RMI::reg(r13), rsi),
2066 "4438EE",
2067 "cmpb %r13b, %sil",
2068 ));
2069 insns.push((
2070 Inst::cmp_rmi_r(1, RMI::reg(r13), r10),
2071 "4538EA",
2072 "cmpb %r13b, %r10b",
2073 ));
2074 insns.push((
2075 Inst::cmp_rmi_r(1, RMI::reg(r13), r14),
2076 "4538EE",
2077 "cmpb %r13b, %r14b",
2078 ));
2079
2080 // ========================================================
2081 // Push64
2082 insns.push((Inst::push64(RMI::reg(rdi)), "57", "pushq %rdi"));
2083 insns.push((Inst::push64(RMI::reg(r8)), "4150", "pushq %r8"));
2084 insns.push((
2085 Inst::push64(RMI::mem(Addr::imm_reg_reg_shift(321, rsi, rcx, 3))),
2086 "FFB4CE41010000",
2087 "pushq 321(%rsi,%rcx,8)",
2088 ));
2089 insns.push((
2090 Inst::push64(RMI::mem(Addr::imm_reg_reg_shift(321, r9, rbx, 2))),
2091 "41FFB49941010000",
2092 "pushq 321(%r9,%rbx,4)",
2093 ));
2094 insns.push((Inst::push64(RMI::imm(0)), "6A00", "pushq $0"));
2095 insns.push((Inst::push64(RMI::imm(127)), "6A7F", "pushq $127"));
2096 insns.push((Inst::push64(RMI::imm(128)), "6880000000", "pushq $128"));
2097 insns.push((
2098 Inst::push64(RMI::imm(0x31415927)),
2099 "6827594131",
2100 "pushq $826366247",
2101 ));
2102 insns.push((
2103 Inst::push64(RMI::imm(-128i32 as u32)),
2104 "6A80",
2105 "pushq $-128",
2106 ));
2107 insns.push((
2108 Inst::push64(RMI::imm(-129i32 as u32)),
2109 "687FFFFFFF",
2110 "pushq $-129",
2111 ));
2112 insns.push((
2113 Inst::push64(RMI::imm(-0x75c4e8a1i32 as u32)),
2114 "685F173B8A",
2115 "pushq $-1975838881",
2116 ));
2117
2118 // ========================================================
2119 // Pop64
2120 insns.push((Inst::pop64(w_rax), "58", "popq %rax"));
2121 insns.push((Inst::pop64(w_rdi), "5F", "popq %rdi"));
2122 insns.push((Inst::pop64(w_r8), "4158", "popq %r8"));
2123 insns.push((Inst::pop64(w_r15), "415F", "popq %r15"));
2124
2125 // ========================================================
2126 // CallKnown skipped for now
2127
2128 // ========================================================
2129 // CallUnknown
2130 insns.push((Inst::call_unknown(RM::reg(rbp)), "FFD5", "call *%rbp"));
2131 insns.push((Inst::call_unknown(RM::reg(r11)), "41FFD3", "call *%r11"));
2132 insns.push((
2133 Inst::call_unknown(RM::mem(Addr::imm_reg_reg_shift(321, rsi, rcx, 3))),
2134 "FF94CE41010000",
2135 "call *321(%rsi,%rcx,8)",
2136 ));
2137 insns.push((
2138 Inst::call_unknown(RM::mem(Addr::imm_reg_reg_shift(321, r10, rdx, 2))),
2139 "41FF949241010000",
2140 "call *321(%r10,%rdx,4)",
2141 ));
2142
2143 // ========================================================
2144 // Ret
2145 insns.push((Inst::ret(), "C3", "ret"));
2146
2147 // ========================================================
2148 // JmpKnown skipped for now
2149
2150 // ========================================================
2151 // JmpCondSymm isn't a real instruction
2152
2153 // ========================================================
2154 // JmpCond skipped for now
2155
2156 // ========================================================
2157 // JmpCondCompound isn't a real instruction
2158
2159 // ========================================================
2160 // JmpUnknown
2161 insns.push((Inst::jmp_unknown(RM::reg(rbp)), "FFE5", "jmp *%rbp"));
2162 insns.push((Inst::jmp_unknown(RM::reg(r11)), "41FFE3", "jmp *%r11"));
2163 insns.push((
2164 Inst::jmp_unknown(RM::mem(Addr::imm_reg_reg_shift(321, rsi, rcx, 3))),
2165 "FFA4CE41010000",
2166 "jmp *321(%rsi,%rcx,8)",
2167 ));
2168 insns.push((
2169 Inst::jmp_unknown(RM::mem(Addr::imm_reg_reg_shift(321, r10, rdx, 2))),
2170 "41FFA49241010000",
2171 "jmp *321(%r10,%rdx,4)",
2172 ));
2173
2174 // ========================================================
2175 // Actually run the tests!
2176 let flags = settings::Flags::new(settings::builder());
2177 let rru = regs::create_reg_universe_systemv(&flags);
2178 for (insn, expected_encoding, expected_printing) in insns {
2179 // Check the printed text is as expected.
2180 let actual_printing = insn.show_rru(Some(&rru));
2181 assert_eq!(expected_printing, actual_printing);
2182
2183 let mut sink = test_utils::TestCodeSink::new();
2184 let mut buffer = MachBuffer::new();
2185 insn.emit(&mut buffer, &flags, &mut Default::default());
2186 let buffer = buffer.finish();
2187 buffer.emit(&mut sink);
2188 let actual_encoding = &sink.stringify();
2189 assert_eq!(expected_encoding, actual_encoding);
2190 }
2191 }
2192