GDB (xrefs)
/tmp/gdb-7.10/gdb/disasm.c
Go to the documentation of this file.
1 /* Disassemble support for GDB.
2 
3  Copyright (C) 2000-2015 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 3 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, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "target.h"
22 #include "value.h"
23 #include "ui-out.h"
24 #include "disasm.h"
25 #include "gdbcore.h"
26 #include "dis-asm.h"
27 
28 /* Disassemble functions.
29  FIXME: We should get rid of all the duplicate code in gdb that does
30  the same thing: disassemble_command() and the gdbtk variation. */
31 
32 /* This Structure is used to store line number information.
33  We need a different sort of line table from the normal one cuz we can't
34  depend upon implicit line-end pc's for lines to do the
35  reordering in this function. */
36 
38 {
39  int line;
42 };
43 
44 /* Like target_read_memory, but slightly different parameters. */
45 static int
46 dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr, unsigned int len,
47  struct disassemble_info *info)
48 {
49  return target_read_code (memaddr, myaddr, len);
50 }
51 
52 /* Like memory_error with slightly different parameters. */
53 static void
54 dis_asm_memory_error (int status, bfd_vma memaddr,
55  struct disassemble_info *info)
56 {
57  memory_error (status, memaddr);
58 }
59 
60 /* Like print_address with slightly different parameters. */
61 static void
62 dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
63 {
64  struct gdbarch *gdbarch = info->application_data;
65 
66  print_address (gdbarch, addr, info->stream);
67 }
68 
69 static int
70 compare_lines (const void *mle1p, const void *mle2p)
71 {
72  struct dis_line_entry *mle1, *mle2;
73  int val;
74 
75  mle1 = (struct dis_line_entry *) mle1p;
76  mle2 = (struct dis_line_entry *) mle2p;
77 
78  /* End of sequence markers have a line number of 0 but don't want to
79  be sorted to the head of the list, instead sort by PC. */
80  if (mle1->line == 0 || mle2->line == 0)
81  {
82  val = mle1->start_pc - mle2->start_pc;
83  if (val == 0)
84  val = mle1->line - mle2->line;
85  }
86  else
87  {
88  val = mle1->line - mle2->line;
89  if (val == 0)
90  val = mle1->start_pc - mle2->start_pc;
91  }
92  return val;
93 }
94 
95 static int
96 dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout,
97  struct disassemble_info * di,
98  CORE_ADDR low, CORE_ADDR high,
99  int how_many, int flags, struct ui_file *stb)
100 {
101  int num_displayed = 0;
102  CORE_ADDR pc;
103 
104  /* parts of the symbolic representation of the address */
105  int unmapped;
106  int offset;
107  int line;
108  struct cleanup *ui_out_chain;
109 
110  for (pc = low; pc < high;)
111  {
112  char *filename = NULL;
113  char *name = NULL;
114 
115  QUIT;
116  if (how_many >= 0)
117  {
118  if (num_displayed >= how_many)
119  break;
120  else
121  num_displayed++;
122  }
123  ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
124 
125  if ((flags & DISASSEMBLY_OMIT_PC) == 0)
126  ui_out_text (uiout, pc_prefix (pc));
127  ui_out_field_core_addr (uiout, "address", gdbarch, pc);
128 
129  if (!build_address_symbolic (gdbarch, pc, 0, &name, &offset, &filename,
130  &line, &unmapped))
131  {
132  /* We don't care now about line, filename and
133  unmapped. But we might in the future. */
134  ui_out_text (uiout, " <");
135  if ((flags & DISASSEMBLY_OMIT_FNAME) == 0)
136  ui_out_field_string (uiout, "func-name", name);
137  ui_out_text (uiout, "+");
138  ui_out_field_int (uiout, "offset", offset);
139  ui_out_text (uiout, ">:\t");
140  }
141  else
142  ui_out_text (uiout, ":\t");
143 
144  if (filename != NULL)
145  xfree (filename);
146  if (name != NULL)
147  xfree (name);
148 
149  ui_file_rewind (stb);
150  if (flags & DISASSEMBLY_RAW_INSN)
151  {
152  CORE_ADDR old_pc = pc;
153  bfd_byte data;
154  int status;
155  const char *spacer = "";
156 
157  /* Build the opcodes using a temporary stream so we can
158  write them out in a single go for the MI. */
159  struct ui_file *opcode_stream = mem_fileopen ();
160  struct cleanup *cleanups =
161  make_cleanup_ui_file_delete (opcode_stream);
162 
163  pc += gdbarch_print_insn (gdbarch, pc, di);
164  for (;old_pc < pc; old_pc++)
165  {
166  status = (*di->read_memory_func) (old_pc, &data, 1, di);
167  if (status != 0)
168  (*di->memory_error_func) (status, old_pc, di);
169  fprintf_filtered (opcode_stream, "%s%02x",
170  spacer, (unsigned) data);
171  spacer = " ";
172  }
173  ui_out_field_stream (uiout, "opcodes", opcode_stream);
174  ui_out_text (uiout, "\t");
175 
176  do_cleanups (cleanups);
177  }
178  else
179  pc += gdbarch_print_insn (gdbarch, pc, di);
180  ui_out_field_stream (uiout, "inst", stb);
181  ui_file_rewind (stb);
182  do_cleanups (ui_out_chain);
183  ui_out_text (uiout, "\n");
184  }
185  return num_displayed;
186 }
187 
188 /* The idea here is to present a source-O-centric view of a
189  function to the user. This means that things are presented
190  in source order, with (possibly) out of order assembly
191  immediately following. */
192 
193 static void
195  struct disassemble_info *di, int nlines,
196  struct linetable_entry *le,
197  CORE_ADDR low, CORE_ADDR high,
198  struct symtab *symtab,
199  int how_many, int flags, struct ui_file *stb)
200 {
201  int newlines = 0;
202  struct dis_line_entry *mle;
203  struct symtab_and_line sal;
204  int i;
205  int out_of_order = 0;
206  int next_line = 0;
207  int num_displayed = 0;
208  enum print_source_lines_flags psl_flags = 0;
209  struct cleanup *ui_out_chain;
210  struct cleanup *ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
211  struct cleanup *ui_out_list_chain = make_cleanup (null_cleanup, 0);
212 
213  if (flags & DISASSEMBLY_FILENAME)
214  psl_flags |= PRINT_SOURCE_LINES_FILENAME;
215 
216  mle = (struct dis_line_entry *) alloca (nlines
217  * sizeof (struct dis_line_entry));
218 
219  /* Copy linetable entries for this function into our data
220  structure, creating end_pc's and setting out_of_order as
221  appropriate. */
222 
223  /* First, skip all the preceding functions. */
224 
225  for (i = 0; i < nlines - 1 && le[i].pc < low; i++);
226 
227  /* Now, copy all entries before the end of this function. */
228 
229  for (; i < nlines - 1 && le[i].pc < high; i++)
230  {
231  if (le[i].line == le[i + 1].line && le[i].pc == le[i + 1].pc)
232  continue; /* Ignore duplicates. */
233 
234  /* Skip any end-of-function markers. */
235  if (le[i].line == 0)
236  continue;
237 
238  mle[newlines].line = le[i].line;
239  if (le[i].line > le[i + 1].line)
240  out_of_order = 1;
241  mle[newlines].start_pc = le[i].pc;
242  mle[newlines].end_pc = le[i + 1].pc;
243  newlines++;
244  }
245 
246  /* If we're on the last line, and it's part of the function,
247  then we need to get the end pc in a special way. */
248 
249  if (i == nlines - 1 && le[i].pc < high)
250  {
251  mle[newlines].line = le[i].line;
252  mle[newlines].start_pc = le[i].pc;
253  sal = find_pc_line (le[i].pc, 0);
254  mle[newlines].end_pc = sal.end;
255  newlines++;
256  }
257 
258  /* Now, sort mle by line #s (and, then by addresses within
259  lines). */
260 
261  if (out_of_order)
262  qsort (mle, newlines, sizeof (struct dis_line_entry), compare_lines);
263 
264  /* Now, for each line entry, emit the specified lines (unless
265  they have been emitted before), followed by the assembly code
266  for that line. */
267 
268  ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
269 
270  for (i = 0; i < newlines; i++)
271  {
272  /* Print out everything from next_line to the current line. */
273  if (mle[i].line >= next_line)
274  {
275  if (next_line != 0)
276  {
277  /* Just one line to print. */
278  if (next_line == mle[i].line)
279  {
280  ui_out_tuple_chain
282  "src_and_asm_line");
283  print_source_lines (symtab, next_line, mle[i].line + 1, psl_flags);
284  }
285  else
286  {
287  /* Several source lines w/o asm instructions associated. */
288  for (; next_line < mle[i].line; next_line++)
289  {
290  struct cleanup *ui_out_list_chain_line;
291  struct cleanup *ui_out_tuple_chain_line;
292 
293  ui_out_tuple_chain_line
295  "src_and_asm_line");
296  print_source_lines (symtab, next_line, next_line + 1,
297  psl_flags);
298  ui_out_list_chain_line
300  "line_asm_insn");
301  do_cleanups (ui_out_list_chain_line);
302  do_cleanups (ui_out_tuple_chain_line);
303  }
304  /* Print the last line and leave list open for
305  asm instructions to be added. */
306  ui_out_tuple_chain
308  "src_and_asm_line");
309  print_source_lines (symtab, next_line, mle[i].line + 1, psl_flags);
310  }
311  }
312  else
313  {
314  ui_out_tuple_chain
316  "src_and_asm_line");
317  print_source_lines (symtab, mle[i].line, mle[i].line + 1, psl_flags);
318  }
319 
320  next_line = mle[i].line + 1;
321  ui_out_list_chain
322  = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
323  }
324 
325  num_displayed += dump_insns (gdbarch, uiout, di,
326  mle[i].start_pc, mle[i].end_pc,
327  how_many, flags, stb);
328 
329  /* When we've reached the end of the mle array, or we've seen the last
330  assembly range for this source line, close out the list/tuple. */
331  if (i == (newlines - 1) || mle[i + 1].line > mle[i].line)
332  {
333  do_cleanups (ui_out_list_chain);
334  do_cleanups (ui_out_tuple_chain);
335  ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
336  ui_out_list_chain = make_cleanup (null_cleanup, 0);
337  ui_out_text (uiout, "\n");
338  }
339  if (how_many >= 0 && num_displayed >= how_many)
340  break;
341  }
342  do_cleanups (ui_out_chain);
343 }
344 
345 
346 static void
347 do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
348  struct disassemble_info * di,
349  CORE_ADDR low, CORE_ADDR high,
350  int how_many, int flags, struct ui_file *stb)
351 {
352  int num_displayed = 0;
353  struct cleanup *ui_out_chain;
354 
355  ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
356 
357  num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many,
358  flags, stb);
359 
360  do_cleanups (ui_out_chain);
361 }
362 
363 /* Initialize the disassemble info struct ready for the specified
364  stream. */
365 
366 static int ATTRIBUTE_PRINTF (2, 3)
367 fprintf_disasm (void *stream, const char *format, ...)
368 {
369  va_list args;
370 
371  va_start (args, format);
372  vfprintf_filtered (stream, format, args);
373  va_end (args);
374  /* Something non -ve. */
375  return 0;
376 }
377 
378 struct disassemble_info
380 {
381  struct disassemble_info di;
382 
383  init_disassemble_info (&di, file, fprintf_disasm);
384  di.flavour = bfd_target_unknown_flavour;
385  di.memory_error_func = dis_asm_memory_error;
386  di.print_address_func = dis_asm_print_address;
387  /* NOTE: cagney/2003-04-28: The original code, from the old Insight
388  disassembler had a local optomization here. By default it would
389  access the executable file, instead of the target memory (there
390  was a growing list of exceptions though). Unfortunately, the
391  heuristic was flawed. Commands like "disassemble &variable"
392  didn't work as they relied on the access going to the target.
393  Further, it has been supperseeded by trust-read-only-sections
394  (although that should be superseeded by target_trust..._p()). */
395  di.read_memory_func = dis_asm_read_memory;
396  di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
397  di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
398  di.endian = gdbarch_byte_order (gdbarch);
399  di.endian_code = gdbarch_byte_order_for_code (gdbarch);
400  di.application_data = gdbarch;
401  disassemble_init_for_target (&di);
402  return di;
403 }
404 
405 void
406 gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
407  char *file_string, int flags, int how_many,
408  CORE_ADDR low, CORE_ADDR high)
409 {
410  struct ui_file *stb = mem_fileopen ();
411  struct cleanup *cleanups = make_cleanup_ui_file_delete (stb);
412  struct disassemble_info di = gdb_disassemble_info (gdbarch, stb);
413  struct symtab *symtab;
414  struct linetable_entry *le = NULL;
415  int nlines = -1;
416 
417  /* Assume symtab is valid for whole PC range. */
418  symtab = find_pc_line_symtab (low);
419 
420  if (symtab != NULL && SYMTAB_LINETABLE (symtab) != NULL)
421  {
422  /* Convert the linetable to a bunch of my_line_entry's. */
423  le = SYMTAB_LINETABLE (symtab)->item;
424  nlines = SYMTAB_LINETABLE (symtab)->nitems;
425  }
426 
427  if (!(flags & DISASSEMBLY_SOURCE) || nlines <= 0
428  || symtab == NULL || SYMTAB_LINETABLE (symtab) == NULL)
429  do_assembly_only (gdbarch, uiout, &di, low, high, how_many, flags, stb);
430 
431  else if (flags & DISASSEMBLY_SOURCE)
432  do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low,
433  high, symtab, how_many, flags, stb);
434 
435  do_cleanups (cleanups);
437 }
438 
439 /* Print the instruction at address MEMADDR in debugged memory,
440  on STREAM. Returns the length of the instruction, in bytes,
441  and, if requested, the number of branch delay slot instructions. */
442 
443 int
445  struct ui_file *stream, int *branch_delay_insns)
446 {
447  struct disassemble_info di;
448  int length;
449 
450  di = gdb_disassemble_info (gdbarch, stream);
451  length = gdbarch_print_insn (gdbarch, memaddr, &di);
452  if (branch_delay_insns)
453  {
454  if (di.insn_info_valid)
455  *branch_delay_insns = di.branch_delay_insns;
456  else
457  *branch_delay_insns = 0;
458  }
459  return length;
460 }
461 
462 static void
463 do_ui_file_delete (void *arg)
464 {
465  ui_file_delete (arg);
466 }
467 
468 /* Return the length in bytes of the instruction at address MEMADDR in
469  debugged memory. */
470 
471 int
473 {
474  static struct ui_file *null_stream = NULL;
475 
476  /* Dummy file descriptor for the disassembler. */
477  if (!null_stream)
478  {
479  null_stream = ui_file_new ();
480  make_final_cleanup (do_ui_file_delete, null_stream);
481  }
482 
483  return gdb_print_insn (gdbarch, addr, null_stream, NULL);
484 }
485 
486 /* fprintf-function for gdb_buffered_insn_length. This function is a
487  nop, we don't want to print anything, we just want to compute the
488  length of the insn. */
489 
490 static int ATTRIBUTE_PRINTF (2, 3)
491 gdb_buffered_insn_length_fprintf (void *stream, const char *format, ...)
492 {
493  return 0;
494 }
495 
496 /* Initialize a struct disassemble_info for gdb_buffered_insn_length. */
497 
498 static void
500  struct disassemble_info *di,
501  const gdb_byte *insn, int max_len,
502  CORE_ADDR addr)
503 {
504  init_disassemble_info (di, NULL, gdb_buffered_insn_length_fprintf);
505 
506  /* init_disassemble_info installs buffer_read_memory, etc.
507  so we don't need to do that here.
508  The cast is necessary until disassemble_info is const-ified. */
509  di->buffer = (gdb_byte *) insn;
510  di->buffer_length = max_len;
511  di->buffer_vma = addr;
512 
513  di->arch = gdbarch_bfd_arch_info (gdbarch)->arch;
514  di->mach = gdbarch_bfd_arch_info (gdbarch)->mach;
515  di->endian = gdbarch_byte_order (gdbarch);
516  di->endian_code = gdbarch_byte_order_for_code (gdbarch);
517 
518  disassemble_init_for_target (di);
519 }
520 
521 /* Return the length in bytes of INSN. MAX_LEN is the size of the
522  buffer containing INSN. */
523 
524 int
526  const gdb_byte *insn, int max_len, CORE_ADDR addr)
527 {
528  struct disassemble_info di;
529 
530  gdb_buffered_insn_length_init_dis (gdbarch, &di, insn, max_len, addr);
531 
532  return gdbarch_print_insn (gdbarch, addr, &di);
533 }
static int dis_asm_read_memory(bfd_vma memaddr, gdb_byte *myaddr, unsigned int len, struct disassemble_info *info)
Definition: disasm.c:46
#define DISASSEMBLY_SOURCE
Definition: disasm.h:24
void ui_out_field_stream(struct ui_out *uiout, const char *fldname, struct ui_file *stream)
Definition: ui-out.c:509
void ui_out_field_int(struct ui_out *uiout, const char *fldname, int value)
Definition: ui-out.c:467
#define DISASSEMBLY_OMIT_FNAME
Definition: disasm.h:26
static void dis_asm_print_address(bfd_vma addr, struct disassemble_info *info)
Definition: disasm.c:62
bfd_vma CORE_ADDR
Definition: common-types.h:41
#define DISASSEMBLY_OMIT_PC
Definition: disasm.h:28
void print_address(struct gdbarch *, CORE_ADDR, struct ui_file *)
Definition: printcmd.c:741
void xfree(void *)
Definition: common-utils.c:97
CORE_ADDR end
Definition: symtab.h:1377
struct type ** const(pascal_builtin_types[])
static int branch_delay_insns
Definition: printcmd.c:70
void ui_file_delete(struct ui_file *file)
Definition: ui-file.c:76
int gdb_insn_length(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: disasm.c:472
struct ui_file * gdb_stdout
Definition: main.c:71
static int ATTRIBUTE_PRINTF(2, 3)
Definition: disasm.c:366
const char * pc_prefix(CORE_ADDR)
Definition: printcmd.c:752
Definition: ui-out.c:99
void ui_out_text(struct ui_out *uiout, const char *string)
Definition: ui-out.c:582
static void do_mixed_source_and_assembly(struct gdbarch *gdbarch, struct ui_out *uiout, struct disassemble_info *di, int nlines, struct linetable_entry *le, CORE_ADDR low, CORE_ADDR high, struct symtab *symtab, int how_many, int flags, struct ui_file *stb)
Definition: disasm.c:194
int target_read_code(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1456
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1885
void null_cleanup(void *arg)
Definition: cleanups.c:295
void memory_error(enum target_xfer_status err, CORE_ADDR memaddr)
Definition: corefile.c:217
const char *const name
Definition: aarch64-tdep.c:68
static int compare_lines(const void *mle1p, const void *mle2p)
Definition: disasm.c:70
CORE_ADDR pc
Definition: symtab.h:865
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3315
struct cleanup * make_cleanup_ui_out_list_begin_end(struct ui_out *uiout, const char *id)
Definition: ui-out.c:459
struct cleanup * make_cleanup_ui_out_tuple_begin_end(struct ui_out *uiout, const char *id)
Definition: ui-out.c:451
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
struct ui_file * ui_file_new(void)
Definition: ui-file.c:57
void vfprintf_filtered(struct ui_file *stream, const char *format, va_list args)
Definition: utils.c:2302
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
int gdb_print_insn(struct gdbarch *gdbarch, CORE_ADDR memaddr, struct ui_file *stream, int *branch_delay_insns)
Definition: disasm.c:444
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
Definition: symtab.h:862
void print_source_lines(struct symtab *s, int line, int stopline, enum print_source_lines_flags flags)
Definition: source.c:1482
int line
Definition: disasm.c:39
Definition: symtab.h:925
struct ui_file * mem_fileopen(void)
Definition: ui-file.c:427
void gdb_disassembly(struct gdbarch *gdbarch, struct ui_out *uiout, char *file_string, int flags, int how_many, CORE_ADDR low, CORE_ADDR high)
Definition: disasm.c:406
static void do_ui_file_delete(void *arg)
Definition: disasm.c:463
#define DISASSEMBLY_FILENAME
Definition: disasm.h:27
CORE_ADDR end_pc
Definition: disasm.c:41
int build_address_symbolic(struct gdbarch *, CORE_ADDR addr, int do_demangle, char **name, int *offset, char **filename, int *line, int *unmapped)
Definition: printcmd.c:611
bfd_byte gdb_byte
Definition: common-types.h:38
static void do_assembly_only(struct gdbarch *gdbarch, struct ui_out *uiout, struct disassemble_info *di, CORE_ADDR low, CORE_ADDR high, int how_many, int flags, struct ui_file *stb)
Definition: disasm.c:347
struct cleanup * make_cleanup_ui_file_delete(struct ui_file *arg)
Definition: utils.c:237
static void gdb_buffered_insn_length_init_dis(struct gdbarch *gdbarch, struct disassemble_info *di, const gdb_byte *insn, int max_len, CORE_ADDR addr)
Definition: disasm.c:499
print_source_lines_flags
Definition: symtab.h:1430
int offset
Definition: agent.c:65
#define qsort
Definition: ada-exp.c:2747
#define DISASSEMBLY_RAW_INSN
Definition: disasm.h:25
int line
Definition: symtab.h:1570
struct disassemble_info gdb_disassemble_info(struct gdbarch *gdbarch, struct ui_file *file)
Definition: disasm.c:379
static void dis_asm_memory_error(int status, bfd_vma memaddr, struct disassemble_info *info)
Definition: disasm.c:54
void ui_file_rewind(struct ui_file *file)
Definition: ui-file.c:204
struct cleanup * make_final_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:136
void ui_out_field_core_addr(struct ui_out *uiout, const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
Definition: ui-out.c:499
Definition: disasm.c:37
static int dump_insns(struct gdbarch *gdbarch, struct ui_out *uiout, struct disassemble_info *di, CORE_ADDR low, CORE_ADDR high, int how_many, int flags, struct ui_file *stb)
Definition: disasm.c:96
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition: gdbarch.c:1411
void ui_out_field_string(struct ui_out *uiout, const char *fldname, const char *string)
Definition: ui-out.c:541
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
int line
Definition: symtab.h:864
#define QUIT
Definition: defs.h:160
struct symtab * find_pc_line_symtab(CORE_ADDR pc)
Definition: symtab.c:3328
int gdbarch_print_insn(struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
Definition: gdbarch.c:3057
enum bfd_endian gdbarch_byte_order_for_code(struct gdbarch *gdbarch)
Definition: gdbarch.c:1429
#define SYMTAB_LINETABLE(symtab)
Definition: symtab.h:966
int gdb_buffered_insn_length(struct gdbarch *gdbarch, const gdb_byte *insn, int max_len, CORE_ADDR addr)
Definition: disasm.c:525
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
const ULONGEST const LONGEST len
Definition: target.h:309
CORE_ADDR start_pc
Definition: disasm.c:40