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);
341 gdb_disassembly (struct ui_out *uiout,
344 int mixed_source_and_assembly,
345 int how_many, CORE_ADDR low, CORE_ADDR high)
347 struct ui_stream *stb = ui_out_stream_new (uiout);
348 struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
349 disassemble_info di = gdb_disassemble_info (current_gdbarch, stb->stream);
350 /* To collect the instruction outputted from opcodes. */
351 struct symtab *symtab = NULL;
352 struct linetable_entry *le = NULL;
355 /* Assume symtab is valid for whole PC range */
356 symtab = find_pc_symtab (low);
358 if (symtab != NULL && symtab->linetable != NULL)
360 /* Convert the linetable to a bunch of my_line_entry's. */
361 le = symtab->linetable->item;
362 nlines = symtab->linetable->nitems;
365 if (!mixed_source_and_assembly || nlines <= 0
366 || symtab == NULL || symtab->linetable == NULL)
367 do_assembly_only (uiout, &di, low, high, how_many, stb);
369 else if (mixed_source_and_assembly)
370 do_mixed_source_and_assembly (uiout, &di, nlines, le, low,
371 high, symtab, how_many, stb);
373 do_cleanups (cleanups);
374 gdb_flush (gdb_stdout);
377 /* Print the instruction at address MEMADDR in debugged memory,
378 on STREAM. Returns length of the instruction, in bytes. */
381 gdb_print_insn (CORE_ADDR memaddr, struct ui_file *stream)
383 disassemble_info di = gdb_disassemble_info (current_gdbarch, stream);
384 return TARGET_PRINT_INSN (memaddr, &di);
388 /* FIXME: cagney/2003-04-28: This global deprecated_tm_print_insn_info
390 disassemble_info deprecated_tm_print_insn_info;
392 extern void _initialize_disasm (void);
395 _initialize_disasm (void)
398 INIT_DISASSEMBLE_INFO_NO_ARCH (deprecated_tm_print_insn_info, gdb_stdout,
399 (fprintf_ftype)fprintf_filtered);
400 deprecated_tm_print_insn_info.flavour = bfd_target_unknown_flavour;
401 deprecated_tm_print_insn_info.read_memory_func = dis_asm_read_memory;
402 deprecated_tm_print_insn_info.memory_error_func = dis_asm_memory_error;
403 deprecated_tm_print_insn_info.print_address_func = dis_asm_print_address;