1 /* Disassemble support for GDB.
3 Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
26 #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
, bfd_byte
*myaddr
, unsigned int len
,
49 disassemble_info
*info
)
51 return target_read_memory (memaddr
, (char *) myaddr
, len
);
54 /* Like memory_error with slightly different parameters. */
56 dis_asm_memory_error (int status
, bfd_vma memaddr
, disassemble_info
*info
)
58 memory_error (status
, memaddr
);
61 /* Like print_address with slightly different parameters. */
63 dis_asm_print_address (bfd_vma addr
, struct disassemble_info
*info
)
65 print_address (addr
, info
->stream
);
69 compare_lines (const void *mle1p
, const void *mle2p
)
71 struct dis_line_entry
*mle1
, *mle2
;
74 mle1
= (struct dis_line_entry
*) mle1p
;
75 mle2
= (struct dis_line_entry
*) mle2p
;
77 val
= mle1
->line
- mle2
->line
;
82 return mle1
->start_pc
- mle2
->start_pc
;
86 dump_insns (struct ui_out
*uiout
, disassemble_info
* di
,
87 CORE_ADDR low
, CORE_ADDR high
,
88 int how_many
, struct ui_stream
*stb
)
90 int num_displayed
= 0;
93 /* parts of the symbolic representation of the address */
97 struct cleanup
*ui_out_chain
;
99 for (pc
= low
; pc
< high
;)
101 char *filename
= NULL
;
107 if (num_displayed
>= how_many
)
112 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
113 ui_out_field_core_addr (uiout
, "address", pc
);
115 if (!build_address_symbolic (pc
, 0, &name
, &offset
, &filename
,
118 /* We don't care now about line, filename and
119 unmapped. But we might in the future. */
120 ui_out_text (uiout
, " <");
121 ui_out_field_string (uiout
, "func-name", name
);
122 ui_out_text (uiout
, "+");
123 ui_out_field_int (uiout
, "offset", offset
);
124 ui_out_text (uiout
, ">:\t");
127 ui_out_text (uiout
, ":\t");
129 if (filename
!= NULL
)
134 ui_file_rewind (stb
->stream
);
135 pc
+= TARGET_PRINT_INSN (pc
, di
);
136 ui_out_field_stream (uiout
, "inst", stb
);
137 ui_file_rewind (stb
->stream
);
138 do_cleanups (ui_out_chain
);
139 ui_out_text (uiout
, "\n");
141 return num_displayed
;
144 /* The idea here is to present a source-O-centric view of a
145 function to the user. This means that things are presented
146 in source order, with (possibly) out of order assembly
147 immediately following. */
149 do_mixed_source_and_assembly (struct ui_out
*uiout
,
150 struct disassemble_info
*di
, int nlines
,
151 struct linetable_entry
*le
,
152 CORE_ADDR low
, CORE_ADDR high
,
153 struct symtab
*symtab
,
154 int how_many
, struct ui_stream
*stb
)
157 struct dis_line_entry
*mle
;
158 struct symtab_and_line sal
;
160 int out_of_order
= 0;
163 int num_displayed
= 0;
164 struct cleanup
*ui_out_chain
;
166 mle
= (struct dis_line_entry
*) alloca (nlines
167 * sizeof (struct dis_line_entry
));
169 /* Copy linetable entries for this function into our data
170 structure, creating end_pc's and setting out_of_order as
173 /* First, skip all the preceding functions. */
175 for (i
= 0; i
< nlines
- 1 && le
[i
].pc
< low
; i
++);
177 /* Now, copy all entries before the end of this function. */
179 for (; i
< nlines
- 1 && le
[i
].pc
< high
; i
++)
181 if (le
[i
].line
== le
[i
+ 1].line
&& le
[i
].pc
== le
[i
+ 1].pc
)
182 continue; /* Ignore duplicates */
184 /* Skip any end-of-function markers. */
188 mle
[newlines
].line
= le
[i
].line
;
189 if (le
[i
].line
> le
[i
+ 1].line
)
191 mle
[newlines
].start_pc
= le
[i
].pc
;
192 mle
[newlines
].end_pc
= le
[i
+ 1].pc
;
196 /* If we're on the last line, and it's part of the function,
197 then we need to get the end pc in a special way. */
199 if (i
== nlines
- 1 && le
[i
].pc
< high
)
201 mle
[newlines
].line
= le
[i
].line
;
202 mle
[newlines
].start_pc
= le
[i
].pc
;
203 sal
= find_pc_line (le
[i
].pc
, 0);
204 mle
[newlines
].end_pc
= sal
.end
;
208 /* Now, sort mle by line #s (and, then by addresses within
212 qsort (mle
, newlines
, sizeof (struct dis_line_entry
), compare_lines
);
214 /* Now, for each line entry, emit the specified lines (unless
215 they have been emitted before), followed by the assembly code
218 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
220 for (i
= 0; i
< newlines
; i
++)
222 struct cleanup
*ui_out_tuple_chain
= NULL
;
223 struct cleanup
*ui_out_list_chain
= NULL
;
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");
276 /* Don't close the list if the lines are not in order. */
277 if (i
< (newlines
- 1) && mle
[i
+ 1].line
<= mle
[i
].line
)
281 num_displayed
+= dump_insns (uiout
, di
, mle
[i
].start_pc
, mle
[i
].end_pc
,
285 do_cleanups (ui_out_list_chain
);
286 do_cleanups (ui_out_tuple_chain
);
287 ui_out_text (uiout
, "\n");
291 if (num_displayed
>= how_many
)
294 do_cleanups (ui_out_chain
);
299 do_assembly_only (struct ui_out
*uiout
, disassemble_info
* di
,
300 CORE_ADDR low
, CORE_ADDR high
,
301 int how_many
, struct ui_stream
*stb
)
303 int num_displayed
= 0;
304 struct cleanup
*ui_out_chain
;
306 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
308 num_displayed
= dump_insns (uiout
, di
, low
, high
, how_many
, stb
);
310 do_cleanups (ui_out_chain
);
313 /* Initialize the disassemble info struct ready for the specified
316 static disassemble_info
317 gdb_disassemble_info (struct gdbarch
*gdbarch
, struct ui_file
*file
)
320 INIT_DISASSEMBLE_INFO_NO_ARCH (di
, file
,
321 (fprintf_ftype
) fprintf_filtered
);
322 di
.flavour
= bfd_target_unknown_flavour
;
323 di
.memory_error_func
= dis_asm_memory_error
;
324 di
.print_address_func
= dis_asm_print_address
;
325 /* NOTE: cagney/2003-04-28: The original code, from the old Insight
326 disassembler had a local optomization here. By default it would
327 access the executable file, instead of the target memory (there
328 was a growing list of exceptions though). Unfortunatly, the
329 heuristic was flawed. Commands like "disassemble &variable"
330 didn't work as they relied on the access going to the target.
331 Further, it has been supperseeded by trust-read-only-sections
332 (although that should be superseeded by target_trust..._p()). */
333 di
.read_memory_func
= dis_asm_read_memory
;
334 di
.arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
335 di
.mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
336 di
.endian
= gdbarch_byte_order (gdbarch
);
342 gdb_disassembly (struct ui_out
*uiout
,
345 int mixed_source_and_assembly
,
346 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
348 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
349 struct cleanup
*cleanups
= make_cleanup_ui_out_stream_delete (stb
);
350 disassemble_info di
= gdb_disassemble_info (current_gdbarch
, stb
->stream
);
351 /* To collect the instruction outputted from opcodes. */
352 struct symtab
*symtab
= NULL
;
353 struct linetable_entry
*le
= NULL
;
356 /* Assume symtab is valid for whole PC range */
357 symtab
= find_pc_symtab (low
);
359 if (symtab
!= NULL
&& symtab
->linetable
!= NULL
)
361 /* Convert the linetable to a bunch of my_line_entry's. */
362 le
= symtab
->linetable
->item
;
363 nlines
= symtab
->linetable
->nitems
;
366 if (!mixed_source_and_assembly
|| nlines
<= 0
367 || symtab
== NULL
|| symtab
->linetable
== NULL
)
368 do_assembly_only (uiout
, &di
, low
, high
, how_many
, stb
);
370 else if (mixed_source_and_assembly
)
371 do_mixed_source_and_assembly (uiout
, &di
, nlines
, le
, low
,
372 high
, symtab
, how_many
, stb
);
374 do_cleanups (cleanups
);
375 gdb_flush (gdb_stdout
);
378 /* Print the instruction at address MEMADDR in debugged memory,
379 on STREAM. Returns length of the instruction, in bytes. */
382 gdb_print_insn (CORE_ADDR memaddr
, struct ui_file
*stream
)
384 disassemble_info di
= gdb_disassemble_info (current_gdbarch
, stream
);
385 return TARGET_PRINT_INSN (memaddr
, &di
);
389 /* FIXME: cagney/2003-04-28: This global deprecated_tm_print_insn_info
391 disassemble_info deprecated_tm_print_insn_info
;
393 extern void _initialize_disasm (void);
396 _initialize_disasm (void)
399 INIT_DISASSEMBLE_INFO_NO_ARCH (deprecated_tm_print_insn_info
, gdb_stdout
,
400 (fprintf_ftype
)fprintf_filtered
);
401 deprecated_tm_print_insn_info
.flavour
= bfd_target_unknown_flavour
;
402 deprecated_tm_print_insn_info
.read_memory_func
= dis_asm_read_memory
;
403 deprecated_tm_print_insn_info
.memory_error_func
= dis_asm_memory_error
;
404 deprecated_tm_print_insn_info
.print_address_func
= dis_asm_print_address
;