/* Disassemble support for GDB.
- Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007
+ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
This file is part of GDB.
static void
dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
{
- print_address (addr, info->stream);
+ struct gdbarch *gdbarch = info->application_data;
+
+ print_address (gdbarch, addr, info->stream);
}
static int
}
static int
-dump_insns (struct ui_out *uiout, struct disassemble_info * di,
+dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout,
+ struct disassemble_info * di,
CORE_ADDR low, CORE_ADDR high,
- int how_many, struct ui_stream *stb)
+ int how_many, int flags, struct ui_stream *stb)
{
int num_displayed = 0;
CORE_ADDR pc;
num_displayed++;
}
ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- ui_out_field_core_addr (uiout, "address", pc);
+ ui_out_text (uiout, pc_prefix (pc));
+ ui_out_field_core_addr (uiout, "address", gdbarch, pc);
- if (!build_address_symbolic (pc, 0, &name, &offset, &filename,
+ if (!build_address_symbolic (gdbarch, pc, 0, &name, &offset, &filename,
&line, &unmapped))
{
/* We don't care now about line, filename and
unmapped. But we might in the future. */
ui_out_text (uiout, " <");
- ui_out_field_string (uiout, "func-name", name);
+ if ((flags & DISASSEMBLY_OMIT_FNAME) == 0)
+ ui_out_field_string (uiout, "func-name", name);
ui_out_text (uiout, "+");
ui_out_field_int (uiout, "offset", offset);
ui_out_text (uiout, ">:\t");
xfree (name);
ui_file_rewind (stb->stream);
- pc += gdbarch_print_insn (current_gdbarch, pc, di);
+ if (flags & DISASSEMBLY_RAW_INSN)
+ {
+ CORE_ADDR old_pc = pc;
+ bfd_byte data;
+ int status;
+
+ pc += gdbarch_print_insn (gdbarch, pc, di);
+ for (;old_pc < pc; old_pc++)
+ {
+ status = (*di->read_memory_func) (old_pc, &data, 1, di);
+ if (status != 0)
+ (*di->memory_error_func) (status, old_pc, di);
+ ui_out_message (uiout, 0, " %02x", (unsigned)data);
+ }
+ ui_out_text (uiout, "\t");
+ }
+ else
+ pc += gdbarch_print_insn (gdbarch, pc, di);
ui_out_field_stream (uiout, "inst", stb);
ui_file_rewind (stb->stream);
do_cleanups (ui_out_chain);
in source order, with (possibly) out of order assembly
immediately following. */
static void
-do_mixed_source_and_assembly (struct ui_out *uiout,
+do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout,
struct disassemble_info *di, int nlines,
struct linetable_entry *le,
CORE_ADDR low, CORE_ADDR high,
struct symtab *symtab,
- int how_many, struct ui_stream *stb)
+ int how_many, int flags, struct ui_stream *stb)
{
int newlines = 0;
struct dis_line_entry *mle;
int i;
int out_of_order = 0;
int next_line = 0;
- CORE_ADDR pc;
int num_displayed = 0;
struct cleanup *ui_out_chain;
struct cleanup *ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
= make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
}
- num_displayed += dump_insns (uiout, di, mle[i].start_pc, mle[i].end_pc,
- how_many, stb);
+ num_displayed += dump_insns (gdbarch, uiout, di,
+ mle[i].start_pc, mle[i].end_pc,
+ how_many, flags, stb);
/* When we've reached the end of the mle array, or we've seen the last
assembly range for this source line, close out the list/tuple. */
static void
-do_assembly_only (struct ui_out *uiout, struct disassemble_info * di,
+do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
+ struct disassemble_info * di,
CORE_ADDR low, CORE_ADDR high,
- int how_many, struct ui_stream *stb)
+ int how_many, int flags, struct ui_stream *stb)
{
int num_displayed = 0;
struct cleanup *ui_out_chain;
ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
- num_displayed = dump_insns (uiout, di, low, high, how_many, stb);
+ num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many,
+ flags, stb);
do_cleanups (ui_out_chain);
}
/* Initialize the disassemble info struct ready for the specified
stream. */
-static int ATTR_FORMAT (printf, 2, 3)
+static int ATTRIBUTE_PRINTF (2, 3)
fprintf_disasm (void *stream, const char *format, ...)
{
va_list args;
+
va_start (args, format);
vfprintf_filtered (stream, format, args);
va_end (args);
gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file)
{
struct disassemble_info di;
+
init_disassemble_info (&di, file, fprintf_disasm);
di.flavour = bfd_target_unknown_flavour;
di.memory_error_func = dis_asm_memory_error;
di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
di.endian = gdbarch_byte_order (gdbarch);
+ di.endian_code = gdbarch_byte_order_for_code (gdbarch);
+ di.application_data = gdbarch;
disassemble_init_for_target (&di);
return di;
}
void
-gdb_disassembly (struct ui_out *uiout,
- char *file_string,
- int line_num,
- int mixed_source_and_assembly,
- int how_many, CORE_ADDR low, CORE_ADDR high)
+gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
+ char *file_string, int flags, int how_many,
+ CORE_ADDR low, CORE_ADDR high)
{
struct ui_stream *stb = ui_out_stream_new (uiout);
struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
- struct disassemble_info di = gdb_disassemble_info (current_gdbarch, stb->stream);
+ struct disassemble_info di = gdb_disassemble_info (gdbarch, stb->stream);
/* To collect the instruction outputted from opcodes. */
struct symtab *symtab = NULL;
struct linetable_entry *le = NULL;
nlines = symtab->linetable->nitems;
}
- if (!mixed_source_and_assembly || nlines <= 0
+ if (!(flags & DISASSEMBLY_SOURCE) || nlines <= 0
|| symtab == NULL || symtab->linetable == NULL)
- do_assembly_only (uiout, &di, low, high, how_many, stb);
+ do_assembly_only (gdbarch, uiout, &di, low, high, how_many, flags, stb);
- else if (mixed_source_and_assembly)
- do_mixed_source_and_assembly (uiout, &di, nlines, le, low,
- high, symtab, how_many, stb);
+ else if (flags & DISASSEMBLY_SOURCE)
+ do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low,
+ high, symtab, how_many, flags, stb);
do_cleanups (cleanups);
gdb_flush (gdb_stdout);
and, if requested, the number of branch delay slot instructions. */
int
-gdb_print_insn (CORE_ADDR memaddr, struct ui_file *stream,
- int *branch_delay_insns)
+gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
+ struct ui_file *stream, int *branch_delay_insns)
{
struct disassemble_info di;
int length;
- di = gdb_disassemble_info (current_gdbarch, stream);
- length = gdbarch_print_insn (current_gdbarch, memaddr, &di);
+ di = gdb_disassemble_info (gdbarch, stream);
+ length = gdbarch_print_insn (gdbarch, memaddr, &di);
if (branch_delay_insns)
{
if (di.insn_info_valid)
}
return length;
}
+
+static void
+do_ui_file_delete (void *arg)
+{
+ ui_file_delete (arg);
+}
+
+/* Return the length in bytes of the instruction at address MEMADDR in
+ debugged memory. */
+
+int
+gdb_insn_length (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+ static struct ui_file *null_stream = NULL;
+
+ /* Dummy file descriptor for the disassembler. */
+ if (!null_stream)
+ {
+ null_stream = ui_file_new ();
+ make_final_cleanup (do_ui_file_delete, null_stream);
+ }
+
+ return gdb_print_insn (gdbarch, addr, null_stream, NULL);
+}
+
+/* fprintf-function for gdb_buffered_insn_length. This function is a
+ nop, we don't want to print anything, we just want to compute the
+ length of the insn. */
+
+static int ATTRIBUTE_PRINTF (2, 3)
+gdb_buffered_insn_length_fprintf (void *stream, const char *format, ...)
+{
+ return 0;
+}
+
+/* Initialize a struct disassemble_info for gdb_buffered_insn_length. */
+
+static void
+gdb_buffered_insn_length_init_dis (struct gdbarch *gdbarch,
+ struct disassemble_info *di,
+ const gdb_byte *insn, int max_len,
+ CORE_ADDR addr)
+{
+ init_disassemble_info (di, NULL, gdb_buffered_insn_length_fprintf);
+
+ /* init_disassemble_info installs buffer_read_memory, etc.
+ so we don't need to do that here.
+ The cast is necessary until disassemble_info is const-ified. */
+ di->buffer = (gdb_byte *) insn;
+ di->buffer_length = max_len;
+ di->buffer_vma = addr;
+
+ di->arch = gdbarch_bfd_arch_info (gdbarch)->arch;
+ di->mach = gdbarch_bfd_arch_info (gdbarch)->mach;
+ di->endian = gdbarch_byte_order (gdbarch);
+ di->endian_code = gdbarch_byte_order_for_code (gdbarch);
+
+ disassemble_init_for_target (di);
+}
+
+/* Return the length in bytes of INSN. MAX_LEN is the size of the
+ buffer containing INSN. */
+
+int
+gdb_buffered_insn_length (struct gdbarch *gdbarch,
+ const gdb_byte *insn, int max_len, CORE_ADDR addr)
+{
+ struct disassemble_info di;
+
+ gdb_buffered_insn_length_init_dis (gdbarch, &di, insn, max_len, addr);
+
+ return gdbarch_print_insn (gdbarch, addr, &di);
+}