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");
126 if (filename
!= NULL
)
131 ui_file_rewind (stb
->stream
);
132 pc
+= TARGET_PRINT_INSN (pc
, di
);
133 ui_out_field_stream (uiout
, "inst", stb
);
134 ui_file_rewind (stb
->stream
);
135 do_cleanups (ui_out_chain
);
136 ui_out_text (uiout
, "\n");
138 return num_displayed
;
141 /* The idea here is to present a source-O-centric view of a
142 function to the user. This means that things are presented
143 in source order, with (possibly) out of order assembly
144 immediately following. */
146 do_mixed_source_and_assembly (struct ui_out
*uiout
,
147 struct disassemble_info
*di
, int nlines
,
148 struct linetable_entry
*le
,
149 CORE_ADDR low
, CORE_ADDR high
,
150 struct symtab
*symtab
,
151 int how_many
, struct ui_stream
*stb
)
154 struct dis_line_entry
*mle
;
155 struct symtab_and_line sal
;
157 int out_of_order
= 0;
160 int num_displayed
= 0;
161 struct cleanup
*ui_out_chain
;
163 mle
= (struct dis_line_entry
*) alloca (nlines
164 * sizeof (struct dis_line_entry
));
166 /* Copy linetable entries for this function into our data
167 structure, creating end_pc's and setting out_of_order as
170 /* First, skip all the preceding functions. */
172 for (i
= 0; i
< nlines
- 1 && le
[i
].pc
< low
; i
++);
174 /* Now, copy all entries before the end of this function. */
176 for (; i
< nlines
- 1 && le
[i
].pc
< high
; i
++)
178 if (le
[i
].line
== le
[i
+ 1].line
&& le
[i
].pc
== le
[i
+ 1].pc
)
179 continue; /* Ignore duplicates */
181 /* Skip any end-of-function markers. */
185 mle
[newlines
].line
= le
[i
].line
;
186 if (le
[i
].line
> le
[i
+ 1].line
)
188 mle
[newlines
].start_pc
= le
[i
].pc
;
189 mle
[newlines
].end_pc
= le
[i
+ 1].pc
;
193 /* If we're on the last line, and it's part of the function,
194 then we need to get the end pc in a special way. */
196 if (i
== nlines
- 1 && le
[i
].pc
< high
)
198 mle
[newlines
].line
= le
[i
].line
;
199 mle
[newlines
].start_pc
= le
[i
].pc
;
200 sal
= find_pc_line (le
[i
].pc
, 0);
201 mle
[newlines
].end_pc
= sal
.end
;
205 /* Now, sort mle by line #s (and, then by addresses within
209 qsort (mle
, newlines
, sizeof (struct dis_line_entry
), compare_lines
);
211 /* Now, for each line entry, emit the specified lines (unless
212 they have been emitted before), followed by the assembly code
215 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
217 for (i
= 0; i
< newlines
; i
++)
219 struct cleanup
*ui_out_tuple_chain
= NULL
;
220 struct cleanup
*ui_out_list_chain
= NULL
;
223 /* Print out everything from next_line to the current line. */
224 if (mle
[i
].line
>= next_line
)
228 /* Just one line to print. */
229 if (next_line
== mle
[i
].line
)
232 = make_cleanup_ui_out_tuple_begin_end (uiout
,
234 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, 0);
238 /* Several source lines w/o asm instructions associated. */
239 for (; next_line
< mle
[i
].line
; next_line
++)
241 struct cleanup
*ui_out_list_chain_line
;
242 struct cleanup
*ui_out_tuple_chain_line
;
244 ui_out_tuple_chain_line
245 = make_cleanup_ui_out_tuple_begin_end (uiout
,
247 print_source_lines (symtab
, next_line
, next_line
+ 1,
249 ui_out_list_chain_line
250 = make_cleanup_ui_out_list_begin_end (uiout
,
252 do_cleanups (ui_out_list_chain_line
);
253 do_cleanups (ui_out_tuple_chain_line
);
255 /* Print the last line and leave list open for
256 asm instructions to be added. */
258 = make_cleanup_ui_out_tuple_begin_end (uiout
,
260 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, 0);
266 = make_cleanup_ui_out_tuple_begin_end (uiout
, "src_and_asm_line");
267 print_source_lines (symtab
, mle
[i
].line
, mle
[i
].line
+ 1, 0);
270 next_line
= mle
[i
].line
+ 1;
272 = make_cleanup_ui_out_list_begin_end (uiout
, "line_asm_insn");
273 /* Don't close the list if the lines are not in order. */
274 if (i
< (newlines
- 1) && mle
[i
+ 1].line
<= mle
[i
].line
)
278 num_displayed
+= dump_insns (uiout
, di
, mle
[i
].start_pc
, mle
[i
].end_pc
,
282 do_cleanups (ui_out_list_chain
);
283 do_cleanups (ui_out_tuple_chain
);
284 ui_out_text (uiout
, "\n");
288 if (num_displayed
>= how_many
)
291 do_cleanups (ui_out_chain
);
296 do_assembly_only (struct ui_out
*uiout
, disassemble_info
* di
,
297 CORE_ADDR low
, CORE_ADDR high
,
298 int how_many
, struct ui_stream
*stb
)
300 int num_displayed
= 0;
301 struct cleanup
*ui_out_chain
;
303 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
305 num_displayed
= dump_insns (uiout
, di
, low
, high
, how_many
, stb
);
307 do_cleanups (ui_out_chain
);
310 /* Initialize the disassemble info struct ready for the specified
313 static disassemble_info
314 gdb_disassemble_info (struct gdbarch
*gdbarch
, struct ui_file
*file
)
317 INIT_DISASSEMBLE_INFO_NO_ARCH (di
, file
,
318 (fprintf_ftype
) fprintf_filtered
);
319 di
.flavour
= bfd_target_unknown_flavour
;
320 di
.memory_error_func
= dis_asm_memory_error
;
321 di
.print_address_func
= dis_asm_print_address
;
322 /* NOTE: cagney/2003-04-28: The original code, from the old Insight
323 disassembler had a local optomization here. By default it would
324 access the executable file, instead of the target memory (there
325 was a growing list of exceptions though). Unfortunatly, the
326 heuristic was flawed. Commands like "disassemble &variable"
327 didn't work as they relied on the access going to the target.
328 Further, it has been supperseeded by trust-read-only-sections
329 (although that should be superseeded by target_trust..._p()). */
330 di
.read_memory_func
= dis_asm_read_memory
;
331 di
.mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
332 di
.endian
= gdbarch_byte_order (gdbarch
);
337 gdb_disassembly (struct ui_out
*uiout
,
340 int mixed_source_and_assembly
,
341 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
343 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
344 struct cleanup
*cleanups
= make_cleanup_ui_out_stream_delete (stb
);
345 disassemble_info di
= gdb_disassemble_info (current_gdbarch
, stb
->stream
);
346 /* To collect the instruction outputted from opcodes. */
347 struct symtab
*symtab
= NULL
;
348 struct linetable_entry
*le
= NULL
;
351 /* Assume symtab is valid for whole PC range */
352 symtab
= find_pc_symtab (low
);
354 if (symtab
!= NULL
&& symtab
->linetable
!= NULL
)
356 /* Convert the linetable to a bunch of my_line_entry's. */
357 le
= symtab
->linetable
->item
;
358 nlines
= symtab
->linetable
->nitems
;
361 if (!mixed_source_and_assembly
|| nlines
<= 0
362 || symtab
== NULL
|| symtab
->linetable
== NULL
)
363 do_assembly_only (uiout
, &di
, low
, high
, how_many
, stb
);
365 else if (mixed_source_and_assembly
)
366 do_mixed_source_and_assembly (uiout
, &di
, nlines
, le
, low
,
367 high
, symtab
, how_many
, stb
);
369 do_cleanups (cleanups
);
370 gdb_flush (gdb_stdout
);
373 /* Print the instruction at address MEMADDR in debugged memory,
374 on STREAM. Returns length of the instruction, in bytes. */
377 gdb_print_insn (CORE_ADDR memaddr
, struct ui_file
*stream
)
379 disassemble_info di
= gdb_disassemble_info (current_gdbarch
, stream
);
380 return TARGET_PRINT_INSN (memaddr
, &di
);
384 /* FIXME: cagney/2003-04-28: This global deprecated_tm_print_insn_info
386 disassemble_info deprecated_tm_print_insn_info
;
388 extern void _initialize_disasm (void);
391 _initialize_disasm (void)
394 INIT_DISASSEMBLE_INFO_NO_ARCH (deprecated_tm_print_insn_info
, gdb_stdout
,
395 (fprintf_ftype
)fprintf_filtered
);
396 deprecated_tm_print_insn_info
.flavour
= bfd_target_unknown_flavour
;
397 deprecated_tm_print_insn_info
.read_memory_func
= dis_asm_read_memory
;
398 deprecated_tm_print_insn_info
.memory_error_func
= dis_asm_memory_error
;
399 deprecated_tm_print_insn_info
.print_address_func
= dis_asm_print_address
;