1 /* Disassemble support for GDB.
3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "gdb_string.h"
30 /* Disassemble functions.
31 FIXME: We should get rid of all the duplicate code in gdb that does
32 the same thing: disassemble_command() and the gdbtk variation. */
34 /* This Structure is used to store line number information.
35 We need a different sort of line table from the normal one cuz we can't
36 depend upon implicit line-end pc's for lines to do the
37 reordering in this function. */
46 /* Like target_read_memory, but slightly different parameters. */
48 dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr, unsigned int len,
49 struct disassemble_info *info)
51 return target_read_memory (memaddr, myaddr, len);
54 /* Like memory_error with slightly different parameters. */
56 dis_asm_memory_error (int status, bfd_vma memaddr,
57 struct disassemble_info *info)
59 memory_error (status, memaddr);
62 /* Like print_address with slightly different parameters. */
64 dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
66 struct gdbarch *gdbarch = info->application_data;
68 print_address (gdbarch, addr, info->stream);
72 compare_lines (const void *mle1p, const void *mle2p)
74 struct dis_line_entry *mle1, *mle2;
77 mle1 = (struct dis_line_entry *) mle1p;
78 mle2 = (struct dis_line_entry *) mle2p;
80 val = mle1->line - mle2->line;
85 return mle1->start_pc - mle2->start_pc;
89 dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout,
90 struct disassemble_info * di,
91 CORE_ADDR low, CORE_ADDR high,
92 int how_many, int flags, struct ui_stream *stb)
94 int num_displayed = 0;
97 /* parts of the symbolic representation of the address */
101 struct cleanup *ui_out_chain;
103 for (pc = low; pc < high;)
105 char *filename = NULL;
111 if (num_displayed >= how_many)
116 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
117 ui_out_text (uiout, pc_prefix (pc));
118 ui_out_field_core_addr (uiout, "address", gdbarch, pc);
120 if (!build_address_symbolic (gdbarch, pc, 0, &name, &offset, &filename,
123 /* We don't care now about line, filename and
124 unmapped. But we might in the future. */
125 ui_out_text (uiout, " <");
126 if ((flags & DISASSEMBLY_OMIT_FNAME) == 0)
127 ui_out_field_string (uiout, "func-name", name);
128 ui_out_text (uiout, "+");
129 ui_out_field_int (uiout, "offset", offset);
130 ui_out_text (uiout, ">:\t");
133 ui_out_text (uiout, ":\t");
135 if (filename != NULL)
140 ui_file_rewind (stb->stream);
141 if (flags & DISASSEMBLY_RAW_INSN)
143 CORE_ADDR old_pc = pc;
146 const char *spacer = "";
148 /* Build the opcodes using a temporary stream so we can
149 write them out in a single go for the MI. */
150 struct ui_stream *opcode_stream = ui_out_stream_new (uiout);
151 struct cleanup *cleanups =
152 make_cleanup_ui_out_stream_delete (opcode_stream);
154 pc += gdbarch_print_insn (gdbarch, pc, di);
155 for (;old_pc < pc; old_pc++)
157 status = (*di->read_memory_func) (old_pc, &data, 1, di);
159 (*di->memory_error_func) (status, old_pc, di);
160 fprintf_filtered (opcode_stream->stream, "%s%02x",
161 spacer, (unsigned) data);
164 ui_out_field_stream (uiout, "opcodes", opcode_stream);
165 ui_out_text (uiout, "\t");
167 do_cleanups (cleanups);
170 pc += gdbarch_print_insn (gdbarch, pc, di);
171 ui_out_field_stream (uiout, "inst", stb);
172 ui_file_rewind (stb->stream);
173 do_cleanups (ui_out_chain);
174 ui_out_text (uiout, "\n");
176 return num_displayed;
179 /* The idea here is to present a source-O-centric view of a
180 function to the user. This means that things are presented
181 in source order, with (possibly) out of order assembly
182 immediately following. */
185 do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout,
186 struct disassemble_info *di, int nlines,
187 struct linetable_entry *le,
188 CORE_ADDR low, CORE_ADDR high,
189 struct symtab *symtab,
190 int how_many, int flags, struct ui_stream *stb)
193 struct dis_line_entry *mle;
194 struct symtab_and_line sal;
196 int out_of_order = 0;
198 int num_displayed = 0;
199 struct cleanup *ui_out_chain;
200 struct cleanup *ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
201 struct cleanup *ui_out_list_chain = make_cleanup (null_cleanup, 0);
203 mle = (struct dis_line_entry *) alloca (nlines
204 * sizeof (struct dis_line_entry));
206 /* Copy linetable entries for this function into our data
207 structure, creating end_pc's and setting out_of_order as
210 /* First, skip all the preceding functions. */
212 for (i = 0; i < nlines - 1 && le[i].pc < low; i++);
214 /* Now, copy all entries before the end of this function. */
216 for (; i < nlines - 1 && le[i].pc < high; i++)
218 if (le[i].line == le[i + 1].line && le[i].pc == le[i + 1].pc)
219 continue; /* Ignore duplicates. */
221 /* Skip any end-of-function markers. */
225 mle[newlines].line = le[i].line;
226 if (le[i].line > le[i + 1].line)
228 mle[newlines].start_pc = le[i].pc;
229 mle[newlines].end_pc = le[i + 1].pc;
233 /* If we're on the last line, and it's part of the function,
234 then we need to get the end pc in a special way. */
236 if (i == nlines - 1 && le[i].pc < high)
238 mle[newlines].line = le[i].line;
239 mle[newlines].start_pc = le[i].pc;
240 sal = find_pc_line (le[i].pc, 0);
241 mle[newlines].end_pc = sal.end;
245 /* Now, sort mle by line #s (and, then by addresses within
249 qsort (mle, newlines, sizeof (struct dis_line_entry), compare_lines);
251 /* Now, for each line entry, emit the specified lines (unless
252 they have been emitted before), followed by the assembly code
255 ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
257 for (i = 0; i < newlines; i++)
259 /* Print out everything from next_line to the current line. */
260 if (mle[i].line >= next_line)
264 /* Just one line to print. */
265 if (next_line == mle[i].line)
268 = make_cleanup_ui_out_tuple_begin_end (uiout,
270 print_source_lines (symtab, next_line, mle[i].line + 1, 0);
274 /* Several source lines w/o asm instructions associated. */
275 for (; next_line < mle[i].line; next_line++)
277 struct cleanup *ui_out_list_chain_line;
278 struct cleanup *ui_out_tuple_chain_line;
280 ui_out_tuple_chain_line
281 = make_cleanup_ui_out_tuple_begin_end (uiout,
283 print_source_lines (symtab, next_line, next_line + 1,
285 ui_out_list_chain_line
286 = make_cleanup_ui_out_list_begin_end (uiout,
288 do_cleanups (ui_out_list_chain_line);
289 do_cleanups (ui_out_tuple_chain_line);
291 /* Print the last line and leave list open for
292 asm instructions to be added. */
294 = make_cleanup_ui_out_tuple_begin_end (uiout,
296 print_source_lines (symtab, next_line, mle[i].line + 1, 0);
302 = make_cleanup_ui_out_tuple_begin_end (uiout,
304 print_source_lines (symtab, mle[i].line, mle[i].line + 1, 0);
307 next_line = mle[i].line + 1;
309 = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
312 num_displayed += dump_insns (gdbarch, uiout, di,
313 mle[i].start_pc, mle[i].end_pc,
314 how_many, flags, stb);
316 /* When we've reached the end of the mle array, or we've seen the last
317 assembly range for this source line, close out the list/tuple. */
318 if (i == (newlines - 1) || mle[i + 1].line > mle[i].line)
320 do_cleanups (ui_out_list_chain);
321 do_cleanups (ui_out_tuple_chain);
322 ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
323 ui_out_list_chain = make_cleanup (null_cleanup, 0);
324 ui_out_text (uiout, "\n");
326 if (how_many >= 0 && num_displayed >= how_many)
329 do_cleanups (ui_out_chain);
334 do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
335 struct disassemble_info * di,
336 CORE_ADDR low, CORE_ADDR high,
337 int how_many, int flags, struct ui_stream *stb)
339 int num_displayed = 0;
340 struct cleanup *ui_out_chain;
342 ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
344 num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many,
347 do_cleanups (ui_out_chain);
350 /* Initialize the disassemble info struct ready for the specified
353 static int ATTRIBUTE_PRINTF (2, 3)
354 fprintf_disasm (void *stream, const char *format, ...)
358 va_start (args, format);
359 vfprintf_filtered (stream, format, args);
361 /* Something non -ve. */
365 static struct disassemble_info
366 gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file)
368 struct disassemble_info di;
370 init_disassemble_info (&di, file, fprintf_disasm);
371 di.flavour = bfd_target_unknown_flavour;
372 di.memory_error_func = dis_asm_memory_error;
373 di.print_address_func = dis_asm_print_address;
374 /* NOTE: cagney/2003-04-28: The original code, from the old Insight
375 disassembler had a local optomization here. By default it would
376 access the executable file, instead of the target memory (there
377 was a growing list of exceptions though). Unfortunately, the
378 heuristic was flawed. Commands like "disassemble &variable"
379 didn't work as they relied on the access going to the target.
380 Further, it has been supperseeded by trust-read-only-sections
381 (although that should be superseeded by target_trust..._p()). */
382 di.read_memory_func = dis_asm_read_memory;
383 di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
384 di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
385 di.endian = gdbarch_byte_order (gdbarch);
386 di.endian_code = gdbarch_byte_order_for_code (gdbarch);
387 di.application_data = gdbarch;
388 disassemble_init_for_target (&di);
393 gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
394 char *file_string, int flags, int how_many,
395 CORE_ADDR low, CORE_ADDR high)
397 struct ui_stream *stb = ui_out_stream_new (uiout);
398 struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
399 struct disassemble_info di = gdb_disassemble_info (gdbarch, stb->stream);
400 /* To collect the instruction outputted from opcodes. */
401 struct symtab *symtab = NULL;
402 struct linetable_entry *le = NULL;
405 /* Assume symtab is valid for whole PC range. */
406 symtab = find_pc_symtab (low);
408 if (symtab != NULL && symtab->linetable != NULL)
410 /* Convert the linetable to a bunch of my_line_entry's. */
411 le = symtab->linetable->item;
412 nlines = symtab->linetable->nitems;
415 if (!(flags & DISASSEMBLY_SOURCE) || nlines <= 0
416 || symtab == NULL || symtab->linetable == NULL)
417 do_assembly_only (gdbarch, uiout, &di, low, high, how_many, flags, stb);
419 else if (flags & DISASSEMBLY_SOURCE)
420 do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low,
421 high, symtab, how_many, flags, stb);
423 do_cleanups (cleanups);
424 gdb_flush (gdb_stdout);
427 /* Print the instruction at address MEMADDR in debugged memory,
428 on STREAM. Returns the length of the instruction, in bytes,
429 and, if requested, the number of branch delay slot instructions. */
432 gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
433 struct ui_file *stream, int *branch_delay_insns)
435 struct disassemble_info di;
438 di = gdb_disassemble_info (gdbarch, stream);
439 length = gdbarch_print_insn (gdbarch, memaddr, &di);
440 if (branch_delay_insns)
442 if (di.insn_info_valid)
443 *branch_delay_insns = di.branch_delay_insns;
445 *branch_delay_insns = 0;
451 do_ui_file_delete (void *arg)
453 ui_file_delete (arg);
456 /* Return the length in bytes of the instruction at address MEMADDR in
460 gdb_insn_length (struct gdbarch *gdbarch, CORE_ADDR addr)
462 static struct ui_file *null_stream = NULL;
464 /* Dummy file descriptor for the disassembler. */
467 null_stream = ui_file_new ();
468 make_final_cleanup (do_ui_file_delete, null_stream);
471 return gdb_print_insn (gdbarch, addr, null_stream, NULL);
474 /* fprintf-function for gdb_buffered_insn_length. This function is a
475 nop, we don't want to print anything, we just want to compute the
476 length of the insn. */
478 static int ATTRIBUTE_PRINTF (2, 3)
479 gdb_buffered_insn_length_fprintf (void *stream, const char *format, ...)
484 /* Initialize a struct disassemble_info for gdb_buffered_insn_length. */
487 gdb_buffered_insn_length_init_dis (struct gdbarch *gdbarch,
488 struct disassemble_info *di,
489 const gdb_byte *insn, int max_len,
492 init_disassemble_info (di, NULL, gdb_buffered_insn_length_fprintf);
494 /* init_disassemble_info installs buffer_read_memory, etc.
495 so we don't need to do that here.
496 The cast is necessary until disassemble_info is const-ified. */
497 di->buffer = (gdb_byte *) insn;
498 di->buffer_length = max_len;
499 di->buffer_vma = addr;
501 di->arch = gdbarch_bfd_arch_info (gdbarch)->arch;
502 di->mach = gdbarch_bfd_arch_info (gdbarch)->mach;
503 di->endian = gdbarch_byte_order (gdbarch);
504 di->endian_code = gdbarch_byte_order_for_code (gdbarch);
506 disassemble_init_for_target (di);
509 /* Return the length in bytes of INSN. MAX_LEN is the size of the
510 buffer containing INSN. */
513 gdb_buffered_insn_length (struct gdbarch *gdbarch,
514 const gdb_byte *insn, int max_len, CORE_ADDR addr)
516 struct disassemble_info di;
518 gdb_buffered_insn_length_init_dis (gdbarch, &di, insn, max_len, addr);
520 return gdbarch_print_insn (gdbarch, addr, &di);