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