* disasm.c (gdb_disassemble_info): Call disassemble_init_for_target.
[external/binutils.git] / gdb / disasm.c
1 /* Disassemble support for GDB.
2
3    Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
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.
11
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.
16
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.  */
21
22 #include "defs.h"
23 #include "target.h"
24 #include "value.h"
25 #include "ui-out.h"
26 #include "gdb_string.h"
27 #include "disasm.h"
28 #include "gdbcore.h"
29 #include "dis-asm.h"
30
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. */
34
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.  */
39
40 struct dis_line_entry
41 {
42   int line;
43   CORE_ADDR start_pc;
44   CORE_ADDR end_pc;
45 };
46
47 /* Like target_read_memory, but slightly different parameters.  */
48 static int
49 dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr, unsigned int len,
50                      struct disassemble_info *info)
51 {
52   return target_read_memory (memaddr, (char *) myaddr, len);
53 }
54
55 /* Like memory_error with slightly different parameters.  */
56 static void
57 dis_asm_memory_error (int status, bfd_vma memaddr,
58                       struct disassemble_info *info)
59 {
60   memory_error (status, memaddr);
61 }
62
63 /* Like print_address with slightly different parameters.  */
64 static void
65 dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
66 {
67   print_address (addr, info->stream);
68 }
69
70 static int
71 compare_lines (const void *mle1p, const void *mle2p)
72 {
73   struct dis_line_entry *mle1, *mle2;
74   int val;
75
76   mle1 = (struct dis_line_entry *) mle1p;
77   mle2 = (struct dis_line_entry *) mle2p;
78
79   val = mle1->line - mle2->line;
80
81   if (val != 0)
82     return val;
83
84   return mle1->start_pc - mle2->start_pc;
85 }
86
87 static int
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)
91 {
92   int num_displayed = 0;
93   CORE_ADDR pc;
94
95   /* parts of the symbolic representation of the address */
96   int unmapped;
97   int offset;
98   int line;
99   struct cleanup *ui_out_chain;
100
101   for (pc = low; pc < high;)
102     {
103       char *filename = NULL;
104       char *name = NULL;
105
106       QUIT;
107       if (how_many >= 0)
108         {
109           if (num_displayed >= how_many)
110             break;
111           else
112             num_displayed++;
113         }
114       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
115       ui_out_field_core_addr (uiout, "address", pc);
116
117       if (!build_address_symbolic (pc, 0, &name, &offset, &filename,
118                                    &line, &unmapped))
119         {
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");
127         }
128       else
129         ui_out_text (uiout, ":\t");
130
131       if (filename != NULL)
132         xfree (filename);
133       if (name != NULL)
134         xfree (name);
135
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");
142     }
143   return num_displayed;
144 }
145
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.  */
150 static void
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)
157 {
158   int newlines = 0;
159   struct dis_line_entry *mle;
160   struct symtab_and_line sal;
161   int i;
162   int out_of_order = 0;
163   int next_line = 0;
164   CORE_ADDR pc;
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);
169
170   mle = (struct dis_line_entry *) alloca (nlines
171                                           * sizeof (struct dis_line_entry));
172
173   /* Copy linetable entries for this function into our data
174      structure, creating end_pc's and setting out_of_order as
175      appropriate.  */
176
177   /* First, skip all the preceding functions.  */
178
179   for (i = 0; i < nlines - 1 && le[i].pc < low; i++);
180
181   /* Now, copy all entries before the end of this function.  */
182
183   for (; i < nlines - 1 && le[i].pc < high; i++)
184     {
185       if (le[i].line == le[i + 1].line && le[i].pc == le[i + 1].pc)
186         continue;               /* Ignore duplicates */
187
188       /* Skip any end-of-function markers.  */
189       if (le[i].line == 0)
190         continue;
191
192       mle[newlines].line = le[i].line;
193       if (le[i].line > le[i + 1].line)
194         out_of_order = 1;
195       mle[newlines].start_pc = le[i].pc;
196       mle[newlines].end_pc = le[i + 1].pc;
197       newlines++;
198     }
199
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.  */
202
203   if (i == nlines - 1 && le[i].pc < high)
204     {
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;
209       newlines++;
210     }
211
212   /* Now, sort mle by line #s (and, then by addresses within
213      lines). */
214
215   if (out_of_order)
216     qsort (mle, newlines, sizeof (struct dis_line_entry), compare_lines);
217
218   /* Now, for each line entry, emit the specified lines (unless
219      they have been emitted before), followed by the assembly code
220      for that line.  */
221
222   ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
223
224   for (i = 0; i < newlines; i++)
225     {
226       /* Print out everything from next_line to the current line.  */
227       if (mle[i].line >= next_line)
228         {
229           if (next_line != 0)
230             {
231               /* Just one line to print. */
232               if (next_line == mle[i].line)
233                 {
234                   ui_out_tuple_chain
235                     = make_cleanup_ui_out_tuple_begin_end (uiout,
236                                                            "src_and_asm_line");
237                   print_source_lines (symtab, next_line, mle[i].line + 1, 0);
238                 }
239               else
240                 {
241                   /* Several source lines w/o asm instructions associated. */
242                   for (; next_line < mle[i].line; next_line++)
243                     {
244                       struct cleanup *ui_out_list_chain_line;
245                       struct cleanup *ui_out_tuple_chain_line;
246                       
247                       ui_out_tuple_chain_line
248                         = make_cleanup_ui_out_tuple_begin_end (uiout,
249                                                                "src_and_asm_line");
250                       print_source_lines (symtab, next_line, next_line + 1,
251                                           0);
252                       ui_out_list_chain_line
253                         = make_cleanup_ui_out_list_begin_end (uiout,
254                                                               "line_asm_insn");
255                       do_cleanups (ui_out_list_chain_line);
256                       do_cleanups (ui_out_tuple_chain_line);
257                     }
258                   /* Print the last line and leave list open for
259                      asm instructions to be added. */
260                   ui_out_tuple_chain
261                     = make_cleanup_ui_out_tuple_begin_end (uiout,
262                                                            "src_and_asm_line");
263                   print_source_lines (symtab, next_line, mle[i].line + 1, 0);
264                 }
265             }
266           else
267             {
268               ui_out_tuple_chain
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);
271             }
272
273           next_line = mle[i].line + 1;
274           ui_out_list_chain
275             = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
276         }
277
278       num_displayed += dump_insns (uiout, di, mle[i].start_pc, mle[i].end_pc,
279                                    how_many, stb);
280
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)
284         {
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");
290         }
291       if (how_many >= 0 && num_displayed >= how_many)
292         break;
293     }
294   do_cleanups (ui_out_chain);
295 }
296
297
298 static void
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)
302 {
303   int num_displayed = 0;
304   struct cleanup *ui_out_chain;
305
306   ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
307
308   num_displayed = dump_insns (uiout, di, low, high, how_many, stb);
309
310   do_cleanups (ui_out_chain);
311 }
312
313 /* Initialize the disassemble info struct ready for the specified
314    stream.  */
315
316 static int
317 fprintf_disasm (void *stream, const char *format, ...)
318 {
319   va_list args;
320   va_start (args, format);
321   vfprintf_filtered (stream, format, args);
322   va_end (args);
323   /* Something non -ve.  */
324   return 0;
325 }
326
327 static struct disassemble_info
328 gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file)
329 {
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);
347   disassemble_init_for_target (&di);
348   return di;
349 }
350
351 void
352 gdb_disassembly (struct ui_out *uiout,
353                 char *file_string,
354                 int line_num,
355                 int mixed_source_and_assembly,
356                 int how_many, CORE_ADDR low, CORE_ADDR high)
357 {
358   struct ui_stream *stb = ui_out_stream_new (uiout);
359   struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
360   struct disassemble_info di = gdb_disassemble_info (current_gdbarch, stb->stream);
361   /* To collect the instruction outputted from opcodes. */
362   struct symtab *symtab = NULL;
363   struct linetable_entry *le = NULL;
364   int nlines = -1;
365
366   /* Assume symtab is valid for whole PC range */
367   symtab = find_pc_symtab (low);
368
369   if (symtab != NULL && symtab->linetable != NULL)
370     {
371       /* Convert the linetable to a bunch of my_line_entry's.  */
372       le = symtab->linetable->item;
373       nlines = symtab->linetable->nitems;
374     }
375
376   if (!mixed_source_and_assembly || nlines <= 0
377       || symtab == NULL || symtab->linetable == NULL)
378     do_assembly_only (uiout, &di, low, high, how_many, stb);
379
380   else if (mixed_source_and_assembly)
381     do_mixed_source_and_assembly (uiout, &di, nlines, le, low,
382                                   high, symtab, how_many, stb);
383
384   do_cleanups (cleanups);
385   gdb_flush (gdb_stdout);
386 }
387
388 /* Print the instruction at address MEMADDR in debugged memory,
389    on STREAM.  Returns length of the instruction, in bytes.  */
390
391 int
392 gdb_print_insn (CORE_ADDR memaddr, struct ui_file *stream)
393 {
394   struct disassemble_info di = gdb_disassemble_info (current_gdbarch, stream);
395   return TARGET_PRINT_INSN (memaddr, &di);
396 }