[mirror_qemu.git] / disas.c

/* General "disassemble this chunk" code.  Used for debugging. */
#include "qemu/osdep.h"
#include "disas/dis-asm.h"
#include "elf.h"
#include "qemu/qemu-print.h"

#include "cpu.h"
#include "disas/disas.h"
#include "disas/capstone.h"

typedef struct CPUDebug {
    struct disassemble_info info;
    CPUState *cpu;
} CPUDebug;

/* Filled in by elfload.c.  Simplistic, but will do for now. */
struct syminfo *syminfos = NULL;

/*
 * Get LENGTH bytes from info's buffer, at host address memaddr.
 * Transfer them to myaddr.
 */
static int host_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
                            struct disassemble_info *info)
{
    if (memaddr < info->buffer_vma
        || memaddr + length > info->buffer_vma + info->buffer_length) {
        /* Out of bounds.  Use EIO because GDB uses it.  */
        return EIO;
    }
    memcpy (myaddr, info->buffer + (memaddr - info->buffer_vma), length);
    return 0;
}

/*
 * Get LENGTH bytes from info's buffer, at target address memaddr.
 * Transfer them to myaddr.
 */
static int target_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
                              struct disassemble_info *info)
{
    CPUDebug *s = container_of(info, CPUDebug, info);
    int r = cpu_memory_rw_debug(s->cpu, memaddr, myaddr, length, 0);
    return r ? EIO : 0;
}

/*
 * Print an error message.  We can assume that this is in response to
 * an error return from {host,target}_read_memory.
 */
static void perror_memory(int status, bfd_vma memaddr,
                          struct disassemble_info *info)
{
    if (status != EIO) {
        /* Can't happen.  */
        info->fprintf_func(info->stream, "Unknown error %d\n", status);
    } else {
        /* Address between memaddr and memaddr + len was out of bounds.  */
        info->fprintf_func(info->stream,
                           "Address 0x%" PRIx64 " is out of bounds.\n",
                           memaddr);
    }
}

/* Print address in hex. */
static void print_address(bfd_vma addr, struct disassemble_info *info)
{
    info->fprintf_func(info->stream, "0x%" PRIx64, addr);
}

/* Print address in hex, truncated to the width of a host virtual address. */
static void host_print_address(bfd_vma addr, struct disassemble_info *info)
{
    print_address((uintptr_t)addr, info);
}

/* Stub prevents some fruitless earching in optabs disassemblers. */
static int symbol_at_address(bfd_vma addr, struct disassemble_info *info)
{
    return 1;
}

static int print_insn_objdump(bfd_vma pc, disassemble_info *info,
                              const char *prefix)
{
    int i, n = info->buffer_length;
    uint8_t *buf = g_malloc(n);

    info->read_memory_func(pc, buf, n, info);

    for (i = 0; i < n; ++i) {
        if (i % 32 == 0) {
            info->fprintf_func(info->stream, "\n%s: ", prefix);
        }
        info->fprintf_func(info->stream, "%02x", buf[i]);
    }

    g_free(buf);
    return n;
}

static int print_insn_od_host(bfd_vma pc, disassemble_info *info)
{
    return print_insn_objdump(pc, info, "OBJD-H");
}

static int print_insn_od_target(bfd_vma pc, disassemble_info *info)
{
    return print_insn_objdump(pc, info, "OBJD-T");
}

static void initialize_debug(CPUDebug *s)
{
    memset(s, 0, sizeof(*s));
    s->info.arch = bfd_arch_unknown;
    s->info.cap_arch = -1;
    s->info.cap_insn_unit = 4;
    s->info.cap_insn_split = 4;
    s->info.memory_error_func = perror_memory;
    s->info.symbol_at_address_func = symbol_at_address;
}

static void initialize_debug_target(CPUDebug *s, CPUState *cpu)
{
    initialize_debug(s);

    s->cpu = cpu;
    s->info.read_memory_func = target_read_memory;
    s->info.print_address_func = print_address;
#ifdef TARGET_WORDS_BIGENDIAN
    s->info.endian = BFD_ENDIAN_BIG;
#else
    s->info.endian = BFD_ENDIAN_LITTLE;
#endif

    CPUClass *cc = CPU_GET_CLASS(cpu);
    if (cc->disas_set_info) {
        cc->disas_set_info(cpu, &s->info);
    }
}

static void initialize_debug_host(CPUDebug *s)
{
    initialize_debug(s);

    s->info.read_memory_func = host_read_memory;
    s->info.print_address_func = host_print_address;
#ifdef HOST_WORDS_BIGENDIAN
    s->info.endian = BFD_ENDIAN_BIG;
#else
    s->info.endian = BFD_ENDIAN_LITTLE;
#endif
#if defined(CONFIG_TCG_INTERPRETER)
    s->info.print_insn = print_insn_tci;
#elif defined(__i386__)
    s->info.mach = bfd_mach_i386_i386;
    s->info.print_insn = print_insn_i386;
    s->info.cap_arch = CS_ARCH_X86;
    s->info.cap_mode = CS_MODE_32;
    s->info.cap_insn_unit = 1;
    s->info.cap_insn_split = 8;
#elif defined(__x86_64__)
    s->info.mach = bfd_mach_x86_64;
    s->info.print_insn = print_insn_i386;
    s->info.cap_arch = CS_ARCH_X86;
    s->info.cap_mode = CS_MODE_64;
    s->info.cap_insn_unit = 1;
    s->info.cap_insn_split = 8;
#elif defined(_ARCH_PPC)
    s->info.disassembler_options = (char *)"any";
    s->info.print_insn = print_insn_ppc;
    s->info.cap_arch = CS_ARCH_PPC;
# ifdef _ARCH_PPC64
    s->info.cap_mode = CS_MODE_64;
# endif
#elif defined(__riscv) && defined(CONFIG_RISCV_DIS)
#if defined(_ILP32) || (__riscv_xlen == 32)
    s->info.print_insn = print_insn_riscv32;
#elif defined(_LP64)
    s->info.print_insn = print_insn_riscv64;
#else
#error unsupported RISC-V ABI
#endif
#elif defined(__aarch64__)
    s->info.cap_arch = CS_ARCH_ARM64;
# ifdef CONFIG_ARM_A64_DIS
    s->info.print_insn = print_insn_arm_a64;
# endif
#elif defined(__alpha__)
    s->info.print_insn = print_insn_alpha;
#elif defined(__sparc__)
    s->info.print_insn = print_insn_sparc;
    s->info.mach = bfd_mach_sparc_v9b;
#elif defined(__arm__)
    /* TCG only generates code for arm mode.  */
    s->info.print_insn = print_insn_arm;
    s->info.cap_arch = CS_ARCH_ARM;
#elif defined(__MIPSEB__)
    s->info.print_insn = print_insn_big_mips;
#elif defined(__MIPSEL__)
    s->info.print_insn = print_insn_little_mips;
#elif defined(__m68k__)
    s->info.print_insn = print_insn_m68k;
#elif defined(__s390__)
    s->info.print_insn = print_insn_s390;
    s->info.cap_arch = CS_ARCH_SYSZ;
    s->info.cap_insn_unit = 2;
    s->info.cap_insn_split = 6;
#elif defined(__hppa__)
    s->info.print_insn = print_insn_hppa;
#endif
}

/* Disassemble this for me please... (debugging).  */
void target_disas(FILE *out, CPUState *cpu, target_ulong code,
                  target_ulong size)
{
    target_ulong pc;
    int count;
    CPUDebug s;

    initialize_debug_target(&s, cpu);
    s.info.fprintf_func = fprintf;
    s.info.stream = out;
    s.info.buffer_vma = code;
    s.info.buffer_length = size;

    if (s.info.cap_arch >= 0 && cap_disas_target(&s.info, code, size)) {
        return;
    }

    if (s.info.print_insn == NULL) {
        s.info.print_insn = print_insn_od_target;
    }

    for (pc = code; size > 0; pc += count, size -= count) {
	fprintf(out, "0x" TARGET_FMT_lx ":  ", pc);
	count = s.info.print_insn(pc, &s.info);
	fprintf(out, "\n");
	if (count < 0)
	    break;
        if (size < count) {
            fprintf(out,
                    "Disassembler disagrees with translator over instruction "
                    "decoding\n"
                    "Please report this to qemu-devel@nongnu.org\n");
            break;
        }
    }
}

static int plugin_printf(FILE *stream, const char *fmt, ...)
{
    /* We abuse the FILE parameter to pass a GString. */
    GString *s = (GString *)stream;
    int initial_len = s->len;
    va_list va;

    va_start(va, fmt);
    g_string_append_vprintf(s, fmt, va);
    va_end(va);

    return s->len - initial_len;
}

static void plugin_print_address(bfd_vma addr, struct disassemble_info *info)
{
    /* does nothing */
}


/*
 * We should only be dissembling one instruction at a time here. If
 * there is left over it usually indicates the front end has read more
 * bytes than it needed.
 */
char *plugin_disas(CPUState *cpu, uint64_t addr, size_t size)
{
    CPUDebug s;
    GString *ds = g_string_new(NULL);

    initialize_debug_target(&s, cpu);
    s.info.fprintf_func = plugin_printf;
    s.info.stream = (FILE *)ds;  /* abuse this slot */
    s.info.buffer_vma = addr;
    s.info.buffer_length = size;
    s.info.print_address_func = plugin_print_address;

    if (s.info.cap_arch >= 0 && cap_disas_plugin(&s.info, addr, size)) {
        ; /* done */
    } else if (s.info.print_insn) {
        s.info.print_insn(addr, &s.info);
    } else {
        ; /* cannot disassemble -- return empty string */
    }

    /* Return the buffer, freeing the GString container.  */
    return g_string_free(ds, false);
}

/* Disassemble this for me please... (debugging). */
void disas(FILE *out, void *code, unsigned long size)
{
    uintptr_t pc;
    int count;
    CPUDebug s;

    initialize_debug_host(&s);
    s.info.fprintf_func = fprintf;
    s.info.stream = out;
    s.info.buffer = code;
    s.info.buffer_vma = (uintptr_t)code;
    s.info.buffer_length = size;

    if (s.info.cap_arch >= 0 && cap_disas_host(&s.info, code, size)) {
        return;
    }

    if (s.info.print_insn == NULL) {
        s.info.print_insn = print_insn_od_host;
    }
    for (pc = (uintptr_t)code; size > 0; pc += count, size -= count) {
        fprintf(out, "0x%08" PRIxPTR ":  ", pc);
        count = s.info.print_insn(pc, &s.info);
        fprintf(out, "\n");
        if (count < 0) {
            break;
        }
    }

}

/* Look up symbol for debugging purpose.  Returns "" if unknown. */
const char *lookup_symbol(target_ulong orig_addr)
{
    const char *symbol = "";
    struct syminfo *s;

    for (s = syminfos; s; s = s->next) {
        symbol = s->lookup_symbol(s, orig_addr);
        if (symbol[0] != '\0') {
            break;
        }
    }

    return symbol;
}

#if !defined(CONFIG_USER_ONLY)

#include "monitor/monitor.h"

static int
physical_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
                     struct disassemble_info *info)
{
    CPUDebug *s = container_of(info, CPUDebug, info);
    MemTxResult res;

    res = address_space_read(s->cpu->as, memaddr, MEMTXATTRS_UNSPECIFIED,
                             myaddr, length);
    return res == MEMTX_OK ? 0 : EIO;
}

/* Disassembler for the monitor.  */
void monitor_disas(Monitor *mon, CPUState *cpu,
                   target_ulong pc, int nb_insn, int is_physical)
{
    int count, i;
    CPUDebug s;

    initialize_debug_target(&s, cpu);
    s.info.fprintf_func = qemu_fprintf;
    if (is_physical) {
        s.info.read_memory_func = physical_read_memory;
    }
    s.info.buffer_vma = pc;

    if (s.info.cap_arch >= 0 && cap_disas_monitor(&s.info, pc, nb_insn)) {
        return;
    }

    if (!s.info.print_insn) {
        monitor_printf(mon, "0x" TARGET_FMT_lx
                       ": Asm output not supported on this arch\n", pc);
        return;
    }

    for(i = 0; i < nb_insn; i++) {
	monitor_printf(mon, "0x" TARGET_FMT_lx ":  ", pc);
        count = s.info.print_insn(pc, &s.info);
	monitor_printf(mon, "\n");
	if (count < 0)
	    break;
        pc += count;
    }
}
#endif
Commit	Line	Data
b9adb4a6	1	/* General "disassemble this chunk" code. Used for debugging. */
d38ea87a	2	#include "qemu/osdep.h"
3979fca4	3	#include "disas/dis-asm.h"
b9adb4a6	4	#include "elf.h"
30cc9831	5	#include "qemu/qemu-print.h"
b9adb4a6	6
c6105c0a	7	#include "cpu.h"
76cad711	8	#include "disas/disas.h"
8ca80760	9	#include "disas/capstone.h"
c6105c0a	10
f4359b9f BS	11	typedef struct CPUDebug {
f4359b9f BS	12	struct disassemble_info info;
d49190c4	13	CPUState *cpu;
f4359b9f BS	14	} CPUDebug;
f4359b9f BS	15
b9adb4a6	16	/* Filled in by elfload.c. Simplistic, but will do for now. */
e80cfcfc	17	struct syminfo *syminfos = NULL;
b9adb4a6	18
12b6e9b2 RH	19	/*
	20	* Get LENGTH bytes from info's buffer, at host address memaddr.
	21	* Transfer them to myaddr.
	22	*/
	23	static int host_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
	24	struct disassemble_info *info)
aa0aa4fa	25	{
c6105c0a	26	if (memaddr < info->buffer_vma
12b6e9b2	27	\|\| memaddr + length > info->buffer_vma + info->buffer_length) {
c6105c0a FB	28	/* Out of bounds. Use EIO because GDB uses it. */
c6105c0a FB	29	return EIO;
12b6e9b2	30	}
c6105c0a FB	31	memcpy (myaddr, info->buffer + (memaddr - info->buffer_vma), length);
c6105c0a FB	32	return 0;
aa0aa4fa FB	33	}
aa0aa4fa FB	34
12b6e9b2 RH	35	/*
	36	* Get LENGTH bytes from info's buffer, at target address memaddr.
	37	* Transfer them to myaddr.
	38	*/
	39	static int target_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
	40	struct disassemble_info *info)
c6105c0a	41	{
f4359b9f	42	CPUDebug *s = container_of(info, CPUDebug, info);
12b6e9b2	43	int r = cpu_memory_rw_debug(s->cpu, memaddr, myaddr, length, 0);
6766ba50	44	return r ? EIO : 0;
c6105c0a	45	}
c6105c0a	46
12b6e9b2 RH	47	/*
	48	* Print an error message. We can assume that this is in response to
	49	* an error return from {host,target}_read_memory.
	50	*/
	51	static void perror_memory(int status, bfd_vma memaddr,
	52	struct disassemble_info *info)
aa0aa4fa	53	{
12b6e9b2 RH	54	if (status != EIO) {
	55	/* Can't happen. */
	56	info->fprintf_func(info->stream, "Unknown error %d\n", status);
	57	} else {
	58	/* Address between memaddr and memaddr + len was out of bounds. */
	59	info->fprintf_func(info->stream,
	60	"Address 0x%" PRIx64 " is out of bounds.\n",
	61	memaddr);
	62	}
aa0aa4fa FB	63	}
aa0aa4fa FB	64
12b6e9b2 RH	65	/* Print address in hex. */
12b6e9b2 RH	66	static void print_address(bfd_vma addr, struct disassemble_info *info)
aa0aa4fa	67	{
12b6e9b2	68	info->fprintf_func(info->stream, "0x%" PRIx64, addr);
aa0aa4fa FB	69	}
aa0aa4fa FB	70
636bd289	71	/* Print address in hex, truncated to the width of a host virtual address. */
12b6e9b2	72	static void host_print_address(bfd_vma addr, struct disassemble_info *info)
636bd289	73	{
12b6e9b2	74	print_address((uintptr_t)addr, info);
636bd289 PM	75	}
636bd289 PM	76
12b6e9b2 RH	77	/* Stub prevents some fruitless earching in optabs disassemblers. */
12b6e9b2 RH	78	static int symbol_at_address(bfd_vma addr, struct disassemble_info *info)
aa0aa4fa	79	{
12b6e9b2	80	return 1;
aa0aa4fa FB	81	}
aa0aa4fa FB	82
c46ffd57 RH	83	static int print_insn_objdump(bfd_vma pc, disassemble_info *info,
	84	const char *prefix)
	85	{
	86	int i, n = info->buffer_length;
	87	uint8_t *buf = g_malloc(n);
	88
	89	info->read_memory_func(pc, buf, n, info);
	90
	91	for (i = 0; i < n; ++i) {
	92	if (i % 32 == 0) {
	93	info->fprintf_func(info->stream, "\n%s: ", prefix);
	94	}
	95	info->fprintf_func(info->stream, "%02x", buf[i]);
	96	}
	97
	98	g_free(buf);
	99	return n;
	100	}
	101
	102	static int print_insn_od_host(bfd_vma pc, disassemble_info *info)
	103	{
	104	return print_insn_objdump(pc, info, "OBJD-H");
	105	}
	106
	107	static int print_insn_od_target(bfd_vma pc, disassemble_info *info)
	108	{
	109	return print_insn_objdump(pc, info, "OBJD-T");
	110	}
	111
12b6e9b2 RH	112	static void initialize_debug(CPUDebug *s)
	113	{
	114	memset(s, 0, sizeof(*s));
	115	s->info.arch = bfd_arch_unknown;
	116	s->info.cap_arch = -1;
	117	s->info.cap_insn_unit = 4;
	118	s->info.cap_insn_split = 4;
	119	s->info.memory_error_func = perror_memory;
	120	s->info.symbol_at_address_func = symbol_at_address;
	121	}
	122
	123	static void initialize_debug_target(CPUDebug s, CPUState cpu)
	124	{
	125	initialize_debug(s);
	126
	127	s->cpu = cpu;
	128	s->info.read_memory_func = target_read_memory;
	129	s->info.print_address_func = print_address;
	130	#ifdef TARGET_WORDS_BIGENDIAN
	131	s->info.endian = BFD_ENDIAN_BIG;
	132	#else
	133	s->info.endian = BFD_ENDIAN_LITTLE;
	134	#endif
	135
	136	CPUClass *cc = CPU_GET_CLASS(cpu);
	137	if (cc->disas_set_info) {
	138	cc->disas_set_info(cpu, &s->info);
	139	}
	140	}
	141
	142	static void initialize_debug_host(CPUDebug *s)
	143	{
	144	initialize_debug(s);
	145
	146	s->info.read_memory_func = host_read_memory;
	147	s->info.print_address_func = host_print_address;
	148	#ifdef HOST_WORDS_BIGENDIAN
	149	s->info.endian = BFD_ENDIAN_BIG;
	150	#else
	151	s->info.endian = BFD_ENDIAN_LITTLE;
	152	#endif
	153	#if defined(CONFIG_TCG_INTERPRETER)
	154	s->info.print_insn = print_insn_tci;
	155	#elif defined(__i386__)
	156	s->info.mach = bfd_mach_i386_i386;
	157	s->info.print_insn = print_insn_i386;
	158	s->info.cap_arch = CS_ARCH_X86;
	159	s->info.cap_mode = CS_MODE_32;
	160	s->info.cap_insn_unit = 1;
	161	s->info.cap_insn_split = 8;
	162	#elif defined(__x86_64__)
	163	s->info.mach = bfd_mach_x86_64;
	164	s->info.print_insn = print_insn_i386;
	165	s->info.cap_arch = CS_ARCH_X86;
	166	s->info.cap_mode = CS_MODE_64;
	167	s->info.cap_insn_unit = 1;
	168	s->info.cap_insn_split = 8;
	169	#elif defined(_ARCH_PPC)
	170	s->info.disassembler_options = (char *)"any";
	171	s->info.print_insn = print_insn_ppc;
	172	s->info.cap_arch = CS_ARCH_PPC;
	173	# ifdef _ARCH_PPC64
	174	s->info.cap_mode = CS_MODE_64;
	175	# endif
176	#elif defined(__riscv) && defined(CONFIG_RISCV_DIS)
177	#if defined(_ILP32) \|\| (__riscv_xlen == 32)
178	s->info.print_insn = print_insn_riscv32;
179	#elif defined(_LP64)
180	s->info.print_insn = print_insn_riscv64;
181	#else
182	#error unsupported RISC-V ABI
183	#endif
a4038a00	184	#elif defined(__aarch64__)
12b6e9b2	185	s->info.cap_arch = CS_ARCH_ARM64;
a4038a00 RH	186	# ifdef CONFIG_ARM_A64_DIS
	187	s->info.print_insn = print_insn_arm_a64;
	188	# endif
12b6e9b2 RH	189	#elif defined(__alpha__)
	190	s->info.print_insn = print_insn_alpha;
	191	#elif defined(__sparc__)
	192	s->info.print_insn = print_insn_sparc;
	193	s->info.mach = bfd_mach_sparc_v9b;
	194	#elif defined(__arm__)
	195	/* TCG only generates code for arm mode. */
	196	s->info.print_insn = print_insn_arm;
	197	s->info.cap_arch = CS_ARCH_ARM;
	198	#elif defined(__MIPSEB__)
	199	s->info.print_insn = print_insn_big_mips;
	200	#elif defined(__MIPSEL__)
	201	s->info.print_insn = print_insn_little_mips;
	202	#elif defined(__m68k__)
	203	s->info.print_insn = print_insn_m68k;
	204	#elif defined(__s390__)
	205	s->info.print_insn = print_insn_s390;
3d562845 RH	206	s->info.cap_arch = CS_ARCH_SYSZ;
	207	s->info.cap_insn_unit = 2;
	208	s->info.cap_insn_split = 6;
12b6e9b2 RH	209	#elif defined(__hppa__)
	210	s->info.print_insn = print_insn_hppa;
	211	#endif
	212	}
	213
1d48474d	214	/* Disassemble this for me please... (debugging). */
d49190c4	215	void target_disas(FILE out, CPUState cpu, target_ulong code,
1d48474d	216	target_ulong size)
b9adb4a6	217	{
c27004ec	218	target_ulong pc;
b9adb4a6	219	int count;
f4359b9f	220	CPUDebug s;
b9adb4a6	221
12b6e9b2 RH	222	initialize_debug_target(&s, cpu);
	223	s.info.fprintf_func = fprintf;
	224	s.info.stream = out;
f4359b9f BS	225	s.info.buffer_vma = code;
f4359b9f BS	226	s.info.buffer_length = size;
37b9de46	227
8ca80760 RH	228	if (s.info.cap_arch >= 0 && cap_disas_target(&s.info, code, size)) {
	229	return;
	230	}
	231
2de295c5 PC	232	if (s.info.print_insn == NULL) {
2de295c5 PC	233	s.info.print_insn = print_insn_od_target;
c46ffd57	234	}
c6105c0a	235
7e000c2e	236	for (pc = code; size > 0; pc += count, size -= count) {
fa15e030	237	fprintf(out, "0x" TARGET_FMT_lx ": ", pc);
2de295c5	238	count = s.info.print_insn(pc, &s.info);
c27004ec FB	239	fprintf(out, "\n");
	240	if (count < 0)
	241	break;
754d00ae	242	if (size < count) {
	243	fprintf(out,
	244	"Disassembler disagrees with translator over instruction "
	245	"decoding\n"
	246	"Please report this to qemu-devel@nongnu.org\n");
	247	break;
	248	}
c27004ec FB	249	}
	250	}
	251
cbafa236 AB	252	static int plugin_printf(FILE stream, const char fmt, ...)
cbafa236 AB	253	{
b71f3a68 RH	254	/* We abuse the FILE parameter to pass a GString. */
b71f3a68 RH	255	GString s = (GString )stream;
cbafa236	256	int initial_len = s->len;
b71f3a68	257	va_list va;
cbafa236 AB	258
	259	va_start(va, fmt);
	260	g_string_append_vprintf(s, fmt, va);
	261	va_end(va);
	262
	263	return s->len - initial_len;
	264	}
	265
	266	static void plugin_print_address(bfd_vma addr, struct disassemble_info *info)
	267	{
	268	/* does nothing */
	269	}
	270
	271
cbafa236 AB	272	/*
	273	* We should only be dissembling one instruction at a time here. If
	274	* there is left over it usually indicates the front end has read more
	275	* bytes than it needed.
	276	*/
	277	char plugin_disas(CPUState cpu, uint64_t addr, size_t size)
	278	{
cbafa236	279	CPUDebug s;
b71f3a68	280	GString *ds = g_string_new(NULL);
cbafa236	281
12b6e9b2 RH	282	initialize_debug_target(&s, cpu);
12b6e9b2 RH	283	s.info.fprintf_func = plugin_printf;
b71f3a68	284	s.info.stream = (FILE )ds; / abuse this slot */
cbafa236 AB	285	s.info.buffer_vma = addr;
	286	s.info.buffer_length = size;
	287	s.info.print_address_func = plugin_print_address;
cbafa236 AB	288
cbafa236 AB	289	if (s.info.cap_arch >= 0 && cap_disas_plugin(&s.info, addr, size)) {
b71f3a68 RH	290	; /* done */
	291	} else if (s.info.print_insn) {
	292	s.info.print_insn(addr, &s.info);
	293	} else {
	294	; /* cannot disassemble -- return empty string */
cbafa236 AB	295	}
cbafa236 AB	296
b71f3a68 RH	297	/* Return the buffer, freeing the GString container. */
b71f3a68 RH	298	return g_string_free(ds, false);
cbafa236 AB	299	}
cbafa236 AB	300
c27004ec	301	/* Disassemble this for me please... (debugging). */
4c389f6e	302	void disas(FILE out, void code, unsigned long size)
c27004ec	303	{
b0b0f1c9	304	uintptr_t pc;
c27004ec	305	int count;
f4359b9f	306	CPUDebug s;
c27004ec	307
12b6e9b2 RH	308	initialize_debug_host(&s);
	309	s.info.fprintf_func = fprintf;
	310	s.info.stream = out;
f4359b9f BS	311	s.info.buffer = code;
	312	s.info.buffer_vma = (uintptr_t)code;
	313	s.info.buffer_length = size;
8ca80760	314
4c389f6e	315	if (s.info.cap_arch >= 0 && cap_disas_host(&s.info, code, size)) {
8ca80760 RH	316	return;
	317	}
	318
12b6e9b2 RH	319	if (s.info.print_insn == NULL) {
12b6e9b2 RH	320	s.info.print_insn = print_insn_od_host;
c46ffd57	321	}
b0b0f1c9 SW	322	for (pc = (uintptr_t)code; size > 0; pc += count, size -= count) {
b0b0f1c9 SW	323	fprintf(out, "0x%08" PRIxPTR ": ", pc);
12b6e9b2	324	count = s.info.print_insn(pc, &s.info);
e5ef4ec2 AB	325	fprintf(out, "\n");
	326	if (count < 0) {
	327	break;
	328	}
b9adb4a6	329	}
e5ef4ec2	330
b9adb4a6 FB	331	}
	332
	333	/* Look up symbol for debugging purpose. Returns "" if unknown. */
c27004ec	334	const char *lookup_symbol(target_ulong orig_addr)
b9adb4a6	335	{
49918a75	336	const char *symbol = "";
e80cfcfc	337	struct syminfo *s;
3b46e624	338
e80cfcfc	339	for (s = syminfos; s; s = s->next) {
49918a75 PB	340	symbol = s->lookup_symbol(s, orig_addr);
	341	if (symbol[0] != '\0') {
	342	break;
	343	}
b9adb4a6	344	}
49918a75 PB	345
49918a75 PB	346	return symbol;
b9adb4a6	347	}
9307c4c1 FB	348
	349	#if !defined(CONFIG_USER_ONLY)
	350
83c9089e	351	#include "monitor/monitor.h"
3d2cfdf1	352
9307c4c1	353	static int
b8d87208	354	physical_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
a5f1b965	355	struct disassemble_info *info)
9307c4c1	356	{
f2c6abc8	357	CPUDebug *s = container_of(info, CPUDebug, info);
6766ba50	358	MemTxResult res;
f2c6abc8	359
6766ba50 PMD	360	res = address_space_read(s->cpu->as, memaddr, MEMTXATTRS_UNSPECIFIED,
	361	myaddr, length);
	362	return res == MEMTX_OK ? 0 : EIO;
9307c4c1 FB	363	}
9307c4c1 FB	364
1d48474d	365	/* Disassembler for the monitor. */
d49190c4	366	void monitor_disas(Monitor mon, CPUState cpu,
1d48474d	367	target_ulong pc, int nb_insn, int is_physical)
9307c4c1	368	{
9307c4c1	369	int count, i;
f4359b9f	370	CPUDebug s;
9307c4c1	371
12b6e9b2 RH	372	initialize_debug_target(&s, cpu);
	373	s.info.fprintf_func = qemu_fprintf;
	374	if (is_physical) {
	375	s.info.read_memory_func = physical_read_memory;
37b9de46	376	}
12b6e9b2	377	s.info.buffer_vma = pc;
37b9de46	378
8ca80760 RH	379	if (s.info.cap_arch >= 0 && cap_disas_monitor(&s.info, pc, nb_insn)) {
	380	return;
	381	}
	382
37b9de46 PC	383	if (!s.info.print_insn) {
	384	monitor_printf(mon, "0x" TARGET_FMT_lx
	385	": Asm output not supported on this arch\n", pc);
	386	return;
	387	}
9307c4c1 FB	388
9307c4c1 FB	389	for(i = 0; i < nb_insn; i++) {
376253ec	390	monitor_printf(mon, "0x" TARGET_FMT_lx ": ", pc);
2de295c5	391	count = s.info.print_insn(pc, &s.info);
376253ec	392	monitor_printf(mon, "\n");
9307c4c1 FB	393	if (count < 0)
	394	break;
	395	pc += count;
	396	}
	397	}
	398	#endif