1 // Copyright 2015, ARM Limited
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are met:
6 //
7 // * Redistributions of source code must retain the above copyright notice,
8 // this list of conditions and the following disclaimer.
9 // * Redistributions in binary form must reproduce the above copyright notice,
10 // this list of conditions and the following disclaimer in the documentation
11 // and/or other materials provided with the distribution.
12 // * Neither the name of ARM Limited nor the names of its contributors may be
13 // used to endorse or promote products derived from this software without
14 // specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND
17 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
20 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
27 #include <cstdlib>
28 #include "vixl/a64/disasm-a64.h"
29
30 namespace vixl {
31
Disassembler()32 Disassembler::Disassembler() {
33 buffer_size_ = 256;
34 buffer_ = reinterpret_cast<char*>(malloc(buffer_size_));
35 buffer_pos_ = 0;
36 own_buffer_ = true;
37 code_address_offset_ = 0;
38 }
39
40
Disassembler(char * text_buffer,int buffer_size)41 Disassembler::Disassembler(char* text_buffer, int buffer_size) {
42 buffer_size_ = buffer_size;
43 buffer_ = text_buffer;
44 buffer_pos_ = 0;
45 own_buffer_ = false;
46 code_address_offset_ = 0;
47 }
48
49
~Disassembler()50 Disassembler::~Disassembler() {
51 if (own_buffer_) {
52 free(buffer_);
53 }
54 }
55
56
GetOutput()57 char* Disassembler::GetOutput() {
58 return buffer_;
59 }
60
61
VisitAddSubImmediate(const Instruction * instr)62 void Disassembler::VisitAddSubImmediate(const Instruction* instr) {
63 bool rd_is_zr = RdIsZROrSP(instr);
64 bool stack_op = (rd_is_zr || RnIsZROrSP(instr)) &&
65 (instr->ImmAddSub() == 0) ? true : false;
66 const char *mnemonic = "";
67 const char *form = "'Rds, 'Rns, 'IAddSub";
68 const char *form_cmp = "'Rns, 'IAddSub";
69 const char *form_mov = "'Rds, 'Rns";
70
71 switch (instr->Mask(AddSubImmediateMask)) {
72 case ADD_w_imm:
73 case ADD_x_imm: {
74 mnemonic = "add";
75 if (stack_op) {
76 mnemonic = "mov";
77 form = form_mov;
78 }
79 break;
80 }
81 case ADDS_w_imm:
82 case ADDS_x_imm: {
83 mnemonic = "adds";
84 if (rd_is_zr) {
85 mnemonic = "cmn";
86 form = form_cmp;
87 }
88 break;
89 }
90 case SUB_w_imm:
91 case SUB_x_imm: mnemonic = "sub"; break;
92 case SUBS_w_imm:
93 case SUBS_x_imm: {
94 mnemonic = "subs";
95 if (rd_is_zr) {
96 mnemonic = "cmp";
97 form = form_cmp;
98 }
99 break;
100 }
101 default: VIXL_UNREACHABLE();
102 }
103 Format(instr, mnemonic, form);
104 }
105
106
VisitAddSubShifted(const Instruction * instr)107 void Disassembler::VisitAddSubShifted(const Instruction* instr) {
108 bool rd_is_zr = RdIsZROrSP(instr);
109 bool rn_is_zr = RnIsZROrSP(instr);
110 const char *mnemonic = "";
111 const char *form = "'Rd, 'Rn, 'Rm'NDP";
112 const char *form_cmp = "'Rn, 'Rm'NDP";
113 const char *form_neg = "'Rd, 'Rm'NDP";
114
115 switch (instr->Mask(AddSubShiftedMask)) {
116 case ADD_w_shift:
117 case ADD_x_shift: mnemonic = "add"; break;
118 case ADDS_w_shift:
119 case ADDS_x_shift: {
120 mnemonic = "adds";
121 if (rd_is_zr) {
122 mnemonic = "cmn";
123 form = form_cmp;
124 }
125 break;
126 }
127 case SUB_w_shift:
128 case SUB_x_shift: {
129 mnemonic = "sub";
130 if (rn_is_zr) {
131 mnemonic = "neg";
132 form = form_neg;
133 }
134 break;
135 }
136 case SUBS_w_shift:
137 case SUBS_x_shift: {
138 mnemonic = "subs";
139 if (rd_is_zr) {
140 mnemonic = "cmp";
141 form = form_cmp;
142 } else if (rn_is_zr) {
143 mnemonic = "negs";
144 form = form_neg;
145 }
146 break;
147 }
148 default: VIXL_UNREACHABLE();
149 }
150 Format(instr, mnemonic, form);
151 }
152
153
VisitAddSubExtended(const Instruction * instr)154 void Disassembler::VisitAddSubExtended(const Instruction* instr) {
155 bool rd_is_zr = RdIsZROrSP(instr);
156 const char *mnemonic = "";
157 Extend mode = static_cast<Extend>(instr->ExtendMode());
158 const char *form = ((mode == UXTX) || (mode == SXTX)) ?
159 "'Rds, 'Rns, 'Xm'Ext" : "'Rds, 'Rns, 'Wm'Ext";
160 const char *form_cmp = ((mode == UXTX) || (mode == SXTX)) ?
161 "'Rns, 'Xm'Ext" : "'Rns, 'Wm'Ext";
162
163 switch (instr->Mask(AddSubExtendedMask)) {
164 case ADD_w_ext:
165 case ADD_x_ext: mnemonic = "add"; break;
166 case ADDS_w_ext:
167 case ADDS_x_ext: {
168 mnemonic = "adds";
169 if (rd_is_zr) {
170 mnemonic = "cmn";
171 form = form_cmp;
172 }
173 break;
174 }
175 case SUB_w_ext:
176 case SUB_x_ext: mnemonic = "sub"; break;
177 case SUBS_w_ext:
178 case SUBS_x_ext: {
179 mnemonic = "subs";
180 if (rd_is_zr) {
181 mnemonic = "cmp";
182 form = form_cmp;
183 }
184 break;
185 }
186 default: VIXL_UNREACHABLE();
187 }
188 Format(instr, mnemonic, form);
189 }
190
191
VisitAddSubWithCarry(const Instruction * instr)192 void Disassembler::VisitAddSubWithCarry(const Instruction* instr) {
193 bool rn_is_zr = RnIsZROrSP(instr);
194 const char *mnemonic = "";
195 const char *form = "'Rd, 'Rn, 'Rm";
196 const char *form_neg = "'Rd, 'Rm";
197
198 switch (instr->Mask(AddSubWithCarryMask)) {
199 case ADC_w:
200 case ADC_x: mnemonic = "adc"; break;
201 case ADCS_w:
202 case ADCS_x: mnemonic = "adcs"; break;
203 case SBC_w:
204 case SBC_x: {
205 mnemonic = "sbc";
206 if (rn_is_zr) {
207 mnemonic = "ngc";
208 form = form_neg;
209 }
210 break;
211 }
212 case SBCS_w:
213 case SBCS_x: {
214 mnemonic = "sbcs";
215 if (rn_is_zr) {
216 mnemonic = "ngcs";
217 form = form_neg;
218 }
219 break;
220 }
221 default: VIXL_UNREACHABLE();
222 }
223 Format(instr, mnemonic, form);
224 }
225
226
VisitLogicalImmediate(const Instruction * instr)227 void Disassembler::VisitLogicalImmediate(const Instruction* instr) {
228 bool rd_is_zr = RdIsZROrSP(instr);
229 bool rn_is_zr = RnIsZROrSP(instr);
230 const char *mnemonic = "";
231 const char *form = "'Rds, 'Rn, 'ITri";
232
233 if (instr->ImmLogical() == 0) {
234 // The immediate encoded in the instruction is not in the expected format.
235 Format(instr, "unallocated", "(LogicalImmediate)");
236 return;
237 }
238
239 switch (instr->Mask(LogicalImmediateMask)) {
240 case AND_w_imm:
241 case AND_x_imm: mnemonic = "and"; break;
242 case ORR_w_imm:
243 case ORR_x_imm: {
244 mnemonic = "orr";
245 unsigned reg_size = (instr->SixtyFourBits() == 1) ? kXRegSize
246 : kWRegSize;
247 if (rn_is_zr && !IsMovzMovnImm(reg_size, instr->ImmLogical())) {
248 mnemonic = "mov";
249 form = "'Rds, 'ITri";
250 }
251 break;
252 }
253 case EOR_w_imm:
254 case EOR_x_imm: mnemonic = "eor"; break;
255 case ANDS_w_imm:
256 case ANDS_x_imm: {
257 mnemonic = "ands";
258 if (rd_is_zr) {
259 mnemonic = "tst";
260 form = "'Rn, 'ITri";
261 }
262 break;
263 }
264 default: VIXL_UNREACHABLE();
265 }
266 Format(instr, mnemonic, form);
267 }
268
269
IsMovzMovnImm(unsigned reg_size,uint64_t value)270 bool Disassembler::IsMovzMovnImm(unsigned reg_size, uint64_t value) {
271 VIXL_ASSERT((reg_size == kXRegSize) ||
272 ((reg_size == kWRegSize) && (value <= 0xffffffff)));
273
274 // Test for movz: 16 bits set at positions 0, 16, 32 or 48.
275 if (((value & UINT64_C(0xffffffffffff0000)) == 0) ||
276 ((value & UINT64_C(0xffffffff0000ffff)) == 0) ||
277 ((value & UINT64_C(0xffff0000ffffffff)) == 0) ||
278 ((value & UINT64_C(0x0000ffffffffffff)) == 0)) {
279 return true;
280 }
281
282 // Test for movn: NOT(16 bits set at positions 0, 16, 32 or 48).
283 if ((reg_size == kXRegSize) &&
284 (((~value & UINT64_C(0xffffffffffff0000)) == 0) ||
285 ((~value & UINT64_C(0xffffffff0000ffff)) == 0) ||
286 ((~value & UINT64_C(0xffff0000ffffffff)) == 0) ||
287 ((~value & UINT64_C(0x0000ffffffffffff)) == 0))) {
288 return true;
289 }
290 if ((reg_size == kWRegSize) &&
291 (((value & 0xffff0000) == 0xffff0000) ||
292 ((value & 0x0000ffff) == 0x0000ffff))) {
293 return true;
294 }
295 return false;
296 }
297
298
VisitLogicalShifted(const Instruction * instr)299 void Disassembler::VisitLogicalShifted(const Instruction* instr) {
300 bool rd_is_zr = RdIsZROrSP(instr);
301 bool rn_is_zr = RnIsZROrSP(instr);
302 const char *mnemonic = "";
303 const char *form = "'Rd, 'Rn, 'Rm'NLo";
304
305 switch (instr->Mask(LogicalShiftedMask)) {
306 case AND_w:
307 case AND_x: mnemonic = "and"; break;
308 case BIC_w:
309 case BIC_x: mnemonic = "bic"; break;
310 case EOR_w:
311 case EOR_x: mnemonic = "eor"; break;
312 case EON_w:
313 case EON_x: mnemonic = "eon"; break;
314 case BICS_w:
315 case BICS_x: mnemonic = "bics"; break;
316 case ANDS_w:
317 case ANDS_x: {
318 mnemonic = "ands";
319 if (rd_is_zr) {
320 mnemonic = "tst";
321 form = "'Rn, 'Rm'NLo";
322 }
323 break;
324 }
325 case ORR_w:
326 case ORR_x: {
327 mnemonic = "orr";
328 if (rn_is_zr && (instr->ImmDPShift() == 0) && (instr->ShiftDP() == LSL)) {
329 mnemonic = "mov";
330 form = "'Rd, 'Rm";
331 }
332 break;
333 }
334 case ORN_w:
335 case ORN_x: {
336 mnemonic = "orn";
337 if (rn_is_zr) {
338 mnemonic = "mvn";
339 form = "'Rd, 'Rm'NLo";
340 }
341 break;
342 }
343 default: VIXL_UNREACHABLE();
344 }
345
346 Format(instr, mnemonic, form);
347 }
348
349
VisitConditionalCompareRegister(const Instruction * instr)350 void Disassembler::VisitConditionalCompareRegister(const Instruction* instr) {
351 const char *mnemonic = "";
352 const char *form = "'Rn, 'Rm, 'INzcv, 'Cond";
353
354 switch (instr->Mask(ConditionalCompareRegisterMask)) {
355 case CCMN_w:
356 case CCMN_x: mnemonic = "ccmn"; break;
357 case CCMP_w:
358 case CCMP_x: mnemonic = "ccmp"; break;
359 default: VIXL_UNREACHABLE();
360 }
361 Format(instr, mnemonic, form);
362 }
363
364
VisitConditionalCompareImmediate(const Instruction * instr)365 void Disassembler::VisitConditionalCompareImmediate(const Instruction* instr) {
366 const char *mnemonic = "";
367 const char *form = "'Rn, 'IP, 'INzcv, 'Cond";
368
369 switch (instr->Mask(ConditionalCompareImmediateMask)) {
370 case CCMN_w_imm:
371 case CCMN_x_imm: mnemonic = "ccmn"; break;
372 case CCMP_w_imm:
373 case CCMP_x_imm: mnemonic = "ccmp"; break;
374 default: VIXL_UNREACHABLE();
375 }
376 Format(instr, mnemonic, form);
377 }
378
379
VisitConditionalSelect(const Instruction * instr)380 void Disassembler::VisitConditionalSelect(const Instruction* instr) {
381 bool rnm_is_zr = (RnIsZROrSP(instr) && RmIsZROrSP(instr));
382 bool rn_is_rm = (instr->Rn() == instr->Rm());
383 const char *mnemonic = "";
384 const char *form = "'Rd, 'Rn, 'Rm, 'Cond";
385 const char *form_test = "'Rd, 'CInv";
386 const char *form_update = "'Rd, 'Rn, 'CInv";
387
388 Condition cond = static_cast<Condition>(instr->Condition());
389 bool invertible_cond = (cond != al) && (cond != nv);
390
391 switch (instr->Mask(ConditionalSelectMask)) {
392 case CSEL_w:
393 case CSEL_x: mnemonic = "csel"; break;
394 case CSINC_w:
395 case CSINC_x: {
396 mnemonic = "csinc";
397 if (rnm_is_zr && invertible_cond) {
398 mnemonic = "cset";
399 form = form_test;
400 } else if (rn_is_rm && invertible_cond) {
401 mnemonic = "cinc";
402 form = form_update;
403 }
404 break;
405 }
406 case CSINV_w:
407 case CSINV_x: {
408 mnemonic = "csinv";
409 if (rnm_is_zr && invertible_cond) {
410 mnemonic = "csetm";
411 form = form_test;
412 } else if (rn_is_rm && invertible_cond) {
413 mnemonic = "cinv";
414 form = form_update;
415 }
416 break;
417 }
418 case CSNEG_w:
419 case CSNEG_x: {
420 mnemonic = "csneg";
421 if (rn_is_rm && invertible_cond) {
422 mnemonic = "cneg";
423 form = form_update;
424 }
425 break;
426 }
427 default: VIXL_UNREACHABLE();
428 }
429 Format(instr, mnemonic, form);
430 }
431
432
VisitBitfield(const Instruction * instr)433 void Disassembler::VisitBitfield(const Instruction* instr) {
434 unsigned s = instr->ImmS();
435 unsigned r = instr->ImmR();
436 unsigned rd_size_minus_1 =
437 ((instr->SixtyFourBits() == 1) ? kXRegSize : kWRegSize) - 1;
438 const char *mnemonic = "";
439 const char *form = "";
440 const char *form_shift_right = "'Rd, 'Rn, 'IBr";
441 const char *form_extend = "'Rd, 'Wn";
442 const char *form_bfiz = "'Rd, 'Rn, 'IBZ-r, 'IBs+1";
443 const char *form_bfx = "'Rd, 'Rn, 'IBr, 'IBs-r+1";
444 const char *form_lsl = "'Rd, 'Rn, 'IBZ-r";
445
446 switch (instr->Mask(BitfieldMask)) {
447 case SBFM_w:
448 case SBFM_x: {
449 mnemonic = "sbfx";
450 form = form_bfx;
451 if (r == 0) {
452 form = form_extend;
453 if (s == 7) {
454 mnemonic = "sxtb";
455 } else if (s == 15) {
456 mnemonic = "sxth";
457 } else if ((s == 31) && (instr->SixtyFourBits() == 1)) {
458 mnemonic = "sxtw";
459 } else {
460 form = form_bfx;
461 }
462 } else if (s == rd_size_minus_1) {
463 mnemonic = "asr";
464 form = form_shift_right;
465 } else if (s < r) {
466 mnemonic = "sbfiz";
467 form = form_bfiz;
468 }
469 break;
470 }
471 case UBFM_w:
472 case UBFM_x: {
473 mnemonic = "ubfx";
474 form = form_bfx;
475 if (r == 0) {
476 form = form_extend;
477 if (s == 7) {
478 mnemonic = "uxtb";
479 } else if (s == 15) {
480 mnemonic = "uxth";
481 } else {
482 form = form_bfx;
483 }
484 }
485 if (s == rd_size_minus_1) {
486 mnemonic = "lsr";
487 form = form_shift_right;
488 } else if (r == s + 1) {
489 mnemonic = "lsl";
490 form = form_lsl;
491 } else if (s < r) {
492 mnemonic = "ubfiz";
493 form = form_bfiz;
494 }
495 break;
496 }
497 case BFM_w:
498 case BFM_x: {
499 mnemonic = "bfxil";
500 form = form_bfx;
501 if (s < r) {
502 mnemonic = "bfi";
503 form = form_bfiz;
504 }
505 }
506 }
507 Format(instr, mnemonic, form);
508 }
509
510
VisitExtract(const Instruction * instr)511 void Disassembler::VisitExtract(const Instruction* instr) {
512 const char *mnemonic = "";
513 const char *form = "'Rd, 'Rn, 'Rm, 'IExtract";
514
515 switch (instr->Mask(ExtractMask)) {
516 case EXTR_w:
517 case EXTR_x: {
518 if (instr->Rn() == instr->Rm()) {
519 mnemonic = "ror";
520 form = "'Rd, 'Rn, 'IExtract";
521 } else {
522 mnemonic = "extr";
523 }
524 break;
525 }
526 default: VIXL_UNREACHABLE();
527 }
528 Format(instr, mnemonic, form);
529 }
530
531
VisitPCRelAddressing(const Instruction * instr)532 void Disassembler::VisitPCRelAddressing(const Instruction* instr) {
533 switch (instr->Mask(PCRelAddressingMask)) {
534 case ADR: Format(instr, "adr", "'Xd, 'AddrPCRelByte"); break;
535 case ADRP: Format(instr, "adrp", "'Xd, 'AddrPCRelPage"); break;
536 default: Format(instr, "unimplemented", "(PCRelAddressing)");
537 }
538 }
539
540
VisitConditionalBranch(const Instruction * instr)541 void Disassembler::VisitConditionalBranch(const Instruction* instr) {
542 switch (instr->Mask(ConditionalBranchMask)) {
543 case B_cond: Format(instr, "b.'CBrn", "'TImmCond"); break;
544 default: VIXL_UNREACHABLE();
545 }
546 }
547
548
VisitUnconditionalBranchToRegister(const Instruction * instr)549 void Disassembler::VisitUnconditionalBranchToRegister(
550 const Instruction* instr) {
551 const char *mnemonic = "unimplemented";
552 const char *form = "'Xn";
553
554 switch (instr->Mask(UnconditionalBranchToRegisterMask)) {
555 case BR: mnemonic = "br"; break;
556 case BLR: mnemonic = "blr"; break;
557 case RET: {
558 mnemonic = "ret";
559 if (instr->Rn() == kLinkRegCode) {
560 form = NULL;
561 }
562 break;
563 }
564 default: form = "(UnconditionalBranchToRegister)";
565 }
566 Format(instr, mnemonic, form);
567 }
568
569
VisitUnconditionalBranch(const Instruction * instr)570 void Disassembler::VisitUnconditionalBranch(const Instruction* instr) {
571 const char *mnemonic = "";
572 const char *form = "'TImmUncn";
573
574 switch (instr->Mask(UnconditionalBranchMask)) {
575 case B: mnemonic = "b"; break;
576 case BL: mnemonic = "bl"; break;
577 default: VIXL_UNREACHABLE();
578 }
579 Format(instr, mnemonic, form);
580 }
581
582
VisitDataProcessing1Source(const Instruction * instr)583 void Disassembler::VisitDataProcessing1Source(const Instruction* instr) {
584 const char *mnemonic = "";
585 const char *form = "'Rd, 'Rn";
586
587 switch (instr->Mask(DataProcessing1SourceMask)) {
588 #define FORMAT(A, B) \
589 case A##_w: \
590 case A##_x: mnemonic = B; break;
591 FORMAT(RBIT, "rbit");
592 FORMAT(REV16, "rev16");
593 FORMAT(REV, "rev");
594 FORMAT(CLZ, "clz");
595 FORMAT(CLS, "cls");
596 #undef FORMAT
597 case REV32_x: mnemonic = "rev32"; break;
598 default: VIXL_UNREACHABLE();
599 }
600 Format(instr, mnemonic, form);
601 }
602
603
VisitDataProcessing2Source(const Instruction * instr)604 void Disassembler::VisitDataProcessing2Source(const Instruction* instr) {
605 const char *mnemonic = "unimplemented";
606 const char *form = "'Rd, 'Rn, 'Rm";
607 const char *form_wwx = "'Wd, 'Wn, 'Xm";
608
609 switch (instr->Mask(DataProcessing2SourceMask)) {
610 #define FORMAT(A, B) \
611 case A##_w: \
612 case A##_x: mnemonic = B; break;
613 FORMAT(UDIV, "udiv");
614 FORMAT(SDIV, "sdiv");
615 FORMAT(LSLV, "lsl");
616 FORMAT(LSRV, "lsr");
617 FORMAT(ASRV, "asr");
618 FORMAT(RORV, "ror");
619 #undef FORMAT
620 case CRC32B: mnemonic = "crc32b"; break;
621 case CRC32H: mnemonic = "crc32h"; break;
622 case CRC32W: mnemonic = "crc32w"; break;
623 case CRC32X: mnemonic = "crc32x"; form = form_wwx; break;
624 case CRC32CB: mnemonic = "crc32cb"; break;
625 case CRC32CH: mnemonic = "crc32ch"; break;
626 case CRC32CW: mnemonic = "crc32cw"; break;
627 case CRC32CX: mnemonic = "crc32cx"; form = form_wwx; break;
628 default: form = "(DataProcessing2Source)";
629 }
630 Format(instr, mnemonic, form);
631 }
632
633
VisitDataProcessing3Source(const Instruction * instr)634 void Disassembler::VisitDataProcessing3Source(const Instruction* instr) {
635 bool ra_is_zr = RaIsZROrSP(instr);
636 const char *mnemonic = "";
637 const char *form = "'Xd, 'Wn, 'Wm, 'Xa";
638 const char *form_rrr = "'Rd, 'Rn, 'Rm";
639 const char *form_rrrr = "'Rd, 'Rn, 'Rm, 'Ra";
640 const char *form_xww = "'Xd, 'Wn, 'Wm";
641 const char *form_xxx = "'Xd, 'Xn, 'Xm";
642
643 switch (instr->Mask(DataProcessing3SourceMask)) {
644 case MADD_w:
645 case MADD_x: {
646 mnemonic = "madd";
647 form = form_rrrr;
648 if (ra_is_zr) {
649 mnemonic = "mul";
650 form = form_rrr;
651 }
652 break;
653 }
654 case MSUB_w:
655 case MSUB_x: {
656 mnemonic = "msub";
657 form = form_rrrr;
658 if (ra_is_zr) {
659 mnemonic = "mneg";
660 form = form_rrr;
661 }
662 break;
663 }
664 case SMADDL_x: {
665 mnemonic = "smaddl";
666 if (ra_is_zr) {
667 mnemonic = "smull";
668 form = form_xww;
669 }
670 break;
671 }
672 case SMSUBL_x: {
673 mnemonic = "smsubl";
674 if (ra_is_zr) {
675 mnemonic = "smnegl";
676 form = form_xww;
677 }
678 break;
679 }
680 case UMADDL_x: {
681 mnemonic = "umaddl";
682 if (ra_is_zr) {
683 mnemonic = "umull";
684 form = form_xww;
685 }
686 break;
687 }
688 case UMSUBL_x: {
689 mnemonic = "umsubl";
690 if (ra_is_zr) {
691 mnemonic = "umnegl";
692 form = form_xww;
693 }
694 break;
695 }
696 case SMULH_x: {
697 mnemonic = "smulh";
698 form = form_xxx;
699 break;
700 }
701 case UMULH_x: {
702 mnemonic = "umulh";
703 form = form_xxx;
704 break;
705 }
706 default: VIXL_UNREACHABLE();
707 }
708 Format(instr, mnemonic, form);
709 }
710
711
VisitCompareBranch(const Instruction * instr)712 void Disassembler::VisitCompareBranch(const Instruction* instr) {
713 const char *mnemonic = "";
714 const char *form = "'Rt, 'TImmCmpa";
715
716 switch (instr->Mask(CompareBranchMask)) {
717 case CBZ_w:
718 case CBZ_x: mnemonic = "cbz"; break;
719 case CBNZ_w:
720 case CBNZ_x: mnemonic = "cbnz"; break;
721 default: VIXL_UNREACHABLE();
722 }
723 Format(instr, mnemonic, form);
724 }
725
726
VisitTestBranch(const Instruction * instr)727 void Disassembler::VisitTestBranch(const Instruction* instr) {
728 const char *mnemonic = "";
729 // If the top bit of the immediate is clear, the tested register is
730 // disassembled as Wt, otherwise Xt. As the top bit of the immediate is
731 // encoded in bit 31 of the instruction, we can reuse the Rt form, which
732 // uses bit 31 (normally "sf") to choose the register size.
733 const char *form = "'Rt, 'IS, 'TImmTest";
734
735 switch (instr->Mask(TestBranchMask)) {
736 case TBZ: mnemonic = "tbz"; break;
737 case TBNZ: mnemonic = "tbnz"; break;
738 default: VIXL_UNREACHABLE();
739 }
740 Format(instr, mnemonic, form);
741 }
742
743
VisitMoveWideImmediate(const Instruction * instr)744 void Disassembler::VisitMoveWideImmediate(const Instruction* instr) {
745 const char *mnemonic = "";
746 const char *form = "'Rd, 'IMoveImm";
747
748 // Print the shift separately for movk, to make it clear which half word will
749 // be overwritten. Movn and movz print the computed immediate, which includes
750 // shift calculation.
751 switch (instr->Mask(MoveWideImmediateMask)) {
752 case MOVN_w:
753 case MOVN_x:
754 if ((instr->ImmMoveWide()) || (instr->ShiftMoveWide() == 0)) {
755 if ((instr->SixtyFourBits() == 0) && (instr->ImmMoveWide() == 0xffff)) {
756 mnemonic = "movn";
757 } else {
758 mnemonic = "mov";
759 form = "'Rd, 'IMoveNeg";
760 }
761 } else {
762 mnemonic = "movn";
763 }
764 break;
765 case MOVZ_w:
766 case MOVZ_x:
767 if ((instr->ImmMoveWide()) || (instr->ShiftMoveWide() == 0))
768 mnemonic = "mov";
769 else
770 mnemonic = "movz";
771 break;
772 case MOVK_w:
773 case MOVK_x: mnemonic = "movk"; form = "'Rd, 'IMoveLSL"; break;
774 default: VIXL_UNREACHABLE();
775 }
776 Format(instr, mnemonic, form);
777 }
778
779
780 #define LOAD_STORE_LIST(V) \
781 V(STRB_w, "strb", "'Wt") \
782 V(STRH_w, "strh", "'Wt") \
783 V(STR_w, "str", "'Wt") \
784 V(STR_x, "str", "'Xt") \
785 V(LDRB_w, "ldrb", "'Wt") \
786 V(LDRH_w, "ldrh", "'Wt") \
787 V(LDR_w, "ldr", "'Wt") \
788 V(LDR_x, "ldr", "'Xt") \
789 V(LDRSB_x, "ldrsb", "'Xt") \
790 V(LDRSH_x, "ldrsh", "'Xt") \
791 V(LDRSW_x, "ldrsw", "'Xt") \
792 V(LDRSB_w, "ldrsb", "'Wt") \
793 V(LDRSH_w, "ldrsh", "'Wt") \
794 V(STR_b, "str", "'Bt") \
795 V(STR_h, "str", "'Ht") \
796 V(STR_s, "str", "'St") \
797 V(STR_d, "str", "'Dt") \
798 V(LDR_b, "ldr", "'Bt") \
799 V(LDR_h, "ldr", "'Ht") \
800 V(LDR_s, "ldr", "'St") \
801 V(LDR_d, "ldr", "'Dt") \
802 V(STR_q, "str", "'Qt") \
803 V(LDR_q, "ldr", "'Qt")
804
VisitLoadStorePreIndex(const Instruction * instr)805 void Disassembler::VisitLoadStorePreIndex(const Instruction* instr) {
806 const char *mnemonic = "unimplemented";
807 const char *form = "(LoadStorePreIndex)";
808
809 switch (instr->Mask(LoadStorePreIndexMask)) {
810 #define LS_PREINDEX(A, B, C) \
811 case A##_pre: mnemonic = B; form = C ", ['Xns'ILS]!"; break;
812 LOAD_STORE_LIST(LS_PREINDEX)
813 #undef LS_PREINDEX
814 }
815 Format(instr, mnemonic, form);
816 }
817
818
VisitLoadStorePostIndex(const Instruction * instr)819 void Disassembler::VisitLoadStorePostIndex(const Instruction* instr) {
820 const char *mnemonic = "unimplemented";
821 const char *form = "(LoadStorePostIndex)";
822
823 switch (instr->Mask(LoadStorePostIndexMask)) {
824 #define LS_POSTINDEX(A, B, C) \
825 case A##_post: mnemonic = B; form = C ", ['Xns]'ILS"; break;
826 LOAD_STORE_LIST(LS_POSTINDEX)
827 #undef LS_POSTINDEX
828 }
829 Format(instr, mnemonic, form);
830 }
831
832
VisitLoadStoreUnsignedOffset(const Instruction * instr)833 void Disassembler::VisitLoadStoreUnsignedOffset(const Instruction* instr) {
834 const char *mnemonic = "unimplemented";
835 const char *form = "(LoadStoreUnsignedOffset)";
836
837 switch (instr->Mask(LoadStoreUnsignedOffsetMask)) {
838 #define LS_UNSIGNEDOFFSET(A, B, C) \
839 case A##_unsigned: mnemonic = B; form = C ", ['Xns'ILU]"; break;
840 LOAD_STORE_LIST(LS_UNSIGNEDOFFSET)
841 #undef LS_UNSIGNEDOFFSET
842 case PRFM_unsigned: mnemonic = "prfm"; form = "'PrefOp, ['Xns'ILU]";
843 }
844 Format(instr, mnemonic, form);
845 }
846
847
VisitLoadStoreRegisterOffset(const Instruction * instr)848 void Disassembler::VisitLoadStoreRegisterOffset(const Instruction* instr) {
849 const char *mnemonic = "unimplemented";
850 const char *form = "(LoadStoreRegisterOffset)";
851
852 switch (instr->Mask(LoadStoreRegisterOffsetMask)) {
853 #define LS_REGISTEROFFSET(A, B, C) \
854 case A##_reg: mnemonic = B; form = C ", ['Xns, 'Offsetreg]"; break;
855 LOAD_STORE_LIST(LS_REGISTEROFFSET)
856 #undef LS_REGISTEROFFSET
857 case PRFM_reg: mnemonic = "prfm"; form = "'PrefOp, ['Xns, 'Offsetreg]";
858 }
859 Format(instr, mnemonic, form);
860 }
861
862
VisitLoadStoreUnscaledOffset(const Instruction * instr)863 void Disassembler::VisitLoadStoreUnscaledOffset(const Instruction* instr) {
864 const char *mnemonic = "unimplemented";
865 const char *form = "'Wt, ['Xns'ILS]";
866 const char *form_x = "'Xt, ['Xns'ILS]";
867 const char *form_b = "'Bt, ['Xns'ILS]";
868 const char *form_h = "'Ht, ['Xns'ILS]";
869 const char *form_s = "'St, ['Xns'ILS]";
870 const char *form_d = "'Dt, ['Xns'ILS]";
871 const char *form_q = "'Qt, ['Xns'ILS]";
872 const char *form_prefetch = "'PrefOp, ['Xns'ILS]";
873
874 switch (instr->Mask(LoadStoreUnscaledOffsetMask)) {
875 case STURB_w: mnemonic = "sturb"; break;
876 case STURH_w: mnemonic = "sturh"; break;
877 case STUR_w: mnemonic = "stur"; break;
878 case STUR_x: mnemonic = "stur"; form = form_x; break;
879 case STUR_b: mnemonic = "stur"; form = form_b; break;
880 case STUR_h: mnemonic = "stur"; form = form_h; break;
881 case STUR_s: mnemonic = "stur"; form = form_s; break;
882 case STUR_d: mnemonic = "stur"; form = form_d; break;
883 case STUR_q: mnemonic = "stur"; form = form_q; break;
884 case LDURB_w: mnemonic = "ldurb"; break;
885 case LDURH_w: mnemonic = "ldurh"; break;
886 case LDUR_w: mnemonic = "ldur"; break;
887 case LDUR_x: mnemonic = "ldur"; form = form_x; break;
888 case LDUR_b: mnemonic = "ldur"; form = form_b; break;
889 case LDUR_h: mnemonic = "ldur"; form = form_h; break;
890 case LDUR_s: mnemonic = "ldur"; form = form_s; break;
891 case LDUR_d: mnemonic = "ldur"; form = form_d; break;
892 case LDUR_q: mnemonic = "ldur"; form = form_q; break;
893 case LDURSB_x: form = form_x; VIXL_FALLTHROUGH();
894 case LDURSB_w: mnemonic = "ldursb"; break;
895 case LDURSH_x: form = form_x; VIXL_FALLTHROUGH();
896 case LDURSH_w: mnemonic = "ldursh"; break;
897 case LDURSW_x: mnemonic = "ldursw"; form = form_x; break;
898 case PRFUM: mnemonic = "prfum"; form = form_prefetch; break;
899 default: form = "(LoadStoreUnscaledOffset)";
900 }
901 Format(instr, mnemonic, form);
902 }
903
904
VisitLoadLiteral(const Instruction * instr)905 void Disassembler::VisitLoadLiteral(const Instruction* instr) {
906 const char *mnemonic = "ldr";
907 const char *form = "(LoadLiteral)";
908
909 switch (instr->Mask(LoadLiteralMask)) {
910 case LDR_w_lit: form = "'Wt, 'ILLiteral 'LValue"; break;
911 case LDR_x_lit: form = "'Xt, 'ILLiteral 'LValue"; break;
912 case LDR_s_lit: form = "'St, 'ILLiteral 'LValue"; break;
913 case LDR_d_lit: form = "'Dt, 'ILLiteral 'LValue"; break;
914 case LDR_q_lit: form = "'Qt, 'ILLiteral 'LValue"; break;
915 case LDRSW_x_lit: {
916 mnemonic = "ldrsw";
917 form = "'Xt, 'ILLiteral 'LValue";
918 break;
919 }
920 case PRFM_lit: {
921 mnemonic = "prfm";
922 form = "'PrefOp, 'ILLiteral 'LValue";
923 break;
924 }
925 default: mnemonic = "unimplemented";
926 }
927 Format(instr, mnemonic, form);
928 }
929
930
931 #define LOAD_STORE_PAIR_LIST(V) \
932 V(STP_w, "stp", "'Wt, 'Wt2", "2") \
933 V(LDP_w, "ldp", "'Wt, 'Wt2", "2") \
934 V(LDPSW_x, "ldpsw", "'Xt, 'Xt2", "2") \
935 V(STP_x, "stp", "'Xt, 'Xt2", "3") \
936 V(LDP_x, "ldp", "'Xt, 'Xt2", "3") \
937 V(STP_s, "stp", "'St, 'St2", "2") \
938 V(LDP_s, "ldp", "'St, 'St2", "2") \
939 V(STP_d, "stp", "'Dt, 'Dt2", "3") \
940 V(LDP_d, "ldp", "'Dt, 'Dt2", "3") \
941 V(LDP_q, "ldp", "'Qt, 'Qt2", "4") \
942 V(STP_q, "stp", "'Qt, 'Qt2", "4")
943
VisitLoadStorePairPostIndex(const Instruction * instr)944 void Disassembler::VisitLoadStorePairPostIndex(const Instruction* instr) {
945 const char *mnemonic = "unimplemented";
946 const char *form = "(LoadStorePairPostIndex)";
947
948 switch (instr->Mask(LoadStorePairPostIndexMask)) {
949 #define LSP_POSTINDEX(A, B, C, D) \
950 case A##_post: mnemonic = B; form = C ", ['Xns]'ILP" D; break;
951 LOAD_STORE_PAIR_LIST(LSP_POSTINDEX)
952 #undef LSP_POSTINDEX
953 }
954 Format(instr, mnemonic, form);
955 }
956
957
VisitLoadStorePairPreIndex(const Instruction * instr)958 void Disassembler::VisitLoadStorePairPreIndex(const Instruction* instr) {
959 const char *mnemonic = "unimplemented";
960 const char *form = "(LoadStorePairPreIndex)";
961
962 switch (instr->Mask(LoadStorePairPreIndexMask)) {
963 #define LSP_PREINDEX(A, B, C, D) \
964 case A##_pre: mnemonic = B; form = C ", ['Xns'ILP" D "]!"; break;
965 LOAD_STORE_PAIR_LIST(LSP_PREINDEX)
966 #undef LSP_PREINDEX
967 }
968 Format(instr, mnemonic, form);
969 }
970
971
VisitLoadStorePairOffset(const Instruction * instr)972 void Disassembler::VisitLoadStorePairOffset(const Instruction* instr) {
973 const char *mnemonic = "unimplemented";
974 const char *form = "(LoadStorePairOffset)";
975
976 switch (instr->Mask(LoadStorePairOffsetMask)) {
977 #define LSP_OFFSET(A, B, C, D) \
978 case A##_off: mnemonic = B; form = C ", ['Xns'ILP" D "]"; break;
979 LOAD_STORE_PAIR_LIST(LSP_OFFSET)
980 #undef LSP_OFFSET
981 }
982 Format(instr, mnemonic, form);
983 }
984
985
VisitLoadStorePairNonTemporal(const Instruction * instr)986 void Disassembler::VisitLoadStorePairNonTemporal(const Instruction* instr) {
987 const char *mnemonic = "unimplemented";
988 const char *form;
989
990 switch (instr->Mask(LoadStorePairNonTemporalMask)) {
991 case STNP_w: mnemonic = "stnp"; form = "'Wt, 'Wt2, ['Xns'ILP2]"; break;
992 case LDNP_w: mnemonic = "ldnp"; form = "'Wt, 'Wt2, ['Xns'ILP2]"; break;
993 case STNP_x: mnemonic = "stnp"; form = "'Xt, 'Xt2, ['Xns'ILP3]"; break;
994 case LDNP_x: mnemonic = "ldnp"; form = "'Xt, 'Xt2, ['Xns'ILP3]"; break;
995 case STNP_s: mnemonic = "stnp"; form = "'St, 'St2, ['Xns'ILP2]"; break;
996 case LDNP_s: mnemonic = "ldnp"; form = "'St, 'St2, ['Xns'ILP2]"; break;
997 case STNP_d: mnemonic = "stnp"; form = "'Dt, 'Dt2, ['Xns'ILP3]"; break;
998 case LDNP_d: mnemonic = "ldnp"; form = "'Dt, 'Dt2, ['Xns'ILP3]"; break;
999 case STNP_q: mnemonic = "stnp"; form = "'Qt, 'Qt2, ['Xns'ILP4]"; break;
1000 case LDNP_q: mnemonic = "ldnp"; form = "'Qt, 'Qt2, ['Xns'ILP4]"; break;
1001 default: form = "(LoadStorePairNonTemporal)";
1002 }
1003 Format(instr, mnemonic, form);
1004 }
1005
1006
VisitLoadStoreExclusive(const Instruction * instr)1007 void Disassembler::VisitLoadStoreExclusive(const Instruction* instr) {
1008 const char *mnemonic = "unimplemented";
1009 const char *form;
1010
1011 switch (instr->Mask(LoadStoreExclusiveMask)) {
1012 case STXRB_w: mnemonic = "stxrb"; form = "'Ws, 'Wt, ['Xns]"; break;
1013 case STXRH_w: mnemonic = "stxrh"; form = "'Ws, 'Wt, ['Xns]"; break;
1014 case STXR_w: mnemonic = "stxr"; form = "'Ws, 'Wt, ['Xns]"; break;
1015 case STXR_x: mnemonic = "stxr"; form = "'Ws, 'Xt, ['Xns]"; break;
1016 case LDXRB_w: mnemonic = "ldxrb"; form = "'Wt, ['Xns]"; break;
1017 case LDXRH_w: mnemonic = "ldxrh"; form = "'Wt, ['Xns]"; break;
1018 case LDXR_w: mnemonic = "ldxr"; form = "'Wt, ['Xns]"; break;
1019 case LDXR_x: mnemonic = "ldxr"; form = "'Xt, ['Xns]"; break;
1020 case STXP_w: mnemonic = "stxp"; form = "'Ws, 'Wt, 'Wt2, ['Xns]"; break;
1021 case STXP_x: mnemonic = "stxp"; form = "'Ws, 'Xt, 'Xt2, ['Xns]"; break;
1022 case LDXP_w: mnemonic = "ldxp"; form = "'Wt, 'Wt2, ['Xns]"; break;
1023 case LDXP_x: mnemonic = "ldxp"; form = "'Xt, 'Xt2, ['Xns]"; break;
1024 case STLXRB_w: mnemonic = "stlxrb"; form = "'Ws, 'Wt, ['Xns]"; break;
1025 case STLXRH_w: mnemonic = "stlxrh"; form = "'Ws, 'Wt, ['Xns]"; break;
1026 case STLXR_w: mnemonic = "stlxr"; form = "'Ws, 'Wt, ['Xns]"; break;
1027 case STLXR_x: mnemonic = "stlxr"; form = "'Ws, 'Xt, ['Xns]"; break;
1028 case LDAXRB_w: mnemonic = "ldaxrb"; form = "'Wt, ['Xns]"; break;
1029 case LDAXRH_w: mnemonic = "ldaxrh"; form = "'Wt, ['Xns]"; break;
1030 case LDAXR_w: mnemonic = "ldaxr"; form = "'Wt, ['Xns]"; break;
1031 case LDAXR_x: mnemonic = "ldaxr"; form = "'Xt, ['Xns]"; break;
1032 case STLXP_w: mnemonic = "stlxp"; form = "'Ws, 'Wt, 'Wt2, ['Xns]"; break;
1033 case STLXP_x: mnemonic = "stlxp"; form = "'Ws, 'Xt, 'Xt2, ['Xns]"; break;
1034 case LDAXP_w: mnemonic = "ldaxp"; form = "'Wt, 'Wt2, ['Xns]"; break;
1035 case LDAXP_x: mnemonic = "ldaxp"; form = "'Xt, 'Xt2, ['Xns]"; break;
1036 case STLRB_w: mnemonic = "stlrb"; form = "'Wt, ['Xns]"; break;
1037 case STLRH_w: mnemonic = "stlrh"; form = "'Wt, ['Xns]"; break;
1038 case STLR_w: mnemonic = "stlr"; form = "'Wt, ['Xns]"; break;
1039 case STLR_x: mnemonic = "stlr"; form = "'Xt, ['Xns]"; break;
1040 case LDARB_w: mnemonic = "ldarb"; form = "'Wt, ['Xns]"; break;
1041 case LDARH_w: mnemonic = "ldarh"; form = "'Wt, ['Xns]"; break;
1042 case LDAR_w: mnemonic = "ldar"; form = "'Wt, ['Xns]"; break;
1043 case LDAR_x: mnemonic = "ldar"; form = "'Xt, ['Xns]"; break;
1044 default: form = "(LoadStoreExclusive)";
1045 }
1046 Format(instr, mnemonic, form);
1047 }
1048
1049
VisitFPCompare(const Instruction * instr)1050 void Disassembler::VisitFPCompare(const Instruction* instr) {
1051 const char *mnemonic = "unimplemented";
1052 const char *form = "'Fn, 'Fm";
1053 const char *form_zero = "'Fn, #0.0";
1054
1055 switch (instr->Mask(FPCompareMask)) {
1056 case FCMP_s_zero:
1057 case FCMP_d_zero: form = form_zero; VIXL_FALLTHROUGH();
1058 case FCMP_s:
1059 case FCMP_d: mnemonic = "fcmp"; break;
1060 case FCMPE_s_zero:
1061 case FCMPE_d_zero: form = form_zero; VIXL_FALLTHROUGH();
1062 case FCMPE_s:
1063 case FCMPE_d: mnemonic = "fcmpe"; break;
1064 default: form = "(FPCompare)";
1065 }
1066 Format(instr, mnemonic, form);
1067 }
1068
1069
VisitFPConditionalCompare(const Instruction * instr)1070 void Disassembler::VisitFPConditionalCompare(const Instruction* instr) {
1071 const char *mnemonic = "unmplemented";
1072 const char *form = "'Fn, 'Fm, 'INzcv, 'Cond";
1073
1074 switch (instr->Mask(FPConditionalCompareMask)) {
1075 case FCCMP_s:
1076 case FCCMP_d: mnemonic = "fccmp"; break;
1077 case FCCMPE_s:
1078 case FCCMPE_d: mnemonic = "fccmpe"; break;
1079 default: form = "(FPConditionalCompare)";
1080 }
1081 Format(instr, mnemonic, form);
1082 }
1083
1084
VisitFPConditionalSelect(const Instruction * instr)1085 void Disassembler::VisitFPConditionalSelect(const Instruction* instr) {
1086 const char *mnemonic = "";
1087 const char *form = "'Fd, 'Fn, 'Fm, 'Cond";
1088
1089 switch (instr->Mask(FPConditionalSelectMask)) {
1090 case FCSEL_s:
1091 case FCSEL_d: mnemonic = "fcsel"; break;
1092 default: VIXL_UNREACHABLE();
1093 }
1094 Format(instr, mnemonic, form);
1095 }
1096
1097
VisitFPDataProcessing1Source(const Instruction * instr)1098 void Disassembler::VisitFPDataProcessing1Source(const Instruction* instr) {
1099 const char *mnemonic = "unimplemented";
1100 const char *form = "'Fd, 'Fn";
1101
1102 switch (instr->Mask(FPDataProcessing1SourceMask)) {
1103 #define FORMAT(A, B) \
1104 case A##_s: \
1105 case A##_d: mnemonic = B; break;
1106 FORMAT(FMOV, "fmov");
1107 FORMAT(FABS, "fabs");
1108 FORMAT(FNEG, "fneg");
1109 FORMAT(FSQRT, "fsqrt");
1110 FORMAT(FRINTN, "frintn");
1111 FORMAT(FRINTP, "frintp");
1112 FORMAT(FRINTM, "frintm");
1113 FORMAT(FRINTZ, "frintz");
1114 FORMAT(FRINTA, "frinta");
1115 FORMAT(FRINTX, "frintx");
1116 FORMAT(FRINTI, "frinti");
1117 #undef FORMAT
1118 case FCVT_ds: mnemonic = "fcvt"; form = "'Dd, 'Sn"; break;
1119 case FCVT_sd: mnemonic = "fcvt"; form = "'Sd, 'Dn"; break;
1120 case FCVT_hs: mnemonic = "fcvt"; form = "'Hd, 'Sn"; break;
1121 case FCVT_sh: mnemonic = "fcvt"; form = "'Sd, 'Hn"; break;
1122 case FCVT_dh: mnemonic = "fcvt"; form = "'Dd, 'Hn"; break;
1123 case FCVT_hd: mnemonic = "fcvt"; form = "'Hd, 'Dn"; break;
1124 default: form = "(FPDataProcessing1Source)";
1125 }
1126 Format(instr, mnemonic, form);
1127 }
1128
1129
VisitFPDataProcessing2Source(const Instruction * instr)1130 void Disassembler::VisitFPDataProcessing2Source(const Instruction* instr) {
1131 const char *mnemonic = "";
1132 const char *form = "'Fd, 'Fn, 'Fm";
1133
1134 switch (instr->Mask(FPDataProcessing2SourceMask)) {
1135 #define FORMAT(A, B) \
1136 case A##_s: \
1137 case A##_d: mnemonic = B; break;
1138 FORMAT(FMUL, "fmul");
1139 FORMAT(FDIV, "fdiv");
1140 FORMAT(FADD, "fadd");
1141 FORMAT(FSUB, "fsub");
1142 FORMAT(FMAX, "fmax");
1143 FORMAT(FMIN, "fmin");
1144 FORMAT(FMAXNM, "fmaxnm");
1145 FORMAT(FMINNM, "fminnm");
1146 FORMAT(FNMUL, "fnmul");
1147 #undef FORMAT
1148 default: VIXL_UNREACHABLE();
1149 }
1150 Format(instr, mnemonic, form);
1151 }
1152
1153
VisitFPDataProcessing3Source(const Instruction * instr)1154 void Disassembler::VisitFPDataProcessing3Source(const Instruction* instr) {
1155 const char *mnemonic = "";
1156 const char *form = "'Fd, 'Fn, 'Fm, 'Fa";
1157
1158 switch (instr->Mask(FPDataProcessing3SourceMask)) {
1159 #define FORMAT(A, B) \
1160 case A##_s: \
1161 case A##_d: mnemonic = B; break;
1162 FORMAT(FMADD, "fmadd");
1163 FORMAT(FMSUB, "fmsub");
1164 FORMAT(FNMADD, "fnmadd");
1165 FORMAT(FNMSUB, "fnmsub");
1166 #undef FORMAT
1167 default: VIXL_UNREACHABLE();
1168 }
1169 Format(instr, mnemonic, form);
1170 }
1171
1172
VisitFPImmediate(const Instruction * instr)1173 void Disassembler::VisitFPImmediate(const Instruction* instr) {
1174 const char *mnemonic = "";
1175 const char *form = "(FPImmediate)";
1176
1177 switch (instr->Mask(FPImmediateMask)) {
1178 case FMOV_s_imm: mnemonic = "fmov"; form = "'Sd, 'IFPSingle"; break;
1179 case FMOV_d_imm: mnemonic = "fmov"; form = "'Dd, 'IFPDouble"; break;
1180 default: VIXL_UNREACHABLE();
1181 }
1182 Format(instr, mnemonic, form);
1183 }
1184
1185
VisitFPIntegerConvert(const Instruction * instr)1186 void Disassembler::VisitFPIntegerConvert(const Instruction* instr) {
1187 const char *mnemonic = "unimplemented";
1188 const char *form = "(FPIntegerConvert)";
1189 const char *form_rf = "'Rd, 'Fn";
1190 const char *form_fr = "'Fd, 'Rn";
1191
1192 switch (instr->Mask(FPIntegerConvertMask)) {
1193 case FMOV_ws:
1194 case FMOV_xd: mnemonic = "fmov"; form = form_rf; break;
1195 case FMOV_sw:
1196 case FMOV_dx: mnemonic = "fmov"; form = form_fr; break;
1197 case FMOV_d1_x: mnemonic = "fmov"; form = "'Vd.D[1], 'Rn"; break;
1198 case FMOV_x_d1: mnemonic = "fmov"; form = "'Rd, 'Vn.D[1]"; break;
1199 case FCVTAS_ws:
1200 case FCVTAS_xs:
1201 case FCVTAS_wd:
1202 case FCVTAS_xd: mnemonic = "fcvtas"; form = form_rf; break;
1203 case FCVTAU_ws:
1204 case FCVTAU_xs:
1205 case FCVTAU_wd:
1206 case FCVTAU_xd: mnemonic = "fcvtau"; form = form_rf; break;
1207 case FCVTMS_ws:
1208 case FCVTMS_xs:
1209 case FCVTMS_wd:
1210 case FCVTMS_xd: mnemonic = "fcvtms"; form = form_rf; break;
1211 case FCVTMU_ws:
1212 case FCVTMU_xs:
1213 case FCVTMU_wd:
1214 case FCVTMU_xd: mnemonic = "fcvtmu"; form = form_rf; break;
1215 case FCVTNS_ws:
1216 case FCVTNS_xs:
1217 case FCVTNS_wd:
1218 case FCVTNS_xd: mnemonic = "fcvtns"; form = form_rf; break;
1219 case FCVTNU_ws:
1220 case FCVTNU_xs:
1221 case FCVTNU_wd:
1222 case FCVTNU_xd: mnemonic = "fcvtnu"; form = form_rf; break;
1223 case FCVTZU_xd:
1224 case FCVTZU_ws:
1225 case FCVTZU_wd:
1226 case FCVTZU_xs: mnemonic = "fcvtzu"; form = form_rf; break;
1227 case FCVTZS_xd:
1228 case FCVTZS_wd:
1229 case FCVTZS_xs:
1230 case FCVTZS_ws: mnemonic = "fcvtzs"; form = form_rf; break;
1231 case FCVTPU_xd:
1232 case FCVTPU_ws:
1233 case FCVTPU_wd:
1234 case FCVTPU_xs: mnemonic = "fcvtpu"; form = form_rf; break;
1235 case FCVTPS_xd:
1236 case FCVTPS_wd:
1237 case FCVTPS_xs:
1238 case FCVTPS_ws: mnemonic = "fcvtps"; form = form_rf; break;
1239 case SCVTF_sw:
1240 case SCVTF_sx:
1241 case SCVTF_dw:
1242 case SCVTF_dx: mnemonic = "scvtf"; form = form_fr; break;
1243 case UCVTF_sw:
1244 case UCVTF_sx:
1245 case UCVTF_dw:
1246 case UCVTF_dx: mnemonic = "ucvtf"; form = form_fr; break;
1247 }
1248 Format(instr, mnemonic, form);
1249 }
1250
1251
VisitFPFixedPointConvert(const Instruction * instr)1252 void Disassembler::VisitFPFixedPointConvert(const Instruction* instr) {
1253 const char *mnemonic = "";
1254 const char *form = "'Rd, 'Fn, 'IFPFBits";
1255 const char *form_fr = "'Fd, 'Rn, 'IFPFBits";
1256
1257 switch (instr->Mask(FPFixedPointConvertMask)) {
1258 case FCVTZS_ws_fixed:
1259 case FCVTZS_xs_fixed:
1260 case FCVTZS_wd_fixed:
1261 case FCVTZS_xd_fixed: mnemonic = "fcvtzs"; break;
1262 case FCVTZU_ws_fixed:
1263 case FCVTZU_xs_fixed:
1264 case FCVTZU_wd_fixed:
1265 case FCVTZU_xd_fixed: mnemonic = "fcvtzu"; break;
1266 case SCVTF_sw_fixed:
1267 case SCVTF_sx_fixed:
1268 case SCVTF_dw_fixed:
1269 case SCVTF_dx_fixed: mnemonic = "scvtf"; form = form_fr; break;
1270 case UCVTF_sw_fixed:
1271 case UCVTF_sx_fixed:
1272 case UCVTF_dw_fixed:
1273 case UCVTF_dx_fixed: mnemonic = "ucvtf"; form = form_fr; break;
1274 default: VIXL_UNREACHABLE();
1275 }
1276 Format(instr, mnemonic, form);
1277 }
1278
1279
VisitSystem(const Instruction * instr)1280 void Disassembler::VisitSystem(const Instruction* instr) {
1281 // Some system instructions hijack their Op and Cp fields to represent a
1282 // range of immediates instead of indicating a different instruction. This
1283 // makes the decoding tricky.
1284 const char *mnemonic = "unimplemented";
1285 const char *form = "(System)";
1286
1287 if (instr->Mask(SystemExclusiveMonitorFMask) == SystemExclusiveMonitorFixed) {
1288 switch (instr->Mask(SystemExclusiveMonitorMask)) {
1289 case CLREX: {
1290 mnemonic = "clrex";
1291 form = (instr->CRm() == 0xf) ? NULL : "'IX";
1292 break;
1293 }
1294 }
1295 } else if (instr->Mask(SystemSysRegFMask) == SystemSysRegFixed) {
1296 switch (instr->Mask(SystemSysRegMask)) {
1297 case MRS: {
1298 mnemonic = "mrs";
1299 switch (instr->ImmSystemRegister()) {
1300 case NZCV: form = "'Xt, nzcv"; break;
1301 case FPCR: form = "'Xt, fpcr"; break;
1302 default: form = "'Xt, (unknown)"; break;
1303 }
1304 break;
1305 }
1306 case MSR: {
1307 mnemonic = "msr";
1308 switch (instr->ImmSystemRegister()) {
1309 case NZCV: form = "nzcv, 'Xt"; break;
1310 case FPCR: form = "fpcr, 'Xt"; break;
1311 default: form = "(unknown), 'Xt"; break;
1312 }
1313 break;
1314 }
1315 }
1316 } else if (instr->Mask(SystemHintFMask) == SystemHintFixed) {
1317 switch (instr->ImmHint()) {
1318 case NOP: {
1319 mnemonic = "nop";
1320 form = NULL;
1321 break;
1322 }
1323 }
1324 } else if (instr->Mask(MemBarrierFMask) == MemBarrierFixed) {
1325 switch (instr->Mask(MemBarrierMask)) {
1326 case DMB: {
1327 mnemonic = "dmb";
1328 form = "'M";
1329 break;
1330 }
1331 case DSB: {
1332 mnemonic = "dsb";
1333 form = "'M";
1334 break;
1335 }
1336 case ISB: {
1337 mnemonic = "isb";
1338 form = NULL;
1339 break;
1340 }
1341 }
1342 } else if (instr->Mask(SystemSysFMask) == SystemSysFixed) {
1343 switch (instr->SysOp()) {
1344 case IVAU:
1345 mnemonic = "ic";
1346 form = "ivau, 'Xt";
1347 break;
1348 case CVAC:
1349 mnemonic = "dc";
1350 form = "cvac, 'Xt";
1351 break;
1352 case CVAU:
1353 mnemonic = "dc";
1354 form = "cvau, 'Xt";
1355 break;
1356 case CIVAC:
1357 mnemonic = "dc";
1358 form = "civac, 'Xt";
1359 break;
1360 case ZVA:
1361 mnemonic = "dc";
1362 form = "zva, 'Xt";
1363 break;
1364 default:
1365 mnemonic = "sys";
1366 if (instr->Rt() == 31) {
1367 form = "'G1, 'Kn, 'Km, 'G2";
1368 } else {
1369 form = "'G1, 'Kn, 'Km, 'G2, 'Xt";
1370 }
1371 break;
1372 }
1373 }
1374 Format(instr, mnemonic, form);
1375 }
1376
1377
VisitException(const Instruction * instr)1378 void Disassembler::VisitException(const Instruction* instr) {
1379 const char *mnemonic = "unimplemented";
1380 const char *form = "'IDebug";
1381
1382 switch (instr->Mask(ExceptionMask)) {
1383 case HLT: mnemonic = "hlt"; break;
1384 case BRK: mnemonic = "brk"; break;
1385 case SVC: mnemonic = "svc"; break;
1386 case HVC: mnemonic = "hvc"; break;
1387 case SMC: mnemonic = "smc"; break;
1388 case DCPS1: mnemonic = "dcps1"; form = "{'IDebug}"; break;
1389 case DCPS2: mnemonic = "dcps2"; form = "{'IDebug}"; break;
1390 case DCPS3: mnemonic = "dcps3"; form = "{'IDebug}"; break;
1391 default: form = "(Exception)";
1392 }
1393 Format(instr, mnemonic, form);
1394 }
1395
1396
VisitCrypto2RegSHA(const Instruction * instr)1397 void Disassembler::VisitCrypto2RegSHA(const Instruction* instr) {
1398 VisitUnimplemented(instr);
1399 }
1400
1401
VisitCrypto3RegSHA(const Instruction * instr)1402 void Disassembler::VisitCrypto3RegSHA(const Instruction* instr) {
1403 VisitUnimplemented(instr);
1404 }
1405
1406
VisitCryptoAES(const Instruction * instr)1407 void Disassembler::VisitCryptoAES(const Instruction* instr) {
1408 VisitUnimplemented(instr);
1409 }
1410
1411
VisitNEON2RegMisc(const Instruction * instr)1412 void Disassembler::VisitNEON2RegMisc(const Instruction* instr) {
1413 const char *mnemonic = "unimplemented";
1414 const char *form = "'Vd.%s, 'Vn.%s";
1415 const char *form_cmp_zero = "'Vd.%s, 'Vn.%s, #0";
1416 const char *form_fcmp_zero = "'Vd.%s, 'Vn.%s, #0.0";
1417 NEONFormatDecoder nfd(instr);
1418
1419 static const NEONFormatMap map_lp_ta = {
1420 {23, 22, 30}, {NF_4H, NF_8H, NF_2S, NF_4S, NF_1D, NF_2D}
1421 };
1422
1423 static const NEONFormatMap map_cvt_ta = {
1424 {22}, {NF_4S, NF_2D}
1425 };
1426
1427 static const NEONFormatMap map_cvt_tb = {
1428 {22, 30}, {NF_4H, NF_8H, NF_2S, NF_4S}
1429 };
1430
1431 if (instr->Mask(NEON2RegMiscOpcode) <= NEON_NEG_opcode) {
1432 // These instructions all use a two bit size field, except NOT and RBIT,
1433 // which use the field to encode the operation.
1434 switch (instr->Mask(NEON2RegMiscMask)) {
1435 case NEON_REV64: mnemonic = "rev64"; break;
1436 case NEON_REV32: mnemonic = "rev32"; break;
1437 case NEON_REV16: mnemonic = "rev16"; break;
1438 case NEON_SADDLP:
1439 mnemonic = "saddlp";
1440 nfd.SetFormatMap(0, &map_lp_ta);
1441 break;
1442 case NEON_UADDLP:
1443 mnemonic = "uaddlp";
1444 nfd.SetFormatMap(0, &map_lp_ta);
1445 break;
1446 case NEON_SUQADD: mnemonic = "suqadd"; break;
1447 case NEON_USQADD: mnemonic = "usqadd"; break;
1448 case NEON_CLS: mnemonic = "cls"; break;
1449 case NEON_CLZ: mnemonic = "clz"; break;
1450 case NEON_CNT: mnemonic = "cnt"; break;
1451 case NEON_SADALP:
1452 mnemonic = "sadalp";
1453 nfd.SetFormatMap(0, &map_lp_ta);
1454 break;
1455 case NEON_UADALP:
1456 mnemonic = "uadalp";
1457 nfd.SetFormatMap(0, &map_lp_ta);
1458 break;
1459 case NEON_SQABS: mnemonic = "sqabs"; break;
1460 case NEON_SQNEG: mnemonic = "sqneg"; break;
1461 case NEON_CMGT_zero: mnemonic = "cmgt"; form = form_cmp_zero; break;
1462 case NEON_CMGE_zero: mnemonic = "cmge"; form = form_cmp_zero; break;
1463 case NEON_CMEQ_zero: mnemonic = "cmeq"; form = form_cmp_zero; break;
1464 case NEON_CMLE_zero: mnemonic = "cmle"; form = form_cmp_zero; break;
1465 case NEON_CMLT_zero: mnemonic = "cmlt"; form = form_cmp_zero; break;
1466 case NEON_ABS: mnemonic = "abs"; break;
1467 case NEON_NEG: mnemonic = "neg"; break;
1468 case NEON_RBIT_NOT:
1469 switch (instr->FPType()) {
1470 case 0: mnemonic = "mvn"; break;
1471 case 1: mnemonic = "rbit"; break;
1472 default: form = "(NEON2RegMisc)";
1473 }
1474 nfd.SetFormatMaps(nfd.LogicalFormatMap());
1475 break;
1476 }
1477 } else {
1478 // These instructions all use a one bit size field, except XTN, SQXTUN,
1479 // SHLL, SQXTN and UQXTN, which use a two bit size field.
1480 nfd.SetFormatMaps(nfd.FPFormatMap());
1481 switch (instr->Mask(NEON2RegMiscFPMask)) {
1482 case NEON_FABS: mnemonic = "fabs"; break;
1483 case NEON_FNEG: mnemonic = "fneg"; break;
1484 case NEON_FCVTN:
1485 mnemonic = instr->Mask(NEON_Q) ? "fcvtn2" : "fcvtn";
1486 nfd.SetFormatMap(0, &map_cvt_tb);
1487 nfd.SetFormatMap(1, &map_cvt_ta);
1488 break;
1489 case NEON_FCVTXN:
1490 mnemonic = instr->Mask(NEON_Q) ? "fcvtxn2" : "fcvtxn";
1491 nfd.SetFormatMap(0, &map_cvt_tb);
1492 nfd.SetFormatMap(1, &map_cvt_ta);
1493 break;
1494 case NEON_FCVTL:
1495 mnemonic = instr->Mask(NEON_Q) ? "fcvtl2" : "fcvtl";
1496 nfd.SetFormatMap(0, &map_cvt_ta);
1497 nfd.SetFormatMap(1, &map_cvt_tb);
1498 break;
1499 case NEON_FRINTN: mnemonic = "frintn"; break;
1500 case NEON_FRINTA: mnemonic = "frinta"; break;
1501 case NEON_FRINTP: mnemonic = "frintp"; break;
1502 case NEON_FRINTM: mnemonic = "frintm"; break;
1503 case NEON_FRINTX: mnemonic = "frintx"; break;
1504 case NEON_FRINTZ: mnemonic = "frintz"; break;
1505 case NEON_FRINTI: mnemonic = "frinti"; break;
1506 case NEON_FCVTNS: mnemonic = "fcvtns"; break;
1507 case NEON_FCVTNU: mnemonic = "fcvtnu"; break;
1508 case NEON_FCVTPS: mnemonic = "fcvtps"; break;
1509 case NEON_FCVTPU: mnemonic = "fcvtpu"; break;
1510 case NEON_FCVTMS: mnemonic = "fcvtms"; break;
1511 case NEON_FCVTMU: mnemonic = "fcvtmu"; break;
1512 case NEON_FCVTZS: mnemonic = "fcvtzs"; break;
1513 case NEON_FCVTZU: mnemonic = "fcvtzu"; break;
1514 case NEON_FCVTAS: mnemonic = "fcvtas"; break;
1515 case NEON_FCVTAU: mnemonic = "fcvtau"; break;
1516 case NEON_FSQRT: mnemonic = "fsqrt"; break;
1517 case NEON_SCVTF: mnemonic = "scvtf"; break;
1518 case NEON_UCVTF: mnemonic = "ucvtf"; break;
1519 case NEON_URSQRTE: mnemonic = "ursqrte"; break;
1520 case NEON_URECPE: mnemonic = "urecpe"; break;
1521 case NEON_FRSQRTE: mnemonic = "frsqrte"; break;
1522 case NEON_FRECPE: mnemonic = "frecpe"; break;
1523 case NEON_FCMGT_zero: mnemonic = "fcmgt"; form = form_fcmp_zero; break;
1524 case NEON_FCMGE_zero: mnemonic = "fcmge"; form = form_fcmp_zero; break;
1525 case NEON_FCMEQ_zero: mnemonic = "fcmeq"; form = form_fcmp_zero; break;
1526 case NEON_FCMLE_zero: mnemonic = "fcmle"; form = form_fcmp_zero; break;
1527 case NEON_FCMLT_zero: mnemonic = "fcmlt"; form = form_fcmp_zero; break;
1528 default:
1529 if ((NEON_XTN_opcode <= instr->Mask(NEON2RegMiscOpcode)) &&
1530 (instr->Mask(NEON2RegMiscOpcode) <= NEON_UQXTN_opcode)) {
1531 nfd.SetFormatMap(0, nfd.IntegerFormatMap());
1532 nfd.SetFormatMap(1, nfd.LongIntegerFormatMap());
1533
1534 switch (instr->Mask(NEON2RegMiscMask)) {
1535 case NEON_XTN: mnemonic = "xtn"; break;
1536 case NEON_SQXTN: mnemonic = "sqxtn"; break;
1537 case NEON_UQXTN: mnemonic = "uqxtn"; break;
1538 case NEON_SQXTUN: mnemonic = "sqxtun"; break;
1539 case NEON_SHLL:
1540 mnemonic = "shll";
1541 nfd.SetFormatMap(0, nfd.LongIntegerFormatMap());
1542 nfd.SetFormatMap(1, nfd.IntegerFormatMap());
1543 switch (instr->NEONSize()) {
1544 case 0: form = "'Vd.%s, 'Vn.%s, #8"; break;
1545 case 1: form = "'Vd.%s, 'Vn.%s, #16"; break;
1546 case 2: form = "'Vd.%s, 'Vn.%s, #32"; break;
1547 default: form = "(NEON2RegMisc)";
1548 }
1549 }
1550 Format(instr, nfd.Mnemonic(mnemonic), nfd.Substitute(form));
1551 return;
1552 } else {
1553 form = "(NEON2RegMisc)";
1554 }
1555 }
1556 }
1557 Format(instr, mnemonic, nfd.Substitute(form));
1558 }
1559
1560
VisitNEON3Same(const Instruction * instr)1561 void Disassembler::VisitNEON3Same(const Instruction* instr) {
1562 const char *mnemonic = "unimplemented";
1563 const char *form = "'Vd.%s, 'Vn.%s, 'Vm.%s";
1564 NEONFormatDecoder nfd(instr);
1565
1566 if (instr->Mask(NEON3SameLogicalFMask) == NEON3SameLogicalFixed) {
1567 switch (instr->Mask(NEON3SameLogicalMask)) {
1568 case NEON_AND: mnemonic = "and"; break;
1569 case NEON_ORR:
1570 mnemonic = "orr";
1571 if (instr->Rm() == instr->Rn()) {
1572 mnemonic = "mov";
1573 form = "'Vd.%s, 'Vn.%s";
1574 }
1575 break;
1576 case NEON_ORN: mnemonic = "orn"; break;
1577 case NEON_EOR: mnemonic = "eor"; break;
1578 case NEON_BIC: mnemonic = "bic"; break;
1579 case NEON_BIF: mnemonic = "bif"; break;
1580 case NEON_BIT: mnemonic = "bit"; break;
1581 case NEON_BSL: mnemonic = "bsl"; break;
1582 default: form = "(NEON3Same)";
1583 }
1584 nfd.SetFormatMaps(nfd.LogicalFormatMap());
1585 } else {
1586 static const char *mnemonics[] = {
1587 "shadd", "uhadd", "shadd", "uhadd",
1588 "sqadd", "uqadd", "sqadd", "uqadd",
1589 "srhadd", "urhadd", "srhadd", "urhadd",
1590 NULL, NULL, NULL, NULL, // Handled by logical cases above.
1591 "shsub", "uhsub", "shsub", "uhsub",
1592 "sqsub", "uqsub", "sqsub", "uqsub",
1593 "cmgt", "cmhi", "cmgt", "cmhi",
1594 "cmge", "cmhs", "cmge", "cmhs",
1595 "sshl", "ushl", "sshl", "ushl",
1596 "sqshl", "uqshl", "sqshl", "uqshl",
1597 "srshl", "urshl", "srshl", "urshl",
1598 "sqrshl", "uqrshl", "sqrshl", "uqrshl",
1599 "smax", "umax", "smax", "umax",
1600 "smin", "umin", "smin", "umin",
1601 "sabd", "uabd", "sabd", "uabd",
1602 "saba", "uaba", "saba", "uaba",
1603 "add", "sub", "add", "sub",
1604 "cmtst", "cmeq", "cmtst", "cmeq",
1605 "mla", "mls", "mla", "mls",
1606 "mul", "pmul", "mul", "pmul",
1607 "smaxp", "umaxp", "smaxp", "umaxp",
1608 "sminp", "uminp", "sminp", "uminp",
1609 "sqdmulh", "sqrdmulh", "sqdmulh", "sqrdmulh",
1610 "addp", "unallocated", "addp", "unallocated",
1611 "fmaxnm", "fmaxnmp", "fminnm", "fminnmp",
1612 "fmla", "unallocated", "fmls", "unallocated",
1613 "fadd", "faddp", "fsub", "fabd",
1614 "fmulx", "fmul", "unallocated", "unallocated",
1615 "fcmeq", "fcmge", "unallocated", "fcmgt",
1616 "unallocated", "facge", "unallocated", "facgt",
1617 "fmax", "fmaxp", "fmin", "fminp",
1618 "frecps", "fdiv", "frsqrts", "unallocated"};
1619
1620 // Operation is determined by the opcode bits (15-11), the top bit of
1621 // size (23) and the U bit (29).
1622 unsigned index = (instr->Bits(15, 11) << 2) | (instr->Bit(23) << 1) |
1623 instr->Bit(29);
1624 VIXL_ASSERT(index < (sizeof(mnemonics) / sizeof(mnemonics[0])));
1625 mnemonic = mnemonics[index];
1626 // Assert that index is not one of the previously handled logical
1627 // instructions.
1628 VIXL_ASSERT(mnemonic != NULL);
1629
1630 if (instr->Mask(NEON3SameFPFMask) == NEON3SameFPFixed) {
1631 nfd.SetFormatMaps(nfd.FPFormatMap());
1632 }
1633 }
1634 Format(instr, mnemonic, nfd.Substitute(form));
1635 }
1636
1637
VisitNEON3Different(const Instruction * instr)1638 void Disassembler::VisitNEON3Different(const Instruction* instr) {
1639 const char *mnemonic = "unimplemented";
1640 const char *form = "'Vd.%s, 'Vn.%s, 'Vm.%s";
1641
1642 NEONFormatDecoder nfd(instr);
1643 nfd.SetFormatMap(0, nfd.LongIntegerFormatMap());
1644
1645 // Ignore the Q bit. Appending a "2" suffix is handled later.
1646 switch (instr->Mask(NEON3DifferentMask) & ~NEON_Q) {
1647 case NEON_PMULL: mnemonic = "pmull"; break;
1648 case NEON_SABAL: mnemonic = "sabal"; break;
1649 case NEON_SABDL: mnemonic = "sabdl"; break;
1650 case NEON_SADDL: mnemonic = "saddl"; break;
1651 case NEON_SMLAL: mnemonic = "smlal"; break;
1652 case NEON_SMLSL: mnemonic = "smlsl"; break;
1653 case NEON_SMULL: mnemonic = "smull"; break;
1654 case NEON_SSUBL: mnemonic = "ssubl"; break;
1655 case NEON_SQDMLAL: mnemonic = "sqdmlal"; break;
1656 case NEON_SQDMLSL: mnemonic = "sqdmlsl"; break;
1657 case NEON_SQDMULL: mnemonic = "sqdmull"; break;
1658 case NEON_UABAL: mnemonic = "uabal"; break;
1659 case NEON_UABDL: mnemonic = "uabdl"; break;
1660 case NEON_UADDL: mnemonic = "uaddl"; break;
1661 case NEON_UMLAL: mnemonic = "umlal"; break;
1662 case NEON_UMLSL: mnemonic = "umlsl"; break;
1663 case NEON_UMULL: mnemonic = "umull"; break;
1664 case NEON_USUBL: mnemonic = "usubl"; break;
1665 case NEON_SADDW:
1666 mnemonic = "saddw";
1667 nfd.SetFormatMap(1, nfd.LongIntegerFormatMap());
1668 break;
1669 case NEON_SSUBW:
1670 mnemonic = "ssubw";
1671 nfd.SetFormatMap(1, nfd.LongIntegerFormatMap());
1672 break;
1673 case NEON_UADDW:
1674 mnemonic = "uaddw";
1675 nfd.SetFormatMap(1, nfd.LongIntegerFormatMap());
1676 break;
1677 case NEON_USUBW:
1678 mnemonic = "usubw";
1679 nfd.SetFormatMap(1, nfd.LongIntegerFormatMap());
1680 break;
1681 case NEON_ADDHN:
1682 mnemonic = "addhn";
1683 nfd.SetFormatMaps(nfd.LongIntegerFormatMap());
1684 nfd.SetFormatMap(0, nfd.IntegerFormatMap());
1685 break;
1686 case NEON_RADDHN:
1687 mnemonic = "raddhn";
1688 nfd.SetFormatMaps(nfd.LongIntegerFormatMap());
1689 nfd.SetFormatMap(0, nfd.IntegerFormatMap());
1690 break;
1691 case NEON_RSUBHN:
1692 mnemonic = "rsubhn";
1693 nfd.SetFormatMaps(nfd.LongIntegerFormatMap());
1694 nfd.SetFormatMap(0, nfd.IntegerFormatMap());
1695 break;
1696 case NEON_SUBHN:
1697 mnemonic = "subhn";
1698 nfd.SetFormatMaps(nfd.LongIntegerFormatMap());
1699 nfd.SetFormatMap(0, nfd.IntegerFormatMap());
1700 break;
1701 default: form = "(NEON3Different)";
1702 }
1703 Format(instr, nfd.Mnemonic(mnemonic), nfd.Substitute(form));
1704 }
1705
1706
VisitNEONAcrossLanes(const Instruction * instr)1707 void Disassembler::VisitNEONAcrossLanes(const Instruction* instr) {
1708 const char *mnemonic = "unimplemented";
1709 const char *form = "%sd, 'Vn.%s";
1710
1711 NEONFormatDecoder nfd(instr, NEONFormatDecoder::ScalarFormatMap(),
1712 NEONFormatDecoder::IntegerFormatMap());
1713
1714 if (instr->Mask(NEONAcrossLanesFPFMask) == NEONAcrossLanesFPFixed) {
1715 nfd.SetFormatMap(0, nfd.FPScalarFormatMap());
1716 nfd.SetFormatMap(1, nfd.FPFormatMap());
1717 switch (instr->Mask(NEONAcrossLanesFPMask)) {
1718 case NEON_FMAXV: mnemonic = "fmaxv"; break;
1719 case NEON_FMINV: mnemonic = "fminv"; break;
1720 case NEON_FMAXNMV: mnemonic = "fmaxnmv"; break;
1721 case NEON_FMINNMV: mnemonic = "fminnmv"; break;
1722 default: form = "(NEONAcrossLanes)"; break;
1723 }
1724 } else if (instr->Mask(NEONAcrossLanesFMask) == NEONAcrossLanesFixed) {
1725 switch (instr->Mask(NEONAcrossLanesMask)) {
1726 case NEON_ADDV: mnemonic = "addv"; break;
1727 case NEON_SMAXV: mnemonic = "smaxv"; break;
1728 case NEON_SMINV: mnemonic = "sminv"; break;
1729 case NEON_UMAXV: mnemonic = "umaxv"; break;
1730 case NEON_UMINV: mnemonic = "uminv"; break;
1731 case NEON_SADDLV:
1732 mnemonic = "saddlv";
1733 nfd.SetFormatMap(0, nfd.LongScalarFormatMap());
1734 break;
1735 case NEON_UADDLV:
1736 mnemonic = "uaddlv";
1737 nfd.SetFormatMap(0, nfd.LongScalarFormatMap());
1738 break;
1739 default: form = "(NEONAcrossLanes)"; break;
1740 }
1741 }
1742 Format(instr, mnemonic, nfd.Substitute(form,
1743 NEONFormatDecoder::kPlaceholder, NEONFormatDecoder::kFormat));
1744 }
1745
1746
VisitNEONByIndexedElement(const Instruction * instr)1747 void Disassembler::VisitNEONByIndexedElement(const Instruction* instr) {
1748 const char *mnemonic = "unimplemented";
1749 bool l_instr = false;
1750 bool fp_instr = false;
1751
1752 const char *form = "'Vd.%s, 'Vn.%s, 'Ve.%s['IVByElemIndex]";
1753
1754 static const NEONFormatMap map_ta = {
1755 {23, 22}, {NF_UNDEF, NF_4S, NF_2D}
1756 };
1757 NEONFormatDecoder nfd(instr, &map_ta,
1758 NEONFormatDecoder::IntegerFormatMap(),
1759 NEONFormatDecoder::ScalarFormatMap());
1760
1761 switch (instr->Mask(NEONByIndexedElementMask)) {
1762 case NEON_SMULL_byelement: mnemonic = "smull"; l_instr = true; break;
1763 case NEON_UMULL_byelement: mnemonic = "umull"; l_instr = true; break;
1764 case NEON_SMLAL_byelement: mnemonic = "smlal"; l_instr = true; break;
1765 case NEON_UMLAL_byelement: mnemonic = "umlal"; l_instr = true; break;
1766 case NEON_SMLSL_byelement: mnemonic = "smlsl"; l_instr = true; break;
1767 case NEON_UMLSL_byelement: mnemonic = "umlsl"; l_instr = true; break;
1768 case NEON_SQDMULL_byelement: mnemonic = "sqdmull"; l_instr = true; break;
1769 case NEON_SQDMLAL_byelement: mnemonic = "sqdmlal"; l_instr = true; break;
1770 case NEON_SQDMLSL_byelement: mnemonic = "sqdmlsl"; l_instr = true; break;
1771 case NEON_MUL_byelement: mnemonic = "mul"; break;
1772 case NEON_MLA_byelement: mnemonic = "mla"; break;
1773 case NEON_MLS_byelement: mnemonic = "mls"; break;
1774 case NEON_SQDMULH_byelement: mnemonic = "sqdmulh"; break;
1775 case NEON_SQRDMULH_byelement: mnemonic = "sqrdmulh"; break;
1776 default:
1777 switch (instr->Mask(NEONByIndexedElementFPMask)) {
1778 case NEON_FMUL_byelement: mnemonic = "fmul"; fp_instr = true; break;
1779 case NEON_FMLA_byelement: mnemonic = "fmla"; fp_instr = true; break;
1780 case NEON_FMLS_byelement: mnemonic = "fmls"; fp_instr = true; break;
1781 case NEON_FMULX_byelement: mnemonic = "fmulx"; fp_instr = true; break;
1782 }
1783 }
1784
1785 if (l_instr) {
1786 Format(instr, nfd.Mnemonic(mnemonic), nfd.Substitute(form));
1787 } else if (fp_instr) {
1788 nfd.SetFormatMap(0, nfd.FPFormatMap());
1789 Format(instr, mnemonic, nfd.Substitute(form));
1790 } else {
1791 nfd.SetFormatMap(0, nfd.IntegerFormatMap());
1792 Format(instr, mnemonic, nfd.Substitute(form));
1793 }
1794 }
1795
1796
VisitNEONCopy(const Instruction * instr)1797 void Disassembler::VisitNEONCopy(const Instruction* instr) {
1798 const char *mnemonic = "unimplemented";
1799 const char *form = "(NEONCopy)";
1800
1801 NEONFormatDecoder nfd(instr, NEONFormatDecoder::TriangularFormatMap(),
1802 NEONFormatDecoder::TriangularScalarFormatMap());
1803
1804 if (instr->Mask(NEONCopyInsElementMask) == NEON_INS_ELEMENT) {
1805 mnemonic = "mov";
1806 nfd.SetFormatMap(0, nfd.TriangularScalarFormatMap());
1807 form = "'Vd.%s['IVInsIndex1], 'Vn.%s['IVInsIndex2]";
1808 } else if (instr->Mask(NEONCopyInsGeneralMask) == NEON_INS_GENERAL) {
1809 mnemonic = "mov";
1810 nfd.SetFormatMap(0, nfd.TriangularScalarFormatMap());
1811 if (nfd.GetVectorFormat() == kFormatD) {
1812 form = "'Vd.%s['IVInsIndex1], 'Xn";
1813 } else {
1814 form = "'Vd.%s['IVInsIndex1], 'Wn";
1815 }
1816 } else if (instr->Mask(NEONCopyUmovMask) == NEON_UMOV) {
1817 if (instr->Mask(NEON_Q) || ((instr->ImmNEON5() & 7) == 4)) {
1818 mnemonic = "mov";
1819 } else {
1820 mnemonic = "umov";
1821 }
1822 nfd.SetFormatMap(0, nfd.TriangularScalarFormatMap());
1823 if (nfd.GetVectorFormat() == kFormatD) {
1824 form = "'Xd, 'Vn.%s['IVInsIndex1]";
1825 } else {
1826 form = "'Wd, 'Vn.%s['IVInsIndex1]";
1827 }
1828 } else if (instr->Mask(NEONCopySmovMask) == NEON_SMOV) {
1829 mnemonic = "smov";
1830 nfd.SetFormatMap(0, nfd.TriangularScalarFormatMap());
1831 form = "'Rdq, 'Vn.%s['IVInsIndex1]";
1832 } else if (instr->Mask(NEONCopyDupElementMask) == NEON_DUP_ELEMENT) {
1833 mnemonic = "dup";
1834 form = "'Vd.%s, 'Vn.%s['IVInsIndex1]";
1835 } else if (instr->Mask(NEONCopyDupGeneralMask) == NEON_DUP_GENERAL) {
1836 mnemonic = "dup";
1837 if (nfd.GetVectorFormat() == kFormat2D) {
1838 form = "'Vd.%s, 'Xn";
1839 } else {
1840 form = "'Vd.%s, 'Wn";
1841 }
1842 }
1843 Format(instr, mnemonic, nfd.Substitute(form));
1844 }
1845
1846
VisitNEONExtract(const Instruction * instr)1847 void Disassembler::VisitNEONExtract(const Instruction* instr) {
1848 const char *mnemonic = "unimplemented";
1849 const char *form = "(NEONExtract)";
1850 NEONFormatDecoder nfd(instr, NEONFormatDecoder::LogicalFormatMap());
1851 if (instr->Mask(NEONExtractMask) == NEON_EXT) {
1852 mnemonic = "ext";
1853 form = "'Vd.%s, 'Vn.%s, 'Vm.%s, 'IVExtract";
1854 }
1855 Format(instr, mnemonic, nfd.Substitute(form));
1856 }
1857
1858
VisitNEONLoadStoreMultiStruct(const Instruction * instr)1859 void Disassembler::VisitNEONLoadStoreMultiStruct(const Instruction* instr) {
1860 const char *mnemonic = "unimplemented";
1861 const char *form = "(NEONLoadStoreMultiStruct)";
1862 const char *form_1v = "{'Vt.%1$s}, ['Xns]";
1863 const char *form_2v = "{'Vt.%1$s, 'Vt2.%1$s}, ['Xns]";
1864 const char *form_3v = "{'Vt.%1$s, 'Vt2.%1$s, 'Vt3.%1$s}, ['Xns]";
1865 const char *form_4v = "{'Vt.%1$s, 'Vt2.%1$s, 'Vt3.%1$s, 'Vt4.%1$s}, ['Xns]";
1866 NEONFormatDecoder nfd(instr, NEONFormatDecoder::LoadStoreFormatMap());
1867
1868 switch (instr->Mask(NEONLoadStoreMultiStructMask)) {
1869 case NEON_LD1_1v: mnemonic = "ld1"; form = form_1v; break;
1870 case NEON_LD1_2v: mnemonic = "ld1"; form = form_2v; break;
1871 case NEON_LD1_3v: mnemonic = "ld1"; form = form_3v; break;
1872 case NEON_LD1_4v: mnemonic = "ld1"; form = form_4v; break;
1873 case NEON_LD2: mnemonic = "ld2"; form = form_2v; break;
1874 case NEON_LD3: mnemonic = "ld3"; form = form_3v; break;
1875 case NEON_LD4: mnemonic = "ld4"; form = form_4v; break;
1876 case NEON_ST1_1v: mnemonic = "st1"; form = form_1v; break;
1877 case NEON_ST1_2v: mnemonic = "st1"; form = form_2v; break;
1878 case NEON_ST1_3v: mnemonic = "st1"; form = form_3v; break;
1879 case NEON_ST1_4v: mnemonic = "st1"; form = form_4v; break;
1880 case NEON_ST2: mnemonic = "st2"; form = form_2v; break;
1881 case NEON_ST3: mnemonic = "st3"; form = form_3v; break;
1882 case NEON_ST4: mnemonic = "st4"; form = form_4v; break;
1883 default: break;
1884 }
1885
1886 Format(instr, mnemonic, nfd.Substitute(form));
1887 }
1888
1889
VisitNEONLoadStoreMultiStructPostIndex(const Instruction * instr)1890 void Disassembler::VisitNEONLoadStoreMultiStructPostIndex(
1891 const Instruction* instr) {
1892 const char *mnemonic = "unimplemented";
1893 const char *form = "(NEONLoadStoreMultiStructPostIndex)";
1894 const char *form_1v = "{'Vt.%1$s}, ['Xns], 'Xmr1";
1895 const char *form_2v = "{'Vt.%1$s, 'Vt2.%1$s}, ['Xns], 'Xmr2";
1896 const char *form_3v = "{'Vt.%1$s, 'Vt2.%1$s, 'Vt3.%1$s}, ['Xns], 'Xmr3";
1897 const char *form_4v =
1898 "{'Vt.%1$s, 'Vt2.%1$s, 'Vt3.%1$s, 'Vt4.%1$s}, ['Xns], 'Xmr4";
1899 NEONFormatDecoder nfd(instr, NEONFormatDecoder::LoadStoreFormatMap());
1900
1901 switch (instr->Mask(NEONLoadStoreMultiStructPostIndexMask)) {
1902 case NEON_LD1_1v_post: mnemonic = "ld1"; form = form_1v; break;
1903 case NEON_LD1_2v_post: mnemonic = "ld1"; form = form_2v; break;
1904 case NEON_LD1_3v_post: mnemonic = "ld1"; form = form_3v; break;
1905 case NEON_LD1_4v_post: mnemonic = "ld1"; form = form_4v; break;
1906 case NEON_LD2_post: mnemonic = "ld2"; form = form_2v; break;
1907 case NEON_LD3_post: mnemonic = "ld3"; form = form_3v; break;
1908 case NEON_LD4_post: mnemonic = "ld4"; form = form_4v; break;
1909 case NEON_ST1_1v_post: mnemonic = "st1"; form = form_1v; break;
1910 case NEON_ST1_2v_post: mnemonic = "st1"; form = form_2v; break;
1911 case NEON_ST1_3v_post: mnemonic = "st1"; form = form_3v; break;
1912 case NEON_ST1_4v_post: mnemonic = "st1"; form = form_4v; break;
1913 case NEON_ST2_post: mnemonic = "st2"; form = form_2v; break;
1914 case NEON_ST3_post: mnemonic = "st3"; form = form_3v; break;
1915 case NEON_ST4_post: mnemonic = "st4"; form = form_4v; break;
1916 default: break;
1917 }
1918
1919 Format(instr, mnemonic, nfd.Substitute(form));
1920 }
1921
1922
VisitNEONLoadStoreSingleStruct(const Instruction * instr)1923 void Disassembler::VisitNEONLoadStoreSingleStruct(const Instruction* instr) {
1924 const char *mnemonic = "unimplemented";
1925 const char *form = "(NEONLoadStoreSingleStruct)";
1926
1927 const char *form_1b = "{'Vt.b}['IVLSLane0], ['Xns]";
1928 const char *form_1h = "{'Vt.h}['IVLSLane1], ['Xns]";
1929 const char *form_1s = "{'Vt.s}['IVLSLane2], ['Xns]";
1930 const char *form_1d = "{'Vt.d}['IVLSLane3], ['Xns]";
1931 NEONFormatDecoder nfd(instr, NEONFormatDecoder::LoadStoreFormatMap());
1932
1933 switch (instr->Mask(NEONLoadStoreSingleStructMask)) {
1934 case NEON_LD1_b: mnemonic = "ld1"; form = form_1b; break;
1935 case NEON_LD1_h: mnemonic = "ld1"; form = form_1h; break;
1936 case NEON_LD1_s:
1937 mnemonic = "ld1";
1938 VIXL_STATIC_ASSERT((NEON_LD1_s | (1 << NEONLSSize_offset)) == NEON_LD1_d);
1939 form = ((instr->NEONLSSize() & 1) == 0) ? form_1s : form_1d;
1940 break;
1941 case NEON_ST1_b: mnemonic = "st1"; form = form_1b; break;
1942 case NEON_ST1_h: mnemonic = "st1"; form = form_1h; break;
1943 case NEON_ST1_s:
1944 mnemonic = "st1";
1945 VIXL_STATIC_ASSERT((NEON_ST1_s | (1 << NEONLSSize_offset)) == NEON_ST1_d);
1946 form = ((instr->NEONLSSize() & 1) == 0) ? form_1s : form_1d;
1947 break;
1948 case NEON_LD1R:
1949 mnemonic = "ld1r";
1950 form = "{'Vt.%s}, ['Xns]";
1951 break;
1952 case NEON_LD2_b:
1953 case NEON_ST2_b:
1954 mnemonic = (instr->LdStXLoad() == 1) ? "ld2" : "st2";
1955 form = "{'Vt.b, 'Vt2.b}['IVLSLane0], ['Xns]";
1956 break;
1957 case NEON_LD2_h:
1958 case NEON_ST2_h:
1959 mnemonic = (instr->LdStXLoad() == 1) ? "ld2" : "st2";
1960 form = "{'Vt.h, 'Vt2.h}['IVLSLane1], ['Xns]";
1961 break;
1962 case NEON_LD2_s:
1963 case NEON_ST2_s:
1964 VIXL_STATIC_ASSERT((NEON_ST2_s | (1 << NEONLSSize_offset)) == NEON_ST2_d);
1965 VIXL_STATIC_ASSERT((NEON_LD2_s | (1 << NEONLSSize_offset)) == NEON_LD2_d);
1966 mnemonic = (instr->LdStXLoad() == 1) ? "ld2" : "st2";
1967 if ((instr->NEONLSSize() & 1) == 0)
1968 form = "{'Vt.s, 'Vt2.s}['IVLSLane2], ['Xns]";
1969 else
1970 form = "{'Vt.d, 'Vt2.d}['IVLSLane3], ['Xns]";
1971 break;
1972 case NEON_LD2R:
1973 mnemonic = "ld2r";
1974 form = "{'Vt.%s, 'Vt2.%s}, ['Xns]";
1975 break;
1976 case NEON_LD3_b:
1977 case NEON_ST3_b:
1978 mnemonic = (instr->LdStXLoad() == 1) ? "ld3" : "st3";
1979 form = "{'Vt.b, 'Vt2.b, 'Vt3.b}['IVLSLane0], ['Xns]";
1980 break;
1981 case NEON_LD3_h:
1982 case NEON_ST3_h:
1983 mnemonic = (instr->LdStXLoad() == 1) ? "ld3" : "st3";
1984 form = "{'Vt.h, 'Vt2.h, 'Vt3.h}['IVLSLane1], ['Xns]";
1985 break;
1986 case NEON_LD3_s:
1987 case NEON_ST3_s:
1988 mnemonic = (instr->LdStXLoad() == 1) ? "ld3" : "st3";
1989 if ((instr->NEONLSSize() & 1) == 0)
1990 form = "{'Vt.s, 'Vt2.s, 'Vt3.s}['IVLSLane2], ['Xns]";
1991 else
1992 form = "{'Vt.d, 'Vt2.d, 'Vt3.d}['IVLSLane3], ['Xns]";
1993 break;
1994 case NEON_LD3R:
1995 mnemonic = "ld3r";
1996 form = "{'Vt.%s, 'Vt2.%s, 'Vt3.%s}, ['Xns]";
1997 break;
1998 case NEON_LD4_b:
1999 case NEON_ST4_b:
2000 mnemonic = (instr->LdStXLoad() == 1) ? "ld4" : "st4";
2001 form = "{'Vt.b, 'Vt2.b, 'Vt3.b, 'Vt4.b}['IVLSLane0], ['Xns]";
2002 break;
2003 case NEON_LD4_h:
2004 case NEON_ST4_h:
2005 mnemonic = (instr->LdStXLoad() == 1) ? "ld4" : "st4";
2006 form = "{'Vt.h, 'Vt2.h, 'Vt3.h, 'Vt4.h}['IVLSLane1], ['Xns]";
2007 break;
2008 case NEON_LD4_s:
2009 case NEON_ST4_s:
2010 VIXL_STATIC_ASSERT((NEON_LD4_s | (1 << NEONLSSize_offset)) == NEON_LD4_d);
2011 VIXL_STATIC_ASSERT((NEON_ST4_s | (1 << NEONLSSize_offset)) == NEON_ST4_d);
2012 mnemonic = (instr->LdStXLoad() == 1) ? "ld4" : "st4";
2013 if ((instr->NEONLSSize() & 1) == 0)
2014 form = "{'Vt.s, 'Vt2.s, 'Vt3.s, 'Vt4.s}['IVLSLane2], ['Xns]";
2015 else
2016 form = "{'Vt.d, 'Vt2.d, 'Vt3.d, 'Vt4.d}['IVLSLane3], ['Xns]";
2017 break;
2018 case NEON_LD4R:
2019 mnemonic = "ld4r";
2020 form = "{'Vt.%1$s, 'Vt2.%1$s, 'Vt3.%1$s, 'Vt4.%1$s}, ['Xns]";
2021 break;
2022 default: break;
2023 }
2024
2025 Format(instr, mnemonic, nfd.Substitute(form));
2026 }
2027
2028
VisitNEONLoadStoreSingleStructPostIndex(const Instruction * instr)2029 void Disassembler::VisitNEONLoadStoreSingleStructPostIndex(
2030 const Instruction* instr) {
2031 const char *mnemonic = "unimplemented";
2032 const char *form = "(NEONLoadStoreSingleStructPostIndex)";
2033
2034 const char *form_1b = "{'Vt.b}['IVLSLane0], ['Xns], 'Xmb1";
2035 const char *form_1h = "{'Vt.h}['IVLSLane1], ['Xns], 'Xmb2";
2036 const char *form_1s = "{'Vt.s}['IVLSLane2], ['Xns], 'Xmb4";
2037 const char *form_1d = "{'Vt.d}['IVLSLane3], ['Xns], 'Xmb8";
2038 NEONFormatDecoder nfd(instr, NEONFormatDecoder::LoadStoreFormatMap());
2039
2040 switch (instr->Mask(NEONLoadStoreSingleStructPostIndexMask)) {
2041 case NEON_LD1_b_post: mnemonic = "ld1"; form = form_1b; break;
2042 case NEON_LD1_h_post: mnemonic = "ld1"; form = form_1h; break;
2043 case NEON_LD1_s_post:
2044 mnemonic = "ld1";
2045 VIXL_STATIC_ASSERT((NEON_LD1_s | (1 << NEONLSSize_offset)) == NEON_LD1_d);
2046 form = ((instr->NEONLSSize() & 1) == 0) ? form_1s : form_1d;
2047 break;
2048 case NEON_ST1_b_post: mnemonic = "st1"; form = form_1b; break;
2049 case NEON_ST1_h_post: mnemonic = "st1"; form = form_1h; break;
2050 case NEON_ST1_s_post:
2051 mnemonic = "st1";
2052 VIXL_STATIC_ASSERT((NEON_ST1_s | (1 << NEONLSSize_offset)) == NEON_ST1_d);
2053 form = ((instr->NEONLSSize() & 1) == 0) ? form_1s : form_1d;
2054 break;
2055 case NEON_LD1R_post:
2056 mnemonic = "ld1r";
2057 form = "{'Vt.%s}, ['Xns], 'Xmz1";
2058 break;
2059 case NEON_LD2_b_post:
2060 case NEON_ST2_b_post:
2061 mnemonic = (instr->LdStXLoad() == 1) ? "ld2" : "st2";
2062 form = "{'Vt.b, 'Vt2.b}['IVLSLane0], ['Xns], 'Xmb2";
2063 break;
2064 case NEON_ST2_h_post:
2065 case NEON_LD2_h_post:
2066 mnemonic = (instr->LdStXLoad() == 1) ? "ld2" : "st2";
2067 form = "{'Vt.h, 'Vt2.h}['IVLSLane1], ['Xns], 'Xmb4";
2068 break;
2069 case NEON_LD2_s_post:
2070 case NEON_ST2_s_post:
2071 mnemonic = (instr->LdStXLoad() == 1) ? "ld2" : "st2";
2072 if ((instr->NEONLSSize() & 1) == 0)
2073 form = "{'Vt.s, 'Vt2.s}['IVLSLane2], ['Xns], 'Xmb8";
2074 else
2075 form = "{'Vt.d, 'Vt2.d}['IVLSLane3], ['Xns], 'Xmb16";
2076 break;
2077 case NEON_LD2R_post:
2078 mnemonic = "ld2r";
2079 form = "{'Vt.%s, 'Vt2.%s}, ['Xns], 'Xmz2";
2080 break;
2081 case NEON_LD3_b_post:
2082 case NEON_ST3_b_post:
2083 mnemonic = (instr->LdStXLoad() == 1) ? "ld3" : "st3";
2084 form = "{'Vt.b, 'Vt2.b, 'Vt3.b}['IVLSLane0], ['Xns], 'Xmb3";
2085 break;
2086 case NEON_LD3_h_post:
2087 case NEON_ST3_h_post:
2088 mnemonic = (instr->LdStXLoad() == 1) ? "ld3" : "st3";
2089 form = "{'Vt.h, 'Vt2.h, 'Vt3.h}['IVLSLane1], ['Xns], 'Xmb6";
2090 break;
2091 case NEON_LD3_s_post:
2092 case NEON_ST3_s_post:
2093 mnemonic = (instr->LdStXLoad() == 1) ? "ld3" : "st3";
2094 if ((instr->NEONLSSize() & 1) == 0)
2095 form = "{'Vt.s, 'Vt2.s, 'Vt3.s}['IVLSLane2], ['Xns], 'Xmb12";
2096 else
2097 form = "{'Vt.d, 'Vt2.d, 'Vt3.d}['IVLSLane3], ['Xns], 'Xmr3";
2098 break;
2099 case NEON_LD3R_post:
2100 mnemonic = "ld3r";
2101 form = "{'Vt.%s, 'Vt2.%s, 'Vt3.%s}, ['Xns], 'Xmz3";
2102 break;
2103 case NEON_LD4_b_post:
2104 case NEON_ST4_b_post:
2105 mnemonic = (instr->LdStXLoad() == 1) ? "ld4" : "st4";
2106 form = "{'Vt.b, 'Vt2.b, 'Vt3.b, 'Vt4.b}['IVLSLane0], ['Xns], 'Xmb4";
2107 break;
2108 case NEON_LD4_h_post:
2109 case NEON_ST4_h_post:
2110 mnemonic = (instr->LdStXLoad()) == 1 ? "ld4" : "st4";
2111 form = "{'Vt.h, 'Vt2.h, 'Vt3.h, 'Vt4.h}['IVLSLane1], ['Xns], 'Xmb8";
2112 break;
2113 case NEON_LD4_s_post:
2114 case NEON_ST4_s_post:
2115 mnemonic = (instr->LdStXLoad() == 1) ? "ld4" : "st4";
2116 if ((instr->NEONLSSize() & 1) == 0)
2117 form = "{'Vt.s, 'Vt2.s, 'Vt3.s, 'Vt4.s}['IVLSLane2], ['Xns], 'Xmb16";
2118 else
2119 form = "{'Vt.d, 'Vt2.d, 'Vt3.d, 'Vt4.d}['IVLSLane3], ['Xns], 'Xmb32";
2120 break;
2121 case NEON_LD4R_post:
2122 mnemonic = "ld4r";
2123 form = "{'Vt.%1$s, 'Vt2.%1$s, 'Vt3.%1$s, 'Vt4.%1$s}, ['Xns], 'Xmz4";
2124 break;
2125 default: break;
2126 }
2127
2128 Format(instr, mnemonic, nfd.Substitute(form));
2129 }
2130
2131
VisitNEONModifiedImmediate(const Instruction * instr)2132 void Disassembler::VisitNEONModifiedImmediate(const Instruction* instr) {
2133 const char *mnemonic = "unimplemented";
2134 const char *form = "'Vt.%s, 'IVMIImm8, lsl 'IVMIShiftAmt1";
2135
2136 int cmode = instr->NEONCmode();
2137 int cmode_3 = (cmode >> 3) & 1;
2138 int cmode_2 = (cmode >> 2) & 1;
2139 int cmode_1 = (cmode >> 1) & 1;
2140 int cmode_0 = cmode & 1;
2141 int q = instr->NEONQ();
2142 int op = instr->NEONModImmOp();
2143
2144 static const NEONFormatMap map_b = { {30}, {NF_8B, NF_16B} };
2145 static const NEONFormatMap map_h = { {30}, {NF_4H, NF_8H} };
2146 static const NEONFormatMap map_s = { {30}, {NF_2S, NF_4S} };
2147 NEONFormatDecoder nfd(instr, &map_b);
2148
2149 if (cmode_3 == 0) {
2150 if (cmode_0 == 0) {
2151 mnemonic = (op == 1) ? "mvni" : "movi";
2152 } else { // cmode<0> == '1'.
2153 mnemonic = (op == 1) ? "bic" : "orr";
2154 }
2155 nfd.SetFormatMap(0, &map_s);
2156 } else { // cmode<3> == '1'.
2157 if (cmode_2 == 0) {
2158 if (cmode_0 == 0) {
2159 mnemonic = (op == 1) ? "mvni" : "movi";
2160 } else { // cmode<0> == '1'.
2161 mnemonic = (op == 1) ? "bic" : "orr";
2162 }
2163 nfd.SetFormatMap(0, &map_h);
2164 } else { // cmode<2> == '1'.
2165 if (cmode_1 == 0) {
2166 mnemonic = (op == 1) ? "mvni" : "movi";
2167 form = "'Vt.%s, 'IVMIImm8, msl 'IVMIShiftAmt2";
2168 nfd.SetFormatMap(0, &map_s);
2169 } else { // cmode<1> == '1'.
2170 if (cmode_0 == 0) {
2171 mnemonic = "movi";
2172 if (op == 0) {
2173 form = "'Vt.%s, 'IVMIImm8";
2174 } else {
2175 form = (q == 0) ? "'Dd, 'IVMIImm" : "'Vt.2d, 'IVMIImm";
2176 }
2177 } else { // cmode<0> == '1'
2178 mnemonic = "fmov";
2179 if (op == 0) {
2180 form = "'Vt.%s, 'IVMIImmFPSingle";
2181 nfd.SetFormatMap(0, &map_s);
2182 } else {
2183 if (q == 1) {
2184 form = "'Vt.2d, 'IVMIImmFPDouble";
2185 }
2186 }
2187 }
2188 }
2189 }
2190 }
2191 Format(instr, mnemonic, nfd.Substitute(form));
2192 }
2193
2194
VisitNEONScalar2RegMisc(const Instruction * instr)2195 void Disassembler::VisitNEONScalar2RegMisc(const Instruction* instr) {
2196 const char *mnemonic = "unimplemented";
2197 const char *form = "%sd, %sn";
2198 const char *form_0 = "%sd, %sn, #0";
2199 const char *form_fp0 = "%sd, %sn, #0.0";
2200
2201 NEONFormatDecoder nfd(instr, NEONFormatDecoder::ScalarFormatMap());
2202
2203 if (instr->Mask(NEON2RegMiscOpcode) <= NEON_NEG_scalar_opcode) {
2204 // These instructions all use a two bit size field, except NOT and RBIT,
2205 // which use the field to encode the operation.
2206 switch (instr->Mask(NEONScalar2RegMiscMask)) {
2207 case NEON_CMGT_zero_scalar: mnemonic = "cmgt"; form = form_0; break;
2208 case NEON_CMGE_zero_scalar: mnemonic = "cmge"; form = form_0; break;
2209 case NEON_CMLE_zero_scalar: mnemonic = "cmle"; form = form_0; break;
2210 case NEON_CMLT_zero_scalar: mnemonic = "cmlt"; form = form_0; break;
2211 case NEON_CMEQ_zero_scalar: mnemonic = "cmeq"; form = form_0; break;
2212 case NEON_NEG_scalar: mnemonic = "neg"; break;
2213 case NEON_SQNEG_scalar: mnemonic = "sqneg"; break;
2214 case NEON_ABS_scalar: mnemonic = "abs"; break;
2215 case NEON_SQABS_scalar: mnemonic = "sqabs"; break;
2216 case NEON_SUQADD_scalar: mnemonic = "suqadd"; break;
2217 case NEON_USQADD_scalar: mnemonic = "usqadd"; break;
2218 default: form = "(NEONScalar2RegMisc)";
2219 }
2220 } else {
2221 // These instructions all use a one bit size field, except SQXTUN, SQXTN
2222 // and UQXTN, which use a two bit size field.
2223 nfd.SetFormatMaps(nfd.FPScalarFormatMap());
2224 switch (instr->Mask(NEONScalar2RegMiscFPMask)) {
2225 case NEON_FRSQRTE_scalar: mnemonic = "frsqrte"; break;
2226 case NEON_FRECPE_scalar: mnemonic = "frecpe"; break;
2227 case NEON_SCVTF_scalar: mnemonic = "scvtf"; break;
2228 case NEON_UCVTF_scalar: mnemonic = "ucvtf"; break;
2229 case NEON_FCMGT_zero_scalar: mnemonic = "fcmgt"; form = form_fp0; break;
2230 case NEON_FCMGE_zero_scalar: mnemonic = "fcmge"; form = form_fp0; break;
2231 case NEON_FCMLE_zero_scalar: mnemonic = "fcmle"; form = form_fp0; break;
2232 case NEON_FCMLT_zero_scalar: mnemonic = "fcmlt"; form = form_fp0; break;
2233 case NEON_FCMEQ_zero_scalar: mnemonic = "fcmeq"; form = form_fp0; break;
2234 case NEON_FRECPX_scalar: mnemonic = "frecpx"; break;
2235 case NEON_FCVTNS_scalar: mnemonic = "fcvtns"; break;
2236 case NEON_FCVTNU_scalar: mnemonic = "fcvtnu"; break;
2237 case NEON_FCVTPS_scalar: mnemonic = "fcvtps"; break;
2238 case NEON_FCVTPU_scalar: mnemonic = "fcvtpu"; break;
2239 case NEON_FCVTMS_scalar: mnemonic = "fcvtms"; break;
2240 case NEON_FCVTMU_scalar: mnemonic = "fcvtmu"; break;
2241 case NEON_FCVTZS_scalar: mnemonic = "fcvtzs"; break;
2242 case NEON_FCVTZU_scalar: mnemonic = "fcvtzu"; break;
2243 case NEON_FCVTAS_scalar: mnemonic = "fcvtas"; break;
2244 case NEON_FCVTAU_scalar: mnemonic = "fcvtau"; break;
2245 case NEON_FCVTXN_scalar:
2246 nfd.SetFormatMap(0, nfd.LongScalarFormatMap());
2247 mnemonic = "fcvtxn";
2248 break;
2249 default:
2250 nfd.SetFormatMap(0, nfd.ScalarFormatMap());
2251 nfd.SetFormatMap(1, nfd.LongScalarFormatMap());
2252 switch (instr->Mask(NEONScalar2RegMiscMask)) {
2253 case NEON_SQXTN_scalar: mnemonic = "sqxtn"; break;
2254 case NEON_UQXTN_scalar: mnemonic = "uqxtn"; break;
2255 case NEON_SQXTUN_scalar: mnemonic = "sqxtun"; break;
2256 default: form = "(NEONScalar2RegMisc)";
2257 }
2258 }
2259 }
2260 Format(instr, mnemonic, nfd.SubstitutePlaceholders(form));
2261 }
2262
2263
VisitNEONScalar3Diff(const Instruction * instr)2264 void Disassembler::VisitNEONScalar3Diff(const Instruction* instr) {
2265 const char *mnemonic = "unimplemented";
2266 const char *form = "%sd, %sn, %sm";
2267 NEONFormatDecoder nfd(instr, NEONFormatDecoder::LongScalarFormatMap(),
2268 NEONFormatDecoder::ScalarFormatMap());
2269
2270 switch (instr->Mask(NEONScalar3DiffMask)) {
2271 case NEON_SQDMLAL_scalar : mnemonic = "sqdmlal"; break;
2272 case NEON_SQDMLSL_scalar : mnemonic = "sqdmlsl"; break;
2273 case NEON_SQDMULL_scalar : mnemonic = "sqdmull"; break;
2274 default: form = "(NEONScalar3Diff)";
2275 }
2276 Format(instr, mnemonic, nfd.SubstitutePlaceholders(form));
2277 }
2278
2279
VisitNEONScalar3Same(const Instruction * instr)2280 void Disassembler::VisitNEONScalar3Same(const Instruction* instr) {
2281 const char *mnemonic = "unimplemented";
2282 const char *form = "%sd, %sn, %sm";
2283 NEONFormatDecoder nfd(instr, NEONFormatDecoder::ScalarFormatMap());
2284
2285 if (instr->Mask(NEONScalar3SameFPFMask) == NEONScalar3SameFPFixed) {
2286 nfd.SetFormatMaps(nfd.FPScalarFormatMap());
2287 switch (instr->Mask(NEONScalar3SameFPMask)) {
2288 case NEON_FACGE_scalar: mnemonic = "facge"; break;
2289 case NEON_FACGT_scalar: mnemonic = "facgt"; break;
2290 case NEON_FCMEQ_scalar: mnemonic = "fcmeq"; break;
2291 case NEON_FCMGE_scalar: mnemonic = "fcmge"; break;
2292 case NEON_FCMGT_scalar: mnemonic = "fcmgt"; break;
2293 case NEON_FMULX_scalar: mnemonic = "fmulx"; break;
2294 case NEON_FRECPS_scalar: mnemonic = "frecps"; break;
2295 case NEON_FRSQRTS_scalar: mnemonic = "frsqrts"; break;
2296 case NEON_FABD_scalar: mnemonic = "fabd"; break;
2297 default: form = "(NEONScalar3Same)";
2298 }
2299 } else {
2300 switch (instr->Mask(NEONScalar3SameMask)) {
2301 case NEON_ADD_scalar: mnemonic = "add"; break;
2302 case NEON_SUB_scalar: mnemonic = "sub"; break;
2303 case NEON_CMEQ_scalar: mnemonic = "cmeq"; break;
2304 case NEON_CMGE_scalar: mnemonic = "cmge"; break;
2305 case NEON_CMGT_scalar: mnemonic = "cmgt"; break;
2306 case NEON_CMHI_scalar: mnemonic = "cmhi"; break;
2307 case NEON_CMHS_scalar: mnemonic = "cmhs"; break;
2308 case NEON_CMTST_scalar: mnemonic = "cmtst"; break;
2309 case NEON_UQADD_scalar: mnemonic = "uqadd"; break;
2310 case NEON_SQADD_scalar: mnemonic = "sqadd"; break;
2311 case NEON_UQSUB_scalar: mnemonic = "uqsub"; break;
2312 case NEON_SQSUB_scalar: mnemonic = "sqsub"; break;
2313 case NEON_USHL_scalar: mnemonic = "ushl"; break;
2314 case NEON_SSHL_scalar: mnemonic = "sshl"; break;
2315 case NEON_UQSHL_scalar: mnemonic = "uqshl"; break;
2316 case NEON_SQSHL_scalar: mnemonic = "sqshl"; break;
2317 case NEON_URSHL_scalar: mnemonic = "urshl"; break;
2318 case NEON_SRSHL_scalar: mnemonic = "srshl"; break;
2319 case NEON_UQRSHL_scalar: mnemonic = "uqrshl"; break;
2320 case NEON_SQRSHL_scalar: mnemonic = "sqrshl"; break;
2321 case NEON_SQDMULH_scalar: mnemonic = "sqdmulh"; break;
2322 case NEON_SQRDMULH_scalar: mnemonic = "sqrdmulh"; break;
2323 default: form = "(NEONScalar3Same)";
2324 }
2325 }
2326 Format(instr, mnemonic, nfd.SubstitutePlaceholders(form));
2327 }
2328
2329
VisitNEONScalarByIndexedElement(const Instruction * instr)2330 void Disassembler::VisitNEONScalarByIndexedElement(const Instruction* instr) {
2331 const char *mnemonic = "unimplemented";
2332 const char *form = "%sd, %sn, 'Ve.%s['IVByElemIndex]";
2333 NEONFormatDecoder nfd(instr, NEONFormatDecoder::ScalarFormatMap());
2334 bool long_instr = false;
2335
2336 switch (instr->Mask(NEONScalarByIndexedElementMask)) {
2337 case NEON_SQDMULL_byelement_scalar:
2338 mnemonic = "sqdmull";
2339 long_instr = true;
2340 break;
2341 case NEON_SQDMLAL_byelement_scalar:
2342 mnemonic = "sqdmlal";
2343 long_instr = true;
2344 break;
2345 case NEON_SQDMLSL_byelement_scalar:
2346 mnemonic = "sqdmlsl";
2347 long_instr = true;
2348 break;
2349 case NEON_SQDMULH_byelement_scalar:
2350 mnemonic = "sqdmulh";
2351 break;
2352 case NEON_SQRDMULH_byelement_scalar:
2353 mnemonic = "sqrdmulh";
2354 break;
2355 default:
2356 nfd.SetFormatMap(0, nfd.FPScalarFormatMap());
2357 switch (instr->Mask(NEONScalarByIndexedElementFPMask)) {
2358 case NEON_FMUL_byelement_scalar: mnemonic = "fmul"; break;
2359 case NEON_FMLA_byelement_scalar: mnemonic = "fmla"; break;
2360 case NEON_FMLS_byelement_scalar: mnemonic = "fmls"; break;
2361 case NEON_FMULX_byelement_scalar: mnemonic = "fmulx"; break;
2362 default: form = "(NEONScalarByIndexedElement)";
2363 }
2364 }
2365
2366 if (long_instr) {
2367 nfd.SetFormatMap(0, nfd.LongScalarFormatMap());
2368 }
2369
2370 Format(instr, mnemonic, nfd.Substitute(
2371 form, nfd.kPlaceholder, nfd.kPlaceholder, nfd.kFormat));
2372 }
2373
2374
VisitNEONScalarCopy(const Instruction * instr)2375 void Disassembler::VisitNEONScalarCopy(const Instruction* instr) {
2376 const char *mnemonic = "unimplemented";
2377 const char *form = "(NEONScalarCopy)";
2378
2379 NEONFormatDecoder nfd(instr, NEONFormatDecoder::TriangularScalarFormatMap());
2380
2381 if (instr->Mask(NEONScalarCopyMask) == NEON_DUP_ELEMENT_scalar) {
2382 mnemonic = "mov";
2383 form = "%sd, 'Vn.%s['IVInsIndex1]";
2384 }
2385
2386 Format(instr, mnemonic, nfd.Substitute(form, nfd.kPlaceholder, nfd.kFormat));
2387 }
2388
2389
VisitNEONScalarPairwise(const Instruction * instr)2390 void Disassembler::VisitNEONScalarPairwise(const Instruction* instr) {
2391 const char *mnemonic = "unimplemented";
2392 const char *form = "%sd, 'Vn.%s";
2393 NEONFormatMap map = { {22}, {NF_2S, NF_2D} };
2394 NEONFormatDecoder nfd(instr, NEONFormatDecoder::FPScalarFormatMap(), &map);
2395
2396 switch (instr->Mask(NEONScalarPairwiseMask)) {
2397 case NEON_ADDP_scalar: mnemonic = "addp"; break;
2398 case NEON_FADDP_scalar: mnemonic = "faddp"; break;
2399 case NEON_FMAXP_scalar: mnemonic = "fmaxp"; break;
2400 case NEON_FMAXNMP_scalar: mnemonic = "fmaxnmp"; break;
2401 case NEON_FMINP_scalar: mnemonic = "fminp"; break;
2402 case NEON_FMINNMP_scalar: mnemonic = "fminnmp"; break;
2403 default: form = "(NEONScalarPairwise)";
2404 }
2405 Format(instr, mnemonic, nfd.Substitute(form,
2406 NEONFormatDecoder::kPlaceholder, NEONFormatDecoder::kFormat));
2407 }
2408
2409
VisitNEONScalarShiftImmediate(const Instruction * instr)2410 void Disassembler::VisitNEONScalarShiftImmediate(const Instruction* instr) {
2411 const char *mnemonic = "unimplemented";
2412 const char *form = "%sd, %sn, 'Is1";
2413 const char *form_2 = "%sd, %sn, 'Is2";
2414
2415 static const NEONFormatMap map_shift = {
2416 {22, 21, 20, 19},
2417 {NF_UNDEF, NF_B, NF_H, NF_H, NF_S, NF_S, NF_S, NF_S,
2418 NF_D, NF_D, NF_D, NF_D, NF_D, NF_D, NF_D, NF_D}
2419 };
2420 static const NEONFormatMap map_shift_narrow = {
2421 {21, 20, 19},
2422 {NF_UNDEF, NF_H, NF_S, NF_S, NF_D, NF_D, NF_D, NF_D}
2423 };
2424 NEONFormatDecoder nfd(instr, &map_shift);
2425
2426 if (instr->ImmNEONImmh()) { // immh has to be non-zero.
2427 switch (instr->Mask(NEONScalarShiftImmediateMask)) {
2428 case NEON_FCVTZU_imm_scalar: mnemonic = "fcvtzu"; break;
2429 case NEON_FCVTZS_imm_scalar: mnemonic = "fcvtzs"; break;
2430 case NEON_SCVTF_imm_scalar: mnemonic = "scvtf"; break;
2431 case NEON_UCVTF_imm_scalar: mnemonic = "ucvtf"; break;
2432 case NEON_SRI_scalar: mnemonic = "sri"; break;
2433 case NEON_SSHR_scalar: mnemonic = "sshr"; break;
2434 case NEON_USHR_scalar: mnemonic = "ushr"; break;
2435 case NEON_SRSHR_scalar: mnemonic = "srshr"; break;
2436 case NEON_URSHR_scalar: mnemonic = "urshr"; break;
2437 case NEON_SSRA_scalar: mnemonic = "ssra"; break;
2438 case NEON_USRA_scalar: mnemonic = "usra"; break;
2439 case NEON_SRSRA_scalar: mnemonic = "srsra"; break;
2440 case NEON_URSRA_scalar: mnemonic = "ursra"; break;
2441 case NEON_SHL_scalar: mnemonic = "shl"; form = form_2; break;
2442 case NEON_SLI_scalar: mnemonic = "sli"; form = form_2; break;
2443 case NEON_SQSHLU_scalar: mnemonic = "sqshlu"; form = form_2; break;
2444 case NEON_SQSHL_imm_scalar: mnemonic = "sqshl"; form = form_2; break;
2445 case NEON_UQSHL_imm_scalar: mnemonic = "uqshl"; form = form_2; break;
2446 case NEON_UQSHRN_scalar:
2447 mnemonic = "uqshrn";
2448 nfd.SetFormatMap(1, &map_shift_narrow);
2449 break;
2450 case NEON_UQRSHRN_scalar:
2451 mnemonic = "uqrshrn";
2452 nfd.SetFormatMap(1, &map_shift_narrow);
2453 break;
2454 case NEON_SQSHRN_scalar:
2455 mnemonic = "sqshrn";
2456 nfd.SetFormatMap(1, &map_shift_narrow);
2457 break;
2458 case NEON_SQRSHRN_scalar:
2459 mnemonic = "sqrshrn";
2460 nfd.SetFormatMap(1, &map_shift_narrow);
2461 break;
2462 case NEON_SQSHRUN_scalar:
2463 mnemonic = "sqshrun";
2464 nfd.SetFormatMap(1, &map_shift_narrow);
2465 break;
2466 case NEON_SQRSHRUN_scalar:
2467 mnemonic = "sqrshrun";
2468 nfd.SetFormatMap(1, &map_shift_narrow);
2469 break;
2470 default:
2471 form = "(NEONScalarShiftImmediate)";
2472 }
2473 } else {
2474 form = "(NEONScalarShiftImmediate)";
2475 }
2476 Format(instr, mnemonic, nfd.SubstitutePlaceholders(form));
2477 }
2478
2479
VisitNEONShiftImmediate(const Instruction * instr)2480 void Disassembler::VisitNEONShiftImmediate(const Instruction* instr) {
2481 const char *mnemonic = "unimplemented";
2482 const char *form = "'Vd.%s, 'Vn.%s, 'Is1";
2483 const char *form_shift_2 = "'Vd.%s, 'Vn.%s, 'Is2";
2484 const char *form_xtl = "'Vd.%s, 'Vn.%s";
2485
2486 // 0001->8H, 001x->4S, 01xx->2D, all others undefined.
2487 static const NEONFormatMap map_shift_ta = {
2488 {22, 21, 20, 19},
2489 {NF_UNDEF, NF_8H, NF_4S, NF_4S, NF_2D, NF_2D, NF_2D, NF_2D}
2490 };
2491
2492 // 00010->8B, 00011->16B, 001x0->4H, 001x1->8H,
2493 // 01xx0->2S, 01xx1->4S, 1xxx1->2D, all others undefined.
2494 static const NEONFormatMap map_shift_tb = {
2495 {22, 21, 20, 19, 30},
2496 {NF_UNDEF, NF_UNDEF, NF_8B, NF_16B, NF_4H, NF_8H, NF_4H, NF_8H,
2497 NF_2S, NF_4S, NF_2S, NF_4S, NF_2S, NF_4S, NF_2S, NF_4S,
2498 NF_UNDEF, NF_2D, NF_UNDEF, NF_2D, NF_UNDEF, NF_2D, NF_UNDEF, NF_2D,
2499 NF_UNDEF, NF_2D, NF_UNDEF, NF_2D, NF_UNDEF, NF_2D, NF_UNDEF, NF_2D}
2500 };
2501
2502 NEONFormatDecoder nfd(instr, &map_shift_tb);
2503
2504 if (instr->ImmNEONImmh()) { // immh has to be non-zero.
2505 switch (instr->Mask(NEONShiftImmediateMask)) {
2506 case NEON_SQSHLU: mnemonic = "sqshlu"; form = form_shift_2; break;
2507 case NEON_SQSHL_imm: mnemonic = "sqshl"; form = form_shift_2; break;
2508 case NEON_UQSHL_imm: mnemonic = "uqshl"; form = form_shift_2; break;
2509 case NEON_SHL: mnemonic = "shl"; form = form_shift_2; break;
2510 case NEON_SLI: mnemonic = "sli"; form = form_shift_2; break;
2511 case NEON_SCVTF_imm: mnemonic = "scvtf"; break;
2512 case NEON_UCVTF_imm: mnemonic = "ucvtf"; break;
2513 case NEON_FCVTZU_imm: mnemonic = "fcvtzu"; break;
2514 case NEON_FCVTZS_imm: mnemonic = "fcvtzs"; break;
2515 case NEON_SRI: mnemonic = "sri"; break;
2516 case NEON_SSHR: mnemonic = "sshr"; break;
2517 case NEON_USHR: mnemonic = "ushr"; break;
2518 case NEON_SRSHR: mnemonic = "srshr"; break;
2519 case NEON_URSHR: mnemonic = "urshr"; break;
2520 case NEON_SSRA: mnemonic = "ssra"; break;
2521 case NEON_USRA: mnemonic = "usra"; break;
2522 case NEON_SRSRA: mnemonic = "srsra"; break;
2523 case NEON_URSRA: mnemonic = "ursra"; break;
2524 case NEON_SHRN:
2525 mnemonic = instr->Mask(NEON_Q) ? "shrn2" : "shrn";
2526 nfd.SetFormatMap(1, &map_shift_ta);
2527 break;
2528 case NEON_RSHRN:
2529 mnemonic = instr->Mask(NEON_Q) ? "rshrn2" : "rshrn";
2530 nfd.SetFormatMap(1, &map_shift_ta);
2531 break;
2532 case NEON_UQSHRN:
2533 mnemonic = instr->Mask(NEON_Q) ? "uqshrn2" : "uqshrn";
2534 nfd.SetFormatMap(1, &map_shift_ta);
2535 break;
2536 case NEON_UQRSHRN:
2537 mnemonic = instr->Mask(NEON_Q) ? "uqrshrn2" : "uqrshrn";
2538 nfd.SetFormatMap(1, &map_shift_ta);
2539 break;
2540 case NEON_SQSHRN:
2541 mnemonic = instr->Mask(NEON_Q) ? "sqshrn2" : "sqshrn";
2542 nfd.SetFormatMap(1, &map_shift_ta);
2543 break;
2544 case NEON_SQRSHRN:
2545 mnemonic = instr->Mask(NEON_Q) ? "sqrshrn2" : "sqrshrn";
2546 nfd.SetFormatMap(1, &map_shift_ta);
2547 break;
2548 case NEON_SQSHRUN:
2549 mnemonic = instr->Mask(NEON_Q) ? "sqshrun2" : "sqshrun";
2550 nfd.SetFormatMap(1, &map_shift_ta);
2551 break;
2552 case NEON_SQRSHRUN:
2553 mnemonic = instr->Mask(NEON_Q) ? "sqrshrun2" : "sqrshrun";
2554 nfd.SetFormatMap(1, &map_shift_ta);
2555 break;
2556 case NEON_SSHLL:
2557 nfd.SetFormatMap(0, &map_shift_ta);
2558 if (instr->ImmNEONImmb() == 0 &&
2559 CountSetBits(instr->ImmNEONImmh(), 32) == 1) { // sxtl variant.
2560 form = form_xtl;
2561 mnemonic = instr->Mask(NEON_Q) ? "sxtl2" : "sxtl";
2562 } else { // sshll variant.
2563 form = form_shift_2;
2564 mnemonic = instr->Mask(NEON_Q) ? "sshll2" : "sshll";
2565 }
2566 break;
2567 case NEON_USHLL:
2568 nfd.SetFormatMap(0, &map_shift_ta);
2569 if (instr->ImmNEONImmb() == 0 &&
2570 CountSetBits(instr->ImmNEONImmh(), 32) == 1) { // uxtl variant.
2571 form = form_xtl;
2572 mnemonic = instr->Mask(NEON_Q) ? "uxtl2" : "uxtl";
2573 } else { // ushll variant.
2574 form = form_shift_2;
2575 mnemonic = instr->Mask(NEON_Q) ? "ushll2" : "ushll";
2576 }
2577 break;
2578 default: form = "(NEONShiftImmediate)";
2579 }
2580 } else {
2581 form = "(NEONShiftImmediate)";
2582 }
2583 Format(instr, mnemonic, nfd.Substitute(form));
2584 }
2585
2586
VisitNEONTable(const Instruction * instr)2587 void Disassembler::VisitNEONTable(const Instruction* instr) {
2588 const char *mnemonic = "unimplemented";
2589 const char *form = "(NEONTable)";
2590 const char form_1v[] = "'Vd.%%s, {'Vn.16b}, 'Vm.%%s";
2591 const char form_2v[] = "'Vd.%%s, {'Vn.16b, v%d.16b}, 'Vm.%%s";
2592 const char form_3v[] = "'Vd.%%s, {'Vn.16b, v%d.16b, v%d.16b}, 'Vm.%%s";
2593 const char form_4v[] =
2594 "'Vd.%%s, {'Vn.16b, v%d.16b, v%d.16b, v%d.16b}, 'Vm.%%s";
2595 static const NEONFormatMap map_b = { {30}, {NF_8B, NF_16B} };
2596 NEONFormatDecoder nfd(instr, &map_b);
2597
2598 switch (instr->Mask(NEONTableMask)) {
2599 case NEON_TBL_1v: mnemonic = "tbl"; form = form_1v; break;
2600 case NEON_TBL_2v: mnemonic = "tbl"; form = form_2v; break;
2601 case NEON_TBL_3v: mnemonic = "tbl"; form = form_3v; break;
2602 case NEON_TBL_4v: mnemonic = "tbl"; form = form_4v; break;
2603 case NEON_TBX_1v: mnemonic = "tbx"; form = form_1v; break;
2604 case NEON_TBX_2v: mnemonic = "tbx"; form = form_2v; break;
2605 case NEON_TBX_3v: mnemonic = "tbx"; form = form_3v; break;
2606 case NEON_TBX_4v: mnemonic = "tbx"; form = form_4v; break;
2607 default: break;
2608 }
2609
2610 char re_form[sizeof(form_4v) + 6];
2611 int reg_num = instr->Rn();
2612 snprintf(re_form, sizeof(re_form), form,
2613 (reg_num + 1) % kNumberOfVRegisters,
2614 (reg_num + 2) % kNumberOfVRegisters,
2615 (reg_num + 3) % kNumberOfVRegisters);
2616
2617 Format(instr, mnemonic, nfd.Substitute(re_form));
2618 }
2619
2620
VisitNEONPerm(const Instruction * instr)2621 void Disassembler::VisitNEONPerm(const Instruction* instr) {
2622 const char *mnemonic = "unimplemented";
2623 const char *form = "'Vd.%s, 'Vn.%s, 'Vm.%s";
2624 NEONFormatDecoder nfd(instr);
2625
2626 switch (instr->Mask(NEONPermMask)) {
2627 case NEON_TRN1: mnemonic = "trn1"; break;
2628 case NEON_TRN2: mnemonic = "trn2"; break;
2629 case NEON_UZP1: mnemonic = "uzp1"; break;
2630 case NEON_UZP2: mnemonic = "uzp2"; break;
2631 case NEON_ZIP1: mnemonic = "zip1"; break;
2632 case NEON_ZIP2: mnemonic = "zip2"; break;
2633 default: form = "(NEONPerm)";
2634 }
2635 Format(instr, mnemonic, nfd.Substitute(form));
2636 }
2637
2638
VisitUnimplemented(const Instruction * instr)2639 void Disassembler::VisitUnimplemented(const Instruction* instr) {
2640 Format(instr, "unimplemented", "(Unimplemented)");
2641 }
2642
2643
VisitUnallocated(const Instruction * instr)2644 void Disassembler::VisitUnallocated(const Instruction* instr) {
2645 Format(instr, "unallocated", "(Unallocated)");
2646 }
2647
2648
ProcessOutput(const Instruction *)2649 void Disassembler::ProcessOutput(const Instruction* /*instr*/) {
2650 // The base disasm does nothing more than disassembling into a buffer.
2651 }
2652
2653
AppendRegisterNameToOutput(const Instruction * instr,const CPURegister & reg)2654 void Disassembler::AppendRegisterNameToOutput(const Instruction* instr,
2655 const CPURegister& reg) {
2656 USE(instr);
2657 VIXL_ASSERT(reg.IsValid());
2658 char reg_char;
2659
2660 if (reg.IsRegister()) {
2661 reg_char = reg.Is64Bits() ? 'x' : 'w';
2662 } else {
2663 VIXL_ASSERT(reg.IsVRegister());
2664 switch (reg.SizeInBits()) {
2665 case kBRegSize: reg_char = 'b'; break;
2666 case kHRegSize: reg_char = 'h'; break;
2667 case kSRegSize: reg_char = 's'; break;
2668 case kDRegSize: reg_char = 'd'; break;
2669 default:
2670 VIXL_ASSERT(reg.Is128Bits());
2671 reg_char = 'q';
2672 }
2673 }
2674
2675 if (reg.IsVRegister() || !(reg.Aliases(sp) || reg.Aliases(xzr))) {
2676 // A core or scalar/vector register: [wx]0 - 30, [bhsdq]0 - 31.
2677 AppendToOutput("%c%d", reg_char, reg.code());
2678 } else if (reg.Aliases(sp)) {
2679 // Disassemble w31/x31 as stack pointer wsp/sp.
2680 AppendToOutput("%s", reg.Is64Bits() ? "sp" : "wsp");
2681 } else {
2682 // Disassemble w31/x31 as zero register wzr/xzr.
2683 AppendToOutput("%czr", reg_char);
2684 }
2685 }
2686
2687
AppendPCRelativeOffsetToOutput(const Instruction * instr,int64_t offset)2688 void Disassembler::AppendPCRelativeOffsetToOutput(const Instruction* instr,
2689 int64_t offset) {
2690 USE(instr);
2691 uint64_t abs_offset = offset;
2692 char sign = (offset < 0) ? '-' : '+';
2693 if (offset < 0) {
2694 abs_offset = -abs_offset;
2695 }
2696 AppendToOutput("#%c0x%" PRIx64, sign, offset < 0 ? -offset : offset);
2697 }
2698
2699
AppendAddressToOutput(const Instruction * instr,const void * addr)2700 void Disassembler::AppendAddressToOutput(const Instruction* instr,
2701 const void* addr) {
2702 USE(instr);
2703 AppendToOutput("(addr 0x%" PRIxPTR ")", reinterpret_cast<uintptr_t>(addr));
2704 }
2705
2706
AppendCodeAddressToOutput(const Instruction * instr,const void * addr)2707 void Disassembler::AppendCodeAddressToOutput(const Instruction* instr,
2708 const void* addr) {
2709 AppendAddressToOutput(instr, addr);
2710 }
2711
2712
AppendDataAddressToOutput(const Instruction * instr,const void * addr)2713 void Disassembler::AppendDataAddressToOutput(const Instruction* instr,
2714 const void* addr) {
2715 AppendAddressToOutput(instr, addr);
2716 }
2717
2718
AppendCodeRelativeAddressToOutput(const Instruction * instr,const void * addr)2719 void Disassembler::AppendCodeRelativeAddressToOutput(const Instruction* instr,
2720 const void* addr) {
2721 USE(instr);
2722 int64_t rel_addr = CodeRelativeAddress(addr);
2723 if (rel_addr >= 0) {
2724 AppendToOutput("(addr 0x%" PRIx64 ")", rel_addr);
2725 } else {
2726 AppendToOutput("(addr -0x%" PRIx64 ")", -rel_addr);
2727 }
2728 }
2729
2730
AppendCodeRelativeCodeAddressToOutput(const Instruction * instr,const void * addr)2731 void Disassembler::AppendCodeRelativeCodeAddressToOutput(
2732 const Instruction* instr, const void* addr) {
2733 AppendCodeRelativeAddressToOutput(instr, addr);
2734 }
2735
2736
AppendCodeRelativeDataAddressToOutput(const Instruction * instr,const void * addr)2737 void Disassembler::AppendCodeRelativeDataAddressToOutput(
2738 const Instruction* instr, const void* addr) {
2739 AppendCodeRelativeAddressToOutput(instr, addr);
2740 }
2741
2742
MapCodeAddress(int64_t base_address,const Instruction * instr_address)2743 void Disassembler::MapCodeAddress(int64_t base_address,
2744 const Instruction* instr_address) {
2745 set_code_address_offset(
2746 base_address - reinterpret_cast<intptr_t>(instr_address));
2747 }
CodeRelativeAddress(const void * addr)2748 int64_t Disassembler::CodeRelativeAddress(const void* addr) {
2749 return reinterpret_cast<intptr_t>(addr) + code_address_offset();
2750 }
2751
2752
Format(const Instruction * instr,const char * mnemonic,const char * format)2753 void Disassembler::Format(const Instruction* instr, const char* mnemonic,
2754 const char* format) {
2755 VIXL_ASSERT(mnemonic != NULL);
2756 ResetOutput();
2757 Substitute(instr, mnemonic);
2758 if (format != NULL) {
2759 VIXL_ASSERT(buffer_pos_ < buffer_size_);
2760 buffer_[buffer_pos_++] = ' ';
2761 Substitute(instr, format);
2762 }
2763 VIXL_ASSERT(buffer_pos_ < buffer_size_);
2764 buffer_[buffer_pos_] = 0;
2765 ProcessOutput(instr);
2766 }
2767
2768
Substitute(const Instruction * instr,const char * string)2769 void Disassembler::Substitute(const Instruction* instr, const char* string) {
2770 char chr = *string++;
2771 while (chr != '\0') {
2772 if (chr == '\'') {
2773 string += SubstituteField(instr, string);
2774 } else {
2775 VIXL_ASSERT(buffer_pos_ < buffer_size_);
2776 buffer_[buffer_pos_++] = chr;
2777 }
2778 chr = *string++;
2779 }
2780 }
2781
2782
SubstituteField(const Instruction * instr,const char * format)2783 int Disassembler::SubstituteField(const Instruction* instr,
2784 const char* format) {
2785 switch (format[0]) {
2786 // NB. The remaining substitution prefix characters are: GJKUZ.
2787 case 'R': // Register. X or W, selected by sf bit.
2788 case 'F': // FP register. S or D, selected by type field.
2789 case 'V': // Vector register, V, vector format.
2790 case 'W':
2791 case 'X':
2792 case 'B':
2793 case 'H':
2794 case 'S':
2795 case 'D':
2796 case 'Q': return SubstituteRegisterField(instr, format);
2797 case 'I': return SubstituteImmediateField(instr, format);
2798 case 'L': return SubstituteLiteralField(instr, format);
2799 case 'N': return SubstituteShiftField(instr, format);
2800 case 'P': return SubstitutePrefetchField(instr, format);
2801 case 'C': return SubstituteConditionField(instr, format);
2802 case 'E': return SubstituteExtendField(instr, format);
2803 case 'A': return SubstitutePCRelAddressField(instr, format);
2804 case 'T': return SubstituteBranchTargetField(instr, format);
2805 case 'O': return SubstituteLSRegOffsetField(instr, format);
2806 case 'M': return SubstituteBarrierField(instr, format);
2807 case 'K': return SubstituteCrField(instr, format);
2808 case 'G': return SubstituteSysOpField(instr, format);
2809 default: {
2810 VIXL_UNREACHABLE();
2811 return 1;
2812 }
2813 }
2814 }
2815
2816
SubstituteRegisterField(const Instruction * instr,const char * format)2817 int Disassembler::SubstituteRegisterField(const Instruction* instr,
2818 const char* format) {
2819 char reg_prefix = format[0];
2820 unsigned reg_num = 0;
2821 unsigned field_len = 2;
2822
2823 switch (format[1]) {
2824 case 'd':
2825 reg_num = instr->Rd();
2826 if (format[2] == 'q') {
2827 reg_prefix = instr->NEONQ() ? 'X' : 'W';
2828 field_len = 3;
2829 }
2830 break;
2831 case 'n': reg_num = instr->Rn(); break;
2832 case 'm':
2833 reg_num = instr->Rm();
2834 switch (format[2]) {
2835 // Handle registers tagged with b (bytes), z (instruction), or
2836 // r (registers), used for address updates in
2837 // NEON load/store instructions.
2838 case 'r':
2839 case 'b':
2840 case 'z': {
2841 field_len = 3;
2842 char* eimm;
2843 int imm = static_cast<int>(strtol(&format[3], &eimm, 10));
2844 field_len += eimm - &format[3];
2845 if (reg_num == 31) {
2846 switch (format[2]) {
2847 case 'z':
2848 imm *= (1 << instr->NEONLSSize());
2849 break;
2850 case 'r':
2851 imm *= (instr->NEONQ() == 0) ? kDRegSizeInBytes
2852 : kQRegSizeInBytes;
2853 break;
2854 case 'b':
2855 break;
2856 }
2857 AppendToOutput("#%d", imm);
2858 return field_len;
2859 }
2860 break;
2861 }
2862 }
2863 break;
2864 case 'e':
2865 // This is register Rm, but using a 4-bit specifier. Used in NEON
2866 // by-element instructions.
2867 reg_num = (instr->Rm() & 0xf);
2868 break;
2869 case 'a': reg_num = instr->Ra(); break;
2870 case 's': reg_num = instr->Rs(); break;
2871 case 't':
2872 reg_num = instr->Rt();
2873 if (format[0] == 'V') {
2874 if ((format[2] >= '2') && (format[2] <= '4')) {
2875 // Handle consecutive vector register specifiers Vt2, Vt3 and Vt4.
2876 reg_num = (reg_num + format[2] - '1') % 32;
2877 field_len = 3;
2878 }
2879 } else {
2880 if (format[2] == '2') {
2881 // Handle register specifier Rt2.
2882 reg_num = instr->Rt2();
2883 field_len = 3;
2884 }
2885 }
2886 break;
2887 default: VIXL_UNREACHABLE();
2888 }
2889
2890 // Increase field length for registers tagged as stack.
2891 if (format[2] == 's') {
2892 field_len = 3;
2893 }
2894
2895 CPURegister::RegisterType reg_type = CPURegister::kRegister;
2896 unsigned reg_size = kXRegSize;
2897
2898 if (reg_prefix == 'R') {
2899 reg_prefix = instr->SixtyFourBits() ? 'X' : 'W';
2900 } else if (reg_prefix == 'F') {
2901 reg_prefix = ((instr->FPType() & 1) == 0) ? 'S' : 'D';
2902 }
2903
2904 switch (reg_prefix) {
2905 case 'W':
2906 reg_type = CPURegister::kRegister; reg_size = kWRegSize; break;
2907 case 'X':
2908 reg_type = CPURegister::kRegister; reg_size = kXRegSize; break;
2909 case 'B':
2910 reg_type = CPURegister::kVRegister; reg_size = kBRegSize; break;
2911 case 'H':
2912 reg_type = CPURegister::kVRegister; reg_size = kHRegSize; break;
2913 case 'S':
2914 reg_type = CPURegister::kVRegister; reg_size = kSRegSize; break;
2915 case 'D':
2916 reg_type = CPURegister::kVRegister; reg_size = kDRegSize; break;
2917 case 'Q':
2918 reg_type = CPURegister::kVRegister; reg_size = kQRegSize; break;
2919 case 'V':
2920 AppendToOutput("v%d", reg_num);
2921 return field_len;
2922 default:
2923 VIXL_UNREACHABLE();
2924 }
2925
2926 if ((reg_type == CPURegister::kRegister) &&
2927 (reg_num == kZeroRegCode) && (format[2] == 's')) {
2928 reg_num = kSPRegInternalCode;
2929 }
2930
2931 AppendRegisterNameToOutput(instr, CPURegister(reg_num, reg_size, reg_type));
2932
2933 return field_len;
2934 }
2935
2936
SubstituteImmediateField(const Instruction * instr,const char * format)2937 int Disassembler::SubstituteImmediateField(const Instruction* instr,
2938 const char* format) {
2939 VIXL_ASSERT(format[0] == 'I');
2940
2941 switch (format[1]) {
2942 case 'M': { // IMoveImm, IMoveNeg or IMoveLSL.
2943 if (format[5] == 'L') {
2944 AppendToOutput("#0x%" PRIx32, instr->ImmMoveWide());
2945 if (instr->ShiftMoveWide() > 0) {
2946 AppendToOutput(", lsl #%" PRId32, 16 * instr->ShiftMoveWide());
2947 }
2948 } else {
2949 VIXL_ASSERT((format[5] == 'I') || (format[5] == 'N'));
2950 uint64_t imm = static_cast<uint64_t>(instr->ImmMoveWide()) <<
2951 (16 * instr->ShiftMoveWide());
2952 if (format[5] == 'N')
2953 imm = ~imm;
2954 if (!instr->SixtyFourBits())
2955 imm &= UINT64_C(0xffffffff);
2956 AppendToOutput("#0x%" PRIx64, imm);
2957 }
2958 return 8;
2959 }
2960 case 'L': {
2961 switch (format[2]) {
2962 case 'L': { // ILLiteral - Immediate Load Literal.
2963 AppendToOutput("pc%+" PRId32,
2964 instr->ImmLLiteral() << kLiteralEntrySizeLog2);
2965 return 9;
2966 }
2967 case 'S': { // ILS - Immediate Load/Store.
2968 if (instr->ImmLS() != 0) {
2969 AppendToOutput(", #%" PRId32, instr->ImmLS());
2970 }
2971 return 3;
2972 }
2973 case 'P': { // ILPx - Immediate Load/Store Pair, x = access size.
2974 if (instr->ImmLSPair() != 0) {
2975 // format[3] is the scale value. Convert to a number.
2976 int scale = 1 << (format[3] - '0');
2977 AppendToOutput(", #%" PRId32, instr->ImmLSPair() * scale);
2978 }
2979 return 4;
2980 }
2981 case 'U': { // ILU - Immediate Load/Store Unsigned.
2982 if (instr->ImmLSUnsigned() != 0) {
2983 int shift = instr->SizeLS();
2984 AppendToOutput(", #%" PRId32, instr->ImmLSUnsigned() << shift);
2985 }
2986 return 3;
2987 }
2988 }
2989 }
2990 case 'C': { // ICondB - Immediate Conditional Branch.
2991 int64_t offset = instr->ImmCondBranch() << 2;
2992 AppendPCRelativeOffsetToOutput(instr, offset);
2993 return 6;
2994 }
2995 case 'A': { // IAddSub.
2996 VIXL_ASSERT(instr->ShiftAddSub() <= 1);
2997 int64_t imm = instr->ImmAddSub() << (12 * instr->ShiftAddSub());
2998 AppendToOutput("#0x%" PRIx64 " (%" PRId64 ")", imm, imm);
2999 return 7;
3000 }
3001 case 'F': { // IFPSingle, IFPDouble or IFPFBits.
3002 if (format[3] == 'F') { // IFPFbits.
3003 AppendToOutput("#%" PRId32, 64 - instr->FPScale());
3004 return 8;
3005 } else {
3006 AppendToOutput("#0x%" PRIx32 " (%.4f)", instr->ImmFP(),
3007 format[3] == 'S' ? instr->ImmFP32() : instr->ImmFP64());
3008 return 9;
3009 }
3010 }
3011 case 'T': { // ITri - Immediate Triangular Encoded.
3012 AppendToOutput("#0x%" PRIx64, instr->ImmLogical());
3013 return 4;
3014 }
3015 case 'N': { // INzcv.
3016 int nzcv = (instr->Nzcv() << Flags_offset);
3017 AppendToOutput("#%c%c%c%c", ((nzcv & NFlag) == 0) ? 'n' : 'N',
3018 ((nzcv & ZFlag) == 0) ? 'z' : 'Z',
3019 ((nzcv & CFlag) == 0) ? 'c' : 'C',
3020 ((nzcv & VFlag) == 0) ? 'v' : 'V');
3021 return 5;
3022 }
3023 case 'P': { // IP - Conditional compare.
3024 AppendToOutput("#%" PRId32, instr->ImmCondCmp());
3025 return 2;
3026 }
3027 case 'B': { // Bitfields.
3028 return SubstituteBitfieldImmediateField(instr, format);
3029 }
3030 case 'E': { // IExtract.
3031 AppendToOutput("#%" PRId32, instr->ImmS());
3032 return 8;
3033 }
3034 case 'S': { // IS - Test and branch bit.
3035 AppendToOutput("#%" PRId32, (instr->ImmTestBranchBit5() << 5) |
3036 instr->ImmTestBranchBit40());
3037 return 2;
3038 }
3039 case 's': { // Is - Shift (immediate).
3040 switch (format[2]) {
3041 case '1': { // Is1 - SSHR.
3042 int shift = 16 << HighestSetBitPosition(instr->ImmNEONImmh());
3043 shift -= instr->ImmNEONImmhImmb();
3044 AppendToOutput("#%d", shift);
3045 return 3;
3046 }
3047 case '2': { // Is2 - SLI.
3048 int shift = instr->ImmNEONImmhImmb();
3049 shift -= 8 << HighestSetBitPosition(instr->ImmNEONImmh());
3050 AppendToOutput("#%d", shift);
3051 return 3;
3052 }
3053 default: {
3054 VIXL_UNIMPLEMENTED();
3055 return 0;
3056 }
3057 }
3058 }
3059 case 'D': { // IDebug - HLT and BRK instructions.
3060 AppendToOutput("#0x%" PRIx32, instr->ImmException());
3061 return 6;
3062 }
3063 case 'V': { // Immediate Vector.
3064 switch (format[2]) {
3065 case 'E': { // IVExtract.
3066 AppendToOutput("#%" PRId32, instr->ImmNEONExt());
3067 return 9;
3068 }
3069 case 'B': { // IVByElemIndex.
3070 int vm_index = (instr->NEONH() << 1) | instr->NEONL();
3071 if (instr->NEONSize() == 1) {
3072 vm_index = (vm_index << 1) | instr->NEONM();
3073 }
3074 AppendToOutput("%d", vm_index);
3075 return strlen("IVByElemIndex");
3076 }
3077 case 'I': { // INS element.
3078 if (strncmp(format, "IVInsIndex", strlen("IVInsIndex")) == 0) {
3079 int rd_index, rn_index;
3080 int imm5 = instr->ImmNEON5();
3081 int imm4 = instr->ImmNEON4();
3082 int tz = CountTrailingZeros(imm5, 32);
3083 rd_index = imm5 >> (tz + 1);
3084 rn_index = imm4 >> tz;
3085 if (strncmp(format, "IVInsIndex1", strlen("IVInsIndex1")) == 0) {
3086 AppendToOutput("%d", rd_index);
3087 return strlen("IVInsIndex1");
3088 } else if (strncmp(format, "IVInsIndex2",
3089 strlen("IVInsIndex2")) == 0) {
3090 AppendToOutput("%d", rn_index);
3091 return strlen("IVInsIndex2");
3092 } else {
3093 VIXL_UNIMPLEMENTED();
3094 return 0;
3095 }
3096 }
3097 VIXL_FALLTHROUGH();
3098 }
3099 case 'L': { // IVLSLane[0123] - suffix indicates access size shift.
3100 AppendToOutput("%d", instr->NEONLSIndex(format[8] - '0'));
3101 return 9;
3102 }
3103 case 'M': { // Modified Immediate cases.
3104 if (strncmp(format,
3105 "IVMIImmFPSingle",
3106 strlen("IVMIImmFPSingle")) == 0) {
3107 AppendToOutput("#0x%" PRIx32 " (%.4f)", instr->ImmNEONabcdefgh(),
3108 instr->ImmNEONFP32());
3109 return strlen("IVMIImmFPSingle");
3110 } else if (strncmp(format,
3111 "IVMIImmFPDouble",
3112 strlen("IVMIImmFPDouble")) == 0) {
3113 AppendToOutput("#0x%" PRIx32 " (%.4f)", instr->ImmNEONabcdefgh(),
3114 instr->ImmNEONFP64());
3115 return strlen("IVMIImmFPDouble");
3116 } else if (strncmp(format, "IVMIImm8", strlen("IVMIImm8")) == 0) {
3117 uint64_t imm8 = instr->ImmNEONabcdefgh();
3118 AppendToOutput("#0x%" PRIx64, imm8);
3119 return strlen("IVMIImm8");
3120 } else if (strncmp(format, "IVMIImm", strlen("IVMIImm")) == 0) {
3121 uint64_t imm8 = instr->ImmNEONabcdefgh();
3122 uint64_t imm = 0;
3123 for (int i = 0; i < 8; ++i) {
3124 if (imm8 & (1 << i)) {
3125 imm |= (UINT64_C(0xff) << (8 * i));
3126 }
3127 }
3128 AppendToOutput("#0x%" PRIx64, imm);
3129 return strlen("IVMIImm");
3130 } else if (strncmp(format, "IVMIShiftAmt1",
3131 strlen("IVMIShiftAmt1")) == 0) {
3132 int cmode = instr->NEONCmode();
3133 int shift_amount = 8 * ((cmode >> 1) & 3);
3134 AppendToOutput("#%d", shift_amount);
3135 return strlen("IVMIShiftAmt1");
3136 } else if (strncmp(format, "IVMIShiftAmt2",
3137 strlen("IVMIShiftAmt2")) == 0) {
3138 int cmode = instr->NEONCmode();
3139 int shift_amount = 8 << (cmode & 1);
3140 AppendToOutput("#%d", shift_amount);
3141 return strlen("IVMIShiftAmt2");
3142 } else {
3143 VIXL_UNIMPLEMENTED();
3144 return 0;
3145 }
3146 }
3147 default: {
3148 VIXL_UNIMPLEMENTED();
3149 return 0;
3150 }
3151 }
3152 }
3153 case 'X': { // IX - CLREX instruction.
3154 AppendToOutput("#0x%" PRIx32, instr->CRm());
3155 return 2;
3156 }
3157 default: {
3158 VIXL_UNIMPLEMENTED();
3159 return 0;
3160 }
3161 }
3162 }
3163
3164
SubstituteBitfieldImmediateField(const Instruction * instr,const char * format)3165 int Disassembler::SubstituteBitfieldImmediateField(const Instruction* instr,
3166 const char* format) {
3167 VIXL_ASSERT((format[0] == 'I') && (format[1] == 'B'));
3168 unsigned r = instr->ImmR();
3169 unsigned s = instr->ImmS();
3170
3171 switch (format[2]) {
3172 case 'r': { // IBr.
3173 AppendToOutput("#%d", r);
3174 return 3;
3175 }
3176 case 's': { // IBs+1 or IBs-r+1.
3177 if (format[3] == '+') {
3178 AppendToOutput("#%d", s + 1);
3179 return 5;
3180 } else {
3181 VIXL_ASSERT(format[3] == '-');
3182 AppendToOutput("#%d", s - r + 1);
3183 return 7;
3184 }
3185 }
3186 case 'Z': { // IBZ-r.
3187 VIXL_ASSERT((format[3] == '-') && (format[4] == 'r'));
3188 unsigned reg_size = (instr->SixtyFourBits() == 1) ? kXRegSize : kWRegSize;
3189 AppendToOutput("#%d", reg_size - r);
3190 return 5;
3191 }
3192 default: {
3193 VIXL_UNREACHABLE();
3194 return 0;
3195 }
3196 }
3197 }
3198
3199
SubstituteLiteralField(const Instruction * instr,const char * format)3200 int Disassembler::SubstituteLiteralField(const Instruction* instr,
3201 const char* format) {
3202 VIXL_ASSERT(strncmp(format, "LValue", 6) == 0);
3203 USE(format);
3204
3205 const void * address = instr->LiteralAddress<const void *>();
3206 switch (instr->Mask(LoadLiteralMask)) {
3207 case LDR_w_lit:
3208 case LDR_x_lit:
3209 case LDRSW_x_lit:
3210 case LDR_s_lit:
3211 case LDR_d_lit:
3212 case LDR_q_lit:
3213 AppendCodeRelativeDataAddressToOutput(instr, address);
3214 break;
3215 case PRFM_lit: {
3216 // Use the prefetch hint to decide how to print the address.
3217 switch (instr->PrefetchHint()) {
3218 case 0x0: // PLD: prefetch for load.
3219 case 0x2: // PST: prepare for store.
3220 AppendCodeRelativeDataAddressToOutput(instr, address);
3221 break;
3222 case 0x1: // PLI: preload instructions.
3223 AppendCodeRelativeCodeAddressToOutput(instr, address);
3224 break;
3225 case 0x3: // Unallocated hint.
3226 AppendCodeRelativeAddressToOutput(instr, address);
3227 break;
3228 }
3229 break;
3230 }
3231 default:
3232 VIXL_UNREACHABLE();
3233 }
3234
3235 return 6;
3236 }
3237
3238
SubstituteShiftField(const Instruction * instr,const char * format)3239 int Disassembler::SubstituteShiftField(const Instruction* instr,
3240 const char* format) {
3241 VIXL_ASSERT(format[0] == 'N');
3242 VIXL_ASSERT(instr->ShiftDP() <= 0x3);
3243
3244 switch (format[1]) {
3245 case 'D': { // HDP.
3246 VIXL_ASSERT(instr->ShiftDP() != ROR);
3247 VIXL_FALLTHROUGH();
3248 }
3249 case 'L': { // HLo.
3250 if (instr->ImmDPShift() != 0) {
3251 const char* shift_type[] = {"lsl", "lsr", "asr", "ror"};
3252 AppendToOutput(", %s #%" PRId32, shift_type[instr->ShiftDP()],
3253 instr->ImmDPShift());
3254 }
3255 return 3;
3256 }
3257 default:
3258 VIXL_UNIMPLEMENTED();
3259 return 0;
3260 }
3261 }
3262
3263
SubstituteConditionField(const Instruction * instr,const char * format)3264 int Disassembler::SubstituteConditionField(const Instruction* instr,
3265 const char* format) {
3266 VIXL_ASSERT(format[0] == 'C');
3267 const char* condition_code[] = { "eq", "ne", "hs", "lo",
3268 "mi", "pl", "vs", "vc",
3269 "hi", "ls", "ge", "lt",
3270 "gt", "le", "al", "nv" };
3271 int cond;
3272 switch (format[1]) {
3273 case 'B': cond = instr->ConditionBranch(); break;
3274 case 'I': {
3275 cond = InvertCondition(static_cast<Condition>(instr->Condition()));
3276 break;
3277 }
3278 default: cond = instr->Condition();
3279 }
3280 AppendToOutput("%s", condition_code[cond]);
3281 return 4;
3282 }
3283
3284
SubstitutePCRelAddressField(const Instruction * instr,const char * format)3285 int Disassembler::SubstitutePCRelAddressField(const Instruction* instr,
3286 const char* format) {
3287 VIXL_ASSERT((strcmp(format, "AddrPCRelByte") == 0) || // Used by `adr`.
3288 (strcmp(format, "AddrPCRelPage") == 0)); // Used by `adrp`.
3289
3290 int64_t offset = instr->ImmPCRel();
3291
3292 // Compute the target address based on the effective address (after applying
3293 // code_address_offset). This is required for correct behaviour of adrp.
3294 const Instruction* base = instr + code_address_offset();
3295 if (format[9] == 'P') {
3296 offset *= kPageSize;
3297 base = AlignDown(base, kPageSize);
3298 }
3299 // Strip code_address_offset before printing, so we can use the
3300 // semantically-correct AppendCodeRelativeAddressToOutput.
3301 const void* target =
3302 reinterpret_cast<const void*>(base + offset - code_address_offset());
3303
3304 AppendPCRelativeOffsetToOutput(instr, offset);
3305 AppendToOutput(" ");
3306 AppendCodeRelativeAddressToOutput(instr, target);
3307 return 13;
3308 }
3309
3310
SubstituteBranchTargetField(const Instruction * instr,const char * format)3311 int Disassembler::SubstituteBranchTargetField(const Instruction* instr,
3312 const char* format) {
3313 VIXL_ASSERT(strncmp(format, "TImm", 4) == 0);
3314
3315 int64_t offset = 0;
3316 switch (format[5]) {
3317 // BImmUncn - unconditional branch immediate.
3318 case 'n': offset = instr->ImmUncondBranch(); break;
3319 // BImmCond - conditional branch immediate.
3320 case 'o': offset = instr->ImmCondBranch(); break;
3321 // BImmCmpa - compare and branch immediate.
3322 case 'm': offset = instr->ImmCmpBranch(); break;
3323 // BImmTest - test and branch immediate.
3324 case 'e': offset = instr->ImmTestBranch(); break;
3325 default: VIXL_UNIMPLEMENTED();
3326 }
3327 offset <<= kInstructionSizeLog2;
3328 const void* target_address = reinterpret_cast<const void*>(instr + offset);
3329 VIXL_STATIC_ASSERT(sizeof(*instr) == 1);
3330
3331 AppendPCRelativeOffsetToOutput(instr, offset);
3332 AppendToOutput(" ");
3333 AppendCodeRelativeCodeAddressToOutput(instr, target_address);
3334
3335 return 8;
3336 }
3337
3338
SubstituteExtendField(const Instruction * instr,const char * format)3339 int Disassembler::SubstituteExtendField(const Instruction* instr,
3340 const char* format) {
3341 VIXL_ASSERT(strncmp(format, "Ext", 3) == 0);
3342 VIXL_ASSERT(instr->ExtendMode() <= 7);
3343 USE(format);
3344
3345 const char* extend_mode[] = { "uxtb", "uxth", "uxtw", "uxtx",
3346 "sxtb", "sxth", "sxtw", "sxtx" };
3347
3348 // If rd or rn is SP, uxtw on 32-bit registers and uxtx on 64-bit
3349 // registers becomes lsl.
3350 if (((instr->Rd() == kZeroRegCode) || (instr->Rn() == kZeroRegCode)) &&
3351 (((instr->ExtendMode() == UXTW) && (instr->SixtyFourBits() == 0)) ||
3352 (instr->ExtendMode() == UXTX))) {
3353 if (instr->ImmExtendShift() > 0) {
3354 AppendToOutput(", lsl #%" PRId32, instr->ImmExtendShift());
3355 }
3356 } else {
3357 AppendToOutput(", %s", extend_mode[instr->ExtendMode()]);
3358 if (instr->ImmExtendShift() > 0) {
3359 AppendToOutput(" #%" PRId32, instr->ImmExtendShift());
3360 }
3361 }
3362 return 3;
3363 }
3364
3365
SubstituteLSRegOffsetField(const Instruction * instr,const char * format)3366 int Disassembler::SubstituteLSRegOffsetField(const Instruction* instr,
3367 const char* format) {
3368 VIXL_ASSERT(strncmp(format, "Offsetreg", 9) == 0);
3369 const char* extend_mode[] = { "undefined", "undefined", "uxtw", "lsl",
3370 "undefined", "undefined", "sxtw", "sxtx" };
3371 USE(format);
3372
3373 unsigned shift = instr->ImmShiftLS();
3374 Extend ext = static_cast<Extend>(instr->ExtendMode());
3375 char reg_type = ((ext == UXTW) || (ext == SXTW)) ? 'w' : 'x';
3376
3377 unsigned rm = instr->Rm();
3378 if (rm == kZeroRegCode) {
3379 AppendToOutput("%czr", reg_type);
3380 } else {
3381 AppendToOutput("%c%d", reg_type, rm);
3382 }
3383
3384 // Extend mode UXTX is an alias for shift mode LSL here.
3385 if (!((ext == UXTX) && (shift == 0))) {
3386 AppendToOutput(", %s", extend_mode[ext]);
3387 if (shift != 0) {
3388 AppendToOutput(" #%d", instr->SizeLS());
3389 }
3390 }
3391 return 9;
3392 }
3393
3394
SubstitutePrefetchField(const Instruction * instr,const char * format)3395 int Disassembler::SubstitutePrefetchField(const Instruction* instr,
3396 const char* format) {
3397 VIXL_ASSERT(format[0] == 'P');
3398 USE(format);
3399
3400 static const char* hints[] = {"ld", "li", "st"};
3401 static const char* stream_options[] = {"keep", "strm"};
3402
3403 unsigned hint = instr->PrefetchHint();
3404 unsigned target = instr->PrefetchTarget() + 1;
3405 unsigned stream = instr->PrefetchStream();
3406
3407 if ((hint >= (sizeof(hints) / sizeof(hints[0]))) || (target > 3)) {
3408 // Unallocated prefetch operations.
3409 int prefetch_mode = instr->ImmPrefetchOperation();
3410 AppendToOutput("#0b%c%c%c%c%c",
3411 (prefetch_mode & (1 << 4)) ? '1' : '0',
3412 (prefetch_mode & (1 << 3)) ? '1' : '0',
3413 (prefetch_mode & (1 << 2)) ? '1' : '0',
3414 (prefetch_mode & (1 << 1)) ? '1' : '0',
3415 (prefetch_mode & (1 << 0)) ? '1' : '0');
3416 } else {
3417 VIXL_ASSERT(stream < (sizeof(stream_options) / sizeof(stream_options[0])));
3418 AppendToOutput("p%sl%d%s", hints[hint], target, stream_options[stream]);
3419 }
3420 return 6;
3421 }
3422
SubstituteBarrierField(const Instruction * instr,const char * format)3423 int Disassembler::SubstituteBarrierField(const Instruction* instr,
3424 const char* format) {
3425 VIXL_ASSERT(format[0] == 'M');
3426 USE(format);
3427
3428 static const char* options[4][4] = {
3429 { "sy (0b0000)", "oshld", "oshst", "osh" },
3430 { "sy (0b0100)", "nshld", "nshst", "nsh" },
3431 { "sy (0b1000)", "ishld", "ishst", "ish" },
3432 { "sy (0b1100)", "ld", "st", "sy" }
3433 };
3434 int domain = instr->ImmBarrierDomain();
3435 int type = instr->ImmBarrierType();
3436
3437 AppendToOutput("%s", options[domain][type]);
3438 return 1;
3439 }
3440
SubstituteSysOpField(const Instruction * instr,const char * format)3441 int Disassembler::SubstituteSysOpField(const Instruction* instr,
3442 const char* format) {
3443 VIXL_ASSERT(format[0] == 'G');
3444 int op = -1;
3445 switch (format[1]) {
3446 case '1': op = instr->SysOp1(); break;
3447 case '2': op = instr->SysOp2(); break;
3448 default:
3449 VIXL_UNREACHABLE();
3450 }
3451 AppendToOutput("#%d", op);
3452 return 2;
3453 }
3454
SubstituteCrField(const Instruction * instr,const char * format)3455 int Disassembler::SubstituteCrField(const Instruction* instr,
3456 const char* format) {
3457 VIXL_ASSERT(format[0] == 'K');
3458 int cr = -1;
3459 switch (format[1]) {
3460 case 'n': cr = instr->CRn(); break;
3461 case 'm': cr = instr->CRm(); break;
3462 default:
3463 VIXL_UNREACHABLE();
3464 }
3465 AppendToOutput("C%d", cr);
3466 return 2;
3467 }
3468
ResetOutput()3469 void Disassembler::ResetOutput() {
3470 buffer_pos_ = 0;
3471 buffer_[buffer_pos_] = 0;
3472 }
3473
3474
AppendToOutput(const char * format,...)3475 void Disassembler::AppendToOutput(const char* format, ...) {
3476 va_list args;
3477 va_start(args, format);
3478 buffer_pos_ += vsnprintf(&buffer_[buffer_pos_], buffer_size_ - buffer_pos_,
3479 format, args);
3480 va_end(args);
3481 }
3482
3483
ProcessOutput(const Instruction * instr)3484 void PrintDisassembler::ProcessOutput(const Instruction* instr) {
3485 fprintf(stream_, "0x%016" PRIx64 " %08" PRIx32 "\t\t%s\n",
3486 reinterpret_cast<uint64_t>(instr),
3487 instr->InstructionBits(),
3488 GetOutput());
3489 }
3490
3491 } // namespace vixl
3492