1 /* Disassemble support for GDB.
3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
4 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
;
67 print_address (gdbarch
, addr
, info
->stream
);
71 compare_lines (const void *mle1p
, const void *mle2p
)
73 struct dis_line_entry
*mle1
, *mle2
;
76 mle1
= (struct dis_line_entry
*) mle1p
;
77 mle2
= (struct dis_line_entry
*) mle2p
;
79 val
= mle1
->line
- mle2
->line
;
84 return mle1
->start_pc
- mle2
->start_pc
;
88 dump_insns (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
89 struct disassemble_info
* di
,
90 CORE_ADDR low
, CORE_ADDR high
,
91 int how_many
, int flags
, struct ui_stream
*stb
)
93 int num_displayed
= 0;
96 /* parts of the symbolic representation of the address */
100 struct cleanup
*ui_out_chain
;
102 for (pc
= low
; pc
< high
;)
104 char *filename
= NULL
;
110 if (num_displayed
>= how_many
)
115 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
116 ui_out_text (uiout
, pc_prefix (pc
));
117 ui_out_field_core_addr (uiout
, "address", gdbarch
, pc
);
119 if (!build_address_symbolic (pc
, 0, &name
, &offset
, &filename
,
122 /* We don't care now about line, filename and
123 unmapped. But we might in the future. */
124 ui_out_text (uiout
, " <");
125 if ((flags
& DISASSEMBLY_OMIT_FNAME
) == 0)
126 ui_out_field_string (uiout
, "func-name", name
);
127 ui_out_text (uiout
, "+");
128 ui_out_field_int (uiout
, "offset", offset
);
129 ui_out_text (uiout
, ">:\t");
132 ui_out_text (uiout
, ":\t");
134 if (filename
!= NULL
)
139 ui_file_rewind (stb
->stream
);
140 if (flags
& DISASSEMBLY_RAW_INSN
)
142 CORE_ADDR old_pc
= pc
;
145 pc
+= gdbarch_print_insn (gdbarch
, pc
, di
);
146 for (;old_pc
< pc
; old_pc
++)
148 status
= (*di
->read_memory_func
) (old_pc
, &data
, 1, di
);
150 (*di
->memory_error_func
) (status
, old_pc
, di
);
151 ui_out_message (uiout
, 0, " %02x", (unsigned)data
);
153 ui_out_text (uiout
, "\t");
156 pc
+= gdbarch_print_insn (gdbarch
, pc
, di
);
157 ui_out_field_stream (uiout
, "inst", stb
);
158 ui_file_rewind (stb
->stream
);
159 do_cleanups (ui_out_chain
);
160 ui_out_text (uiout
, "\n");
162 return num_displayed
;
165 /* The idea here is to present a source-O-centric view of a
166 function to the user. This means that things are presented
167 in source order, with (possibly) out of order assembly
168 immediately following. */
170 do_mixed_source_and_assembly (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
171 struct disassemble_info
*di
, int nlines
,
172 struct linetable_entry
*le
,
173 CORE_ADDR low
, CORE_ADDR high
,
174 struct symtab
*symtab
,
175 int how_many
, int flags
, struct ui_stream
*stb
)
178 struct dis_line_entry
*mle
;
179 struct symtab_and_line sal
;
181 int out_of_order
= 0;
184 int num_displayed
= 0;
185 struct cleanup
*ui_out_chain
;
186 struct cleanup
*ui_out_tuple_chain
= make_cleanup (null_cleanup
, 0);
187 struct cleanup
*ui_out_list_chain
= make_cleanup (null_cleanup
, 0);
189 mle
= (struct dis_line_entry
*) alloca (nlines
190 * sizeof (struct dis_line_entry
));
192 /* Copy linetable entries for this function into our data
193 structure, creating end_pc's and setting out_of_order as
196 /* First, skip all the preceding functions. */
198 for (i
= 0; i
< nlines
- 1 && le
[i
].pc
< low
; i
++);
200 /* Now, copy all entries before the end of this function. */
202 for (; i
< nlines
- 1 && le
[i
].pc
< high
; i
++)
204 if (le
[i
].line
== le
[i
+ 1].line
&& le
[i
].pc
== le
[i
+ 1].pc
)
205 continue; /* Ignore duplicates */
207 /* Skip any end-of-function markers. */
211 mle
[newlines
].line
= le
[i
].line
;
212 if (le
[i
].line
> le
[i
+ 1].line
)
214 mle
[newlines
].start_pc
= le
[i
].pc
;
215 mle
[newlines
].end_pc
= le
[i
+ 1].pc
;
219 /* If we're on the last line, and it's part of the function,
220 then we need to get the end pc in a special way. */
222 if (i
== nlines
- 1 && le
[i
].pc
< high
)
224 mle
[newlines
].line
= le
[i
].line
;
225 mle
[newlines
].start_pc
= le
[i
].pc
;
226 sal
= find_pc_line (le
[i
].pc
, 0);
227 mle
[newlines
].end_pc
= sal
.end
;
231 /* Now, sort mle by line #s (and, then by addresses within
235 qsort (mle
, newlines
, sizeof (struct dis_line_entry
), compare_lines
);
237 /* Now, for each line entry, emit the specified lines (unless
238 they have been emitted before), followed by the assembly code
241 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
243 for (i
= 0; i
< newlines
; i
++)
245 /* Print out everything from next_line to the current line. */
246 if (mle
[i
].line
>= next_line
)
250 /* Just one line to print. */
251 if (next_line
== mle
[i
].line
)
254 = make_cleanup_ui_out_tuple_begin_end (uiout
,
256 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, 0);
260 /* Several source lines w/o asm instructions associated. */
261 for (; next_line
< mle
[i
].line
; next_line
++)
263 struct cleanup
*ui_out_list_chain_line
;
264 struct cleanup
*ui_out_tuple_chain_line
;
266 ui_out_tuple_chain_line
267 = make_cleanup_ui_out_tuple_begin_end (uiout
,
269 print_source_lines (symtab
, next_line
, next_line
+ 1,
271 ui_out_list_chain_line
272 = make_cleanup_ui_out_list_begin_end (uiout
,
274 do_cleanups (ui_out_list_chain_line
);
275 do_cleanups (ui_out_tuple_chain_line
);
277 /* Print the last line and leave list open for
278 asm instructions to be added. */
280 = make_cleanup_ui_out_tuple_begin_end (uiout
,
282 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, 0);
288 = make_cleanup_ui_out_tuple_begin_end (uiout
, "src_and_asm_line");
289 print_source_lines (symtab
, mle
[i
].line
, mle
[i
].line
+ 1, 0);
292 next_line
= mle
[i
].line
+ 1;
294 = make_cleanup_ui_out_list_begin_end (uiout
, "line_asm_insn");
297 num_displayed
+= dump_insns (gdbarch
, uiout
, di
,
298 mle
[i
].start_pc
, mle
[i
].end_pc
,
299 how_many
, flags
, stb
);
301 /* When we've reached the end of the mle array, or we've seen the last
302 assembly range for this source line, close out the list/tuple. */
303 if (i
== (newlines
- 1) || mle
[i
+ 1].line
> mle
[i
].line
)
305 do_cleanups (ui_out_list_chain
);
306 do_cleanups (ui_out_tuple_chain
);
307 ui_out_tuple_chain
= make_cleanup (null_cleanup
, 0);
308 ui_out_list_chain
= make_cleanup (null_cleanup
, 0);
309 ui_out_text (uiout
, "\n");
311 if (how_many
>= 0 && num_displayed
>= how_many
)
314 do_cleanups (ui_out_chain
);
319 do_assembly_only (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
320 struct disassemble_info
* di
,
321 CORE_ADDR low
, CORE_ADDR high
,
322 int how_many
, int flags
, struct ui_stream
*stb
)
324 int num_displayed
= 0;
325 struct cleanup
*ui_out_chain
;
327 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
329 num_displayed
= dump_insns (gdbarch
, uiout
, di
, low
, high
, how_many
,
332 do_cleanups (ui_out_chain
);
335 /* Initialize the disassemble info struct ready for the specified
338 static int ATTR_FORMAT (printf
, 2, 3)
339 fprintf_disasm (void *stream
, const char *format
, ...)
342 va_start (args
, format
);
343 vfprintf_filtered (stream
, format
, args
);
345 /* Something non -ve. */
349 static struct disassemble_info
350 gdb_disassemble_info (struct gdbarch
*gdbarch
, struct ui_file
*file
)
352 struct disassemble_info di
;
353 init_disassemble_info (&di
, file
, fprintf_disasm
);
354 di
.flavour
= bfd_target_unknown_flavour
;
355 di
.memory_error_func
= dis_asm_memory_error
;
356 di
.print_address_func
= dis_asm_print_address
;
357 /* NOTE: cagney/2003-04-28: The original code, from the old Insight
358 disassembler had a local optomization here. By default it would
359 access the executable file, instead of the target memory (there
360 was a growing list of exceptions though). Unfortunately, the
361 heuristic was flawed. Commands like "disassemble &variable"
362 didn't work as they relied on the access going to the target.
363 Further, it has been supperseeded by trust-read-only-sections
364 (although that should be superseeded by target_trust..._p()). */
365 di
.read_memory_func
= dis_asm_read_memory
;
366 di
.arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
367 di
.mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
368 di
.endian
= gdbarch_byte_order (gdbarch
);
369 di
.endian_code
= gdbarch_byte_order_for_code (gdbarch
);
370 di
.application_data
= gdbarch
;
371 disassemble_init_for_target (&di
);
376 gdb_disassembly (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
377 char *file_string
, int flags
, int how_many
,
378 CORE_ADDR low
, CORE_ADDR high
)
380 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
381 struct cleanup
*cleanups
= make_cleanup_ui_out_stream_delete (stb
);
382 struct disassemble_info di
= gdb_disassemble_info (gdbarch
, stb
->stream
);
383 /* To collect the instruction outputted from opcodes. */
384 struct symtab
*symtab
= NULL
;
385 struct linetable_entry
*le
= NULL
;
388 /* Assume symtab is valid for whole PC range */
389 symtab
= find_pc_symtab (low
);
391 if (symtab
!= NULL
&& symtab
->linetable
!= NULL
)
393 /* Convert the linetable to a bunch of my_line_entry's. */
394 le
= symtab
->linetable
->item
;
395 nlines
= symtab
->linetable
->nitems
;
398 if (!(flags
& DISASSEMBLY_SOURCE
) || nlines
<= 0
399 || symtab
== NULL
|| symtab
->linetable
== NULL
)
400 do_assembly_only (gdbarch
, uiout
, &di
, low
, high
, how_many
, flags
, stb
);
402 else if (flags
& DISASSEMBLY_SOURCE
)
403 do_mixed_source_and_assembly (gdbarch
, uiout
, &di
, nlines
, le
, low
,
404 high
, symtab
, how_many
, flags
, stb
);
406 do_cleanups (cleanups
);
407 gdb_flush (gdb_stdout
);
410 /* Print the instruction at address MEMADDR in debugged memory,
411 on STREAM. Returns the length of the instruction, in bytes,
412 and, if requested, the number of branch delay slot instructions. */
415 gdb_print_insn (struct gdbarch
*gdbarch
, CORE_ADDR memaddr
,
416 struct ui_file
*stream
, int *branch_delay_insns
)
418 struct disassemble_info di
;
421 di
= gdb_disassemble_info (gdbarch
, stream
);
422 length
= gdbarch_print_insn (gdbarch
, memaddr
, &di
);
423 if (branch_delay_insns
)
425 if (di
.insn_info_valid
)
426 *branch_delay_insns
= di
.branch_delay_insns
;
428 *branch_delay_insns
= 0;