10720f45efe19daf33c384b0ef12e4bc2d8cfc6f
[openocd.git] / src / target / arm_disassembler.c
1 /***************************************************************************
2 * Copyright (C) 2006 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2009 by David Brownell *
6 * *
7 * This program is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation; either version 2 of the License, or *
10 * (at your option) any later version. *
11 * *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
16 * *
17 * You should have received a copy of the GNU General Public License *
18 * along with this program; if not, write to the *
19 * Free Software Foundation, Inc., *
20 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
21 ***************************************************************************/
22 #ifdef HAVE_CONFIG_H
23 #include "config.h"
24 #endif
25
26 #include "target.h"
27 #include "arm_disassembler.h"
28 #include <helper/log.h>
29
30
31 /*
32 * This disassembler supports two main functions for OpenOCD:
33 *
34 * - Various "disassemble" commands. OpenOCD can serve as a
35 * machine-language debugger, without help from GDB.
36 *
37 * - Single stepping. Not all ARM cores support hardware single
38 * stepping. To work without that support, the debugger must
39 * be able to decode instructions to find out where to put a
40 * "next instruction" breakpoint.
41 *
42 * In addition, interpretation of ETM trace data needs some of the
43 * decoding mechanisms.
44 *
45 * At this writing (September 2009) neither function is complete.
46 *
47 * - ARM decoding
48 * * Old-style syntax (not UAL) is generally used
49 * * VFP instructions are not understood (ARMv5 and later)
50 * except as coprocessor 10/11 operations
51 * * Most ARM instructions through ARMv6 are decoded, but some
52 * of the post-ARMv4 opcodes may not be handled yet
53 * CPS, SDIV, UDIV, LDREX*, STREX*, QASX, ...
54 * * NEON instructions are not understood (ARMv7-A)
55 *
56 * - Thumb/Thumb2 decoding
57 * * UAL syntax should be consistently used
58 * * Any Thumb2 instructions used in Cortex-M3 (ARMv7-M) should
59 * be handled properly. Accordingly, so should the subset
60 * used in Cortex-M0/M1; and "original" 16-bit Thumb from
61 * ARMv4T and ARMv5T.
62 * * Conditional effects of Thumb2 "IT" (if-then) instructions
63 * are not handled: the affected instructions are not shown
64 * with their now-conditional suffixes.
65 * * Some ARMv6 and ARMv7-M Thumb2 instructions may not be
66 * handled (minimally for coprocessor access).
67 * * SIMD instructions, and some other Thumb2 instructions
68 * from ARMv7-A, are not understood.
69 *
70 * - ThumbEE decoding
71 * * As a Thumb2 variant, the Thumb2 comments (above) apply.
72 * * Opcodes changed by ThumbEE mode are not handled; these
73 * instructions wrongly decode as LDM and STM.
74 *
75 * - Jazelle decoding ... no support whatsoever for Jazelle mode
76 * or decoding. ARM encourages use of the more generic ThumbEE
77 * mode, instead of Jazelle mode, in current chips.
78 *
79 * - Single-step/emulation ... spotty support, which is only weakly
80 * tested. Thumb2 is not supported. (Arguably a full simulator
81 * is not needed to support just single stepping. Recognizing
82 * branch vs non-branch instructions suffices, except when the
83 * instruction faults and triggers a synchronous exception which
84 * can be intercepted using other means.)
85 *
86 * ARM DDI 0406B "ARM Architecture Reference Manual, ARM v7-A and
87 * ARM v7-R edition" gives the most complete coverage of the various
88 * generations of ARM instructions. At this writing it is publicly
89 * accessible to anyone willing to create an account at the ARM
90 * web site; see http://www.arm.com/documentation/ for information.
91 *
92 * ARM DDI 0403C "ARMv7-M Architecture Reference Manual" provides
93 * more details relevant to the Thumb2-only processors (such as
94 * the Cortex-M implementations).
95 */
96
97 /* textual represenation of the condition field */
98 /* ALways (default) is ommitted (empty string) */
99 static const char *arm_condition_strings[] =
100 {
101 "EQ", "NE", "CS", "CC", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE", "", "NV"
102 };
103
104 /* make up for C's missing ROR */
105 static uint32_t ror(uint32_t value, int places)
106 {
107 return (value >> places) | (value << (32 - places));
108 }
109
110 static int evaluate_unknown(uint32_t opcode,
111 uint32_t address, struct arm_instruction *instruction)
112 {
113 instruction->type = ARM_UNDEFINED_INSTRUCTION;
114 snprintf(instruction->text, 128,
115 "0x%8.8" PRIx32 "\t0x%8.8" PRIx32
116 "\tUNDEFINED INSTRUCTION", address, opcode);
117 return ERROR_OK;
118 }
119
120 static int evaluate_pld(uint32_t opcode,
121 uint32_t address, struct arm_instruction *instruction)
122 {
123 /* PLD */
124 if ((opcode & 0x0d70f000) == 0x0550f000)
125 {
126 instruction->type = ARM_PLD;
127
128 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tPLD ...TODO...", address, opcode);
129
130 return ERROR_OK;
131 }
132 return evaluate_unknown(opcode, address, instruction);
133 }
134
135 static int evaluate_srs(uint32_t opcode,
136 uint32_t address, struct arm_instruction *instruction)
137 {
138 const char *wback = (opcode & (1 << 21)) ? "!" : "";
139 const char *mode = "";
140
141 switch ((opcode >> 23) & 0x3) {
142 case 0:
143 mode = "DA";
144 break;
145 case 1:
146 /* "IA" is default */
147 break;
148 case 2:
149 mode = "DB";
150 break;
151 case 3:
152 mode = "IB";
153 break;
154 }
155
156 switch (opcode & 0x0e500000) {
157 case 0x08400000:
158 snprintf(instruction->text, 128, "0x%8.8" PRIx32
159 "\t0x%8.8" PRIx32
160 "\tSRS%s\tSP%s, #%d",
161 address, opcode,
162 mode, wback,
163 (unsigned)(opcode & 0x1f));
164 break;
165 case 0x08100000:
166 snprintf(instruction->text, 128, "0x%8.8" PRIx32
167 "\t0x%8.8" PRIx32
168 "\tRFE%s\tr%d%s",
169 address, opcode,
170 mode,
171 (unsigned)((opcode >> 16) & 0xf), wback);
172 break;
173 default:
174 return evaluate_unknown(opcode, address, instruction);
175 }
176 return ERROR_OK;
177 }
178
179 static int evaluate_swi(uint32_t opcode,
180 uint32_t address, struct arm_instruction *instruction)
181 {
182 instruction->type = ARM_SWI;
183
184 snprintf(instruction->text, 128,
185 "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tSVC %#6.6" PRIx32,
186 address, opcode, (opcode & 0xffffff));
187
188 return ERROR_OK;
189 }
190
191 static int evaluate_blx_imm(uint32_t opcode,
192 uint32_t address, struct arm_instruction *instruction)
193 {
194 int offset;
195 uint32_t immediate;
196 uint32_t target_address;
197
198 instruction->type = ARM_BLX;
199 immediate = opcode & 0x00ffffff;
200
201 /* sign extend 24-bit immediate */
202 if (immediate & 0x00800000)
203 offset = 0xff000000 | immediate;
204 else
205 offset = immediate;
206
207 /* shift two bits left */
208 offset <<= 2;
209
210 /* odd/event halfword */
211 if (opcode & 0x01000000)
212 offset |= 0x2;
213
214 target_address = address + 8 + offset;
215
216 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tBLX 0x%8.8" PRIx32 "", address, opcode, target_address);
217
218 instruction->info.b_bl_bx_blx.reg_operand = -1;
219 instruction->info.b_bl_bx_blx.target_address = target_address;
220
221 return ERROR_OK;
222 }
223
224 static int evaluate_b_bl(uint32_t opcode,
225 uint32_t address, struct arm_instruction *instruction)
226 {
227 uint8_t L;
228 uint32_t immediate;
229 int offset;
230 uint32_t target_address;
231
232 immediate = opcode & 0x00ffffff;
233 L = (opcode & 0x01000000) >> 24;
234
235 /* sign extend 24-bit immediate */
236 if (immediate & 0x00800000)
237 offset = 0xff000000 | immediate;
238 else
239 offset = immediate;
240
241 /* shift two bits left */
242 offset <<= 2;
243
244 target_address = address + 8 + offset;
245
246 if (L)
247 instruction->type = ARM_BL;
248 else
249 instruction->type = ARM_B;
250
251 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tB%s%s 0x%8.8" PRIx32 , address, opcode,
252 (L) ? "L" : "", COND(opcode), target_address);
253
254 instruction->info.b_bl_bx_blx.reg_operand = -1;
255 instruction->info.b_bl_bx_blx.target_address = target_address;
256
257 return ERROR_OK;
258 }
259
260 /* Coprocessor load/store and double register transfers */
261 /* both normal and extended instruction space (condition field b1111) */
262 static int evaluate_ldc_stc_mcrr_mrrc(uint32_t opcode,
263 uint32_t address, struct arm_instruction *instruction)
264 {
265 uint8_t cp_num = (opcode & 0xf00) >> 8;
266
267 /* MCRR or MRRC */
268 if (((opcode & 0x0ff00000) == 0x0c400000) || ((opcode & 0x0ff00000) == 0x0c400000))
269 {
270 uint8_t cp_opcode, Rd, Rn, CRm;
271 char *mnemonic;
272
273 cp_opcode = (opcode & 0xf0) >> 4;
274 Rd = (opcode & 0xf000) >> 12;
275 Rn = (opcode & 0xf0000) >> 16;
276 CRm = (opcode & 0xf);
277
278 /* MCRR */
279 if ((opcode & 0x0ff00000) == 0x0c400000)
280 {
281 instruction->type = ARM_MCRR;
282 mnemonic = "MCRR";
283 }
284
285 /* MRRC */
286 if ((opcode & 0x0ff00000) == 0x0c500000)
287 {
288 instruction->type = ARM_MRRC;
289 mnemonic = "MRRC";
290 }
291
292 snprintf(instruction->text, 128,
293 "0x%8.8" PRIx32 "\t0x%8.8" PRIx32
294 "\t%s%s%s p%i, %x, r%i, r%i, c%i",
295 address, opcode, mnemonic,
296 ((opcode & 0xf0000000) == 0xf0000000)
297 ? "2" : COND(opcode),
298 COND(opcode), cp_num, cp_opcode, Rd, Rn, CRm);
299 }
300 else /* LDC or STC */
301 {
302 uint8_t CRd, Rn, offset;
303 uint8_t U, N;
304 char *mnemonic;
305 char addressing_mode[32];
306
307 CRd = (opcode & 0xf000) >> 12;
308 Rn = (opcode & 0xf0000) >> 16;
309 offset = (opcode & 0xff) << 2;
310
311 /* load/store */
312 if (opcode & 0x00100000)
313 {
314 instruction->type = ARM_LDC;
315 mnemonic = "LDC";
316 }
317 else
318 {
319 instruction->type = ARM_STC;
320 mnemonic = "STC";
321 }
322
323 U = (opcode & 0x00800000) >> 23;
324 N = (opcode & 0x00400000) >> 22;
325
326 /* addressing modes */
327 if ((opcode & 0x01200000) == 0x01000000) /* offset */
328 snprintf(addressing_mode, 32, "[r%i, #%s%d]",
329 Rn, U ? "" : "-", offset);
330 else if ((opcode & 0x01200000) == 0x01200000) /* pre-indexed */
331 snprintf(addressing_mode, 32, "[r%i, #%s%d]!",
332 Rn, U ? "" : "-", offset);
333 else if ((opcode & 0x01200000) == 0x00200000) /* post-indexed */
334 snprintf(addressing_mode, 32, "[r%i], #%s%d",
335 Rn, U ? "" : "-", offset);
336 else if ((opcode & 0x01200000) == 0x00000000) /* unindexed */
337 snprintf(addressing_mode, 32, "[r%i], {%d}",
338 Rn, offset >> 2);
339
340 snprintf(instruction->text, 128, "0x%8.8" PRIx32
341 "\t0x%8.8" PRIx32
342 "\t%s%s%s p%i, c%i, %s",
343 address, opcode, mnemonic,
344 ((opcode & 0xf0000000) == 0xf0000000)
345 ? "2" : COND(opcode),
346 (opcode & (1 << 22)) ? "L" : "",
347 cp_num, CRd, addressing_mode);
348 }
349
350 return ERROR_OK;
351 }
352
353 /* Coprocessor data processing instructions */
354 /* Coprocessor register transfer instructions */
355 /* both normal and extended instruction space (condition field b1111) */
356 static int evaluate_cdp_mcr_mrc(uint32_t opcode,
357 uint32_t address, struct arm_instruction *instruction)
358 {
359 const char *cond;
360 char* mnemonic;
361 uint8_t cp_num, opcode_1, CRd_Rd, CRn, CRm, opcode_2;
362
363 cond = ((opcode & 0xf0000000) == 0xf0000000) ? "2" : COND(opcode);
364 cp_num = (opcode & 0xf00) >> 8;
365 CRd_Rd = (opcode & 0xf000) >> 12;
366 CRn = (opcode & 0xf0000) >> 16;
367 CRm = (opcode & 0xf);
368 opcode_2 = (opcode & 0xe0) >> 5;
369
370 /* CDP or MRC/MCR */
371 if (opcode & 0x00000010) /* bit 4 set -> MRC/MCR */
372 {
373 if (opcode & 0x00100000) /* bit 20 set -> MRC */
374 {
375 instruction->type = ARM_MRC;
376 mnemonic = "MRC";
377 }
378 else /* bit 20 not set -> MCR */
379 {
380 instruction->type = ARM_MCR;
381 mnemonic = "MCR";
382 }
383
384 opcode_1 = (opcode & 0x00e00000) >> 21;
385
386 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s p%i, 0x%2.2x, r%i, c%i, c%i, 0x%2.2x",
387 address, opcode, mnemonic, cond,
388 cp_num, opcode_1, CRd_Rd, CRn, CRm, opcode_2);
389 }
390 else /* bit 4 not set -> CDP */
391 {
392 instruction->type = ARM_CDP;
393 mnemonic = "CDP";
394
395 opcode_1 = (opcode & 0x00f00000) >> 20;
396
397 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s p%i, 0x%2.2x, c%i, c%i, c%i, 0x%2.2x",
398 address, opcode, mnemonic, cond,
399 cp_num, opcode_1, CRd_Rd, CRn, CRm, opcode_2);
400 }
401
402 return ERROR_OK;
403 }
404
405 /* Load/store instructions */
406 static int evaluate_load_store(uint32_t opcode,
407 uint32_t address, struct arm_instruction *instruction)
408 {
409 uint8_t I, P, U, B, W, L;
410 uint8_t Rn, Rd;
411 char *operation; /* "LDR" or "STR" */
412 char *suffix; /* "", "B", "T", "BT" */
413 char offset[32];
414
415 /* examine flags */
416 I = (opcode & 0x02000000) >> 25;
417 P = (opcode & 0x01000000) >> 24;
418 U = (opcode & 0x00800000) >> 23;
419 B = (opcode & 0x00400000) >> 22;
420 W = (opcode & 0x00200000) >> 21;
421 L = (opcode & 0x00100000) >> 20;
422
423 /* target register */
424 Rd = (opcode & 0xf000) >> 12;
425
426 /* base register */
427 Rn = (opcode & 0xf0000) >> 16;
428
429 instruction->info.load_store.Rd = Rd;
430 instruction->info.load_store.Rn = Rn;
431 instruction->info.load_store.U = U;
432
433 /* determine operation */
434 if (L)
435 operation = "LDR";
436 else
437 operation = "STR";
438
439 /* determine instruction type and suffix */
440 if (B)
441 {
442 if ((P == 0) && (W == 1))
443 {
444 if (L)
445 instruction->type = ARM_LDRBT;
446 else
447 instruction->type = ARM_STRBT;
448 suffix = "BT";
449 }
450 else
451 {
452 if (L)
453 instruction->type = ARM_LDRB;
454 else
455 instruction->type = ARM_STRB;
456 suffix = "B";
457 }
458 }
459 else
460 {
461 if ((P == 0) && (W == 1))
462 {
463 if (L)
464 instruction->type = ARM_LDRT;
465 else
466 instruction->type = ARM_STRT;
467 suffix = "T";
468 }
469 else
470 {
471 if (L)
472 instruction->type = ARM_LDR;
473 else
474 instruction->type = ARM_STR;
475 suffix = "";
476 }
477 }
478
479 if (!I) /* #+-<offset_12> */
480 {
481 uint32_t offset_12 = (opcode & 0xfff);
482 if (offset_12)
483 snprintf(offset, 32, ", #%s0x%" PRIx32 "", (U) ? "" : "-", offset_12);
484 else
485 snprintf(offset, 32, "%s", "");
486
487 instruction->info.load_store.offset_mode = 0;
488 instruction->info.load_store.offset.offset = offset_12;
489 }
490 else /* either +-<Rm> or +-<Rm>, <shift>, #<shift_imm> */
491 {
492 uint8_t shift_imm, shift;
493 uint8_t Rm;
494
495 shift_imm = (opcode & 0xf80) >> 7;
496 shift = (opcode & 0x60) >> 5;
497 Rm = (opcode & 0xf);
498
499 /* LSR encodes a shift by 32 bit as 0x0 */
500 if ((shift == 0x1) && (shift_imm == 0x0))
501 shift_imm = 0x20;
502
503 /* ASR encodes a shift by 32 bit as 0x0 */
504 if ((shift == 0x2) && (shift_imm == 0x0))
505 shift_imm = 0x20;
506
507 /* ROR by 32 bit is actually a RRX */
508 if ((shift == 0x3) && (shift_imm == 0x0))
509 shift = 0x4;
510
511 instruction->info.load_store.offset_mode = 1;
512 instruction->info.load_store.offset.reg.Rm = Rm;
513 instruction->info.load_store.offset.reg.shift = shift;
514 instruction->info.load_store.offset.reg.shift_imm = shift_imm;
515
516 if ((shift_imm == 0x0) && (shift == 0x0)) /* +-<Rm> */
517 {
518 snprintf(offset, 32, ", %sr%i", (U) ? "" : "-", Rm);
519 }
520 else /* +-<Rm>, <Shift>, #<shift_imm> */
521 {
522 switch (shift)
523 {
524 case 0x0: /* LSL */
525 snprintf(offset, 32, ", %sr%i, LSL #0x%x", (U) ? "" : "-", Rm, shift_imm);
526 break;
527 case 0x1: /* LSR */
528 snprintf(offset, 32, ", %sr%i, LSR #0x%x", (U) ? "" : "-", Rm, shift_imm);
529 break;
530 case 0x2: /* ASR */
531 snprintf(offset, 32, ", %sr%i, ASR #0x%x", (U) ? "" : "-", Rm, shift_imm);
532 break;
533 case 0x3: /* ROR */
534 snprintf(offset, 32, ", %sr%i, ROR #0x%x", (U) ? "" : "-", Rm, shift_imm);
535 break;
536 case 0x4: /* RRX */
537 snprintf(offset, 32, ", %sr%i, RRX", (U) ? "" : "-", Rm);
538 break;
539 }
540 }
541 }
542
543 if (P == 1)
544 {
545 if (W == 0) /* offset */
546 {
547 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, [r%i%s]",
548 address, opcode, operation, COND(opcode), suffix,
549 Rd, Rn, offset);
550
551 instruction->info.load_store.index_mode = 0;
552 }
553 else /* pre-indexed */
554 {
555 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, [r%i%s]!",
556 address, opcode, operation, COND(opcode), suffix,
557 Rd, Rn, offset);
558
559 instruction->info.load_store.index_mode = 1;
560 }
561 }
562 else /* post-indexed */
563 {
564 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, [r%i]%s",
565 address, opcode, operation, COND(opcode), suffix,
566 Rd, Rn, offset);
567
568 instruction->info.load_store.index_mode = 2;
569 }
570
571 return ERROR_OK;
572 }
573
574 static int evaluate_extend(uint32_t opcode, uint32_t address, char *cp)
575 {
576 unsigned rm = (opcode >> 0) & 0xf;
577 unsigned rd = (opcode >> 12) & 0xf;
578 unsigned rn = (opcode >> 16) & 0xf;
579 char *type, *rot;
580
581 switch ((opcode >> 24) & 0x3) {
582 case 0:
583 type = "B16";
584 break;
585 case 1:
586 sprintf(cp, "UNDEFINED");
587 return ARM_UNDEFINED_INSTRUCTION;
588 case 2:
589 type = "B";
590 break;
591 default:
592 type = "H";
593 break;
594 }
595
596 switch ((opcode >> 10) & 0x3) {
597 case 0:
598 rot = "";
599 break;
600 case 1:
601 rot = ", ROR #8";
602 break;
603 case 2:
604 rot = ", ROR #16";
605 break;
606 default:
607 rot = ", ROR #24";
608 break;
609 }
610
611 if (rn == 0xf) {
612 sprintf(cp, "%cXT%s%s\tr%d, r%d%s",
613 (opcode & (1 << 22)) ? 'U' : 'S',
614 type, COND(opcode),
615 rd, rm, rot);
616 return ARM_MOV;
617 } else {
618 sprintf(cp, "%cXTA%s%s\tr%d, r%d, r%d%s",
619 (opcode & (1 << 22)) ? 'U' : 'S',
620 type, COND(opcode),
621 rd, rn, rm, rot);
622 return ARM_ADD;
623 }
624 }
625
626 static int evaluate_p_add_sub(uint32_t opcode, uint32_t address, char *cp)
627 {
628 char *prefix;
629 char *op;
630 int type;
631
632 switch ((opcode >> 20) & 0x7) {
633 case 1:
634 prefix = "S";
635 break;
636 case 2:
637 prefix = "Q";
638 break;
639 case 3:
640 prefix = "SH";
641 break;
642 case 5:
643 prefix = "U";
644 break;
645 case 6:
646 prefix = "UQ";
647 break;
648 case 7:
649 prefix = "UH";
650 break;
651 default:
652 goto undef;
653 }
654
655 switch ((opcode >> 5) & 0x7) {
656 case 0:
657 op = "ADD16";
658 type = ARM_ADD;
659 break;
660 case 1:
661 op = "ADDSUBX";
662 type = ARM_ADD;
663 break;
664 case 2:
665 op = "SUBADDX";
666 type = ARM_SUB;
667 break;
668 case 3:
669 op = "SUB16";
670 type = ARM_SUB;
671 break;
672 case 4:
673 op = "ADD8";
674 type = ARM_ADD;
675 break;
676 case 7:
677 op = "SUB8";
678 type = ARM_SUB;
679 break;
680 default:
681 goto undef;
682 }
683
684 sprintf(cp, "%s%s%s\tr%d, r%d, r%d", prefix, op, COND(opcode),
685 (int) (opcode >> 12) & 0xf,
686 (int) (opcode >> 16) & 0xf,
687 (int) (opcode >> 0) & 0xf);
688 return type;
689
690 undef:
691 /* these opcodes might be used someday */
692 sprintf(cp, "UNDEFINED");
693 return ARM_UNDEFINED_INSTRUCTION;
694 }
695
696 /* ARMv6 and later support "media" instructions (includes SIMD) */
697 static int evaluate_media(uint32_t opcode, uint32_t address,
698 struct arm_instruction *instruction)
699 {
700 char *cp = instruction->text;
701 char *mnemonic = NULL;
702
703 sprintf(cp,
704 "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t",
705 address, opcode);
706 cp = strchr(cp, 0);
707
708 /* parallel add/subtract */
709 if ((opcode & 0x01800000) == 0x00000000) {
710 instruction->type = evaluate_p_add_sub(opcode, address, cp);
711 return ERROR_OK;
712 }
713
714 /* halfword pack */
715 if ((opcode & 0x01f00020) == 0x00800000) {
716 char *type, *shift;
717 unsigned imm = (unsigned) (opcode >> 7) & 0x1f;
718
719 if (opcode & (1 << 6)) {
720 type = "TB";
721 shift = "ASR";
722 if (imm == 0)
723 imm = 32;
724 } else {
725 type = "BT";
726 shift = "LSL";
727 }
728 sprintf(cp, "PKH%s%s\tr%d, r%d, r%d, %s #%d",
729 type, COND(opcode),
730 (int) (opcode >> 12) & 0xf,
731 (int) (opcode >> 16) & 0xf,
732 (int) (opcode >> 0) & 0xf,
733 shift, imm);
734 return ERROR_OK;
735 }
736
737 /* word saturate */
738 if ((opcode & 0x01a00020) == 0x00a00000) {
739 char *shift;
740 unsigned imm = (unsigned) (opcode >> 7) & 0x1f;
741
742 if (opcode & (1 << 6)) {
743 shift = "ASR";
744 if (imm == 0)
745 imm = 32;
746 } else {
747 shift = "LSL";
748 }
749
750 sprintf(cp, "%cSAT%s\tr%d, #%d, r%d, %s #%d",
751 (opcode & (1 << 22)) ? 'U' : 'S',
752 COND(opcode),
753 (int) (opcode >> 12) & 0xf,
754 (int) (opcode >> 16) & 0x1f,
755 (int) (opcode >> 0) & 0xf,
756 shift, imm);
757 return ERROR_OK;
758 }
759
760 /* sign extension */
761 if ((opcode & 0x018000f0) == 0x00800070) {
762 instruction->type = evaluate_extend(opcode, address, cp);
763 return ERROR_OK;
764 }
765
766 /* multiplies */
767 if ((opcode & 0x01f00080) == 0x01000000) {
768 unsigned rn = (opcode >> 12) & 0xf;
769
770 if (rn != 0xf)
771 sprintf(cp, "SML%cD%s%s\tr%d, r%d, r%d, r%d",
772 (opcode & (1 << 6)) ? 'S' : 'A',
773 (opcode & (1 << 5)) ? "X" : "",
774 COND(opcode),
775 (int) (opcode >> 16) & 0xf,
776 (int) (opcode >> 0) & 0xf,
777 (int) (opcode >> 8) & 0xf,
778 rn);
779 else
780 sprintf(cp, "SMU%cD%s%s\tr%d, r%d, r%d",
781 (opcode & (1 << 6)) ? 'S' : 'A',
782 (opcode & (1 << 5)) ? "X" : "",
783 COND(opcode),
784 (int) (opcode >> 16) & 0xf,
785 (int) (opcode >> 0) & 0xf,
786 (int) (opcode >> 8) & 0xf);
787 return ERROR_OK;
788 }
789 if ((opcode & 0x01f00000) == 0x01400000) {
790 sprintf(cp, "SML%cLD%s%s\tr%d, r%d, r%d, r%d",
791 (opcode & (1 << 6)) ? 'S' : 'A',
792 (opcode & (1 << 5)) ? "X" : "",
793 COND(opcode),
794 (int) (opcode >> 12) & 0xf,
795 (int) (opcode >> 16) & 0xf,
796 (int) (opcode >> 0) & 0xf,
797 (int) (opcode >> 8) & 0xf);
798 return ERROR_OK;
799 }
800 if ((opcode & 0x01f00000) == 0x01500000) {
801 unsigned rn = (opcode >> 12) & 0xf;
802
803 switch (opcode & 0xc0) {
804 case 3:
805 if (rn == 0xf)
806 goto undef;
807 /* FALL THROUGH */
808 case 0:
809 break;
810 default:
811 goto undef;
812 }
813
814 if (rn != 0xf)
815 sprintf(cp, "SMML%c%s%s\tr%d, r%d, r%d, r%d",
816 (opcode & (1 << 6)) ? 'S' : 'A',
817 (opcode & (1 << 5)) ? "R" : "",
818 COND(opcode),
819 (int) (opcode >> 16) & 0xf,
820 (int) (opcode >> 0) & 0xf,
821 (int) (opcode >> 8) & 0xf,
822 rn);
823 else
824 sprintf(cp, "SMMUL%s%s\tr%d, r%d, r%d",
825 (opcode & (1 << 5)) ? "R" : "",
826 COND(opcode),
827 (int) (opcode >> 16) & 0xf,
828 (int) (opcode >> 0) & 0xf,
829 (int) (opcode >> 8) & 0xf);
830 return ERROR_OK;
831 }
832
833
834 /* simple matches against the remaining decode bits */
835 switch (opcode & 0x01f000f0) {
836 case 0x00a00030:
837 case 0x00e00030:
838 /* parallel halfword saturate */
839 sprintf(cp, "%cSAT16%s\tr%d, #%d, r%d",
840 (opcode & (1 << 22)) ? 'U' : 'S',
841 COND(opcode),
842 (int) (opcode >> 12) & 0xf,
843 (int) (opcode >> 16) & 0xf,
844 (int) (opcode >> 0) & 0xf);
845 return ERROR_OK;
846 case 0x00b00030:
847 mnemonic = "REV";
848 break;
849 case 0x00b000b0:
850 mnemonic = "REV16";
851 break;
852 case 0x00f000b0:
853 mnemonic = "REVSH";
854 break;
855 case 0x008000b0:
856 /* select bytes */
857 sprintf(cp, "SEL%s\tr%d, r%d, r%d", COND(opcode),
858 (int) (opcode >> 12) & 0xf,
859 (int) (opcode >> 16) & 0xf,
860 (int) (opcode >> 0) & 0xf);
861 return ERROR_OK;
862 case 0x01800010:
863 /* unsigned sum of absolute differences */
864 if (((opcode >> 12) & 0xf) == 0xf)
865 sprintf(cp, "USAD8%s\tr%d, r%d, r%d", COND(opcode),
866 (int) (opcode >> 16) & 0xf,
867 (int) (opcode >> 0) & 0xf,
868 (int) (opcode >> 8) & 0xf);
869 else
870 sprintf(cp, "USADA8%s\tr%d, r%d, r%d, r%d", COND(opcode),
871 (int) (opcode >> 16) & 0xf,
872 (int) (opcode >> 0) & 0xf,
873 (int) (opcode >> 8) & 0xf,
874 (int) (opcode >> 12) & 0xf);
875 return ERROR_OK;
876 }
877 if (mnemonic) {
878 unsigned rm = (opcode >> 0) & 0xf;
879 unsigned rd = (opcode >> 12) & 0xf;
880
881 sprintf(cp, "%s%s\tr%d, r%d", mnemonic, COND(opcode), rm, rd);
882 return ERROR_OK;
883 }
884
885 undef:
886 /* these opcodes might be used someday */
887 sprintf(cp, "UNDEFINED");
888 return ERROR_OK;
889 }
890
891 /* Miscellaneous load/store instructions */
892 static int evaluate_misc_load_store(uint32_t opcode,
893 uint32_t address, struct arm_instruction *instruction)
894 {
895 uint8_t P, U, I, W, L, S, H;
896 uint8_t Rn, Rd;
897 char *operation; /* "LDR" or "STR" */
898 char *suffix; /* "H", "SB", "SH", "D" */
899 char offset[32];
900
901 /* examine flags */
902 P = (opcode & 0x01000000) >> 24;
903 U = (opcode & 0x00800000) >> 23;
904 I = (opcode & 0x00400000) >> 22;
905 W = (opcode & 0x00200000) >> 21;
906 L = (opcode & 0x00100000) >> 20;
907 S = (opcode & 0x00000040) >> 6;
908 H = (opcode & 0x00000020) >> 5;
909
910 /* target register */
911 Rd = (opcode & 0xf000) >> 12;
912
913 /* base register */
914 Rn = (opcode & 0xf0000) >> 16;
915
916 instruction->info.load_store.Rd = Rd;
917 instruction->info.load_store.Rn = Rn;
918 instruction->info.load_store.U = U;
919
920 /* determine instruction type and suffix */
921 if (S) /* signed */
922 {
923 if (L) /* load */
924 {
925 if (H)
926 {
927 operation = "LDR";
928 instruction->type = ARM_LDRSH;
929 suffix = "SH";
930 }
931 else
932 {
933 operation = "LDR";
934 instruction->type = ARM_LDRSB;
935 suffix = "SB";
936 }
937 }
938 else /* there are no signed stores, so this is used to encode double-register load/stores */
939 {
940 suffix = "D";
941 if (H)
942 {
943 operation = "STR";
944 instruction->type = ARM_STRD;
945 }
946 else
947 {
948 operation = "LDR";
949 instruction->type = ARM_LDRD;
950 }
951 }
952 }
953 else /* unsigned */
954 {
955 suffix = "H";
956 if (L) /* load */
957 {
958 operation = "LDR";
959 instruction->type = ARM_LDRH;
960 }
961 else /* store */
962 {
963 operation = "STR";
964 instruction->type = ARM_STRH;
965 }
966 }
967
968 if (I) /* Immediate offset/index (#+-<offset_8>)*/
969 {
970 uint32_t offset_8 = ((opcode & 0xf00) >> 4) | (opcode & 0xf);
971 snprintf(offset, 32, "#%s0x%" PRIx32 "", (U) ? "" : "-", offset_8);
972
973 instruction->info.load_store.offset_mode = 0;
974 instruction->info.load_store.offset.offset = offset_8;
975 }
976 else /* Register offset/index (+-<Rm>) */
977 {
978 uint8_t Rm;
979 Rm = (opcode & 0xf);
980 snprintf(offset, 32, "%sr%i", (U) ? "" : "-", Rm);
981
982 instruction->info.load_store.offset_mode = 1;
983 instruction->info.load_store.offset.reg.Rm = Rm;
984 instruction->info.load_store.offset.reg.shift = 0x0;
985 instruction->info.load_store.offset.reg.shift_imm = 0x0;
986 }
987
988 if (P == 1)
989 {
990 if (W == 0) /* offset */
991 {
992 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, [r%i, %s]",
993 address, opcode, operation, COND(opcode), suffix,
994 Rd, Rn, offset);
995
996 instruction->info.load_store.index_mode = 0;
997 }
998 else /* pre-indexed */
999 {
1000 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, [r%i, %s]!",
1001 address, opcode, operation, COND(opcode), suffix,
1002 Rd, Rn, offset);
1003
1004 instruction->info.load_store.index_mode = 1;
1005 }
1006 }
1007 else /* post-indexed */
1008 {
1009 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, [r%i], %s",
1010 address, opcode, operation, COND(opcode), suffix,
1011 Rd, Rn, offset);
1012
1013 instruction->info.load_store.index_mode = 2;
1014 }
1015
1016 return ERROR_OK;
1017 }
1018
1019 /* Load/store multiples instructions */
1020 static int evaluate_ldm_stm(uint32_t opcode,
1021 uint32_t address, struct arm_instruction *instruction)
1022 {
1023 uint8_t P, U, S, W, L, Rn;
1024 uint32_t register_list;
1025 char *addressing_mode;
1026 char *mnemonic;
1027 char reg_list[69];
1028 char *reg_list_p;
1029 int i;
1030 int first_reg = 1;
1031
1032 P = (opcode & 0x01000000) >> 24;
1033 U = (opcode & 0x00800000) >> 23;
1034 S = (opcode & 0x00400000) >> 22;
1035 W = (opcode & 0x00200000) >> 21;
1036 L = (opcode & 0x00100000) >> 20;
1037 register_list = (opcode & 0xffff);
1038 Rn = (opcode & 0xf0000) >> 16;
1039
1040 instruction->info.load_store_multiple.Rn = Rn;
1041 instruction->info.load_store_multiple.register_list = register_list;
1042 instruction->info.load_store_multiple.S = S;
1043 instruction->info.load_store_multiple.W = W;
1044
1045 if (L)
1046 {
1047 instruction->type = ARM_LDM;
1048 mnemonic = "LDM";
1049 }
1050 else
1051 {
1052 instruction->type = ARM_STM;
1053 mnemonic = "STM";
1054 }
1055
1056 if (P)
1057 {
1058 if (U)
1059 {
1060 instruction->info.load_store_multiple.addressing_mode = 1;
1061 addressing_mode = "IB";
1062 }
1063 else
1064 {
1065 instruction->info.load_store_multiple.addressing_mode = 3;
1066 addressing_mode = "DB";
1067 }
1068 }
1069 else
1070 {
1071 if (U)
1072 {
1073 instruction->info.load_store_multiple.addressing_mode = 0;
1074 /* "IA" is the default in UAL syntax */
1075 addressing_mode = "";
1076 }
1077 else
1078 {
1079 instruction->info.load_store_multiple.addressing_mode = 2;
1080 addressing_mode = "DA";
1081 }
1082 }
1083
1084 reg_list_p = reg_list;
1085 for (i = 0; i <= 15; i++)
1086 {
1087 if ((register_list >> i) & 1)
1088 {
1089 if (first_reg)
1090 {
1091 first_reg = 0;
1092 reg_list_p += snprintf(reg_list_p, (reg_list + 69 - reg_list_p), "r%i", i);
1093 }
1094 else
1095 {
1096 reg_list_p += snprintf(reg_list_p, (reg_list + 69 - reg_list_p), ", r%i", i);
1097 }
1098 }
1099 }
1100
1101 snprintf(instruction->text, 128,
1102 "0x%8.8" PRIx32 "\t0x%8.8" PRIx32
1103 "\t%s%s%s r%i%s, {%s}%s",
1104 address, opcode,
1105 mnemonic, addressing_mode, COND(opcode),
1106 Rn, (W) ? "!" : "", reg_list, (S) ? "^" : "");
1107
1108 return ERROR_OK;
1109 }
1110
1111 /* Multiplies, extra load/stores */
1112 static int evaluate_mul_and_extra_ld_st(uint32_t opcode,
1113 uint32_t address, struct arm_instruction *instruction)
1114 {
1115 /* Multiply (accumulate) (long) and Swap/swap byte */
1116 if ((opcode & 0x000000f0) == 0x00000090)
1117 {
1118 /* Multiply (accumulate) */
1119 if ((opcode & 0x0f800000) == 0x00000000)
1120 {
1121 uint8_t Rm, Rs, Rn, Rd, S;
1122 Rm = opcode & 0xf;
1123 Rs = (opcode & 0xf00) >> 8;
1124 Rn = (opcode & 0xf000) >> 12;
1125 Rd = (opcode & 0xf0000) >> 16;
1126 S = (opcode & 0x00100000) >> 20;
1127
1128 /* examine A bit (accumulate) */
1129 if (opcode & 0x00200000)
1130 {
1131 instruction->type = ARM_MLA;
1132 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tMLA%s%s r%i, r%i, r%i, r%i",
1133 address, opcode, COND(opcode), (S) ? "S" : "", Rd, Rm, Rs, Rn);
1134 }
1135 else
1136 {
1137 instruction->type = ARM_MUL;
1138 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tMUL%s%s r%i, r%i, r%i",
1139 address, opcode, COND(opcode), (S) ? "S" : "", Rd, Rm, Rs);
1140 }
1141
1142 return ERROR_OK;
1143 }
1144
1145 /* Multiply (accumulate) long */
1146 if ((opcode & 0x0f800000) == 0x00800000)
1147 {
1148 char* mnemonic = NULL;
1149 uint8_t Rm, Rs, RdHi, RdLow, S;
1150 Rm = opcode & 0xf;
1151 Rs = (opcode & 0xf00) >> 8;
1152 RdHi = (opcode & 0xf000) >> 12;
1153 RdLow = (opcode & 0xf0000) >> 16;
1154 S = (opcode & 0x00100000) >> 20;
1155
1156 switch ((opcode & 0x00600000) >> 21)
1157 {
1158 case 0x0:
1159 instruction->type = ARM_UMULL;
1160 mnemonic = "UMULL";
1161 break;
1162 case 0x1:
1163 instruction->type = ARM_UMLAL;
1164 mnemonic = "UMLAL";
1165 break;
1166 case 0x2:
1167 instruction->type = ARM_SMULL;
1168 mnemonic = "SMULL";
1169 break;
1170 case 0x3:
1171 instruction->type = ARM_SMLAL;
1172 mnemonic = "SMLAL";
1173 break;
1174 }
1175
1176 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, r%i, r%i, r%i",
1177 address, opcode, mnemonic, COND(opcode), (S) ? "S" : "",
1178 RdLow, RdHi, Rm, Rs);
1179
1180 return ERROR_OK;
1181 }
1182
1183 /* Swap/swap byte */
1184 if ((opcode & 0x0f800000) == 0x01000000)
1185 {
1186 uint8_t Rm, Rd, Rn;
1187 Rm = opcode & 0xf;
1188 Rd = (opcode & 0xf000) >> 12;
1189 Rn = (opcode & 0xf0000) >> 16;
1190
1191 /* examine B flag */
1192 instruction->type = (opcode & 0x00400000) ? ARM_SWPB : ARM_SWP;
1193
1194 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s r%i, r%i, [r%i]",
1195 address, opcode, (opcode & 0x00400000) ? "SWPB" : "SWP", COND(opcode), Rd, Rm, Rn);
1196 return ERROR_OK;
1197 }
1198
1199 }
1200
1201 return evaluate_misc_load_store(opcode, address, instruction);
1202 }
1203
1204 static int evaluate_mrs_msr(uint32_t opcode,
1205 uint32_t address, struct arm_instruction *instruction)
1206 {
1207 int R = (opcode & 0x00400000) >> 22;
1208 char *PSR = (R) ? "SPSR" : "CPSR";
1209
1210 /* Move register to status register (MSR) */
1211 if (opcode & 0x00200000)
1212 {
1213 instruction->type = ARM_MSR;
1214
1215 /* immediate variant */
1216 if (opcode & 0x02000000)
1217 {
1218 uint8_t immediate = (opcode & 0xff);
1219 uint8_t rotate = (opcode & 0xf00);
1220
1221 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tMSR%s %s_%s%s%s%s, 0x%8.8" PRIx32 ,
1222 address, opcode, COND(opcode), PSR,
1223 (opcode & 0x10000) ? "c" : "",
1224 (opcode & 0x20000) ? "x" : "",
1225 (opcode & 0x40000) ? "s" : "",
1226 (opcode & 0x80000) ? "f" : "",
1227 ror(immediate, (rotate * 2))
1228 );
1229 }
1230 else /* register variant */
1231 {
1232 uint8_t Rm = opcode & 0xf;
1233 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tMSR%s %s_%s%s%s%s, r%i",
1234 address, opcode, COND(opcode), PSR,
1235 (opcode & 0x10000) ? "c" : "",
1236 (opcode & 0x20000) ? "x" : "",
1237 (opcode & 0x40000) ? "s" : "",
1238 (opcode & 0x80000) ? "f" : "",
1239 Rm
1240 );
1241 }
1242
1243 }
1244 else /* Move status register to register (MRS) */
1245 {
1246 uint8_t Rd;
1247
1248 instruction->type = ARM_MRS;
1249 Rd = (opcode & 0x0000f000) >> 12;
1250
1251 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tMRS%s r%i, %s",
1252 address, opcode, COND(opcode), Rd, PSR);
1253 }
1254
1255 return ERROR_OK;
1256 }
1257
1258 /* Miscellaneous instructions */
1259 static int evaluate_misc_instr(uint32_t opcode,
1260 uint32_t address, struct arm_instruction *instruction)
1261 {
1262 /* MRS/MSR */
1263 if ((opcode & 0x000000f0) == 0x00000000)
1264 {
1265 evaluate_mrs_msr(opcode, address, instruction);
1266 }
1267
1268 /* BX */
1269 if ((opcode & 0x006000f0) == 0x00200010)
1270 {
1271 uint8_t Rm;
1272 instruction->type = ARM_BX;
1273 Rm = opcode & 0xf;
1274
1275 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tBX%s r%i",
1276 address, opcode, COND(opcode), Rm);
1277
1278 instruction->info.b_bl_bx_blx.reg_operand = Rm;
1279 instruction->info.b_bl_bx_blx.target_address = -1;
1280 }
1281
1282 /* BXJ - "Jazelle" support (ARMv5-J) */
1283 if ((opcode & 0x006000f0) == 0x00200020)
1284 {
1285 uint8_t Rm;
1286 instruction->type = ARM_BX;
1287 Rm = opcode & 0xf;
1288
1289 snprintf(instruction->text, 128,
1290 "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tBXJ%s r%i",
1291 address, opcode, COND(opcode), Rm);
1292
1293 instruction->info.b_bl_bx_blx.reg_operand = Rm;
1294 instruction->info.b_bl_bx_blx.target_address = -1;
1295 }
1296
1297 /* CLZ */
1298 if ((opcode & 0x006000f0) == 0x00600010)
1299 {
1300 uint8_t Rm, Rd;
1301 instruction->type = ARM_CLZ;
1302 Rm = opcode & 0xf;
1303 Rd = (opcode & 0xf000) >> 12;
1304
1305 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tCLZ%s r%i, r%i",
1306 address, opcode, COND(opcode), Rd, Rm);
1307 }
1308
1309 /* BLX(2) */
1310 if ((opcode & 0x006000f0) == 0x00200030)
1311 {
1312 uint8_t Rm;
1313 instruction->type = ARM_BLX;
1314 Rm = opcode & 0xf;
1315
1316 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tBLX%s r%i",
1317 address, opcode, COND(opcode), Rm);
1318
1319 instruction->info.b_bl_bx_blx.reg_operand = Rm;
1320 instruction->info.b_bl_bx_blx.target_address = -1;
1321 }
1322
1323 /* Enhanced DSP add/subtracts */
1324 if ((opcode & 0x0000000f0) == 0x00000050)
1325 {
1326 uint8_t Rm, Rd, Rn;
1327 char *mnemonic = NULL;
1328 Rm = opcode & 0xf;
1329 Rd = (opcode & 0xf000) >> 12;
1330 Rn = (opcode & 0xf0000) >> 16;
1331
1332 switch ((opcode & 0x00600000) >> 21)
1333 {
1334 case 0x0:
1335 instruction->type = ARM_QADD;
1336 mnemonic = "QADD";
1337 break;
1338 case 0x1:
1339 instruction->type = ARM_QSUB;
1340 mnemonic = "QSUB";
1341 break;
1342 case 0x2:
1343 instruction->type = ARM_QDADD;
1344 mnemonic = "QDADD";
1345 break;
1346 case 0x3:
1347 instruction->type = ARM_QDSUB;
1348 mnemonic = "QDSUB";
1349 break;
1350 }
1351
1352 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s r%i, r%i, r%i",
1353 address, opcode, mnemonic, COND(opcode), Rd, Rm, Rn);
1354 }
1355
1356 /* Software breakpoints */
1357 if ((opcode & 0x0000000f0) == 0x00000070)
1358 {
1359 uint32_t immediate;
1360 instruction->type = ARM_BKPT;
1361 immediate = ((opcode & 0x000fff00) >> 4) | (opcode & 0xf);
1362
1363 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tBKPT 0x%4.4" PRIx32 "",
1364 address, opcode, immediate);
1365 }
1366
1367 /* Enhanced DSP multiplies */
1368 if ((opcode & 0x000000090) == 0x00000080)
1369 {
1370 int x = (opcode & 0x20) >> 5;
1371 int y = (opcode & 0x40) >> 6;
1372
1373 /* SMLA < x><y> */
1374 if ((opcode & 0x00600000) == 0x00000000)
1375 {
1376 uint8_t Rd, Rm, Rs, Rn;
1377 instruction->type = ARM_SMLAxy;
1378 Rd = (opcode & 0xf0000) >> 16;
1379 Rm = (opcode & 0xf);
1380 Rs = (opcode & 0xf00) >> 8;
1381 Rn = (opcode & 0xf000) >> 12;
1382
1383 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tSMLA%s%s%s r%i, r%i, r%i, r%i",
1384 address, opcode, (x) ? "T" : "B", (y) ? "T" : "B", COND(opcode),
1385 Rd, Rm, Rs, Rn);
1386 }
1387
1388 /* SMLAL < x><y> */
1389 if ((opcode & 0x00600000) == 0x00400000)
1390 {
1391 uint8_t RdLow, RdHi, Rm, Rs;
1392 instruction->type = ARM_SMLAxy;
1393 RdHi = (opcode & 0xf0000) >> 16;
1394 RdLow = (opcode & 0xf000) >> 12;
1395 Rm = (opcode & 0xf);
1396 Rs = (opcode & 0xf00) >> 8;
1397
1398 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tSMLA%s%s%s r%i, r%i, r%i, r%i",
1399 address, opcode, (x) ? "T" : "B", (y) ? "T" : "B", COND(opcode),
1400 RdLow, RdHi, Rm, Rs);
1401 }
1402
1403 /* SMLAW < y> */
1404 if (((opcode & 0x00600000) == 0x00100000) && (x == 0))
1405 {
1406 uint8_t Rd, Rm, Rs, Rn;
1407 instruction->type = ARM_SMLAWy;
1408 Rd = (opcode & 0xf0000) >> 16;
1409 Rm = (opcode & 0xf);
1410 Rs = (opcode & 0xf00) >> 8;
1411 Rn = (opcode & 0xf000) >> 12;
1412
1413 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tSMLAW%s%s r%i, r%i, r%i, r%i",
1414 address, opcode, (y) ? "T" : "B", COND(opcode),
1415 Rd, Rm, Rs, Rn);
1416 }
1417
1418 /* SMUL < x><y> */
1419 if ((opcode & 0x00600000) == 0x00300000)
1420 {
1421 uint8_t Rd, Rm, Rs;
1422 instruction->type = ARM_SMULxy;
1423 Rd = (opcode & 0xf0000) >> 16;
1424 Rm = (opcode & 0xf);
1425 Rs = (opcode & 0xf00) >> 8;
1426
1427 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tSMULW%s%s%s r%i, r%i, r%i",
1428 address, opcode, (x) ? "T" : "B", (y) ? "T" : "B", COND(opcode),
1429 Rd, Rm, Rs);
1430 }
1431
1432 /* SMULW < y> */
1433 if (((opcode & 0x00600000) == 0x00100000) && (x == 1))
1434 {
1435 uint8_t Rd, Rm, Rs;
1436 instruction->type = ARM_SMULWy;
1437 Rd = (opcode & 0xf0000) >> 16;
1438 Rm = (opcode & 0xf);
1439 Rs = (opcode & 0xf00) >> 8;
1440
1441 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tSMULW%s%s r%i, r%i, r%i",
1442 address, opcode, (y) ? "T" : "B", COND(opcode),
1443 Rd, Rm, Rs);
1444 }
1445 }
1446
1447 return ERROR_OK;
1448 }
1449
1450 static int evaluate_data_proc(uint32_t opcode,
1451 uint32_t address, struct arm_instruction *instruction)
1452 {
1453 uint8_t I, op, S, Rn, Rd;
1454 char *mnemonic = NULL;
1455 char shifter_operand[32];
1456
1457 I = (opcode & 0x02000000) >> 25;
1458 op = (opcode & 0x01e00000) >> 21;
1459 S = (opcode & 0x00100000) >> 20;
1460
1461 Rd = (opcode & 0xf000) >> 12;
1462 Rn = (opcode & 0xf0000) >> 16;
1463
1464 instruction->info.data_proc.Rd = Rd;
1465 instruction->info.data_proc.Rn = Rn;
1466 instruction->info.data_proc.S = S;
1467
1468 switch (op)
1469 {
1470 case 0x0:
1471 instruction->type = ARM_AND;
1472 mnemonic = "AND";
1473 break;
1474 case 0x1:
1475 instruction->type = ARM_EOR;
1476 mnemonic = "EOR";
1477 break;
1478 case 0x2:
1479 instruction->type = ARM_SUB;
1480 mnemonic = "SUB";
1481 break;
1482 case 0x3:
1483 instruction->type = ARM_RSB;
1484 mnemonic = "RSB";
1485 break;
1486 case 0x4:
1487 instruction->type = ARM_ADD;
1488 mnemonic = "ADD";
1489 break;
1490 case 0x5:
1491 instruction->type = ARM_ADC;
1492 mnemonic = "ADC";
1493 break;
1494 case 0x6:
1495 instruction->type = ARM_SBC;
1496 mnemonic = "SBC";
1497 break;
1498 case 0x7:
1499 instruction->type = ARM_RSC;
1500 mnemonic = "RSC";
1501 break;
1502 case 0x8:
1503 instruction->type = ARM_TST;
1504 mnemonic = "TST";
1505 break;
1506 case 0x9:
1507 instruction->type = ARM_TEQ;
1508 mnemonic = "TEQ";
1509 break;
1510 case 0xa:
1511 instruction->type = ARM_CMP;
1512 mnemonic = "CMP";
1513 break;
1514 case 0xb:
1515 instruction->type = ARM_CMN;
1516 mnemonic = "CMN";
1517 break;
1518 case 0xc:
1519 instruction->type = ARM_ORR;
1520 mnemonic = "ORR";
1521 break;
1522 case 0xd:
1523 instruction->type = ARM_MOV;
1524 mnemonic = "MOV";
1525 break;
1526 case 0xe:
1527 instruction->type = ARM_BIC;
1528 mnemonic = "BIC";
1529 break;
1530 case 0xf:
1531 instruction->type = ARM_MVN;
1532 mnemonic = "MVN";
1533 break;
1534 }
1535
1536 if (I) /* immediate shifter operand (#<immediate>)*/
1537 {
1538 uint8_t immed_8 = opcode & 0xff;
1539 uint8_t rotate_imm = (opcode & 0xf00) >> 8;
1540 uint32_t immediate;
1541
1542 immediate = ror(immed_8, rotate_imm * 2);
1543
1544 snprintf(shifter_operand, 32, "#0x%" PRIx32 "", immediate);
1545
1546 instruction->info.data_proc.variant = 0;
1547 instruction->info.data_proc.shifter_operand.immediate.immediate = immediate;
1548 }
1549 else /* register-based shifter operand */
1550 {
1551 uint8_t shift, Rm;
1552 shift = (opcode & 0x60) >> 5;
1553 Rm = (opcode & 0xf);
1554
1555 if ((opcode & 0x10) != 0x10) /* Immediate shifts ("<Rm>" or "<Rm>, <shift> #<shift_immediate>") */
1556 {
1557 uint8_t shift_imm;
1558 shift_imm = (opcode & 0xf80) >> 7;
1559
1560 instruction->info.data_proc.variant = 1;
1561 instruction->info.data_proc.shifter_operand.immediate_shift.Rm = Rm;
1562 instruction->info.data_proc.shifter_operand.immediate_shift.shift_imm = shift_imm;
1563 instruction->info.data_proc.shifter_operand.immediate_shift.shift = shift;
1564
1565 /* LSR encodes a shift by 32 bit as 0x0 */
1566 if ((shift == 0x1) && (shift_imm == 0x0))
1567 shift_imm = 0x20;
1568
1569 /* ASR encodes a shift by 32 bit as 0x0 */
1570 if ((shift == 0x2) && (shift_imm == 0x0))
1571 shift_imm = 0x20;
1572
1573 /* ROR by 32 bit is actually a RRX */
1574 if ((shift == 0x3) && (shift_imm == 0x0))
1575 shift = 0x4;
1576
1577 if ((shift_imm == 0x0) && (shift == 0x0))
1578 {
1579 snprintf(shifter_operand, 32, "r%i", Rm);
1580 }
1581 else
1582 {
1583 if (shift == 0x0) /* LSL */
1584 {
1585 snprintf(shifter_operand, 32, "r%i, LSL #0x%x", Rm, shift_imm);
1586 }
1587 else if (shift == 0x1) /* LSR */
1588 {
1589 snprintf(shifter_operand, 32, "r%i, LSR #0x%x", Rm, shift_imm);
1590 }
1591 else if (shift == 0x2) /* ASR */
1592 {
1593 snprintf(shifter_operand, 32, "r%i, ASR #0x%x", Rm, shift_imm);
1594 }
1595 else if (shift == 0x3) /* ROR */
1596 {
1597 snprintf(shifter_operand, 32, "r%i, ROR #0x%x", Rm, shift_imm);
1598 }
1599 else if (shift == 0x4) /* RRX */
1600 {
1601 snprintf(shifter_operand, 32, "r%i, RRX", Rm);
1602 }
1603 }
1604 }
1605 else /* Register shifts ("<Rm>, <shift> <Rs>") */
1606 {
1607 uint8_t Rs = (opcode & 0xf00) >> 8;
1608
1609 instruction->info.data_proc.variant = 2;
1610 instruction->info.data_proc.shifter_operand.register_shift.Rm = Rm;
1611 instruction->info.data_proc.shifter_operand.register_shift.Rs = Rs;
1612 instruction->info.data_proc.shifter_operand.register_shift.shift = shift;
1613
1614 if (shift == 0x0) /* LSL */
1615 {
1616 snprintf(shifter_operand, 32, "r%i, LSL r%i", Rm, Rs);
1617 }
1618 else if (shift == 0x1) /* LSR */
1619 {
1620 snprintf(shifter_operand, 32, "r%i, LSR r%i", Rm, Rs);
1621 }
1622 else if (shift == 0x2) /* ASR */
1623 {
1624 snprintf(shifter_operand, 32, "r%i, ASR r%i", Rm, Rs);
1625 }
1626 else if (shift == 0x3) /* ROR */
1627 {
1628 snprintf(shifter_operand, 32, "r%i, ROR r%i", Rm, Rs);
1629 }
1630 }
1631 }
1632
1633 if ((op < 0x8) || (op == 0xc) || (op == 0xe)) /* <opcode3>{<cond>}{S} <Rd>, <Rn>, <shifter_operand> */
1634 {
1635 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, r%i, %s",
1636 address, opcode, mnemonic, COND(opcode),
1637 (S) ? "S" : "", Rd, Rn, shifter_operand);
1638 }
1639 else if ((op == 0xd) || (op == 0xf)) /* <opcode1>{<cond>}{S} <Rd>, <shifter_operand> */
1640 {
1641 if (opcode == 0xe1a00000) /* print MOV r0,r0 as NOP */
1642 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tNOP",address, opcode);
1643 else
1644 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, %s",
1645 address, opcode, mnemonic, COND(opcode),
1646 (S) ? "S" : "", Rd, shifter_operand);
1647 }
1648 else /* <opcode2>{<cond>} <Rn>, <shifter_operand> */
1649 {
1650 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s r%i, %s",
1651 address, opcode, mnemonic, COND(opcode),
1652 Rn, shifter_operand);
1653 }
1654
1655 return ERROR_OK;
1656 }
1657
1658 int arm_evaluate_opcode(uint32_t opcode, uint32_t address,
1659 struct arm_instruction *instruction)
1660 {
1661 /* clear fields, to avoid confusion */
1662 memset(instruction, 0, sizeof(struct arm_instruction));
1663 instruction->opcode = opcode;
1664 instruction->instruction_size = 4;
1665
1666 /* catch opcodes with condition field [31:28] = b1111 */
1667 if ((opcode & 0xf0000000) == 0xf0000000)
1668 {
1669 /* Undefined instruction (or ARMv5E cache preload PLD) */
1670 if ((opcode & 0x08000000) == 0x00000000)
1671 return evaluate_pld(opcode, address, instruction);
1672
1673 /* Undefined instruction (or ARMv6+ SRS/RFE) */
1674 if ((opcode & 0x0e000000) == 0x08000000)
1675 return evaluate_srs(opcode, address, instruction);
1676
1677 /* Branch and branch with link and change to Thumb */
1678 if ((opcode & 0x0e000000) == 0x0a000000)
1679 return evaluate_blx_imm(opcode, address, instruction);
1680
1681 /* Extended coprocessor opcode space (ARMv5 and higher)*/
1682 /* Coprocessor load/store and double register transfers */
1683 if ((opcode & 0x0e000000) == 0x0c000000)
1684 return evaluate_ldc_stc_mcrr_mrrc(opcode, address, instruction);
1685
1686 /* Coprocessor data processing */
1687 if ((opcode & 0x0f000100) == 0x0c000000)
1688 return evaluate_cdp_mcr_mrc(opcode, address, instruction);
1689
1690 /* Coprocessor register transfers */
1691 if ((opcode & 0x0f000010) == 0x0c000010)
1692 return evaluate_cdp_mcr_mrc(opcode, address, instruction);
1693
1694 /* Undefined instruction */
1695 if ((opcode & 0x0f000000) == 0x0f000000)
1696 {
1697 instruction->type = ARM_UNDEFINED_INSTRUCTION;
1698 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tUNDEFINED INSTRUCTION", address, opcode);
1699 return ERROR_OK;
1700 }
1701 }
1702
1703 /* catch opcodes with [27:25] = b000 */
1704 if ((opcode & 0x0e000000) == 0x00000000)
1705 {
1706 /* Multiplies, extra load/stores */
1707 if ((opcode & 0x00000090) == 0x00000090)
1708 return evaluate_mul_and_extra_ld_st(opcode, address, instruction);
1709
1710 /* Miscellaneous instructions */
1711 if ((opcode & 0x0f900000) == 0x01000000)
1712 return evaluate_misc_instr(opcode, address, instruction);
1713
1714 return evaluate_data_proc(opcode, address, instruction);
1715 }
1716
1717 /* catch opcodes with [27:25] = b001 */
1718 if ((opcode & 0x0e000000) == 0x02000000)
1719 {
1720 /* Undefined instruction */
1721 if ((opcode & 0x0fb00000) == 0x03000000)
1722 {
1723 instruction->type = ARM_UNDEFINED_INSTRUCTION;
1724 snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tUNDEFINED INSTRUCTION", address, opcode);
1725 return ERROR_OK;
1726 }
1727
1728 /* Move immediate to status register */
1729 if ((opcode & 0x0fb00000) == 0x03200000)
1730 return evaluate_mrs_msr(opcode, address, instruction);
1731
1732 return evaluate_data_proc(opcode, address, instruction);
1733
1734 }
1735
1736 /* catch opcodes with [27:25] = b010 */
1737 if ((opcode & 0x0e000000) == 0x04000000)
1738 {
1739 /* Load/store immediate offset */
1740 return evaluate_load_store(opcode, address, instruction);
1741 }
1742
1743 /* catch opcodes with [27:25] = b011 */
1744 if ((opcode & 0x0e000000) == 0x06000000)
1745 {
1746 /* Load/store register offset */
1747 if ((opcode & 0x00000010) == 0x00000000)
1748 return evaluate_load_store(opcode, address, instruction);
1749
1750 /* Architecturally Undefined instruction
1751 * ... don't expect these to ever be used
1752 */
1753 if ((opcode & 0x07f000f0) == 0x07f000f0)
1754 {
1755 instruction->type = ARM_UNDEFINED_INSTRUCTION;
1756 snprintf(instruction->text, 128,
1757 "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tUNDEF",
1758 address, opcode);
1759 return ERROR_OK;
1760 }
1761
1762 /* "media" instructions */
1763 return evaluate_media(opcode, address, instruction);
1764 }
1765
1766 /* catch opcodes with [27:25] = b100 */
1767 if ((opcode & 0x0e000000) == 0x08000000)
1768 {
1769 /* Load/store multiple */
1770 return evaluate_ldm_stm(opcode, address, instruction);
1771 }
1772
1773 /* catch opcodes with [27:25] = b101 */
1774 if ((opcode & 0x0e000000) == 0x0a000000)
1775 {
1776 /* Branch and branch with link */
1777 return evaluate_b_bl(opcode, address, instruction);
1778 }
1779
1780 /* catch opcodes with [27:25] = b110 */
1781 if ((opcode & 0x0e000000) == 0x0c000000)
1782 {
1783 /* Coprocessor load/store and double register transfers */
1784 return evaluate_ldc_stc_mcrr_mrrc(opcode, address, instruction);
1785 }
1786
1787 /* catch opcodes with [27:25] = b111 */
1788 if ((opcode & 0x0e000000) == 0x0e000000)
1789 {
1790 /* Software interrupt */
1791 if ((opcode & 0x0f000000) == 0x0f000000)
1792 return evaluate_swi(opcode, address, instruction);
1793
1794 /* Coprocessor data processing */
1795 if ((opcode & 0x0f000010) == 0x0e000000)
1796 return evaluate_cdp_mcr_mrc(opcode, address, instruction);
1797
1798 /* Coprocessor register transfers */
1799 if ((opcode & 0x0f000010) == 0x0e000010)
1800 return evaluate_cdp_mcr_mrc(opcode, address, instruction);
1801 }
1802
1803 LOG_ERROR("ARM: should never reach this point (opcode=%08x)",
1804 (unsigned) opcode);
1805 return -1;
1806 }
1807
1808 static int evaluate_b_bl_blx_thumb(uint16_t opcode,
1809 uint32_t address, struct arm_instruction *instruction)
1810 {
1811 uint32_t offset = opcode & 0x7ff;
1812 uint32_t opc = (opcode >> 11) & 0x3;
1813 uint32_t target_address;
1814 char *mnemonic = NULL;
1815
1816 /* sign extend 11-bit offset */
1817 if (((opc == 0) || (opc == 2)) && (offset & 0x00000400))
1818 offset = 0xfffff800 | offset;
1819
1820 target_address = address + 4 + (offset << 1);
1821
1822 switch (opc)
1823 {
1824 /* unconditional branch */
1825 case 0:
1826 instruction->type = ARM_B;
1827 mnemonic = "B";
1828 break;
1829 /* BLX suffix */
1830 case 1:
1831 instruction->type = ARM_BLX;
1832 mnemonic = "BLX";
1833 target_address &= 0xfffffffc;
1834 break;
1835 /* BL/BLX prefix */
1836 case 2:
1837 instruction->type = ARM_UNKNOWN_INSTUCTION;
1838 mnemonic = "prefix";
1839 target_address = offset << 12;
1840 break;
1841 /* BL suffix */
1842 case 3:
1843 instruction->type = ARM_BL;
1844 mnemonic = "BL";
1845 break;
1846 }
1847
1848 /* TODO: deal correctly with dual opcode (prefixed) BL/BLX;
1849 * these are effectively 32-bit instructions even in Thumb1. For
1850 * disassembly, it's simplest to always use the Thumb2 decoder.
1851 *
1852 * But some cores will evidently handle them as two instructions,
1853 * where exceptions may occur between the two. The ETMv3.2+ ID
1854 * register has a bit which exposes this behavior.
1855 */
1856
1857 snprintf(instruction->text, 128,
1858 "0x%8.8" PRIx32 " 0x%4.4x \t%s\t%#8.8" PRIx32,
1859 address, opcode, mnemonic, target_address);
1860
1861 instruction->info.b_bl_bx_blx.reg_operand = -1;
1862 instruction->info.b_bl_bx_blx.target_address = target_address;
1863
1864 return ERROR_OK;
1865 }
1866
1867 static int evaluate_add_sub_thumb(uint16_t opcode,
1868 uint32_t address, struct arm_instruction *instruction)
1869 {
1870 uint8_t Rd = (opcode >> 0) & 0x7;
1871 uint8_t Rn = (opcode >> 3) & 0x7;
1872 uint8_t Rm_imm = (opcode >> 6) & 0x7;
1873 uint32_t opc = opcode & (1 << 9);
1874 uint32_t reg_imm = opcode & (1 << 10);
1875 char *mnemonic;
1876
1877 if (opc)
1878 {
1879 instruction->type = ARM_SUB;
1880 mnemonic = "SUBS";
1881 }
1882 else
1883 {
1884 /* REVISIT: if reg_imm == 0, display as "MOVS" */
1885 instruction->type = ARM_ADD;
1886 mnemonic = "ADDS";
1887 }
1888
1889 instruction->info.data_proc.Rd = Rd;
1890 instruction->info.data_proc.Rn = Rn;
1891 instruction->info.data_proc.S = 1;
1892
1893 if (reg_imm)
1894 {
1895 instruction->info.data_proc.variant = 0; /*immediate*/
1896 instruction->info.data_proc.shifter_operand.immediate.immediate = Rm_imm;
1897 snprintf(instruction->text, 128,
1898 "0x%8.8" PRIx32 " 0x%4.4x \t%s\tr%i, r%i, #%d",
1899 address, opcode, mnemonic, Rd, Rn, Rm_imm);
1900 }
1901 else
1902 {
1903 instruction->info.data_proc.variant = 1; /*immediate shift*/
1904 instruction->info.data_proc.shifter_operand.immediate_shift.Rm = Rm_imm;
1905 snprintf(instruction->text, 128,
1906 "0x%8.8" PRIx32 " 0x%4.4x \t%s\tr%i, r%i, r%i",
1907 address, opcode, mnemonic, Rd, Rn, Rm_imm);
1908 }
1909
1910 return ERROR_OK;
1911 }
1912
1913 static int evaluate_shift_imm_thumb(uint16_t opcode,
1914 uint32_t address, struct arm_instruction *instruction)
1915 {
1916 uint8_t Rd = (opcode >> 0) & 0x7;
1917 uint8_t Rm = (opcode >> 3) & 0x7;
1918 uint8_t imm = (opcode >> 6) & 0x1f;
1919 uint8_t opc = (opcode >> 11) & 0x3;
1920 char *mnemonic = NULL;
1921
1922 switch (opc)
1923 {
1924 case 0:
1925 instruction->type = ARM_MOV;
1926 mnemonic = "LSLS";
1927 instruction->info.data_proc.shifter_operand.immediate_shift.shift = 0;
1928 break;
1929 case 1:
1930 instruction->type = ARM_MOV;
1931 mnemonic = "LSRS";
1932 instruction->info.data_proc.shifter_operand.immediate_shift.shift = 1;
1933 break;
1934 case 2:
1935 instruction->type = ARM_MOV;
1936 mnemonic = "ASRS";
1937 instruction->info.data_proc.shifter_operand.immediate_shift.shift = 2;
1938 break;
1939 }
1940
1941 if ((imm == 0) && (opc != 0))
1942 imm = 32;
1943
1944 instruction->info.data_proc.Rd = Rd;
1945 instruction->info.data_proc.Rn = -1;
1946 instruction->info.data_proc.S = 1;
1947
1948 instruction->info.data_proc.variant = 1; /*immediate_shift*/
1949 instruction->info.data_proc.shifter_operand.immediate_shift.Rm = Rm;
1950 instruction->info.data_proc.shifter_operand.immediate_shift.shift_imm = imm;
1951
1952 snprintf(instruction->text, 128,
1953 "0x%8.8" PRIx32 " 0x%4.4x \t%s\tr%i, r%i, #%#2.2x" ,
1954 address, opcode, mnemonic, Rd, Rm, imm);
1955
1956 return ERROR_OK;
1957 }
1958
1959 static int evaluate_data_proc_imm_thumb(uint16_t opcode,
1960 uint32_t address, struct arm_instruction *instruction)
1961 {
1962 uint8_t imm = opcode & 0xff;
1963 uint8_t Rd = (opcode >> 8) & 0x7;
1964 uint32_t opc = (opcode >> 11) & 0x3;
1965 char *mnemonic = NULL;
1966
1967 instruction->info.data_proc.Rd = Rd;
1968 instruction->info.data_proc.Rn = Rd;
1969 instruction->info.data_proc.S = 1;
1970 instruction->info.data_proc.variant = 0; /*immediate*/
1971 instruction->info.data_proc.shifter_operand.immediate.immediate = imm;
1972
1973 switch (opc)
1974 {
1975 case 0:
1976 instruction->type = ARM_MOV;
1977 mnemonic = "MOVS";
1978 instruction->info.data_proc.Rn = -1;
1979 break;
1980 case 1:
1981 instruction->type = ARM_CMP;
1982 mnemonic = "CMP";
1983 instruction->info.data_proc.Rd = -1;
1984 break;
1985 case 2:
1986 instruction->type = ARM_ADD;
1987 mnemonic = "ADDS";
1988 break;
1989 case 3:
1990 instruction->type = ARM_SUB;
1991 mnemonic = "SUBS";
1992 break;
1993 }
1994
1995 snprintf(instruction->text, 128,
1996 "0x%8.8" PRIx32 " 0x%4.4x \t%s\tr%i, #%#2.2x",
1997 address, opcode, mnemonic, Rd, imm);
1998
1999 return ERROR_OK;
2000 }
2001
2002 static int evaluate_data_proc_thumb(uint16_t opcode,
2003 uint32_t address, struct arm_instruction *instruction)
2004 {
2005 uint8_t high_reg, op, Rm, Rd,H1,H2;
2006 char *mnemonic = NULL;
2007 bool nop = false;
2008
2009 high_reg = (opcode & 0x0400) >> 10;
2010 op = (opcode & 0x03C0) >> 6;
2011
2012 Rd = (opcode & 0x0007);
2013 Rm = (opcode & 0x0038) >> 3;
2014 H1 = (opcode & 0x0080) >> 7;
2015 H2 = (opcode & 0x0040) >> 6;
2016
2017 instruction->info.data_proc.Rd = Rd;
2018 instruction->info.data_proc.Rn = Rd;
2019 instruction->info.data_proc.S = (!high_reg || (instruction->type == ARM_CMP));
2020 instruction->info.data_proc.variant = 1 /*immediate shift*/;
2021 instruction->info.data_proc.shifter_operand.immediate_shift.Rm = Rm;
2022
2023 if (high_reg)
2024 {
2025 Rd |= H1 << 3;
2026 Rm |= H2 << 3;
2027 op >>= 2;
2028
2029 switch (op)
2030 {
2031 case 0x0:
2032 instruction->type = ARM_ADD;
2033 mnemonic = "ADD";
2034 break;
2035 case 0x1:
2036 instruction->type = ARM_CMP;
2037 mnemonic = "CMP";
2038 break;
2039 case 0x2:
2040 instruction->type = ARM_MOV;
2041 mnemonic = "MOV";
2042 if (Rd == Rm)
2043 nop = true;
2044 break;
2045 case 0x3:
2046 if ((opcode & 0x7) == 0x0)
2047 {
2048 instruction->info.b_bl_bx_blx.reg_operand = Rm;
2049 if (H1)
2050 {
2051 instruction->type = ARM_BLX;
2052 snprintf(instruction->text, 128,
2053 "0x%8.8" PRIx32
2054 " 0x%4.4x \tBLX\tr%i",
2055 address, opcode, Rm);
2056 }
2057 else
2058 {
2059 instruction->type = ARM_BX;
2060 snprintf(instruction->text, 128,
2061 "0x%8.8" PRIx32
2062 " 0x%4.4x \tBX\tr%i",
2063 address, opcode, Rm);
2064 }
2065 }
2066 else
2067 {
2068 instruction->type = ARM_UNDEFINED_INSTRUCTION;
2069 snprintf(instruction->text, 128,
2070 "0x%8.8" PRIx32
2071 " 0x%4.4x \t"
2072 "UNDEFINED INSTRUCTION",
2073 address, opcode);
2074 }
2075 return ERROR_OK;
2076 break;
2077 }
2078 }
2079 else
2080 {
2081 switch (op)
2082 {
2083 case 0x0:
2084 instruction->type = ARM_AND;
2085 mnemonic = "ANDS";
2086 break;
2087 case 0x1:
2088 instruction->type = ARM_EOR;
2089 mnemonic = "EORS";
2090 break;
2091 case 0x2:
2092 instruction->type = ARM_MOV;
2093 mnemonic = "LSLS";
2094 instruction->info.data_proc.variant = 2 /*register shift*/;
2095 instruction->info.data_proc.shifter_operand.register_shift.shift = 0;
2096 instruction->info.data_proc.shifter_operand.register_shift.Rm = Rd;
2097 instruction->info.data_proc.shifter_operand.register_shift.Rs = Rm;
2098 break;
2099 case 0x3:
2100 instruction->type = ARM_MOV;
2101 mnemonic = "LSRS";
2102 instruction->info.data_proc.variant = 2 /*register shift*/;
2103 instruction->info.data_proc.shifter_operand.register_shift.shift = 1;
2104 instruction->info.data_proc.shifter_operand.register_shift.Rm = Rd;
2105 instruction->info.data_proc.shifter_operand.register_shift.Rs = Rm;
2106 break;
2107 case 0x4:
2108 instruction->type = ARM_MOV;
2109 mnemonic = "ASRS";
2110 instruction->info.data_proc.variant = 2 /*register shift*/;
2111 instruction->info.data_proc.shifter_operand.register_shift.shift = 2;
2112 instruction->info.data_proc.shifter_operand.register_shift.Rm = Rd;
2113 instruction->info.data_proc.shifter_operand.register_shift.Rs = Rm;
2114 break;
2115 case 0x5:
2116 instruction->type = ARM_ADC;
2117 mnemonic = "ADCS";
2118 break;
2119 case 0x6:
2120 instruction->type = ARM_SBC;
2121 mnemonic = "SBCS";
2122 break;
2123 case 0x7:
2124 instruction->type = ARM_MOV;
2125 mnemonic = "RORS";
2126 instruction->info.data_proc.variant = 2 /*register shift*/;
2127 instruction->info.data_proc.shifter_operand.register_shift.shift = 3;
2128 instruction->info.data_proc.shifter_operand.register_shift.Rm = Rd;
2129 instruction->info.data_proc.shifter_operand.register_shift.Rs = Rm;
2130 break;
2131 case 0x8:
2132 instruction->type = ARM_TST;
2133 mnemonic = "TST";
2134 break;
2135 case 0x9:
2136 instruction->type = ARM_RSB;
2137 mnemonic = "RSBS";
2138 instruction->info.data_proc.variant = 0 /*immediate*/;
2139 instruction->info.data_proc.shifter_operand.immediate.immediate = 0;
2140 instruction->info.data_proc.Rn = Rm;
2141 break;
2142 case 0xA:
2143 instruction->type = ARM_CMP;
2144 mnemonic = "CMP";
2145 break;
2146 case 0xB:
2147 instruction->type = ARM_CMN;
2148 mnemonic = "CMN";
2149 break;
2150 case 0xC:
2151 instruction->type = ARM_ORR;
2152 mnemonic = "ORRS";
2153 break;
2154 case 0xD:
2155 instruction->type = ARM_MUL;
2156 mnemonic = "MULS";
2157 break;
2158 case 0xE:
2159 instruction->type = ARM_BIC;
2160 mnemonic = "BICS";
2161 break;
2162 case 0xF:
2163 instruction->type = ARM_MVN;
2164 mnemonic = "MVNS";
2165 break;
2166 }
2167 }
2168
2169 if (nop)
2170 snprintf(instruction->text, 128,
2171 "0x%8.8" PRIx32 " 0x%4.4x \tNOP\t\t\t"
2172 "; (%s r%i, r%i)",
2173 address, opcode, mnemonic, Rd, Rm);
2174 else
2175 snprintf(instruction->text, 128,
2176 "0x%8.8" PRIx32 " 0x%4.4x \t%s\tr%i, r%i",
2177 address, opcode, mnemonic, Rd, Rm);
2178
2179 return ERROR_OK;
2180 }
2181
2182 /* PC-relative data addressing is word-aligned even with Thumb */
2183 static inline uint32_t thumb_alignpc4(uint32_t addr)
2184 {
2185 return (addr + 4) & ~3;
2186 }
2187
2188 static int evaluate_load_literal_thumb(uint16_t opcode,
2189 uint32_t address, struct arm_instruction *instruction)
2190 {
2191 uint32_t immediate;
2192 uint8_t Rd = (opcode >> 8) & 0x7;
2193
2194 instruction->type = ARM_LDR;
2195 immediate = opcode & 0x000000ff;
2196 immediate *= 4;
2197
2198 instruction->info.load_store.Rd = Rd;
2199 instruction->info.load_store.Rn = 15 /*PC*/;
2200 instruction->info.load_store.index_mode = 0; /*offset*/
2201 instruction->info.load_store.offset_mode = 0; /*immediate*/
2202 instruction->info.load_store.offset.offset = immediate;
2203
2204 snprintf(instruction->text, 128,
2205 "0x%8.8" PRIx32 " 0x%4.4x \t"
2206 "LDR\tr%i, [pc, #%#" PRIx32 "]\t; %#8.8" PRIx32,
2207 address, opcode, Rd, immediate,
2208 thumb_alignpc4(address) + immediate);
2209
2210 return ERROR_OK;
2211 }
2212
2213 static int evaluate_load_store_reg_thumb(uint16_t opcode,
2214 uint32_t address, struct arm_instruction *instruction)
2215 {
2216 uint8_t Rd = (opcode >> 0) & 0x7;
2217 uint8_t Rn = (opcode >> 3) & 0x7;
2218 uint8_t Rm = (opcode >> 6) & 0x7;
2219 uint8_t opc = (opcode >> 9) & 0x7;
2220 char *mnemonic = NULL;
2221
2222 switch (opc)
2223 {
2224 case 0:
2225 instruction->type = ARM_STR;
2226 mnemonic = "STR";
2227 break;
2228 case 1:
2229 instruction->type = ARM_STRH;
2230 mnemonic = "STRH";
2231 break;
2232 case 2:
2233 instruction->type = ARM_STRB;
2234 mnemonic = "STRB";
2235 break;
2236 case 3:
2237 instruction->type = ARM_LDRSB;
2238 mnemonic = "LDRSB";
2239 break;
2240 case 4:
2241 instruction->type = ARM_LDR;
2242 mnemonic = "LDR";
2243 break;
2244 case 5:
2245 instruction->type = ARM_LDRH;
2246 mnemonic = "LDRH";
2247 break;
2248 case 6:
2249 instruction->type = ARM_LDRB;
2250 mnemonic = "LDRB";
2251 break;
2252 case 7:
2253 instruction->type = ARM_LDRSH;
2254 mnemonic = "LDRSH";
2255 break;
2256 }
2257
2258 snprintf(instruction->text, 128,
2259 "0x%8.8" PRIx32 " 0x%4.4x \t%s\tr%i, [r%i, r%i]",
2260 address, opcode, mnemonic, Rd, Rn, Rm);
2261
2262 instruction->info.load_store.Rd = Rd;
2263 instruction->info.load_store.Rn = Rn;
2264 instruction->info.load_store.index_mode = 0; /*offset*/
2265 instruction->info.load_store.offset_mode = 1; /*register*/
2266 instruction->info.load_store.offset.reg.Rm = Rm;
2267
2268 return ERROR_OK;
2269 }
2270
2271 static int evaluate_load_store_imm_thumb(uint16_t opcode,
2272 uint32_t address, struct arm_instruction *instruction)
2273 {
2274 uint32_t offset = (opcode >> 6) & 0x1f;
2275 uint8_t Rd = (opcode >> 0) & 0x7;
2276 uint8_t Rn = (opcode >> 3) & 0x7;
2277 uint32_t L = opcode & (1 << 11);
2278 uint32_t B = opcode & (1 << 12);
2279 char *mnemonic;
2280 char suffix = ' ';
2281 uint32_t shift = 2;
2282
2283 if (L)
2284 {
2285 instruction->type = ARM_LDR;
2286 mnemonic = "LDR";
2287 }
2288 else
2289 {
2290 instruction->type = ARM_STR;
2291 mnemonic = "STR";
2292 }
2293
2294 if ((opcode&0xF000) == 0x8000)
2295 {
2296 suffix = 'H';
2297 shift = 1;
2298 }
2299 else if (B)
2300 {
2301 suffix = 'B';
2302 shift = 0;
2303 }
2304
2305 snprintf(instruction->text, 128,
2306 "0x%8.8" PRIx32 " 0x%4.4x \t%s%c\tr%i, [r%i, #%#" PRIx32 "]",
2307 address, opcode, mnemonic, suffix, Rd, Rn, offset << shift);
2308
2309 instruction->info.load_store.Rd = Rd;
2310 instruction->info.load_store.Rn = Rn;
2311 instruction->info.load_store.index_mode = 0; /*offset*/
2312 instruction->info.load_store.offset_mode = 0; /*immediate*/
2313 instruction->info.load_store.offset.offset = offset << shift;
2314
2315 return ERROR_OK;
2316 }
2317
2318 static int evaluate_load_store_stack_thumb(uint16_t opcode,
2319 uint32_t address, struct arm_instruction *instruction)
2320 {
2321 uint32_t offset = opcode & 0xff;
2322 uint8_t Rd = (opcode >> 8) & 0x7;
2323 uint32_t L = opcode & (1 << 11);
2324 char *mnemonic;
2325
2326 if (L)
2327 {
2328 instruction->type = ARM_LDR;
2329 mnemonic = "LDR";
2330 }
2331 else
2332 {
2333 instruction->type = ARM_STR;
2334 mnemonic = "STR";
2335 }
2336
2337 snprintf(instruction->text, 128,
2338 "0x%8.8" PRIx32 " 0x%4.4x \t%s\tr%i, [SP, #%#" PRIx32 "]",
2339 address, opcode, mnemonic, Rd, offset*4);
2340
2341 instruction->info.load_store.Rd = Rd;
2342 instruction->info.load_store.Rn = 13 /*SP*/;
2343 instruction->info.load_store.index_mode = 0; /*offset*/
2344 instruction->info.load_store.offset_mode = 0; /*immediate*/
2345 instruction->info.load_store.offset.offset = offset*4;
2346
2347 return ERROR_OK;
2348 }
2349
2350 static int evaluate_add_sp_pc_thumb(uint16_t opcode,
2351 uint32_t address, struct arm_instruction *instruction)
2352 {
2353 uint32_t imm = opcode & 0xff;
2354 uint8_t Rd = (opcode >> 8) & 0x7;
2355 uint8_t Rn;
2356 uint32_t SP = opcode & (1 << 11);
2357 const char *reg_name;
2358
2359 instruction->type = ARM_ADD;
2360
2361 if (SP)
2362 {
2363 reg_name = "SP";
2364 Rn = 13;
2365 }
2366 else
2367 {
2368 reg_name = "PC";
2369 Rn = 15;
2370 }
2371
2372 snprintf(instruction->text, 128,
2373 "0x%8.8" PRIx32 " 0x%4.4x \tADD\tr%i, %s, #%#" PRIx32,
2374 address, opcode, Rd, reg_name, imm * 4);
2375
2376 instruction->info.data_proc.variant = 0 /* immediate */;
2377 instruction->info.data_proc.Rd = Rd;
2378 instruction->info.data_proc.Rn = Rn;
2379 instruction->info.data_proc.shifter_operand.immediate.immediate = imm*4;
2380
2381 return ERROR_OK;
2382 }
2383
2384 static int evaluate_adjust_stack_thumb(uint16_t opcode,
2385 uint32_t address, struct arm_instruction *instruction)
2386 {
2387 uint32_t imm = opcode & 0x7f;
2388 uint8_t opc = opcode & (1 << 7);
2389 char *mnemonic;
2390
2391
2392 if (opc)
2393 {
2394 instruction->type = ARM_SUB;
2395 mnemonic = "SUB";
2396 }
2397 else
2398 {
2399 instruction->type = ARM_ADD;
2400 mnemonic = "ADD";
2401 }
2402
2403 snprintf(instruction->text, 128,
2404 "0x%8.8" PRIx32 " 0x%4.4x \t%s\tSP, #%#" PRIx32,
2405 address, opcode, mnemonic, imm*4);
2406
2407 instruction->info.data_proc.variant = 0 /* immediate */;
2408 instruction->info.data_proc.Rd = 13 /*SP*/;
2409 instruction->info.data_proc.Rn = 13 /*SP*/;
2410 instruction->info.data_proc.shifter_operand.immediate.immediate = imm*4;
2411
2412 return ERROR_OK;
2413 }
2414
2415 static int evaluate_breakpoint_thumb(uint16_t opcode,
2416 uint32_t address, struct arm_instruction *instruction)
2417 {
2418 uint32_t imm = opcode & 0xff;
2419
2420 instruction->type = ARM_BKPT;
2421
2422 snprintf(instruction->text, 128,
2423 "0x%8.8" PRIx32 " 0x%4.4x \tBKPT\t%#2.2" PRIx32 "",
2424 address, opcode, imm);
2425
2426 return ERROR_OK;
2427 }
2428
2429 static int evaluate_load_store_multiple_thumb(uint16_t opcode,
2430 uint32_t address, struct arm_instruction *instruction)
2431 {
2432 uint32_t reg_list = opcode & 0xff;
2433 uint32_t L = opcode & (1 << 11);
2434 uint32_t R = opcode & (1 << 8);
2435 uint8_t Rn = (opcode >> 8) & 7;
2436 uint8_t addr_mode = 0 /* IA */;
2437 char reg_names[40];
2438 char *reg_names_p;
2439 char *mnemonic;
2440 char ptr_name[7] = "";
2441 int i;
2442
2443 /* REVISIT: in ThumbEE mode, there are no LDM or STM instructions.
2444 * The STMIA and LDMIA opcodes are used for other instructions.
2445 */
2446
2447 if ((opcode & 0xf000) == 0xc000)
2448 { /* generic load/store multiple */
2449 char *wback = "!";
2450
2451 if (L)
2452 {
2453 instruction->type = ARM_LDM;
2454 mnemonic = "LDM";
2455 if (opcode & (1 << Rn))
2456 wback = "";
2457 }
2458 else
2459 {
2460 instruction->type = ARM_STM;
2461 mnemonic = "STM";
2462 }
2463 snprintf(ptr_name, sizeof ptr_name, "r%i%s, ", Rn, wback);
2464 }
2465 else
2466 { /* push/pop */
2467 Rn = 13; /* SP */
2468 if (L)
2469 {
2470 instruction->type = ARM_LDM;
2471 mnemonic = "POP";
2472 if (R)
2473 reg_list |= (1 << 15) /*PC*/;
2474 }
2475 else
2476 {
2477 instruction->type = ARM_STM;
2478 mnemonic = "PUSH";
2479 addr_mode = 3; /*DB*/
2480 if (R)
2481 reg_list |= (1 << 14) /*LR*/;
2482 }
2483 }
2484
2485 reg_names_p = reg_names;
2486 for (i = 0; i <= 15; i++)
2487 {
2488 if (reg_list & (1 << i))
2489 reg_names_p += snprintf(reg_names_p, (reg_names + 40 - reg_names_p), "r%i, ", i);
2490 }
2491 if (reg_names_p > reg_names)
2492 reg_names_p[-2] = '\0';
2493 else /* invalid op : no registers */
2494 reg_names[0] = '\0';
2495
2496 snprintf(instruction->text, 128,
2497 "0x%8.8" PRIx32 " 0x%4.4x \t%s\t%s{%s}",
2498 address, opcode, mnemonic, ptr_name, reg_names);
2499
2500 instruction->info.load_store_multiple.register_list = reg_list;
2501 instruction->info.load_store_multiple.Rn = Rn;
2502 instruction->info.load_store_multiple.addressing_mode = addr_mode;
2503
2504 return ERROR_OK;
2505 }
2506
2507 static int evaluate_cond_branch_thumb(uint16_t opcode,
2508 uint32_t address, struct arm_instruction *instruction)
2509 {
2510 uint32_t offset = opcode & 0xff;
2511 uint8_t cond = (opcode >> 8) & 0xf;
2512 uint32_t target_address;
2513
2514 if (cond == 0xf)
2515 {
2516 instruction->type = ARM_SWI;
2517 snprintf(instruction->text, 128,
2518 "0x%8.8" PRIx32 " 0x%4.4x \tSVC\t%#2.2" PRIx32,
2519 address, opcode, offset);
2520 return ERROR_OK;
2521 }
2522 else if (cond == 0xe)
2523 {
2524 instruction->type = ARM_UNDEFINED_INSTRUCTION;
2525 snprintf(instruction->text, 128,
2526 "0x%8.8" PRIx32 " 0x%4.4x \tUNDEFINED INSTRUCTION",
2527 address, opcode);
2528 return ERROR_OK;
2529 }
2530
2531 /* sign extend 8-bit offset */
2532 if (offset & 0x00000080)
2533 offset = 0xffffff00 | offset;
2534
2535 target_address = address + 4 + (offset << 1);
2536
2537 snprintf(instruction->text, 128,
2538 "0x%8.8" PRIx32 " 0x%4.4x \tB%s\t%#8.8" PRIx32,
2539 address, opcode,
2540 arm_condition_strings[cond], target_address);
2541
2542 instruction->type = ARM_B;
2543 instruction->info.b_bl_bx_blx.reg_operand = -1;
2544 instruction->info.b_bl_bx_blx.target_address = target_address;
2545
2546 return ERROR_OK;
2547 }
2548
2549 static int evaluate_cb_thumb(uint16_t opcode, uint32_t address,
2550 struct arm_instruction *instruction)
2551 {
2552 unsigned offset;
2553
2554 /* added in Thumb2 */
2555 offset = (opcode >> 3) & 0x1f;
2556 offset |= (opcode & 0x0200) >> 4;
2557
2558 snprintf(instruction->text, 128,
2559 "0x%8.8" PRIx32 " 0x%4.4x \tCB%sZ\tr%d, %#8.8" PRIx32,
2560 address, opcode,
2561 (opcode & 0x0800) ? "N" : "",
2562 opcode & 0x7, address + 4 + (offset << 1));
2563
2564 return ERROR_OK;
2565 }
2566
2567 static int evaluate_extend_thumb(uint16_t opcode, uint32_t address,
2568 struct arm_instruction *instruction)
2569 {
2570 /* added in ARMv6 */
2571 snprintf(instruction->text, 128,
2572 "0x%8.8" PRIx32 " 0x%4.4x \t%cXT%c\tr%d, r%d",
2573 address, opcode,
2574 (opcode & 0x0080) ? 'U' : 'S',
2575 (opcode & 0x0040) ? 'B' : 'H',
2576 opcode & 0x7, (opcode >> 3) & 0x7);
2577
2578 return ERROR_OK;
2579 }
2580
2581 static int evaluate_cps_thumb(uint16_t opcode, uint32_t address,
2582 struct arm_instruction *instruction)
2583 {
2584 /* added in ARMv6 */
2585 if ((opcode & 0x0ff0) == 0x0650)
2586 snprintf(instruction->text, 128,
2587 "0x%8.8" PRIx32 " 0x%4.4x \tSETEND %s",
2588 address, opcode,
2589 (opcode & 0x80) ? "BE" : "LE");
2590 else /* ASSUME (opcode & 0x0fe0) == 0x0660 */
2591 snprintf(instruction->text, 128,
2592 "0x%8.8" PRIx32 " 0x%4.4x \tCPSI%c\t%s%s%s",
2593 address, opcode,
2594 (opcode & 0x0010) ? 'D' : 'E',
2595 (opcode & 0x0004) ? "A" : "",
2596 (opcode & 0x0002) ? "I" : "",
2597 (opcode & 0x0001) ? "F" : "");
2598
2599 return ERROR_OK;
2600 }
2601
2602 static int evaluate_byterev_thumb(uint16_t opcode, uint32_t address,
2603 struct arm_instruction *instruction)
2604 {
2605 char *suffix;
2606
2607 /* added in ARMv6 */
2608 switch ((opcode >> 6) & 3) {
2609 case 0:
2610 suffix = "";
2611 break;
2612 case 1:
2613 suffix = "16";
2614 break;
2615 default:
2616 suffix = "SH";
2617 break;
2618 }
2619 snprintf(instruction->text, 128,
2620 "0x%8.8" PRIx32 " 0x%4.4x \tREV%s\tr%d, r%d",
2621 address, opcode, suffix,
2622 opcode & 0x7, (opcode >> 3) & 0x7);
2623
2624 return ERROR_OK;
2625 }
2626
2627 static int evaluate_hint_thumb(uint16_t opcode, uint32_t address,
2628 struct arm_instruction *instruction)
2629 {
2630 char *hint;
2631
2632 switch ((opcode >> 4) & 0x0f) {
2633 case 0:
2634 hint = "NOP";
2635 break;
2636 case 1:
2637 hint = "YIELD";
2638 break;
2639 case 2:
2640 hint = "WFE";
2641 break;
2642 case 3:
2643 hint = "WFI";
2644 break;
2645 case 4:
2646 hint = "SEV";
2647 break;
2648 default:
2649 hint = "HINT (UNRECOGNIZED)";
2650 break;
2651 }
2652
2653 snprintf(instruction->text, 128,
2654 "0x%8.8" PRIx32 " 0x%4.4x \t%s",
2655 address, opcode, hint);
2656
2657 return ERROR_OK;
2658 }
2659
2660 static int evaluate_ifthen_thumb(uint16_t opcode, uint32_t address,
2661 struct arm_instruction *instruction)
2662 {
2663 unsigned cond = (opcode >> 4) & 0x0f;
2664 char *x = "", *y = "", *z = "";
2665
2666 if (opcode & 0x01)
2667 z = (opcode & 0x02) ? "T" : "E";
2668 if (opcode & 0x03)
2669 y = (opcode & 0x04) ? "T" : "E";
2670 if (opcode & 0x07)
2671 x = (opcode & 0x08) ? "T" : "E";
2672
2673 snprintf(instruction->text, 128,
2674 "0x%8.8" PRIx32 " 0x%4.4x \tIT%s%s%s\t%s",
2675 address, opcode,
2676 x, y, z, arm_condition_strings[cond]);
2677
2678 /* NOTE: strictly speaking, the next 1-4 instructions should
2679 * now be displayed with the relevant conditional suffix...
2680 */
2681
2682 return ERROR_OK;
2683 }
2684
2685 int thumb_evaluate_opcode(uint16_t opcode, uint32_t address, struct arm_instruction *instruction)
2686 {
2687 /* clear fields, to avoid confusion */
2688 memset(instruction, 0, sizeof(struct arm_instruction));
2689 instruction->opcode = opcode;
2690 instruction->instruction_size = 2;
2691
2692 if ((opcode & 0xe000) == 0x0000)
2693 {
2694 /* add/substract register or immediate */
2695 if ((opcode & 0x1800) == 0x1800)
2696 return evaluate_add_sub_thumb(opcode, address, instruction);
2697 /* shift by immediate */
2698 else
2699 return evaluate_shift_imm_thumb(opcode, address, instruction);
2700 }
2701
2702 /* Add/substract/compare/move immediate */
2703 if ((opcode & 0xe000) == 0x2000)
2704 {
2705 return evaluate_data_proc_imm_thumb(opcode, address, instruction);
2706 }
2707
2708 /* Data processing instructions */
2709 if ((opcode & 0xf800) == 0x4000)
2710 {
2711 return evaluate_data_proc_thumb(opcode, address, instruction);
2712 }
2713
2714 /* Load from literal pool */
2715 if ((opcode & 0xf800) == 0x4800)
2716 {
2717 return evaluate_load_literal_thumb(opcode, address, instruction);
2718 }
2719
2720 /* Load/Store register offset */
2721 if ((opcode & 0xf000) == 0x5000)
2722 {
2723 return evaluate_load_store_reg_thumb(opcode, address, instruction);
2724 }
2725
2726 /* Load/Store immediate offset */
2727 if (((opcode & 0xe000) == 0x6000)
2728 ||((opcode & 0xf000) == 0x8000))
2729 {
2730 return evaluate_load_store_imm_thumb(opcode, address, instruction);
2731 }
2732
2733 /* Load/Store from/to stack */
2734 if ((opcode & 0xf000) == 0x9000)
2735 {
2736 return evaluate_load_store_stack_thumb(opcode, address, instruction);
2737 }
2738
2739 /* Add to SP/PC */
2740 if ((opcode & 0xf000) == 0xa000)
2741 {
2742 return evaluate_add_sp_pc_thumb(opcode, address, instruction);
2743 }
2744
2745 /* Misc */
2746 if ((opcode & 0xf000) == 0xb000)
2747 {
2748 switch ((opcode >> 8) & 0x0f) {
2749 case 0x0:
2750 return evaluate_adjust_stack_thumb(opcode, address, instruction);
2751 case 0x1:
2752 case 0x3:
2753 case 0x9:
2754 case 0xb:
2755 return evaluate_cb_thumb(opcode, address, instruction);
2756 case 0x2:
2757 return evaluate_extend_thumb(opcode, address, instruction);
2758 case 0x4:
2759 case 0x5:
2760 case 0xc:
2761 case 0xd:
2762 return evaluate_load_store_multiple_thumb(opcode, address,
2763 instruction);
2764 case 0x6:
2765 return evaluate_cps_thumb(opcode, address, instruction);
2766 case 0xa:
2767 if ((opcode & 0x00c0) == 0x0080)
2768 break;
2769 return evaluate_byterev_thumb(opcode, address, instruction);
2770 case 0xe:
2771 return evaluate_breakpoint_thumb(opcode, address, instruction);
2772 case 0xf:
2773 if (opcode & 0x000f)
2774 return evaluate_ifthen_thumb(opcode, address,
2775 instruction);
2776 else
2777 return evaluate_hint_thumb(opcode, address,
2778 instruction);
2779 }
2780
2781 instruction->type = ARM_UNDEFINED_INSTRUCTION;
2782 snprintf(instruction->text, 128,
2783 "0x%8.8" PRIx32 " 0x%4.4x \tUNDEFINED INSTRUCTION",
2784 address, opcode);
2785 return ERROR_OK;
2786 }
2787
2788 /* Load/Store multiple */
2789 if ((opcode & 0xf000) == 0xc000)
2790 {
2791 return evaluate_load_store_multiple_thumb(opcode, address, instruction);
2792 }
2793
2794 /* Conditional branch + SWI */
2795 if ((opcode & 0xf000) == 0xd000)
2796 {
2797 return evaluate_cond_branch_thumb(opcode, address, instruction);
2798 }
2799
2800 if ((opcode & 0xe000) == 0xe000)
2801 {
2802 /* Undefined instructions */
2803 if ((opcode & 0xf801) == 0xe801)
2804 {
2805 instruction->type = ARM_UNDEFINED_INSTRUCTION;
2806 snprintf(instruction->text, 128,
2807 "0x%8.8" PRIx32 " 0x%8.8x\t"
2808 "UNDEFINED INSTRUCTION",
2809 address, opcode);
2810 return ERROR_OK;
2811 }
2812 else
2813 { /* Branch to offset */
2814 return evaluate_b_bl_blx_thumb(opcode, address, instruction);
2815 }
2816 }
2817
2818 LOG_ERROR("Thumb: should never reach this point (opcode=%04x)", opcode);
2819 return -1;
2820 }
2821
2822 static int t2ev_b_bl(uint32_t opcode, uint32_t address,
2823 struct arm_instruction *instruction, char *cp)
2824 {
2825 unsigned offset;
2826 unsigned b21 = 1 << 21;
2827 unsigned b22 = 1 << 22;
2828
2829 /* instead of combining two smaller 16-bit branch instructions,
2830 * Thumb2 uses only one larger 32-bit instruction.
2831 */
2832 offset = opcode & 0x7ff;
2833 offset |= (opcode & 0x03ff0000) >> 5;
2834 if (opcode & (1 << 26)) {
2835 offset |= 0xff << 23;
2836 if ((opcode & (1 << 11)) == 0)
2837 b21 = 0;
2838 if ((opcode & (1 << 13)) == 0)
2839 b22 = 0;
2840 } else {
2841 if (opcode & (1 << 11))
2842 b21 = 0;
2843 if (opcode & (1 << 13))
2844 b22 = 0;
2845 }
2846 offset |= b21;
2847 offset |= b22;
2848
2849
2850 address += 4;
2851 address += offset << 1;
2852
2853 instruction->type = (opcode & (1 << 14)) ? ARM_BL : ARM_B;
2854 instruction->info.b_bl_bx_blx.reg_operand = -1;
2855 instruction->info.b_bl_bx_blx.target_address = address;
2856 sprintf(cp, "%s\t%#8.8" PRIx32,
2857 (opcode & (1 << 14)) ? "BL" : "B.W",
2858 address);
2859
2860 return ERROR_OK;
2861 }
2862
2863 static int t2ev_cond_b(uint32_t opcode, uint32_t address,
2864 struct arm_instruction *instruction, char *cp)
2865 {
2866 unsigned offset;
2867 unsigned b17 = 1 << 17;
2868 unsigned b18 = 1 << 18;
2869 unsigned cond = (opcode >> 22) & 0x0f;
2870
2871 offset = opcode & 0x7ff;
2872 offset |= (opcode & 0x003f0000) >> 5;
2873 if (opcode & (1 << 26)) {
2874 offset |= 0xffff << 19;
2875 if ((opcode & (1 << 11)) == 0)
2876 b17 = 0;
2877 if ((opcode & (1 << 13)) == 0)
2878 b18 = 0;
2879 } else {
2880 if (opcode & (1 << 11))
2881 b17 = 0;
2882 if (opcode & (1 << 13))
2883 b18 = 0;
2884 }
2885 offset |= b17;
2886 offset |= b18;
2887
2888 address += 4;
2889 address += offset << 1;
2890
2891 instruction->type = ARM_B;
2892 instruction->info.b_bl_bx_blx.reg_operand = -1;
2893 instruction->info.b_bl_bx_blx.target_address = address;
2894 sprintf(cp, "B%s.W\t%#8.8" PRIx32,
2895 arm_condition_strings[cond],
2896 address);
2897
2898 return ERROR_OK;
2899 }
2900
2901 static const char *special_name(int number)
2902 {
2903 char *special = "(RESERVED)";
2904
2905 switch (number) {
2906 case 0:
2907 special = "apsr";
2908 break;
2909 case 1:
2910 special = "iapsr";
2911 break;
2912 case 2:
2913 special = "eapsr";
2914 break;
2915 case 3:
2916 special = "xpsr";
2917 break;
2918 case 5:
2919 special = "ipsr";
2920 break;
2921 case 6:
2922 special = "epsr";
2923 break;
2924 case 7:
2925 special = "iepsr";
2926 break;
2927 case 8:
2928 special = "msp";
2929 break;
2930 case 9:
2931 special = "psp";
2932 break;
2933 case 16:
2934 special = "primask";
2935 break;
2936 case 17:
2937 special = "basepri";
2938 break;
2939 case 18:
2940 special = "basepri_max";
2941 break;
2942 case 19:
2943 special = "faultmask";
2944 break;
2945 case 20:
2946 special = "control";
2947 break;
2948 }
2949 return special;
2950 }
2951
2952 static int t2ev_hint(uint32_t opcode, uint32_t address,
2953 struct arm_instruction *instruction, char *cp)
2954 {
2955 const char *mnemonic;
2956
2957 if (opcode & 0x0700) {
2958 instruction->type = ARM_UNDEFINED_INSTRUCTION;
2959 strcpy(cp, "UNDEFINED");
2960 return ERROR_OK;
2961 }
2962
2963 if (opcode & 0x00f0) {
2964 sprintf(cp, "DBG\t#%d", (int) opcode & 0xf);
2965 return ERROR_OK;
2966 }
2967
2968 switch (opcode & 0x0f) {
2969 case 0:
2970 mnemonic = "NOP.W";
2971 break;
2972 case 1:
2973 mnemonic = "YIELD.W";
2974 break;
2975 case 2:
2976 mnemonic = "WFE.W";
2977 break;
2978 case 3:
2979 mnemonic = "WFI.W";
2980 break;
2981 case 4:
2982 mnemonic = "SEV.W";
2983 break;
2984 default:
2985 mnemonic = "HINT.W (UNRECOGNIZED)";
2986 break;
2987 }
2988 strcpy(cp, mnemonic);
2989 return ERROR_OK;
2990 }
2991
2992 static int t2ev_misc(uint32_t opcode, uint32_t address,
2993 struct arm_instruction *instruction, char *cp)
2994 {
2995 const char *mnemonic;
2996
2997 switch ((opcode >> 4) & 0x0f) {
2998 case 0:
2999 mnemonic = "LEAVEX";
3000 break;
3001 case 1:
3002 mnemonic = "ENTERX";
3003 break;
3004 case 2:
3005 mnemonic = "CLREX";
3006 break;
3007 case 4:
3008 mnemonic = "DSB";
3009 break;
3010 case 5:
3011 mnemonic = "DMB";
3012 break;
3013 case 6:
3014 mnemonic = "ISB";
3015 break;
3016 default:
3017 return ERROR_INVALID_ARGUMENTS;
3018 }
3019 strcpy(cp, mnemonic);
3020 return ERROR_OK;
3021 }
3022
3023 static int t2ev_b_misc(uint32_t opcode, uint32_t address,
3024 struct arm_instruction *instruction, char *cp)
3025 {
3026 /* permanently undefined */
3027 if ((opcode & 0x07f07000) == 0x07f02000) {
3028 instruction->type = ARM_UNDEFINED_INSTRUCTION;
3029 strcpy(cp, "UNDEFINED");
3030 return ERROR_OK;
3031 }
3032
3033 switch ((opcode >> 12) & 0x5) {
3034 case 0x1:
3035 case 0x5:
3036 return t2ev_b_bl(opcode, address, instruction, cp);
3037 case 0x4:
3038 goto undef;
3039 case 0:
3040 if (((opcode >> 23) & 0x07) != 0x07)
3041 return t2ev_cond_b(opcode, address, instruction, cp);
3042 if (opcode & (1 << 26))
3043 goto undef;
3044 break;
3045 }
3046
3047 switch ((opcode >> 20) & 0x7f) {
3048 case 0x38:
3049 case 0x39:
3050 sprintf(cp, "MSR\t%s, r%d", special_name(opcode & 0xff),
3051 (int) (opcode >> 16) & 0x0f);
3052 return ERROR_OK;
3053 case 0x3a:
3054 return t2ev_hint(opcode, address, instruction, cp);
3055 case 0x3b:
3056 return t2ev_misc(opcode, address, instruction, cp);
3057 case 0x3c:
3058 sprintf(cp, "BXJ\tr%d", (int) (opcode >> 16) & 0x0f);
3059 return ERROR_OK;
3060 case 0x3e:
3061 case 0x3f:
3062 sprintf(cp, "MRS\tr%d, %s", (int) (opcode >> 8) & 0x0f,
3063 special_name(opcode & 0xff));
3064 return ERROR_OK;
3065 }
3066
3067 undef:
3068 return ERROR_INVALID_ARGUMENTS;
3069 }
3070
3071 static int t2ev_data_mod_immed(uint32_t opcode, uint32_t address,
3072 struct arm_instruction *instruction, char *cp)
3073 {
3074 char *mnemonic = NULL;
3075 int rn = (opcode >> 16) & 0xf;
3076 int rd = (opcode >> 8) & 0xf;
3077 unsigned immed = opcode & 0xff;
3078 unsigned func;
3079 bool one = false;
3080 char *suffix = "";
3081 char *suffix2 = "";
3082
3083 /* ARMv7-M: A5.3.2 Modified immediate constants */
3084 func = (opcode >> 11) & 0x0e;
3085 if (immed & 0x80)
3086 func |= 1;
3087 if (opcode & (1 << 26))
3088 func |= 0x10;
3089
3090 /* "Modified" immediates */
3091 switch (func >> 1) {
3092 case 0:
3093 break;
3094 case 2:
3095 immed <<= 8;
3096 /* FALLTHROUGH */
3097 case 1:
3098 immed += immed << 16;
3099 break;
3100 case 3:
3101 immed += immed << 8;
3102 immed += immed << 16;
3103 break;
3104 default:
3105 immed |= 0x80;
3106 immed = ror(immed, func);
3107 }
3108
3109 if (opcode & (1 << 20))
3110 suffix = "S";
3111
3112 switch ((opcode >> 21) & 0xf) {
3113 case 0:
3114 if (rd == 0xf) {
3115 instruction->type = ARM_TST;
3116 mnemonic = "TST";
3117 one = true;
3118 suffix = "";
3119 rd = rn;
3120 } else {
3121 instruction->type = ARM_AND;
3122 mnemonic = "AND";
3123 }
3124 break;
3125 case 1:
3126 instruction->type = ARM_BIC;
3127 mnemonic = "BIC";
3128 break;
3129 case 2:
3130 if (rn == 0xf) {
3131 instruction->type = ARM_MOV;
3132 mnemonic = "MOV";
3133 one = true;
3134 suffix2 = ".W";
3135 } else {
3136 instruction->type = ARM_ORR;
3137 mnemonic = "ORR";
3138 }
3139 break;
3140 case 3:
3141 if (rn == 0xf) {
3142 instruction->type = ARM_MVN;
3143 mnemonic = "MVN";
3144 one = true;
3145 } else {
3146 // instruction->type = ARM_ORN;
3147 mnemonic = "ORN";
3148 }
3149 break;
3150 case 4:
3151 if (rd == 0xf) {
3152 instruction->type = ARM_TEQ;
3153 mnemonic = "TEQ";
3154 one = true;
3155 suffix = "";
3156 rd = rn;
3157 } else {
3158 instruction->type = ARM_EOR;
3159 mnemonic = "EOR";
3160 }
3161 break;
3162 case 8:
3163 if (rd == 0xf) {
3164 instruction->type = ARM_CMN;
3165 mnemonic = "CMN";
3166 one = true;
3167 suffix = "";
3168 rd = rn;
3169 } else {
3170 instruction->type = ARM_ADD;
3171 mnemonic = "ADD";
3172 suffix2 = ".W";
3173 }
3174 break;
3175 case 10:
3176 instruction->type = ARM_ADC;
3177 mnemonic = "ADC";
3178 suffix2 = ".W";
3179 break;
3180 case 11:
3181 instruction->type = ARM_SBC;
3182 mnemonic = "SBC";
3183 break;
3184 case 13:
3185 if (rd == 0xf) {
3186 instruction->type = ARM_CMP;
3187 mnemonic = "CMP";
3188 one = true;
3189 suffix = "";
3190 rd = rn;
3191 } else {
3192 instruction->type = ARM_SUB;
3193 mnemonic = "SUB";
3194 }
3195 suffix2 = ".W";
3196 break;
3197 case 14:
3198 instruction->type = ARM_RSB;
3199 mnemonic = "RSB";
3200 suffix2 = ".W";
3201 break;
3202 default:
3203 return ERROR_INVALID_ARGUMENTS;
3204 }
3205
3206 if (one)
3207 sprintf(cp, "%s%s\tr%d, #%d\t; %#8.8x",
3208 mnemonic, suffix2 ,rd, immed, immed);
3209 else
3210 sprintf(cp, "%s%s%s\tr%d, r%d, #%d\t; %#8.8x",
3211 mnemonic, suffix, suffix2,
3212 rd, rn, immed, immed);
3213
3214 return ERROR_OK;
3215 }
3216
3217 static int t2ev_data_immed(uint32_t opcode, uint32_t address,
3218 struct arm_instruction *instruction, char *cp)
3219 {
3220 char *mnemonic = NULL;
3221 int rn = (opcode >> 16) & 0xf;
3222 int rd = (opcode >> 8) & 0xf;
3223 unsigned immed;
3224 bool add = false;
3225 bool is_signed = false;
3226
3227 immed = (opcode & 0x0ff) | ((opcode & 0x7000) >> 4);
3228 if (opcode & (1 << 26))
3229 immed |= (1 << 11);
3230
3231 switch ((opcode >> 20) & 0x1f) {
3232 case 0:
3233 if (rn == 0xf) {
3234 add = true;
3235 goto do_adr;
3236 }
3237 mnemonic = "ADDW";
3238 break;
3239 case 4:
3240 immed |= (opcode >> 4) & 0xf000;
3241 sprintf(cp, "MOVW\tr%d, #%d\t; %#3.3x", rd, immed, immed);
3242 return ERROR_OK;
3243 case 0x0a:
3244 if (rn == 0xf)
3245 goto do_adr;
3246 mnemonic = "SUBW";
3247 break;
3248 case 0x0c:
3249 /* move constant to top 16 bits of register */
3250 immed |= (opcode >> 4) & 0xf000;
3251 sprintf(cp, "MOVT\tr%d, #%d\t; %#4.4x", rd, immed, immed);
3252 return ERROR_OK;
3253 case 0x10:
3254 case 0x12:
3255 is_signed = true;
3256 case 0x18:
3257 case 0x1a:
3258 /* signed/unsigned saturated add */
3259 immed = (opcode >> 6) & 0x03;
3260 immed |= (opcode >> 10) & 0x1c;
3261 sprintf(cp, "%sSAT\tr%d, #%d, r%d, %s #%d\t",
3262 is_signed ? "S" : "U",
3263 rd, (int) (opcode & 0x1f) + is_signed, rn,
3264 (opcode & (1 << 21)) ? "ASR" : "LSL",
3265 immed ? immed : 32);
3266 return ERROR_OK;
3267 case 0x14:
3268 is_signed = true;
3269 /* FALLTHROUGH */
3270 case 0x1c:
3271 /* signed/unsigned bitfield extract */
3272 immed = (opcode >> 6) & 0x03;
3273 immed |= (opcode >> 10) & 0x1c;
3274 sprintf(cp, "%sBFX\tr%d, r%d, #%d, #%d\t",
3275 is_signed ? "S" : "U",
3276 rd, rn, immed,
3277 (int) (opcode & 0x1f) + 1);
3278 return ERROR_OK;
3279 case 0x16:
3280 immed = (opcode >> 6) & 0x03;
3281 immed |= (opcode >> 10) & 0x1c;
3282 if (rn == 0xf) /* bitfield clear */
3283 sprintf(cp, "BFC\tr%d, #%d, #%d\t",
3284 rd, immed,
3285 (int) (opcode & 0x1f) + 1 - immed);
3286 else /* bitfield insert */
3287 sprintf(cp, "BFI\tr%d, r%d, #%d, #%d\t",
3288 rd, rn, immed,
3289 (int) (opcode & 0x1f) + 1 - immed);
3290 return ERROR_OK;
3291 default:
3292 return ERROR_INVALID_ARGUMENTS;
3293 }
3294
3295 sprintf(cp, "%s\tr%d, r%d, #%d\t; %#3.3x", mnemonic,
3296 rd, rn, immed, immed);
3297 return ERROR_OK;
3298
3299 do_adr:
3300 address = thumb_alignpc4(address);
3301 if (add)
3302 address += immed;
3303 else
3304 address -= immed;
3305 /* REVISIT "ADD/SUB Rd, PC, #const ; 0x..." might be better;
3306 * not hiding the pc-relative stuff will sometimes be useful.
3307 */
3308 sprintf(cp, "ADR.W\tr%d, %#8.8" PRIx32, rd, address);
3309 return ERROR_OK;
3310 }
3311
3312 static int t2ev_store_single(uint32_t opcode, uint32_t address,
3313 struct arm_instruction *instruction, char *cp)
3314 {
3315 unsigned op = (opcode >> 20) & 0xf;
3316 char *size = "";
3317 char *suffix = "";
3318 char *p1 = "";
3319 char *p2 = "]";
3320 unsigned immed;
3321 unsigned rn = (opcode >> 16) & 0x0f;
3322 unsigned rt = (opcode >> 12) & 0x0f;
3323
3324 if (rn == 0xf)
3325 return ERROR_INVALID_ARGUMENTS;
3326
3327 if (opcode & 0x0800)
3328 op |= 1;
3329 switch (op) {
3330 /* byte */
3331 case 0x8:
3332 case 0x9:
3333 size = "B";
3334 goto imm12;
3335 case 0x1:
3336 size = "B";
3337 goto imm8;
3338 case 0x0:
3339 size = "B";
3340 break;
3341 /* halfword */
3342 case 0xa:
3343 case 0xb:
3344 size = "H";
3345 goto imm12;
3346 case 0x3:
3347 size = "H";
3348 goto imm8;
3349 case 0x2:
3350 size = "H";
3351 break;
3352 /* word */
3353 case 0xc:
3354 case 0xd:
3355 goto imm12;
3356 case 0x5:
3357 goto imm8;
3358 case 0x4: