Update version for v5.1.0 release
[qemu.git] / disas.c
1 /* General "disassemble this chunk" code. Used for debugging. */
2 #include "qemu/osdep.h"
3 #include "disas/dis-asm.h"
4 #include "elf.h"
5 #include "qemu/qemu-print.h"
6
7 #include "cpu.h"
8 #include "disas/disas.h"
9 #include "disas/capstone.h"
10
11 typedef struct CPUDebug {
12 struct disassemble_info info;
13 CPUState *cpu;
14 } CPUDebug;
15
16 /* Filled in by elfload.c. Simplistic, but will do for now. */
17 struct syminfo *syminfos = NULL;
18
19 /* Get LENGTH bytes from info's buffer, at target address memaddr.
20 Transfer them to myaddr. */
21 int
22 buffer_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
23 struct disassemble_info *info)
24 {
25 if (memaddr < info->buffer_vma
26 || memaddr + length > info->buffer_vma + info->buffer_length)
27 /* Out of bounds. Use EIO because GDB uses it. */
28 return EIO;
29 memcpy (myaddr, info->buffer + (memaddr - info->buffer_vma), length);
30 return 0;
31 }
32
33 /* Get LENGTH bytes from info's buffer, at target address memaddr.
34 Transfer them to myaddr. */
35 static int
36 target_read_memory (bfd_vma memaddr,
37 bfd_byte *myaddr,
38 int length,
39 struct disassemble_info *info)
40 {
41 CPUDebug *s = container_of(info, CPUDebug, info);
42 int r;
43
44 r = cpu_memory_rw_debug(s->cpu, memaddr, myaddr, length, 0);
45
46 return r ? EIO : 0;
47 }
48
49 /* Print an error message. We can assume that this is in response to
50 an error return from buffer_read_memory. */
51 void
52 perror_memory (int status, bfd_vma memaddr, struct disassemble_info *info)
53 {
54 if (status != EIO)
55 /* Can't happen. */
56 (*info->fprintf_func) (info->stream, "Unknown error %d\n", status);
57 else
58 /* Actually, address between memaddr and memaddr + len was
59 out of bounds. */
60 (*info->fprintf_func) (info->stream,
61 "Address 0x%" PRIx64 " is out of bounds.\n", memaddr);
62 }
63
64 /* This could be in a separate file, to save minuscule amounts of space
65 in statically linked executables. */
66
67 /* Just print the address is hex. This is included for completeness even
68 though both GDB and objdump provide their own (to print symbolic
69 addresses). */
70
71 void
72 generic_print_address (bfd_vma addr, struct disassemble_info *info)
73 {
74 (*info->fprintf_func) (info->stream, "0x%" PRIx64, addr);
75 }
76
77 /* Print address in hex, truncated to the width of a host virtual address. */
78 static void
79 generic_print_host_address(bfd_vma addr, struct disassemble_info *info)
80 {
81 uint64_t mask = ~0ULL >> (64 - (sizeof(void *) * 8));
82 generic_print_address(addr & mask, info);
83 }
84
85 /* Just return the given address. */
86
87 int
88 generic_symbol_at_address (bfd_vma addr, struct disassemble_info *info)
89 {
90 return 1;
91 }
92
93 bfd_vma bfd_getl64 (const bfd_byte *addr)
94 {
95 unsigned long long v;
96
97 v = (unsigned long long) addr[0];
98 v |= (unsigned long long) addr[1] << 8;
99 v |= (unsigned long long) addr[2] << 16;
100 v |= (unsigned long long) addr[3] << 24;
101 v |= (unsigned long long) addr[4] << 32;
102 v |= (unsigned long long) addr[5] << 40;
103 v |= (unsigned long long) addr[6] << 48;
104 v |= (unsigned long long) addr[7] << 56;
105 return (bfd_vma) v;
106 }
107
108 bfd_vma bfd_getl32 (const bfd_byte *addr)
109 {
110 unsigned long v;
111
112 v = (unsigned long) addr[0];
113 v |= (unsigned long) addr[1] << 8;
114 v |= (unsigned long) addr[2] << 16;
115 v |= (unsigned long) addr[3] << 24;
116 return (bfd_vma) v;
117 }
118
119 bfd_vma bfd_getb32 (const bfd_byte *addr)
120 {
121 unsigned long v;
122
123 v = (unsigned long) addr[0] << 24;
124 v |= (unsigned long) addr[1] << 16;
125 v |= (unsigned long) addr[2] << 8;
126 v |= (unsigned long) addr[3];
127 return (bfd_vma) v;
128 }
129
130 bfd_vma bfd_getl16 (const bfd_byte *addr)
131 {
132 unsigned long v;
133
134 v = (unsigned long) addr[0];
135 v |= (unsigned long) addr[1] << 8;
136 return (bfd_vma) v;
137 }
138
139 bfd_vma bfd_getb16 (const bfd_byte *addr)
140 {
141 unsigned long v;
142
143 v = (unsigned long) addr[0] << 24;
144 v |= (unsigned long) addr[1] << 16;
145 return (bfd_vma) v;
146 }
147
148 static int print_insn_objdump(bfd_vma pc, disassemble_info *info,
149 const char *prefix)
150 {
151 int i, n = info->buffer_length;
152 uint8_t *buf = g_malloc(n);
153
154 info->read_memory_func(pc, buf, n, info);
155
156 for (i = 0; i < n; ++i) {
157 if (i % 32 == 0) {
158 info->fprintf_func(info->stream, "\n%s: ", prefix);
159 }
160 info->fprintf_func(info->stream, "%02x", buf[i]);
161 }
162
163 g_free(buf);
164 return n;
165 }
166
167 static int print_insn_od_host(bfd_vma pc, disassemble_info *info)
168 {
169 return print_insn_objdump(pc, info, "OBJD-H");
170 }
171
172 static int print_insn_od_target(bfd_vma pc, disassemble_info *info)
173 {
174 return print_insn_objdump(pc, info, "OBJD-T");
175 }
176
177 #ifdef CONFIG_CAPSTONE
178 /* Temporary storage for the capstone library. This will be alloced via
179 malloc with a size private to the library; thus there's no reason not
180 to share this across calls and across host vs target disassembly. */
181 static __thread cs_insn *cap_insn;
182
183 /* Initialize the Capstone library. */
184 /* ??? It would be nice to cache this. We would need one handle for the
185 host and one for the target. For most targets we can reset specific
186 parameters via cs_option(CS_OPT_MODE, new_mode), but we cannot change
187 CS_ARCH_* in this way. Thus we would need to be able to close and
188 re-open the target handle with a different arch for the target in order
189 to handle AArch64 vs AArch32 mode switching. */
190 static cs_err cap_disas_start(disassemble_info *info, csh *handle)
191 {
192 cs_mode cap_mode = info->cap_mode;
193 cs_err err;
194
195 cap_mode += (info->endian == BFD_ENDIAN_BIG ? CS_MODE_BIG_ENDIAN
196 : CS_MODE_LITTLE_ENDIAN);
197
198 err = cs_open(info->cap_arch, cap_mode, handle);
199 if (err != CS_ERR_OK) {
200 return err;
201 }
202
203 /* ??? There probably ought to be a better place to put this. */
204 if (info->cap_arch == CS_ARCH_X86) {
205 /* We don't care about errors (if for some reason the library
206 is compiled without AT&T syntax); the user will just have
207 to deal with the Intel syntax. */
208 cs_option(*handle, CS_OPT_SYNTAX, CS_OPT_SYNTAX_ATT);
209 }
210
211 /* "Disassemble" unknown insns as ".byte W,X,Y,Z". */
212 cs_option(*handle, CS_OPT_SKIPDATA, CS_OPT_ON);
213
214 /* Allocate temp space for cs_disasm_iter. */
215 if (cap_insn == NULL) {
216 cap_insn = cs_malloc(*handle);
217 if (cap_insn == NULL) {
218 cs_close(handle);
219 return CS_ERR_MEM;
220 }
221 }
222 return CS_ERR_OK;
223 }
224
225 static void cap_dump_insn_units(disassemble_info *info, cs_insn *insn,
226 int i, int n)
227 {
228 fprintf_function print = info->fprintf_func;
229 FILE *stream = info->stream;
230
231 switch (info->cap_insn_unit) {
232 case 4:
233 if (info->endian == BFD_ENDIAN_BIG) {
234 for (; i < n; i += 4) {
235 print(stream, " %08x", ldl_be_p(insn->bytes + i));
236
237 }
238 } else {
239 for (; i < n; i += 4) {
240 print(stream, " %08x", ldl_le_p(insn->bytes + i));
241 }
242 }
243 break;
244
245 case 2:
246 if (info->endian == BFD_ENDIAN_BIG) {
247 for (; i < n; i += 2) {
248 print(stream, " %04x", lduw_be_p(insn->bytes + i));
249 }
250 } else {
251 for (; i < n; i += 2) {
252 print(stream, " %04x", lduw_le_p(insn->bytes + i));
253 }
254 }
255 break;
256
257 default:
258 for (; i < n; i++) {
259 print(stream, " %02x", insn->bytes[i]);
260 }
261 break;
262 }
263 }
264
265 static void cap_dump_insn(disassemble_info *info, cs_insn *insn,
266 const char *note)
267 {
268 fprintf_function print = info->fprintf_func;
269 int i, n, split;
270
271 print(info->stream, "0x%08" PRIx64 ": ", insn->address);
272
273 n = insn->size;
274 split = info->cap_insn_split;
275
276 /* Dump the first SPLIT bytes of the instruction. */
277 cap_dump_insn_units(info, insn, 0, MIN(n, split));
278
279 /* Add padding up to SPLIT so that mnemonics line up. */
280 if (n < split) {
281 int width = (split - n) / info->cap_insn_unit;
282 width *= (2 * info->cap_insn_unit + 1);
283 print(info->stream, "%*s", width, "");
284 }
285
286 /* Print the actual instruction. */
287 print(info->stream, " %-8s %s", insn->mnemonic, insn->op_str);
288 if (note) {
289 print(info->stream, "\t\t%s", note);
290 }
291 print(info->stream, "\n");
292
293 /* Dump any remaining part of the insn on subsequent lines. */
294 for (i = split; i < n; i += split) {
295 print(info->stream, "0x%08" PRIx64 ": ", insn->address + i);
296 cap_dump_insn_units(info, insn, i, MIN(n, i + split));
297 print(info->stream, "\n");
298 }
299 }
300
301 /* Disassemble SIZE bytes at PC for the target. */
302 static bool cap_disas_target(disassemble_info *info, uint64_t pc, size_t size)
303 {
304 uint8_t cap_buf[1024];
305 csh handle;
306 cs_insn *insn;
307 size_t csize = 0;
308
309 if (cap_disas_start(info, &handle) != CS_ERR_OK) {
310 return false;
311 }
312 insn = cap_insn;
313
314 while (1) {
315 size_t tsize = MIN(sizeof(cap_buf) - csize, size);
316 const uint8_t *cbuf = cap_buf;
317
318 target_read_memory(pc + csize, cap_buf + csize, tsize, info);
319 csize += tsize;
320 size -= tsize;
321
322 while (cs_disasm_iter(handle, &cbuf, &csize, &pc, insn)) {
323 cap_dump_insn(info, insn, NULL);
324 }
325
326 /* If the target memory is not consumed, go back for more... */
327 if (size != 0) {
328 /* ... taking care to move any remaining fractional insn
329 to the beginning of the buffer. */
330 if (csize != 0) {
331 memmove(cap_buf, cbuf, csize);
332 }
333 continue;
334 }
335
336 /* Since the target memory is consumed, we should not have
337 a remaining fractional insn. */
338 if (csize != 0) {
339 (*info->fprintf_func)(info->stream,
340 "Disassembler disagrees with translator "
341 "over instruction decoding\n"
342 "Please report this to qemu-devel@nongnu.org\n");
343 }
344 break;
345 }
346
347 cs_close(&handle);
348 return true;
349 }
350
351 /* Disassemble SIZE bytes at CODE for the host. */
352 static bool cap_disas_host(disassemble_info *info, void *code, size_t size,
353 const char *note)
354 {
355 csh handle;
356 const uint8_t *cbuf;
357 cs_insn *insn;
358 uint64_t pc;
359
360 if (cap_disas_start(info, &handle) != CS_ERR_OK) {
361 return false;
362 }
363 insn = cap_insn;
364
365 cbuf = code;
366 pc = (uintptr_t)code;
367
368 while (cs_disasm_iter(handle, &cbuf, &size, &pc, insn)) {
369 cap_dump_insn(info, insn, note);
370 note = NULL;
371 }
372 if (size != 0) {
373 (*info->fprintf_func)(info->stream,
374 "Disassembler disagrees with TCG over instruction encoding\n"
375 "Please report this to qemu-devel@nongnu.org\n");
376 }
377
378 cs_close(&handle);
379 return true;
380 }
381
382 #if !defined(CONFIG_USER_ONLY)
383 /* Disassemble COUNT insns at PC for the target. */
384 static bool cap_disas_monitor(disassemble_info *info, uint64_t pc, int count)
385 {
386 uint8_t cap_buf[32];
387 csh handle;
388 cs_insn *insn;
389 size_t csize = 0;
390
391 if (cap_disas_start(info, &handle) != CS_ERR_OK) {
392 return false;
393 }
394 insn = cap_insn;
395
396 while (1) {
397 /* We want to read memory for one insn, but generically we do not
398 know how much memory that is. We have a small buffer which is
399 known to be sufficient for all supported targets. Try to not
400 read beyond the page, Just In Case. For even more simplicity,
401 ignore the actual target page size and use a 1k boundary. If
402 that turns out to be insufficient, we'll come back around the
403 loop and read more. */
404 uint64_t epc = QEMU_ALIGN_UP(pc + csize + 1, 1024);
405 size_t tsize = MIN(sizeof(cap_buf) - csize, epc - pc);
406 const uint8_t *cbuf = cap_buf;
407
408 /* Make certain that we can make progress. */
409 assert(tsize != 0);
410 info->read_memory_func(pc, cap_buf + csize, tsize, info);
411 csize += tsize;
412
413 if (cs_disasm_iter(handle, &cbuf, &csize, &pc, insn)) {
414 cap_dump_insn(info, insn, NULL);
415 if (--count <= 0) {
416 break;
417 }
418 }
419 memmove(cap_buf, cbuf, csize);
420 }
421
422 cs_close(&handle);
423 return true;
424 }
425 #endif /* !CONFIG_USER_ONLY */
426 #else
427 # define cap_disas_target(i, p, s) false
428 # define cap_disas_host(i, p, s, n) false
429 # define cap_disas_monitor(i, p, c) false
430 # define cap_disas_plugin(i, p, c) false
431 #endif /* CONFIG_CAPSTONE */
432
433 /* Disassemble this for me please... (debugging). */
434 void target_disas(FILE *out, CPUState *cpu, target_ulong code,
435 target_ulong size)
436 {
437 CPUClass *cc = CPU_GET_CLASS(cpu);
438 target_ulong pc;
439 int count;
440 CPUDebug s;
441
442 INIT_DISASSEMBLE_INFO(s.info, out, fprintf);
443
444 s.cpu = cpu;
445 s.info.read_memory_func = target_read_memory;
446 s.info.buffer_vma = code;
447 s.info.buffer_length = size;
448 s.info.print_address_func = generic_print_address;
449 s.info.cap_arch = -1;
450 s.info.cap_mode = 0;
451 s.info.cap_insn_unit = 4;
452 s.info.cap_insn_split = 4;
453
454 #ifdef TARGET_WORDS_BIGENDIAN
455 s.info.endian = BFD_ENDIAN_BIG;
456 #else
457 s.info.endian = BFD_ENDIAN_LITTLE;
458 #endif
459
460 if (cc->disas_set_info) {
461 cc->disas_set_info(cpu, &s.info);
462 }
463
464 if (s.info.cap_arch >= 0 && cap_disas_target(&s.info, code, size)) {
465 return;
466 }
467
468 if (s.info.print_insn == NULL) {
469 s.info.print_insn = print_insn_od_target;
470 }
471
472 for (pc = code; size > 0; pc += count, size -= count) {
473 fprintf(out, "0x" TARGET_FMT_lx ": ", pc);
474 count = s.info.print_insn(pc, &s.info);
475 fprintf(out, "\n");
476 if (count < 0)
477 break;
478 if (size < count) {
479 fprintf(out,
480 "Disassembler disagrees with translator over instruction "
481 "decoding\n"
482 "Please report this to qemu-devel@nongnu.org\n");
483 break;
484 }
485 }
486 }
487
488 static __thread GString plugin_disas_output;
489
490 static int plugin_printf(FILE *stream, const char *fmt, ...)
491 {
492 va_list va;
493 GString *s = &plugin_disas_output;
494 int initial_len = s->len;
495
496 va_start(va, fmt);
497 g_string_append_vprintf(s, fmt, va);
498 va_end(va);
499
500 return s->len - initial_len;
501 }
502
503 static void plugin_print_address(bfd_vma addr, struct disassemble_info *info)
504 {
505 /* does nothing */
506 }
507
508
509 #ifdef CONFIG_CAPSTONE
510 /* Disassemble a single instruction directly into plugin output */
511 static
512 bool cap_disas_plugin(disassemble_info *info, uint64_t pc, size_t size)
513 {
514 uint8_t cap_buf[1024];
515 csh handle;
516 cs_insn *insn;
517 size_t csize = 0;
518 int count;
519 GString *s = &plugin_disas_output;
520
521 if (cap_disas_start(info, &handle) != CS_ERR_OK) {
522 return false;
523 }
524 insn = cap_insn;
525
526 size_t tsize = MIN(sizeof(cap_buf) - csize, size);
527 const uint8_t *cbuf = cap_buf;
528 target_read_memory(pc, cap_buf, tsize, info);
529
530 count = cs_disasm(handle, cbuf, size, 0, 1, &insn);
531
532 if (count) {
533 g_string_printf(s, "%s %s", insn->mnemonic, insn->op_str);
534 } else {
535 g_string_printf(s, "cs_disasm failed");
536 }
537
538 cs_close(&handle);
539 return true;
540 }
541 #endif
542
543 /*
544 * We should only be dissembling one instruction at a time here. If
545 * there is left over it usually indicates the front end has read more
546 * bytes than it needed.
547 */
548 char *plugin_disas(CPUState *cpu, uint64_t addr, size_t size)
549 {
550 CPUClass *cc = CPU_GET_CLASS(cpu);
551 int count;
552 CPUDebug s;
553 GString *ds = g_string_set_size(&plugin_disas_output, 0);
554
555 g_assert(ds == &plugin_disas_output);
556
557 INIT_DISASSEMBLE_INFO(s.info, NULL, plugin_printf);
558
559 s.cpu = cpu;
560 s.info.read_memory_func = target_read_memory;
561 s.info.buffer_vma = addr;
562 s.info.buffer_length = size;
563 s.info.print_address_func = plugin_print_address;
564 s.info.cap_arch = -1;
565 s.info.cap_mode = 0;
566 s.info.cap_insn_unit = 4;
567 s.info.cap_insn_split = 4;
568
569 #ifdef TARGET_WORDS_BIGENDIAN
570 s.info.endian = BFD_ENDIAN_BIG;
571 #else
572 s.info.endian = BFD_ENDIAN_LITTLE;
573 #endif
574
575 if (cc->disas_set_info) {
576 cc->disas_set_info(cpu, &s.info);
577 }
578
579 if (s.info.cap_arch >= 0 && cap_disas_plugin(&s.info, addr, size)) {
580 return g_strdup(ds->str);
581 }
582
583 if (s.info.print_insn == NULL) {
584 s.info.print_insn = print_insn_od_target;
585 }
586
587 count = s.info.print_insn(addr, &s.info);
588
589 /* The decoder probably read more than it needed it's not critical */
590 if (count < size) {
591 warn_report("%s: %zu bytes left over", __func__, size - count);
592 }
593
594 return g_strdup(ds->str);
595 }
596
597 /* Disassemble this for me please... (debugging). */
598 void disas(FILE *out, void *code, unsigned long size, const char *note)
599 {
600 uintptr_t pc;
601 int count;
602 CPUDebug s;
603 int (*print_insn)(bfd_vma pc, disassemble_info *info) = NULL;
604
605 INIT_DISASSEMBLE_INFO(s.info, out, fprintf);
606 s.info.print_address_func = generic_print_host_address;
607
608 s.info.buffer = code;
609 s.info.buffer_vma = (uintptr_t)code;
610 s.info.buffer_length = size;
611 s.info.cap_arch = -1;
612 s.info.cap_mode = 0;
613 s.info.cap_insn_unit = 4;
614 s.info.cap_insn_split = 4;
615
616 #ifdef HOST_WORDS_BIGENDIAN
617 s.info.endian = BFD_ENDIAN_BIG;
618 #else
619 s.info.endian = BFD_ENDIAN_LITTLE;
620 #endif
621 #if defined(CONFIG_TCG_INTERPRETER)
622 print_insn = print_insn_tci;
623 #elif defined(__i386__)
624 s.info.mach = bfd_mach_i386_i386;
625 print_insn = print_insn_i386;
626 s.info.cap_arch = CS_ARCH_X86;
627 s.info.cap_mode = CS_MODE_32;
628 s.info.cap_insn_unit = 1;
629 s.info.cap_insn_split = 8;
630 #elif defined(__x86_64__)
631 s.info.mach = bfd_mach_x86_64;
632 print_insn = print_insn_i386;
633 s.info.cap_arch = CS_ARCH_X86;
634 s.info.cap_mode = CS_MODE_64;
635 s.info.cap_insn_unit = 1;
636 s.info.cap_insn_split = 8;
637 #elif defined(_ARCH_PPC)
638 s.info.disassembler_options = (char *)"any";
639 print_insn = print_insn_ppc;
640 s.info.cap_arch = CS_ARCH_PPC;
641 # ifdef _ARCH_PPC64
642 s.info.cap_mode = CS_MODE_64;
643 # endif
644 #elif defined(__riscv) && defined(CONFIG_RISCV_DIS)
645 #if defined(_ILP32) || (__riscv_xlen == 32)
646 print_insn = print_insn_riscv32;
647 #elif defined(_LP64)
648 print_insn = print_insn_riscv64;
649 #else
650 #error unsupported RISC-V ABI
651 #endif
652 #elif defined(__aarch64__) && defined(CONFIG_ARM_A64_DIS)
653 print_insn = print_insn_arm_a64;
654 s.info.cap_arch = CS_ARCH_ARM64;
655 #elif defined(__alpha__)
656 print_insn = print_insn_alpha;
657 #elif defined(__sparc__)
658 print_insn = print_insn_sparc;
659 s.info.mach = bfd_mach_sparc_v9b;
660 #elif defined(__arm__)
661 print_insn = print_insn_arm;
662 s.info.cap_arch = CS_ARCH_ARM;
663 /* TCG only generates code for arm mode. */
664 #elif defined(__MIPSEB__)
665 print_insn = print_insn_big_mips;
666 #elif defined(__MIPSEL__)
667 print_insn = print_insn_little_mips;
668 #elif defined(__m68k__)
669 print_insn = print_insn_m68k;
670 #elif defined(__s390__)
671 print_insn = print_insn_s390;
672 #elif defined(__hppa__)
673 print_insn = print_insn_hppa;
674 #endif
675
676 if (s.info.cap_arch >= 0 && cap_disas_host(&s.info, code, size, note)) {
677 return;
678 }
679
680 if (print_insn == NULL) {
681 print_insn = print_insn_od_host;
682 }
683 for (pc = (uintptr_t)code; size > 0; pc += count, size -= count) {
684 fprintf(out, "0x%08" PRIxPTR ": ", pc);
685 count = print_insn(pc, &s.info);
686 if (note) {
687 fprintf(out, "\t\t%s", note);
688 note = NULL;
689 }
690 fprintf(out, "\n");
691 if (count < 0) {
692 break;
693 }
694 }
695
696 }
697
698 /* Look up symbol for debugging purpose. Returns "" if unknown. */
699 const char *lookup_symbol(target_ulong orig_addr)
700 {
701 const char *symbol = "";
702 struct syminfo *s;
703
704 for (s = syminfos; s; s = s->next) {
705 symbol = s->lookup_symbol(s, orig_addr);
706 if (symbol[0] != '\0') {
707 break;
708 }
709 }
710
711 return symbol;
712 }
713
714 #if !defined(CONFIG_USER_ONLY)
715
716 #include "monitor/monitor.h"
717
718 static int
719 physical_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
720 struct disassemble_info *info)
721 {
722 CPUDebug *s = container_of(info, CPUDebug, info);
723 MemTxResult res;
724
725 res = address_space_read(s->cpu->as, memaddr, MEMTXATTRS_UNSPECIFIED,
726 myaddr, length);
727 return res == MEMTX_OK ? 0 : EIO;
728 }
729
730 /* Disassembler for the monitor. */
731 void monitor_disas(Monitor *mon, CPUState *cpu,
732 target_ulong pc, int nb_insn, int is_physical)
733 {
734 CPUClass *cc = CPU_GET_CLASS(cpu);
735 int count, i;
736 CPUDebug s;
737
738 INIT_DISASSEMBLE_INFO(s.info, NULL, qemu_fprintf);
739
740 s.cpu = cpu;
741 s.info.read_memory_func
742 = (is_physical ? physical_read_memory : target_read_memory);
743 s.info.print_address_func = generic_print_address;
744 s.info.buffer_vma = pc;
745 s.info.cap_arch = -1;
746 s.info.cap_mode = 0;
747 s.info.cap_insn_unit = 4;
748 s.info.cap_insn_split = 4;
749
750 #ifdef TARGET_WORDS_BIGENDIAN
751 s.info.endian = BFD_ENDIAN_BIG;
752 #else
753 s.info.endian = BFD_ENDIAN_LITTLE;
754 #endif
755
756 if (cc->disas_set_info) {
757 cc->disas_set_info(cpu, &s.info);
758 }
759
760 if (s.info.cap_arch >= 0 && cap_disas_monitor(&s.info, pc, nb_insn)) {
761 return;
762 }
763
764 if (!s.info.print_insn) {
765 monitor_printf(mon, "0x" TARGET_FMT_lx
766 ": Asm output not supported on this arch\n", pc);
767 return;
768 }
769
770 for(i = 0; i < nb_insn; i++) {
771 monitor_printf(mon, "0x" TARGET_FMT_lx ": ", pc);
772 count = s.info.print_insn(pc, &s.info);
773 monitor_printf(mon, "\n");
774 if (count < 0)
775 break;
776 pc += count;
777 }
778 }
779 #endif