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"
31 /* Disassemble functions.
32 FIXME: We should get rid of all the duplicate code in gdb that does
33 the same thing: disassemble_command() and the gdbtk variation. */
35 /* This Structure is used to store line number information.
36 We need a different sort of line table from the normal one cuz we can't
37 depend upon implicit line-end pc's for lines to do the
38 reordering in this function. */
47 /* Like target_read_memory, but slightly different parameters. */
49 dis_asm_read_memory (bfd_vma memaddr
, bfd_byte
*myaddr
, unsigned int len
,
50 struct disassemble_info
*info
)
52 return target_read_memory (memaddr
, (char *) myaddr
, len
);
55 /* Like memory_error with slightly different parameters. */
57 dis_asm_memory_error (int status
, bfd_vma memaddr
,
58 struct disassemble_info
*info
)
60 memory_error (status
, memaddr
);
63 /* Like print_address with slightly different parameters. */
65 dis_asm_print_address (bfd_vma addr
, struct disassemble_info
*info
)
67 print_address (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 ui_out
*uiout
, 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
+= TARGET_PRINT_INSN (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 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
;
168 mle
= (struct dis_line_entry
*) alloca (nlines
169 * sizeof (struct dis_line_entry
));
171 /* Copy linetable entries for this function into our data
172 structure, creating end_pc's and setting out_of_order as
175 /* First, skip all the preceding functions. */
177 for (i
= 0; i
< nlines
- 1 && le
[i
].pc
< low
; i
++);
179 /* Now, copy all entries before the end of this function. */
181 for (; i
< nlines
- 1 && le
[i
].pc
< high
; i
++)
183 if (le
[i
].line
== le
[i
+ 1].line
&& le
[i
].pc
== le
[i
+ 1].pc
)
184 continue; /* Ignore duplicates */
186 /* Skip any end-of-function markers. */
190 mle
[newlines
].line
= le
[i
].line
;
191 if (le
[i
].line
> le
[i
+ 1].line
)
193 mle
[newlines
].start_pc
= le
[i
].pc
;
194 mle
[newlines
].end_pc
= le
[i
+ 1].pc
;
198 /* If we're on the last line, and it's part of the function,
199 then we need to get the end pc in a special way. */
201 if (i
== nlines
- 1 && le
[i
].pc
< high
)
203 mle
[newlines
].line
= le
[i
].line
;
204 mle
[newlines
].start_pc
= le
[i
].pc
;
205 sal
= find_pc_line (le
[i
].pc
, 0);
206 mle
[newlines
].end_pc
= sal
.end
;
210 /* Now, sort mle by line #s (and, then by addresses within
214 qsort (mle
, newlines
, sizeof (struct dis_line_entry
), compare_lines
);
216 /* Now, for each line entry, emit the specified lines (unless
217 they have been emitted before), followed by the assembly code
220 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
222 for (i
= 0; i
< newlines
; i
++)
224 struct cleanup
*ui_out_tuple_chain
= NULL
;
225 struct cleanup
*ui_out_list_chain
= NULL
;
228 /* Print out everything from next_line to the current line. */
229 if (mle
[i
].line
>= next_line
)
233 /* Just one line to print. */
234 if (next_line
== mle
[i
].line
)
237 = make_cleanup_ui_out_tuple_begin_end (uiout
,
239 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, 0);
243 /* Several source lines w/o asm instructions associated. */
244 for (; next_line
< mle
[i
].line
; next_line
++)
246 struct cleanup
*ui_out_list_chain_line
;
247 struct cleanup
*ui_out_tuple_chain_line
;
249 ui_out_tuple_chain_line
250 = make_cleanup_ui_out_tuple_begin_end (uiout
,
252 print_source_lines (symtab
, next_line
, next_line
+ 1,
254 ui_out_list_chain_line
255 = make_cleanup_ui_out_list_begin_end (uiout
,
257 do_cleanups (ui_out_list_chain_line
);
258 do_cleanups (ui_out_tuple_chain_line
);
260 /* Print the last line and leave list open for
261 asm instructions to be added. */
263 = make_cleanup_ui_out_tuple_begin_end (uiout
,
265 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, 0);
271 = make_cleanup_ui_out_tuple_begin_end (uiout
, "src_and_asm_line");
272 print_source_lines (symtab
, mle
[i
].line
, mle
[i
].line
+ 1, 0);
275 next_line
= mle
[i
].line
+ 1;
277 = make_cleanup_ui_out_list_begin_end (uiout
, "line_asm_insn");
278 /* Don't close the list if the lines are not in order. */
279 if (i
< (newlines
- 1) && mle
[i
+ 1].line
<= mle
[i
].line
)
283 num_displayed
+= dump_insns (uiout
, di
, mle
[i
].start_pc
, mle
[i
].end_pc
,
287 do_cleanups (ui_out_list_chain
);
288 do_cleanups (ui_out_tuple_chain
);
289 ui_out_text (uiout
, "\n");
293 if (num_displayed
>= how_many
)
296 do_cleanups (ui_out_chain
);
301 do_assembly_only (struct ui_out
*uiout
, 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 (uiout
, di
, low
, high
, how_many
, stb
);
312 do_cleanups (ui_out_chain
);
315 /* Initialize the disassemble info struct ready for the specified
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
);
353 gdb_disassembly (struct ui_out
*uiout
,
356 int mixed_source_and_assembly
,
357 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
359 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
360 struct cleanup
*cleanups
= make_cleanup_ui_out_stream_delete (stb
);
361 struct disassemble_info di
= gdb_disassemble_info (current_gdbarch
, stb
->stream
);
362 /* To collect the instruction outputted from opcodes. */
363 struct symtab
*symtab
= NULL
;
364 struct linetable_entry
*le
= NULL
;
367 /* Assume symtab is valid for whole PC range */
368 symtab
= find_pc_symtab (low
);
370 if (symtab
!= NULL
&& symtab
->linetable
!= NULL
)
372 /* Convert the linetable to a bunch of my_line_entry's. */
373 le
= symtab
->linetable
->item
;
374 nlines
= symtab
->linetable
->nitems
;
377 if (!mixed_source_and_assembly
|| nlines
<= 0
378 || symtab
== NULL
|| symtab
->linetable
== NULL
)
379 do_assembly_only (uiout
, &di
, low
, high
, how_many
, stb
);
381 else if (mixed_source_and_assembly
)
382 do_mixed_source_and_assembly (uiout
, &di
, nlines
, le
, low
,
383 high
, symtab
, how_many
, stb
);
385 do_cleanups (cleanups
);
386 gdb_flush (gdb_stdout
);
389 /* Print the instruction at address MEMADDR in debugged memory,
390 on STREAM. Returns length of the instruction, in bytes. */
393 gdb_print_insn (CORE_ADDR memaddr
, struct ui_file
*stream
)
395 struct disassemble_info di
= gdb_disassemble_info (current_gdbarch
, stream
);
396 return TARGET_PRINT_INSN (memaddr
, &di
);