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 print_address (addr
, info
->stream
);
70 compare_lines (const void *mle1p
, const void *mle2p
)
72 struct dis_line_entry
*mle1
, *mle2
;
75 mle1
= (struct dis_line_entry
*) mle1p
;
76 mle2
= (struct dis_line_entry
*) mle2p
;
78 val
= mle1
->line
- mle2
->line
;
83 return mle1
->start_pc
- mle2
->start_pc
;
87 dump_insns (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
88 struct disassemble_info
* di
,
89 CORE_ADDR low
, CORE_ADDR high
,
90 int how_many
, struct ui_stream
*stb
)
92 int num_displayed
= 0;
95 /* parts of the symbolic representation of the address */
99 struct cleanup
*ui_out_chain
;
101 for (pc
= low
; pc
< high
;)
103 char *filename
= NULL
;
109 if (num_displayed
>= how_many
)
114 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
115 ui_out_field_core_addr (uiout
, "address", pc
);
117 if (!build_address_symbolic (pc
, 0, &name
, &offset
, &filename
,
120 /* We don't care now about line, filename and
121 unmapped. But we might in the future. */
122 ui_out_text (uiout
, " <");
123 ui_out_field_string (uiout
, "func-name", name
);
124 ui_out_text (uiout
, "+");
125 ui_out_field_int (uiout
, "offset", offset
);
126 ui_out_text (uiout
, ">:\t");
129 ui_out_text (uiout
, ":\t");
131 if (filename
!= NULL
)
136 ui_file_rewind (stb
->stream
);
137 pc
+= gdbarch_print_insn (gdbarch
, pc
, di
);
138 ui_out_field_stream (uiout
, "inst", stb
);
139 ui_file_rewind (stb
->stream
);
140 do_cleanups (ui_out_chain
);
141 ui_out_text (uiout
, "\n");
143 return num_displayed
;
146 /* The idea here is to present a source-O-centric view of a
147 function to the user. This means that things are presented
148 in source order, with (possibly) out of order assembly
149 immediately following. */
151 do_mixed_source_and_assembly (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
152 struct disassemble_info
*di
, int nlines
,
153 struct linetable_entry
*le
,
154 CORE_ADDR low
, CORE_ADDR high
,
155 struct symtab
*symtab
,
156 int how_many
, struct ui_stream
*stb
)
159 struct dis_line_entry
*mle
;
160 struct symtab_and_line sal
;
162 int out_of_order
= 0;
165 int num_displayed
= 0;
166 struct cleanup
*ui_out_chain
;
167 struct cleanup
*ui_out_tuple_chain
= make_cleanup (null_cleanup
, 0);
168 struct cleanup
*ui_out_list_chain
= make_cleanup (null_cleanup
, 0);
170 mle
= (struct dis_line_entry
*) alloca (nlines
171 * sizeof (struct dis_line_entry
));
173 /* Copy linetable entries for this function into our data
174 structure, creating end_pc's and setting out_of_order as
177 /* First, skip all the preceding functions. */
179 for (i
= 0; i
< nlines
- 1 && le
[i
].pc
< low
; i
++);
181 /* Now, copy all entries before the end of this function. */
183 for (; i
< nlines
- 1 && le
[i
].pc
< high
; i
++)
185 if (le
[i
].line
== le
[i
+ 1].line
&& le
[i
].pc
== le
[i
+ 1].pc
)
186 continue; /* Ignore duplicates */
188 /* Skip any end-of-function markers. */
192 mle
[newlines
].line
= le
[i
].line
;
193 if (le
[i
].line
> le
[i
+ 1].line
)
195 mle
[newlines
].start_pc
= le
[i
].pc
;
196 mle
[newlines
].end_pc
= le
[i
+ 1].pc
;
200 /* If we're on the last line, and it's part of the function,
201 then we need to get the end pc in a special way. */
203 if (i
== nlines
- 1 && le
[i
].pc
< high
)
205 mle
[newlines
].line
= le
[i
].line
;
206 mle
[newlines
].start_pc
= le
[i
].pc
;
207 sal
= find_pc_line (le
[i
].pc
, 0);
208 mle
[newlines
].end_pc
= sal
.end
;
212 /* Now, sort mle by line #s (and, then by addresses within
216 qsort (mle
, newlines
, sizeof (struct dis_line_entry
), compare_lines
);
218 /* Now, for each line entry, emit the specified lines (unless
219 they have been emitted before), followed by the assembly code
222 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
224 for (i
= 0; i
< newlines
; i
++)
226 /* Print out everything from next_line to the current line. */
227 if (mle
[i
].line
>= next_line
)
231 /* Just one line to print. */
232 if (next_line
== mle
[i
].line
)
235 = make_cleanup_ui_out_tuple_begin_end (uiout
,
237 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, 0);
241 /* Several source lines w/o asm instructions associated. */
242 for (; next_line
< mle
[i
].line
; next_line
++)
244 struct cleanup
*ui_out_list_chain_line
;
245 struct cleanup
*ui_out_tuple_chain_line
;
247 ui_out_tuple_chain_line
248 = make_cleanup_ui_out_tuple_begin_end (uiout
,
250 print_source_lines (symtab
, next_line
, next_line
+ 1,
252 ui_out_list_chain_line
253 = make_cleanup_ui_out_list_begin_end (uiout
,
255 do_cleanups (ui_out_list_chain_line
);
256 do_cleanups (ui_out_tuple_chain_line
);
258 /* Print the last line and leave list open for
259 asm instructions to be added. */
261 = make_cleanup_ui_out_tuple_begin_end (uiout
,
263 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, 0);
269 = make_cleanup_ui_out_tuple_begin_end (uiout
, "src_and_asm_line");
270 print_source_lines (symtab
, mle
[i
].line
, mle
[i
].line
+ 1, 0);
273 next_line
= mle
[i
].line
+ 1;
275 = make_cleanup_ui_out_list_begin_end (uiout
, "line_asm_insn");
278 num_displayed
+= dump_insns (gdbarch
, uiout
, di
,
279 mle
[i
].start_pc
, mle
[i
].end_pc
,
282 /* When we've reached the end of the mle array, or we've seen the last
283 assembly range for this source line, close out the list/tuple. */
284 if (i
== (newlines
- 1) || mle
[i
+ 1].line
> mle
[i
].line
)
286 do_cleanups (ui_out_list_chain
);
287 do_cleanups (ui_out_tuple_chain
);
288 ui_out_tuple_chain
= make_cleanup (null_cleanup
, 0);
289 ui_out_list_chain
= make_cleanup (null_cleanup
, 0);
290 ui_out_text (uiout
, "\n");
292 if (how_many
>= 0 && num_displayed
>= how_many
)
295 do_cleanups (ui_out_chain
);
300 do_assembly_only (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
301 struct disassemble_info
* di
,
302 CORE_ADDR low
, CORE_ADDR high
,
303 int how_many
, struct ui_stream
*stb
)
305 int num_displayed
= 0;
306 struct cleanup
*ui_out_chain
;
308 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
310 num_displayed
= dump_insns (gdbarch
, uiout
, di
, low
, high
, how_many
, stb
);
312 do_cleanups (ui_out_chain
);
315 /* Initialize the disassemble info struct ready for the specified
318 static int ATTR_FORMAT (printf
, 2, 3)
319 fprintf_disasm (void *stream
, const char *format
, ...)
322 va_start (args
, format
);
323 vfprintf_filtered (stream
, format
, args
);
325 /* Something non -ve. */
329 static struct disassemble_info
330 gdb_disassemble_info (struct gdbarch
*gdbarch
, struct ui_file
*file
)
332 struct disassemble_info di
;
333 init_disassemble_info (&di
, file
, fprintf_disasm
);
334 di
.flavour
= bfd_target_unknown_flavour
;
335 di
.memory_error_func
= dis_asm_memory_error
;
336 di
.print_address_func
= dis_asm_print_address
;
337 /* NOTE: cagney/2003-04-28: The original code, from the old Insight
338 disassembler had a local optomization here. By default it would
339 access the executable file, instead of the target memory (there
340 was a growing list of exceptions though). Unfortunately, the
341 heuristic was flawed. Commands like "disassemble &variable"
342 didn't work as they relied on the access going to the target.
343 Further, it has been supperseeded by trust-read-only-sections
344 (although that should be superseeded by target_trust..._p()). */
345 di
.read_memory_func
= dis_asm_read_memory
;
346 di
.arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
347 di
.mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
348 di
.endian
= gdbarch_byte_order (gdbarch
);
349 di
.endian_code
= gdbarch_byte_order_for_code (gdbarch
);
350 disassemble_init_for_target (&di
);
355 gdb_disassembly (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
357 int mixed_source_and_assembly
,
358 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
360 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
361 struct cleanup
*cleanups
= make_cleanup_ui_out_stream_delete (stb
);
362 struct disassemble_info di
= gdb_disassemble_info (gdbarch
, stb
->stream
);
363 /* To collect the instruction outputted from opcodes. */
364 struct symtab
*symtab
= NULL
;
365 struct linetable_entry
*le
= NULL
;
368 /* Assume symtab is valid for whole PC range */
369 symtab
= find_pc_symtab (low
);
371 if (symtab
!= NULL
&& symtab
->linetable
!= NULL
)
373 /* Convert the linetable to a bunch of my_line_entry's. */
374 le
= symtab
->linetable
->item
;
375 nlines
= symtab
->linetable
->nitems
;
378 if (!mixed_source_and_assembly
|| nlines
<= 0
379 || symtab
== NULL
|| symtab
->linetable
== NULL
)
380 do_assembly_only (gdbarch
, uiout
, &di
, low
, high
, how_many
, stb
);
382 else if (mixed_source_and_assembly
)
383 do_mixed_source_and_assembly (gdbarch
, uiout
, &di
, nlines
, le
, low
,
384 high
, symtab
, how_many
, stb
);
386 do_cleanups (cleanups
);
387 gdb_flush (gdb_stdout
);
390 /* Print the instruction at address MEMADDR in debugged memory,
391 on STREAM. Returns the length of the instruction, in bytes,
392 and, if requested, the number of branch delay slot instructions. */
395 gdb_print_insn (struct gdbarch
*gdbarch
, CORE_ADDR memaddr
,
396 struct ui_file
*stream
, int *branch_delay_insns
)
398 struct disassemble_info di
;
401 di
= gdb_disassemble_info (gdbarch
, stream
);
402 length
= gdbarch_print_insn (gdbarch
, memaddr
, &di
);
403 if (branch_delay_insns
)
405 if (di
.insn_info_valid
)
406 *branch_delay_insns
= di
.branch_delay_insns
;
408 *branch_delay_insns
= 0;