1 /* Disassemble support for GDB.
3 Copyright 2000, 2001, 2002, 2003, 2004 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
;
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 (uiout
, di
, mle
[i
].start_pc
, mle
[i
].end_pc
,
281 /* When we've reached the end of the mle array, or we've seen the last
282 assembly range for this source line, close out the list/tuple. */
283 if (i
== (newlines
- 1) || mle
[i
+ 1].line
> mle
[i
].line
)
285 do_cleanups (ui_out_list_chain
);
286 do_cleanups (ui_out_tuple_chain
);
287 ui_out_tuple_chain
= make_cleanup (null_cleanup
, 0);
288 ui_out_list_chain
= make_cleanup (null_cleanup
, 0);
289 ui_out_text (uiout
, "\n");
291 if (how_many
>= 0 && num_displayed
>= how_many
)
294 do_cleanups (ui_out_chain
);
299 do_assembly_only (struct ui_out
*uiout
, struct 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
317 fprintf_disasm (void *stream
, const char *format
, ...)
320 va_start (args
, format
);
321 vfprintf_filtered (stream
, format
, args
);
323 /* Something non -ve. */
327 static struct disassemble_info
328 gdb_disassemble_info (struct gdbarch
*gdbarch
, struct ui_file
*file
)
330 struct disassemble_info di
;
331 init_disassemble_info (&di
, file
, fprintf_disasm
);
332 di
.flavour
= bfd_target_unknown_flavour
;
333 di
.memory_error_func
= dis_asm_memory_error
;
334 di
.print_address_func
= dis_asm_print_address
;
335 /* NOTE: cagney/2003-04-28: The original code, from the old Insight
336 disassembler had a local optomization here. By default it would
337 access the executable file, instead of the target memory (there
338 was a growing list of exceptions though). Unfortunately, the
339 heuristic was flawed. Commands like "disassemble &variable"
340 didn't work as they relied on the access going to the target.
341 Further, it has been supperseeded by trust-read-only-sections
342 (although that should be superseeded by target_trust..._p()). */
343 di
.read_memory_func
= dis_asm_read_memory
;
344 di
.arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
345 di
.mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
346 di
.endian
= gdbarch_byte_order (gdbarch
);
351 gdb_disassembly (struct ui_out
*uiout
,
354 int mixed_source_and_assembly
,
355 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
357 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
358 struct cleanup
*cleanups
= make_cleanup_ui_out_stream_delete (stb
);
359 struct disassemble_info di
= gdb_disassemble_info (current_gdbarch
, stb
->stream
);
360 /* To collect the instruction outputted from opcodes. */
361 struct symtab
*symtab
= NULL
;
362 struct linetable_entry
*le
= NULL
;
365 /* Assume symtab is valid for whole PC range */
366 symtab
= find_pc_symtab (low
);
368 if (symtab
!= NULL
&& symtab
->linetable
!= NULL
)
370 /* Convert the linetable to a bunch of my_line_entry's. */
371 le
= symtab
->linetable
->item
;
372 nlines
= symtab
->linetable
->nitems
;
375 if (!mixed_source_and_assembly
|| nlines
<= 0
376 || symtab
== NULL
|| symtab
->linetable
== NULL
)
377 do_assembly_only (uiout
, &di
, low
, high
, how_many
, stb
);
379 else if (mixed_source_and_assembly
)
380 do_mixed_source_and_assembly (uiout
, &di
, nlines
, le
, low
,
381 high
, symtab
, how_many
, stb
);
383 do_cleanups (cleanups
);
384 gdb_flush (gdb_stdout
);
387 /* Print the instruction at address MEMADDR in debugged memory,
388 on STREAM. Returns length of the instruction, in bytes. */
391 gdb_print_insn (CORE_ADDR memaddr
, struct ui_file
*stream
)
393 struct disassemble_info di
= gdb_disassemble_info (current_gdbarch
, stream
);
394 return TARGET_PRINT_INSN (memaddr
, &di
);