daily update
[binutils.git] / binutils / objdump.c
blob838f083f7ae4ff5b43ec5e3dfaf4900ad529c209
1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
22 /* Objdump overview.
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
40 called.
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
51 #include "bfd.h"
52 #include "bfdver.h"
53 #include "progress.h"
54 #include "bucomm.h"
55 #include "dwarf.h"
56 #include "budemang.h"
57 #include "getopt.h"
58 #include "safe-ctype.h"
59 #include "dis-asm.h"
60 #include "libiberty.h"
61 #include "demangle.h"
62 #include "debug.h"
63 #include "budbg.h"
65 /* Internal headers for the ELF .stab-dump code - sorry. */
66 #define BYTES_IN_WORD 32
67 #include "aout/aout64.h"
69 /* Exit status. */
70 static int exit_status = 0;
72 static char *default_target = NULL; /* Default at runtime. */
74 /* The following variables are set based on arguments passed on the
75 command line. */
76 static int show_version = 0; /* Show the version number. */
77 static int dump_section_contents; /* -s */
78 static int dump_section_headers; /* -h */
79 static bfd_boolean dump_file_header; /* -f */
80 static int dump_symtab; /* -t */
81 static int dump_dynamic_symtab; /* -T */
82 static int dump_reloc_info; /* -r */
83 static int dump_dynamic_reloc_info; /* -R */
84 static int dump_ar_hdrs; /* -a */
85 static int dump_private_headers; /* -p */
86 static int prefix_addresses; /* --prefix-addresses */
87 static int with_line_numbers; /* -l */
88 static bfd_boolean with_source_code; /* -S */
89 static int show_raw_insn; /* --show-raw-insn */
90 static int dump_dwarf_section_info; /* --dwarf */
91 static int dump_stab_section_info; /* --stabs */
92 static int do_demangle; /* -C, --demangle */
93 static bfd_boolean disassemble; /* -d */
94 static bfd_boolean disassemble_all; /* -D */
95 static int disassemble_zeroes; /* --disassemble-zeroes */
96 static bfd_boolean formats_info; /* -i */
97 static int wide_output; /* -w */
98 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
99 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
100 static int dump_debugging; /* --debugging */
101 static int dump_debugging_tags; /* --debugging-tags */
102 static int dump_special_syms = 0; /* --special-syms */
103 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
104 static int file_start_context = 0; /* --file-start-context */
106 /* Pointer to an array of section names provided by
107 one or more "-j secname" command line options. */
108 static char **only;
109 /* The total number of slots in the only[] array. */
110 static size_t only_size = 0;
111 /* The number of occupied slots in the only[] array. */
112 static size_t only_used = 0;
114 /* Variables for handling include file path table. */
115 static const char **include_paths;
116 static int include_path_count;
118 /* Extra info to pass to the section disassembler and address printing
119 function. */
120 struct objdump_disasm_info
122 bfd * abfd;
123 asection * sec;
124 bfd_boolean require_sec;
125 arelent ** dynrelbuf;
126 long dynrelcount;
127 disassembler_ftype disassemble_fn;
128 arelent * reloc;
131 /* Architecture to disassemble for, or default if NULL. */
132 static char *machine = NULL;
134 /* Target specific options to the disassembler. */
135 static char *disassembler_options = NULL;
137 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
138 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
140 /* The symbol table. */
141 static asymbol **syms;
143 /* Number of symbols in `syms'. */
144 static long symcount = 0;
146 /* The sorted symbol table. */
147 static asymbol **sorted_syms;
149 /* Number of symbols in `sorted_syms'. */
150 static long sorted_symcount = 0;
152 /* The dynamic symbol table. */
153 static asymbol **dynsyms;
155 /* The synthetic symbol table. */
156 static asymbol *synthsyms;
157 static long synthcount = 0;
159 /* Number of symbols in `dynsyms'. */
160 static long dynsymcount = 0;
162 static bfd_byte *stabs;
163 static bfd_size_type stab_size;
165 static char *strtab;
166 static bfd_size_type stabstr_size;
168 static void
169 usage (FILE *stream, int status)
171 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
172 fprintf (stream, _(" Display information from object <file(s)>.\n"));
173 fprintf (stream, _(" At least one of the following switches must be given:\n"));
174 fprintf (stream, _("\
175 -a, --archive-headers Display archive header information\n\
176 -f, --file-headers Display the contents of the overall file header\n\
177 -p, --private-headers Display object format specific file header contents\n\
178 -h, --[section-]headers Display the contents of the section headers\n\
179 -x, --all-headers Display the contents of all headers\n\
180 -d, --disassemble Display assembler contents of executable sections\n\
181 -D, --disassemble-all Display assembler contents of all sections\n\
182 -S, --source Intermix source code with disassembly\n\
183 -s, --full-contents Display the full contents of all sections requested\n\
184 -g, --debugging Display debug information in object file\n\
185 -e, --debugging-tags Display debug information using ctags style\n\
186 -G, --stabs Display (in raw form) any STABS info in the file\n\
187 -W, --dwarf Display DWARF info in the file\n\
188 -t, --syms Display the contents of the symbol table(s)\n\
189 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
190 -r, --reloc Display the relocation entries in the file\n\
191 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
192 @<file> Read options from <file>\n\
193 -v, --version Display this program's version number\n\
194 -i, --info List object formats and architectures supported\n\
195 -H, --help Display this information\n\
196 "));
197 if (status != 2)
199 fprintf (stream, _("\n The following switches are optional:\n"));
200 fprintf (stream, _("\
201 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
202 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
203 -j, --section=NAME Only display information for section NAME\n\
204 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
205 -EB --endian=big Assume big endian format when disassembling\n\
206 -EL --endian=little Assume little endian format when disassembling\n\
207 --file-start-context Include context from start of file (with -S)\n\
208 -I, --include=DIR Add DIR to search list for source files\n\
209 -l, --line-numbers Include line numbers and filenames in output\n\
210 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
211 The STYLE, if specified, can be `auto', `gnu',\n\
212 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
213 or `gnat'\n\
214 -w, --wide Format output for more than 80 columns\n\
215 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
216 --start-address=ADDR Only process data whose address is >= ADDR\n\
217 --stop-address=ADDR Only process data whose address is <= ADDR\n\
218 --prefix-addresses Print complete address alongside disassembly\n\
219 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
220 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
221 --special-syms Include special symbols in symbol dumps\n\
222 \n"));
223 list_supported_targets (program_name, stream);
224 list_supported_architectures (program_name, stream);
226 disassembler_usage (stream);
228 if (status == 0)
229 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
230 exit (status);
233 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
234 enum option_values
236 OPTION_ENDIAN=150,
237 OPTION_START_ADDRESS,
238 OPTION_STOP_ADDRESS,
239 OPTION_ADJUST_VMA
242 static struct option long_options[]=
244 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
245 {"all-headers", no_argument, NULL, 'x'},
246 {"private-headers", no_argument, NULL, 'p'},
247 {"architecture", required_argument, NULL, 'm'},
248 {"archive-headers", no_argument, NULL, 'a'},
249 {"debugging", no_argument, NULL, 'g'},
250 {"debugging-tags", no_argument, NULL, 'e'},
251 {"demangle", optional_argument, NULL, 'C'},
252 {"disassemble", no_argument, NULL, 'd'},
253 {"disassemble-all", no_argument, NULL, 'D'},
254 {"disassembler-options", required_argument, NULL, 'M'},
255 {"disassemble-zeroes", no_argument, NULL, 'z'},
256 {"dynamic-reloc", no_argument, NULL, 'R'},
257 {"dynamic-syms", no_argument, NULL, 'T'},
258 {"endian", required_argument, NULL, OPTION_ENDIAN},
259 {"file-headers", no_argument, NULL, 'f'},
260 {"file-start-context", no_argument, &file_start_context, 1},
261 {"full-contents", no_argument, NULL, 's'},
262 {"headers", no_argument, NULL, 'h'},
263 {"help", no_argument, NULL, 'H'},
264 {"info", no_argument, NULL, 'i'},
265 {"line-numbers", no_argument, NULL, 'l'},
266 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
267 {"prefix-addresses", no_argument, &prefix_addresses, 1},
268 {"reloc", no_argument, NULL, 'r'},
269 {"section", required_argument, NULL, 'j'},
270 {"section-headers", no_argument, NULL, 'h'},
271 {"show-raw-insn", no_argument, &show_raw_insn, 1},
272 {"source", no_argument, NULL, 'S'},
273 {"special-syms", no_argument, &dump_special_syms, 1},
274 {"include", required_argument, NULL, 'I'},
275 {"dwarf", no_argument, NULL, 'W'},
276 {"stabs", no_argument, NULL, 'G'},
277 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
278 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
279 {"syms", no_argument, NULL, 't'},
280 {"target", required_argument, NULL, 'b'},
281 {"version", no_argument, NULL, 'V'},
282 {"wide", no_argument, NULL, 'w'},
283 {0, no_argument, 0, 0}
286 static void
287 nonfatal (const char *msg)
289 bfd_nonfatal (msg);
290 exit_status = 1;
293 static void
294 dump_section_header (bfd *abfd, asection *section,
295 void *ignored ATTRIBUTE_UNUSED)
297 char *comma = "";
298 unsigned int opb = bfd_octets_per_byte (abfd);
300 /* Ignore linker created section. See elfNN_ia64_object_p in
301 bfd/elfxx-ia64.c. */
302 if (section->flags & SEC_LINKER_CREATED)
303 return;
305 printf ("%3d %-13s %08lx ", section->index,
306 bfd_get_section_name (abfd, section),
307 (unsigned long) bfd_section_size (abfd, section) / opb);
308 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
309 printf (" ");
310 bfd_printf_vma (abfd, section->lma);
311 printf (" %08lx 2**%u", (unsigned long) section->filepos,
312 bfd_get_section_alignment (abfd, section));
313 if (! wide_output)
314 printf ("\n ");
315 printf (" ");
317 #define PF(x, y) \
318 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
320 PF (SEC_HAS_CONTENTS, "CONTENTS");
321 PF (SEC_ALLOC, "ALLOC");
322 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
323 PF (SEC_LOAD, "LOAD");
324 PF (SEC_RELOC, "RELOC");
325 PF (SEC_READONLY, "READONLY");
326 PF (SEC_CODE, "CODE");
327 PF (SEC_DATA, "DATA");
328 PF (SEC_ROM, "ROM");
329 PF (SEC_DEBUGGING, "DEBUGGING");
330 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
331 PF (SEC_EXCLUDE, "EXCLUDE");
332 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
333 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
335 PF (SEC_TIC54X_BLOCK, "BLOCK");
336 PF (SEC_TIC54X_CLINK, "CLINK");
338 PF (SEC_SMALL_DATA, "SMALL_DATA");
339 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
340 PF (SEC_COFF_SHARED, "SHARED");
341 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
342 PF (SEC_GROUP, "GROUP");
344 if ((section->flags & SEC_LINK_ONCE) != 0)
346 const char *ls;
347 struct coff_comdat_info *comdat;
349 switch (section->flags & SEC_LINK_DUPLICATES)
351 default:
352 abort ();
353 case SEC_LINK_DUPLICATES_DISCARD:
354 ls = "LINK_ONCE_DISCARD";
355 break;
356 case SEC_LINK_DUPLICATES_ONE_ONLY:
357 ls = "LINK_ONCE_ONE_ONLY";
358 break;
359 case SEC_LINK_DUPLICATES_SAME_SIZE:
360 ls = "LINK_ONCE_SAME_SIZE";
361 break;
362 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
363 ls = "LINK_ONCE_SAME_CONTENTS";
364 break;
366 printf ("%s%s", comma, ls);
368 comdat = bfd_coff_get_comdat_section (abfd, section);
369 if (comdat != NULL)
370 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
372 comma = ", ";
375 printf ("\n");
376 #undef PF
379 static void
380 dump_headers (bfd *abfd)
382 printf (_("Sections:\n"));
384 #ifndef BFD64
385 printf (_("Idx Name Size VMA LMA File off Algn"));
386 #else
387 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
388 if (bfd_get_arch_size (abfd) == 32)
389 printf (_("Idx Name Size VMA LMA File off Algn"));
390 else
391 printf (_("Idx Name Size VMA LMA File off Algn"));
392 #endif
394 if (wide_output)
395 printf (_(" Flags"));
396 if (abfd->flags & HAS_LOAD_PAGE)
397 printf (_(" Pg"));
398 printf ("\n");
400 bfd_map_over_sections (abfd, dump_section_header, NULL);
403 static asymbol **
404 slurp_symtab (bfd *abfd)
406 asymbol **sy = NULL;
407 long storage;
409 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
411 symcount = 0;
412 return NULL;
415 storage = bfd_get_symtab_upper_bound (abfd);
416 if (storage < 0)
417 bfd_fatal (bfd_get_filename (abfd));
418 if (storage)
419 sy = xmalloc (storage);
421 symcount = bfd_canonicalize_symtab (abfd, sy);
422 if (symcount < 0)
423 bfd_fatal (bfd_get_filename (abfd));
424 return sy;
427 /* Read in the dynamic symbols. */
429 static asymbol **
430 slurp_dynamic_symtab (bfd *abfd)
432 asymbol **sy = NULL;
433 long storage;
435 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
436 if (storage < 0)
438 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
440 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
441 dynsymcount = 0;
442 return NULL;
445 bfd_fatal (bfd_get_filename (abfd));
447 if (storage)
448 sy = xmalloc (storage);
450 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
451 if (dynsymcount < 0)
452 bfd_fatal (bfd_get_filename (abfd));
453 return sy;
456 /* Filter out (in place) symbols that are useless for disassembly.
457 COUNT is the number of elements in SYMBOLS.
458 Return the number of useful symbols. */
460 static long
461 remove_useless_symbols (asymbol **symbols, long count)
463 asymbol **in_ptr = symbols, **out_ptr = symbols;
465 while (--count >= 0)
467 asymbol *sym = *in_ptr++;
469 if (sym->name == NULL || sym->name[0] == '\0')
470 continue;
471 if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
472 continue;
473 if (bfd_is_und_section (sym->section)
474 || bfd_is_com_section (sym->section))
475 continue;
477 *out_ptr++ = sym;
479 return out_ptr - symbols;
482 /* Sort symbols into value order. */
484 static int
485 compare_symbols (const void *ap, const void *bp)
487 const asymbol *a = * (const asymbol **) ap;
488 const asymbol *b = * (const asymbol **) bp;
489 const char *an;
490 const char *bn;
491 size_t anl;
492 size_t bnl;
493 bfd_boolean af;
494 bfd_boolean bf;
495 flagword aflags;
496 flagword bflags;
498 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
499 return 1;
500 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
501 return -1;
503 if (a->section > b->section)
504 return 1;
505 else if (a->section < b->section)
506 return -1;
508 an = bfd_asymbol_name (a);
509 bn = bfd_asymbol_name (b);
510 anl = strlen (an);
511 bnl = strlen (bn);
513 /* The symbols gnu_compiled and gcc2_compiled convey no real
514 information, so put them after other symbols with the same value. */
515 af = (strstr (an, "gnu_compiled") != NULL
516 || strstr (an, "gcc2_compiled") != NULL);
517 bf = (strstr (bn, "gnu_compiled") != NULL
518 || strstr (bn, "gcc2_compiled") != NULL);
520 if (af && ! bf)
521 return 1;
522 if (! af && bf)
523 return -1;
525 /* We use a heuristic for the file name, to try to sort it after
526 more useful symbols. It may not work on non Unix systems, but it
527 doesn't really matter; the only difference is precisely which
528 symbol names get printed. */
530 #define file_symbol(s, sn, snl) \
531 (((s)->flags & BSF_FILE) != 0 \
532 || ((sn)[(snl) - 2] == '.' \
533 && ((sn)[(snl) - 1] == 'o' \
534 || (sn)[(snl) - 1] == 'a')))
536 af = file_symbol (a, an, anl);
537 bf = file_symbol (b, bn, bnl);
539 if (af && ! bf)
540 return 1;
541 if (! af && bf)
542 return -1;
544 /* Try to sort global symbols before local symbols before function
545 symbols before debugging symbols. */
547 aflags = a->flags;
548 bflags = b->flags;
550 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
552 if ((aflags & BSF_DEBUGGING) != 0)
553 return 1;
554 else
555 return -1;
557 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
559 if ((aflags & BSF_FUNCTION) != 0)
560 return -1;
561 else
562 return 1;
564 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
566 if ((aflags & BSF_LOCAL) != 0)
567 return 1;
568 else
569 return -1;
571 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
573 if ((aflags & BSF_GLOBAL) != 0)
574 return -1;
575 else
576 return 1;
579 /* Symbols that start with '.' might be section names, so sort them
580 after symbols that don't start with '.'. */
581 if (an[0] == '.' && bn[0] != '.')
582 return 1;
583 if (an[0] != '.' && bn[0] == '.')
584 return -1;
586 /* Finally, if we can't distinguish them in any other way, try to
587 get consistent results by sorting the symbols by name. */
588 return strcmp (an, bn);
591 /* Sort relocs into address order. */
593 static int
594 compare_relocs (const void *ap, const void *bp)
596 const arelent *a = * (const arelent **) ap;
597 const arelent *b = * (const arelent **) bp;
599 if (a->address > b->address)
600 return 1;
601 else if (a->address < b->address)
602 return -1;
604 /* So that associated relocations tied to the same address show up
605 in the correct order, we don't do any further sorting. */
606 if (a > b)
607 return 1;
608 else if (a < b)
609 return -1;
610 else
611 return 0;
614 /* Print an address (VMA) to the output stream in INFO.
615 If SKIP_ZEROES is TRUE, omit leading zeroes. */
617 static void
618 objdump_print_value (bfd_vma vma, struct disassemble_info *info,
619 bfd_boolean skip_zeroes)
621 char buf[30];
622 char *p;
623 struct objdump_disasm_info *aux;
625 aux = (struct objdump_disasm_info *) info->application_data;
626 bfd_sprintf_vma (aux->abfd, buf, vma);
627 if (! skip_zeroes)
628 p = buf;
629 else
631 for (p = buf; *p == '0'; ++p)
633 if (*p == '\0')
634 --p;
636 (*info->fprintf_func) (info->stream, "%s", p);
639 /* Print the name of a symbol. */
641 static void
642 objdump_print_symname (bfd *abfd, struct disassemble_info *info,
643 asymbol *sym)
645 char *alloc;
646 const char *name;
648 alloc = NULL;
649 name = bfd_asymbol_name (sym);
650 if (do_demangle && name[0] != '\0')
652 /* Demangle the name. */
653 alloc = demangle (abfd, name);
654 name = alloc;
657 if (info != NULL)
658 (*info->fprintf_func) (info->stream, "%s", name);
659 else
660 printf ("%s", name);
662 if (alloc != NULL)
663 free (alloc);
666 /* Locate a symbol given a bfd and a section (from INFO->application_data),
667 and a VMA. If INFO->application_data->require_sec is TRUE, then always
668 require the symbol to be in the section. Returns NULL if there is no
669 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
670 of the symbol in sorted_syms. */
672 static asymbol *
673 find_symbol_for_address (bfd_vma vma,
674 struct disassemble_info *info,
675 long *place)
677 /* @@ Would it speed things up to cache the last two symbols returned,
678 and maybe their address ranges? For many processors, only one memory
679 operand can be present at a time, so the 2-entry cache wouldn't be
680 constantly churned by code doing heavy memory accesses. */
682 /* Indices in `sorted_syms'. */
683 long min = 0;
684 long max = sorted_symcount;
685 long thisplace;
686 struct objdump_disasm_info *aux;
687 bfd *abfd;
688 asection *sec;
689 unsigned int opb;
691 if (sorted_symcount < 1)
692 return NULL;
694 aux = (struct objdump_disasm_info *) info->application_data;
695 abfd = aux->abfd;
696 sec = aux->sec;
697 opb = bfd_octets_per_byte (abfd);
699 /* Perform a binary search looking for the closest symbol to the
700 required value. We are searching the range (min, max]. */
701 while (min + 1 < max)
703 asymbol *sym;
705 thisplace = (max + min) / 2;
706 sym = sorted_syms[thisplace];
708 if (bfd_asymbol_value (sym) > vma)
709 max = thisplace;
710 else if (bfd_asymbol_value (sym) < vma)
711 min = thisplace;
712 else
714 min = thisplace;
715 break;
719 /* The symbol we want is now in min, the low end of the range we
720 were searching. If there are several symbols with the same
721 value, we want the first one. */
722 thisplace = min;
723 while (thisplace > 0
724 && (bfd_asymbol_value (sorted_syms[thisplace])
725 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
726 --thisplace;
728 /* If the file is relocatable, and the symbol could be from this
729 section, prefer a symbol from this section over symbols from
730 others, even if the other symbol's value might be closer.
732 Note that this may be wrong for some symbol references if the
733 sections have overlapping memory ranges, but in that case there's
734 no way to tell what's desired without looking at the relocation
735 table. */
736 if (sorted_syms[thisplace]->section != sec
737 && (aux->require_sec
738 || ((abfd->flags & HAS_RELOC) != 0
739 && vma >= bfd_get_section_vma (abfd, sec)
740 && vma < (bfd_get_section_vma (abfd, sec)
741 + bfd_section_size (abfd, sec) / opb))))
743 long i;
745 for (i = thisplace + 1; i < sorted_symcount; i++)
747 if (bfd_asymbol_value (sorted_syms[i])
748 != bfd_asymbol_value (sorted_syms[thisplace]))
749 break;
752 --i;
754 for (; i >= 0; i--)
756 if (sorted_syms[i]->section == sec
757 && (i == 0
758 || sorted_syms[i - 1]->section != sec
759 || (bfd_asymbol_value (sorted_syms[i])
760 != bfd_asymbol_value (sorted_syms[i - 1]))))
762 thisplace = i;
763 break;
767 if (sorted_syms[thisplace]->section != sec)
769 /* We didn't find a good symbol with a smaller value.
770 Look for one with a larger value. */
771 for (i = thisplace + 1; i < sorted_symcount; i++)
773 if (sorted_syms[i]->section == sec)
775 thisplace = i;
776 break;
781 if (sorted_syms[thisplace]->section != sec
782 && (aux->require_sec
783 || ((abfd->flags & HAS_RELOC) != 0
784 && vma >= bfd_get_section_vma (abfd, sec)
785 && vma < (bfd_get_section_vma (abfd, sec)
786 + bfd_section_size (abfd, sec)))))
787 /* There is no suitable symbol. */
788 return NULL;
791 /* Give the target a chance to reject the symbol. */
792 while (! info->symbol_is_valid (sorted_syms [thisplace], info))
794 ++ thisplace;
795 if (thisplace >= sorted_symcount
796 || bfd_asymbol_value (sorted_syms [thisplace]) > vma)
797 return NULL;
800 if (place != NULL)
801 *place = thisplace;
803 return sorted_syms[thisplace];
806 /* Print an address and the offset to the nearest symbol. */
808 static void
809 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
810 bfd_vma vma, struct disassemble_info *info,
811 bfd_boolean skip_zeroes)
813 objdump_print_value (vma, info, skip_zeroes);
815 if (sym == NULL)
817 bfd_vma secaddr;
819 (*info->fprintf_func) (info->stream, " <%s",
820 bfd_get_section_name (abfd, sec));
821 secaddr = bfd_get_section_vma (abfd, sec);
822 if (vma < secaddr)
824 (*info->fprintf_func) (info->stream, "-0x");
825 objdump_print_value (secaddr - vma, info, TRUE);
827 else if (vma > secaddr)
829 (*info->fprintf_func) (info->stream, "+0x");
830 objdump_print_value (vma - secaddr, info, TRUE);
832 (*info->fprintf_func) (info->stream, ">");
834 else
836 (*info->fprintf_func) (info->stream, " <");
837 objdump_print_symname (abfd, info, sym);
838 if (bfd_asymbol_value (sym) > vma)
840 (*info->fprintf_func) (info->stream, "-0x");
841 objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
843 else if (vma > bfd_asymbol_value (sym))
845 (*info->fprintf_func) (info->stream, "+0x");
846 objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
848 (*info->fprintf_func) (info->stream, ">");
852 /* Print an address (VMA), symbolically if possible.
853 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
855 static void
856 objdump_print_addr (bfd_vma vma,
857 struct disassemble_info *info,
858 bfd_boolean skip_zeroes)
860 struct objdump_disasm_info *aux;
861 asymbol *sym = NULL; /* Initialize to avoid compiler warning. */
862 bfd_boolean skip_find = FALSE;
864 if (sorted_symcount < 1)
866 (*info->fprintf_func) (info->stream, "0x");
867 objdump_print_value (vma, info, skip_zeroes);
868 return;
871 aux = (struct objdump_disasm_info *) info->application_data;
873 if (aux->reloc != NULL
874 && aux->reloc->sym_ptr_ptr != NULL
875 && * aux->reloc->sym_ptr_ptr != NULL)
877 sym = * aux->reloc->sym_ptr_ptr;
879 /* Adjust the vma to the reloc. */
880 vma += bfd_asymbol_value (sym);
882 if (bfd_is_und_section (bfd_get_section (sym)))
883 skip_find = TRUE;
886 if (!skip_find)
887 sym = find_symbol_for_address (vma, info, NULL);
889 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
890 skip_zeroes);
893 /* Print VMA to INFO. This function is passed to the disassembler
894 routine. */
896 static void
897 objdump_print_address (bfd_vma vma, struct disassemble_info *info)
899 objdump_print_addr (vma, info, ! prefix_addresses);
902 /* Determine of the given address has a symbol associated with it. */
904 static int
905 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
907 asymbol * sym;
909 sym = find_symbol_for_address (vma, info, NULL);
911 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
914 /* Hold the last function name and the last line number we displayed
915 in a disassembly. */
917 static char *prev_functionname;
918 static unsigned int prev_line;
920 /* We keep a list of all files that we have seen when doing a
921 disassembly with source, so that we know how much of the file to
922 display. This can be important for inlined functions. */
924 struct print_file_list
926 struct print_file_list *next;
927 const char *filename;
928 const char *modname;
929 unsigned int line;
930 FILE *f;
933 static struct print_file_list *print_files;
935 /* The number of preceding context lines to show when we start
936 displaying a file for the first time. */
938 #define SHOW_PRECEDING_CONTEXT_LINES (5)
940 /* Tries to open MODNAME, and if successful adds a node to print_files
941 linked list and returns that node. Returns NULL on failure. */
943 static struct print_file_list *
944 try_print_file_open (const char *origname, const char *modname)
946 struct print_file_list *p;
947 FILE *f;
949 f = fopen (modname, "r");
950 if (f == NULL)
951 return NULL;
953 if (print_files != NULL && print_files->f != NULL)
955 fclose (print_files->f);
956 print_files->f = NULL;
959 p = xmalloc (sizeof (struct print_file_list));
960 p->filename = origname;
961 p->modname = modname;
962 p->line = 0;
963 p->f = f;
964 p->next = print_files;
965 print_files = p;
966 return p;
969 /* If the the source file, as described in the symtab, is not found
970 try to locate it in one of the paths specified with -I
971 If found, add location to print_files linked list. */
973 static struct print_file_list *
974 update_source_path (const char *filename)
976 struct print_file_list *p;
977 const char *fname;
978 int i;
980 if (filename == NULL)
981 return NULL;
983 p = try_print_file_open (filename, filename);
984 if (p != NULL)
985 return p;
987 if (include_path_count == 0)
988 return NULL;
990 /* Get the name of the file. */
991 fname = strrchr (filename, '/');
992 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
994 /* We could have a mixed forward/back slash case. */
995 char *backslash = strrchr (filename, '\\');
996 if (fname == NULL || (backslash != NULL && backslash > fname))
997 fname = backslash;
998 if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
999 fname = filename + 1;
1001 #endif
1002 if (fname == NULL)
1003 fname = filename;
1004 else
1005 ++fname;
1007 /* If file exists under a new path, we need to add it to the list
1008 so that show_line knows about it. */
1009 for (i = 0; i < include_path_count; i++)
1011 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1013 p = try_print_file_open (filename, modname);
1014 if (p)
1015 return p;
1017 free (modname);
1020 return NULL;
1023 /* Skip ahead to a given line in a file, optionally printing each
1024 line. */
1026 static void
1027 skip_to_line (struct print_file_list *p, unsigned int line,
1028 bfd_boolean show)
1030 while (p->line < line)
1032 char buf[100];
1034 if (fgets (buf, sizeof buf, p->f) == NULL)
1036 fclose (p->f);
1037 p->f = NULL;
1038 break;
1041 if (show)
1042 printf ("%s", buf);
1044 if (strchr (buf, '\n') != NULL)
1045 ++p->line;
1049 /* Show the line number, or the source line, in a disassembly
1050 listing. */
1052 static void
1053 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1055 const char *filename;
1056 const char *functionname;
1057 unsigned int line;
1059 if (! with_line_numbers && ! with_source_code)
1060 return;
1062 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1063 &functionname, &line))
1064 return;
1066 if (filename != NULL && *filename == '\0')
1067 filename = NULL;
1068 if (functionname != NULL && *functionname == '\0')
1069 functionname = NULL;
1071 if (with_line_numbers)
1073 if (functionname != NULL
1074 && (prev_functionname == NULL
1075 || strcmp (functionname, prev_functionname) != 0))
1076 printf ("%s():\n", functionname);
1077 if (line > 0 && line != prev_line)
1078 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1081 if (with_source_code
1082 && filename != NULL
1083 && line > 0)
1085 struct print_file_list **pp, *p;
1087 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1088 if (strcmp ((*pp)->filename, filename) == 0)
1089 break;
1090 p = *pp;
1092 if (p != NULL)
1094 if (p != print_files)
1096 int l;
1098 /* We have reencountered a file name which we saw
1099 earlier. This implies that either we are dumping out
1100 code from an included file, or the same file was
1101 linked in more than once. There are two common cases
1102 of an included file: inline functions in a header
1103 file, and a bison or flex skeleton file. In the
1104 former case we want to just start printing (but we
1105 back up a few lines to give context); in the latter
1106 case we want to continue from where we left off. I
1107 can't think of a good way to distinguish the cases,
1108 so I used a heuristic based on the file name. */
1109 if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
1110 l = p->line;
1111 else
1113 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1114 if (l < 0)
1115 l = 0;
1118 if (p->f == NULL)
1120 p->f = fopen (p->modname, "r");
1121 p->line = 0;
1123 if (p->f != NULL)
1124 skip_to_line (p, l, FALSE);
1126 if (print_files->f != NULL)
1128 fclose (print_files->f);
1129 print_files->f = NULL;
1133 if (p->f != NULL)
1135 skip_to_line (p, line, TRUE);
1136 *pp = p->next;
1137 p->next = print_files;
1138 print_files = p;
1141 else
1143 p = update_source_path (filename);
1145 if (p != NULL)
1147 int l;
1149 if (file_start_context)
1150 l = 0;
1151 else
1152 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1153 if (l < 0)
1154 l = 0;
1155 skip_to_line (p, l, FALSE);
1156 if (p->f != NULL)
1157 skip_to_line (p, line, TRUE);
1162 if (functionname != NULL
1163 && (prev_functionname == NULL
1164 || strcmp (functionname, prev_functionname) != 0))
1166 if (prev_functionname != NULL)
1167 free (prev_functionname);
1168 prev_functionname = xmalloc (strlen (functionname) + 1);
1169 strcpy (prev_functionname, functionname);
1172 if (line > 0 && line != prev_line)
1173 prev_line = line;
1176 /* Pseudo FILE object for strings. */
1177 typedef struct
1179 char *buffer;
1180 size_t pos;
1181 size_t alloc;
1182 } SFILE;
1184 /* sprintf to a "stream". */
1186 static int ATTRIBUTE_PRINTF_2
1187 objdump_sprintf (SFILE *f, const char *format, ...)
1189 size_t n;
1190 va_list args;
1192 while (1)
1194 size_t space = f->alloc - f->pos;
1196 va_start (args, format);
1197 n = vsnprintf (f->buffer + f->pos, space, format, args);
1198 va_end (args);
1200 if (space > n)
1201 break;
1203 f->alloc = (f->alloc + n) * 2;
1204 f->buffer = xrealloc (f->buffer, f->alloc);
1206 f->pos += n;
1208 return n;
1211 /* Returns TRUE if the specified section should be dumped. */
1213 static bfd_boolean
1214 process_section_p (asection * section)
1216 size_t i;
1218 if (only == NULL)
1219 return TRUE;
1221 for (i = 0; i < only_used; i++)
1222 if (strcmp (only [i], section->name) == 0)
1223 return TRUE;
1225 return FALSE;
1229 /* The number of zeroes we want to see before we start skipping them.
1230 The number is arbitrarily chosen. */
1232 #define DEFAULT_SKIP_ZEROES 8
1234 /* The number of zeroes to skip at the end of a section. If the
1235 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1236 SKIP_ZEROES, they will be disassembled. If there are fewer than
1237 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1238 attempt to avoid disassembling zeroes inserted by section
1239 alignment. */
1241 #define DEFAULT_SKIP_ZEROES_AT_END 3
1243 /* Disassemble some data in memory between given values. */
1245 static void
1246 disassemble_bytes (struct disassemble_info * info,
1247 disassembler_ftype disassemble_fn,
1248 bfd_boolean insns,
1249 bfd_byte * data,
1250 bfd_vma start_offset,
1251 bfd_vma stop_offset,
1252 bfd_vma rel_offset,
1253 arelent *** relppp,
1254 arelent ** relppend)
1256 struct objdump_disasm_info *aux;
1257 asection *section;
1258 int octets_per_line;
1259 bfd_boolean done_dot;
1260 int skip_addr_chars;
1261 bfd_vma addr_offset;
1262 unsigned int opb = info->octets_per_byte;
1263 unsigned int skip_zeroes = info->skip_zeroes;
1264 unsigned int skip_zeroes_at_end = info->skip_zeroes_at_end;
1265 int octets = opb;
1266 SFILE sfile;
1268 aux = (struct objdump_disasm_info *) info->application_data;
1269 section = aux->sec;
1271 sfile.alloc = 120;
1272 sfile.buffer = xmalloc (sfile.alloc);
1273 sfile.pos = 0;
1275 if (insns)
1276 octets_per_line = 4;
1277 else
1278 octets_per_line = 16;
1280 /* Figure out how many characters to skip at the start of an
1281 address, to make the disassembly look nicer. We discard leading
1282 zeroes in chunks of 4, ensuring that there is always a leading
1283 zero remaining. */
1284 skip_addr_chars = 0;
1285 if (! prefix_addresses)
1287 char buf[30];
1288 char *s;
1290 bfd_sprintf_vma
1291 (aux->abfd, buf,
1292 (section->vma
1293 + bfd_section_size (section->owner, section) / opb));
1294 s = buf;
1295 while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1296 && s[4] == '0')
1298 skip_addr_chars += 4;
1299 s += 4;
1303 info->insn_info_valid = 0;
1305 done_dot = FALSE;
1306 addr_offset = start_offset;
1307 while (addr_offset < stop_offset)
1309 bfd_vma z;
1310 bfd_boolean need_nl = FALSE;
1311 int previous_octets;
1313 /* Remember the length of the previous instruction. */
1314 previous_octets = octets;
1315 octets = 0;
1317 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1318 print `...'. */
1319 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1320 if (data[z] != 0)
1321 break;
1322 if (! disassemble_zeroes
1323 && (info->insn_info_valid == 0
1324 || info->branch_delay_insns == 0)
1325 && (z - addr_offset * opb >= skip_zeroes
1326 || (z == stop_offset * opb &&
1327 z - addr_offset * opb < skip_zeroes_at_end)))
1329 printf ("\t...\n");
1331 /* If there are more nonzero octets to follow, we only skip
1332 zeroes in multiples of 4, to try to avoid running over
1333 the start of an instruction which happens to start with
1334 zero. */
1335 if (z != stop_offset * opb)
1336 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1338 octets = z - addr_offset * opb;
1340 else
1342 char buf[50];
1343 int bpc = 0;
1344 int pb = 0;
1346 done_dot = FALSE;
1348 if (with_line_numbers || with_source_code)
1349 show_line (aux->abfd, section, addr_offset);
1351 if (! prefix_addresses)
1353 char *s;
1355 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1356 for (s = buf + skip_addr_chars; *s == '0'; s++)
1357 *s = ' ';
1358 if (*s == '\0')
1359 *--s = '0';
1360 printf ("%s:\t", buf + skip_addr_chars);
1362 else
1364 aux->require_sec = TRUE;
1365 objdump_print_address (section->vma + addr_offset, info);
1366 aux->require_sec = FALSE;
1367 putchar (' ');
1370 if (insns)
1372 sfile.pos = 0;
1373 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1374 info->stream = &sfile;
1375 info->bytes_per_line = 0;
1376 info->bytes_per_chunk = 0;
1377 info->flags = 0;
1379 if (info->disassembler_needs_relocs
1380 && *relppp < relppend)
1382 bfd_signed_vma distance_to_rel;
1384 distance_to_rel = (**relppp)->address
1385 - (rel_offset + addr_offset);
1387 /* Check to see if the current reloc is associated with
1388 the instruction that we are about to disassemble. */
1389 if (distance_to_rel == 0
1390 /* FIXME: This is wrong. We are trying to catch
1391 relocs that are addressed part way through the
1392 current instruction, as might happen with a packed
1393 VLIW instruction. Unfortunately we do not know the
1394 length of the current instruction since we have not
1395 disassembled it yet. Instead we take a guess based
1396 upon the length of the previous instruction. The
1397 proper solution is to have a new target-specific
1398 disassembler function which just returns the length
1399 of an instruction at a given address without trying
1400 to display its disassembly. */
1401 || (distance_to_rel > 0
1402 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1404 info->flags = INSN_HAS_RELOC;
1405 aux->reloc = **relppp;
1407 else
1408 aux->reloc = NULL;
1411 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1412 info->fprintf_func = (fprintf_ftype) fprintf;
1413 info->stream = stdout;
1414 if (info->bytes_per_line != 0)
1415 octets_per_line = info->bytes_per_line;
1416 if (octets < 0)
1418 if (sfile.pos)
1419 printf ("%s\n", sfile.buffer);
1420 break;
1423 else
1425 bfd_vma j;
1427 octets = octets_per_line;
1428 if (addr_offset + octets / opb > stop_offset)
1429 octets = (stop_offset - addr_offset) * opb;
1431 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1433 if (ISPRINT (data[j]))
1434 buf[j - addr_offset * opb] = data[j];
1435 else
1436 buf[j - addr_offset * opb] = '.';
1438 buf[j - addr_offset * opb] = '\0';
1441 if (prefix_addresses
1442 ? show_raw_insn > 0
1443 : show_raw_insn >= 0)
1445 bfd_vma j;
1447 /* If ! prefix_addresses and ! wide_output, we print
1448 octets_per_line octets per line. */
1449 pb = octets;
1450 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1451 pb = octets_per_line;
1453 if (info->bytes_per_chunk)
1454 bpc = info->bytes_per_chunk;
1455 else
1456 bpc = 1;
1458 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1460 int k;
1462 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1464 for (k = bpc - 1; k >= 0; k--)
1465 printf ("%02x", (unsigned) data[j + k]);
1466 putchar (' ');
1468 else
1470 for (k = 0; k < bpc; k++)
1471 printf ("%02x", (unsigned) data[j + k]);
1472 putchar (' ');
1476 for (; pb < octets_per_line; pb += bpc)
1478 int k;
1480 for (k = 0; k < bpc; k++)
1481 printf (" ");
1482 putchar (' ');
1485 /* Separate raw data from instruction by extra space. */
1486 if (insns)
1487 putchar ('\t');
1488 else
1489 printf (" ");
1492 if (! insns)
1493 printf ("%s", buf);
1494 else if (sfile.pos)
1495 printf ("%s", sfile.buffer);
1497 if (prefix_addresses
1498 ? show_raw_insn > 0
1499 : show_raw_insn >= 0)
1501 while (pb < octets)
1503 bfd_vma j;
1504 char *s;
1506 putchar ('\n');
1507 j = addr_offset * opb + pb;
1509 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1510 for (s = buf + skip_addr_chars; *s == '0'; s++)
1511 *s = ' ';
1512 if (*s == '\0')
1513 *--s = '0';
1514 printf ("%s:\t", buf + skip_addr_chars);
1516 pb += octets_per_line;
1517 if (pb > octets)
1518 pb = octets;
1519 for (; j < addr_offset * opb + pb; j += bpc)
1521 int k;
1523 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1525 for (k = bpc - 1; k >= 0; k--)
1526 printf ("%02x", (unsigned) data[j + k]);
1527 putchar (' ');
1529 else
1531 for (k = 0; k < bpc; k++)
1532 printf ("%02x", (unsigned) data[j + k]);
1533 putchar (' ');
1539 if (!wide_output)
1540 putchar ('\n');
1541 else
1542 need_nl = TRUE;
1545 while ((*relppp) < relppend
1546 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1548 if (dump_reloc_info || dump_dynamic_reloc_info)
1550 arelent *q;
1552 q = **relppp;
1554 if (wide_output)
1555 putchar ('\t');
1556 else
1557 printf ("\t\t\t");
1559 objdump_print_value (section->vma - rel_offset + q->address,
1560 info, TRUE);
1562 if (q->howto == NULL)
1563 printf (": *unknown*\t");
1564 else if (q->howto->name)
1565 printf (": %s\t", q->howto->name);
1566 else
1567 printf (": %d\t", q->howto->type);
1569 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1570 printf ("*unknown*");
1571 else
1573 const char *sym_name;
1575 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1576 if (sym_name != NULL && *sym_name != '\0')
1577 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1578 else
1580 asection *sym_sec;
1582 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1583 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1584 if (sym_name == NULL || *sym_name == '\0')
1585 sym_name = "*unknown*";
1586 printf ("%s", sym_name);
1590 if (q->addend)
1592 printf ("+0x");
1593 objdump_print_value (q->addend, info, TRUE);
1596 printf ("\n");
1597 need_nl = FALSE;
1599 ++(*relppp);
1602 if (need_nl)
1603 printf ("\n");
1605 addr_offset += octets / opb;
1608 free (sfile.buffer);
1611 static void
1612 disassemble_section (bfd *abfd, asection *section, void *info)
1614 struct disassemble_info * pinfo = (struct disassemble_info *) info;
1615 struct objdump_disasm_info * paux;
1616 unsigned int opb = pinfo->octets_per_byte;
1617 bfd_byte * data = NULL;
1618 bfd_size_type datasize = 0;
1619 arelent ** rel_pp = NULL;
1620 arelent ** rel_ppstart = NULL;
1621 arelent ** rel_ppend;
1622 unsigned long stop_offset;
1623 asymbol * sym = NULL;
1624 long place = 0;
1625 long rel_count;
1626 bfd_vma rel_offset;
1627 unsigned long addr_offset;
1629 /* Sections that do not contain machine
1630 code are not normally disassembled. */
1631 if (! disassemble_all
1632 && only == NULL
1633 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1634 != (SEC_CODE | SEC_HAS_CONTENTS)))
1635 return;
1637 if (! process_section_p (section))
1638 return;
1640 datasize = bfd_get_section_size (section);
1641 if (datasize == 0)
1642 return;
1644 /* Decide which set of relocs to use. Load them if necessary. */
1645 paux = (struct objdump_disasm_info *) pinfo->application_data;
1646 if (paux->dynrelbuf)
1648 rel_pp = paux->dynrelbuf;
1649 rel_count = paux->dynrelcount;
1650 /* Dynamic reloc addresses are absolute, non-dynamic are section
1651 relative. REL_OFFSET specifies the reloc address corresponding
1652 to the start of this section. */
1653 rel_offset = section->vma;
1655 else
1657 rel_count = 0;
1658 rel_pp = NULL;
1659 rel_offset = 0;
1661 if ((section->flags & SEC_RELOC) != 0
1662 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1664 long relsize;
1666 relsize = bfd_get_reloc_upper_bound (abfd, section);
1667 if (relsize < 0)
1668 bfd_fatal (bfd_get_filename (abfd));
1670 if (relsize > 0)
1672 rel_ppstart = rel_pp = xmalloc (relsize);
1673 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1674 if (rel_count < 0)
1675 bfd_fatal (bfd_get_filename (abfd));
1677 /* Sort the relocs by address. */
1678 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1683 rel_ppend = rel_pp + rel_count;
1685 data = xmalloc (datasize);
1687 bfd_get_section_contents (abfd, section, data, 0, datasize);
1689 paux->sec = section;
1690 pinfo->buffer = data;
1691 pinfo->buffer_vma = section->vma;
1692 pinfo->buffer_length = datasize;
1693 pinfo->section = section;
1695 if (start_address == (bfd_vma) -1
1696 || start_address < pinfo->buffer_vma)
1697 addr_offset = 0;
1698 else
1699 addr_offset = start_address - pinfo->buffer_vma;
1701 if (stop_address == (bfd_vma) -1)
1702 stop_offset = datasize / opb;
1703 else
1705 if (stop_address < pinfo->buffer_vma)
1706 stop_offset = 0;
1707 else
1708 stop_offset = stop_address - pinfo->buffer_vma;
1709 if (stop_offset > pinfo->buffer_length / opb)
1710 stop_offset = pinfo->buffer_length / opb;
1713 /* Skip over the relocs belonging to addresses below the
1714 start address. */
1715 while (rel_pp < rel_ppend
1716 && (*rel_pp)->address < rel_offset + addr_offset)
1717 ++rel_pp;
1719 printf (_("Disassembly of section %s:\n"), section->name);
1721 /* Find the nearest symbol forwards from our current position. */
1722 paux->require_sec = TRUE;
1723 sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1724 paux->require_sec = FALSE;
1726 /* Disassemble a block of instructions up to the address associated with
1727 the symbol we have just found. Then print the symbol and find the
1728 next symbol on. Repeat until we have disassembled the entire section
1729 or we have reached the end of the address range we are interested in. */
1730 while (addr_offset < stop_offset)
1732 bfd_vma addr;
1733 asymbol *nextsym;
1734 unsigned long nextstop_offset;
1735 bfd_boolean insns;
1737 addr = section->vma + addr_offset;
1739 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1741 int x;
1743 for (x = place;
1744 (x < sorted_symcount
1745 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1746 ++x)
1747 continue;
1749 pinfo->symbols = sorted_syms + place;
1750 pinfo->num_symbols = x - place;
1752 else
1754 pinfo->symbols = NULL;
1755 pinfo->num_symbols = 0;
1758 if (! prefix_addresses)
1760 pinfo->fprintf_func (pinfo->stream, "\n");
1761 objdump_print_addr_with_sym (abfd, section, sym, addr,
1762 pinfo, FALSE);
1763 pinfo->fprintf_func (pinfo->stream, ":\n");
1766 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1767 nextsym = sym;
1768 else if (sym == NULL)
1769 nextsym = NULL;
1770 else
1772 #define is_valid_next_sym(SYM) \
1773 ((SYM)->section == section \
1774 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1775 && pinfo->symbol_is_valid (SYM, pinfo))
1777 /* Search forward for the next appropriate symbol in
1778 SECTION. Note that all the symbols are sorted
1779 together into one big array, and that some sections
1780 may have overlapping addresses. */
1781 while (place < sorted_symcount
1782 && ! is_valid_next_sym (sorted_syms [place]))
1783 ++place;
1785 if (place >= sorted_symcount)
1786 nextsym = NULL;
1787 else
1788 nextsym = sorted_syms[place];
1791 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1792 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1793 else if (nextsym == NULL)
1794 nextstop_offset = stop_offset;
1795 else
1796 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1798 if (nextstop_offset > stop_offset)
1799 nextstop_offset = stop_offset;
1801 /* If a symbol is explicitly marked as being an object
1802 rather than a function, just dump the bytes without
1803 disassembling them. */
1804 if (disassemble_all
1805 || sym == NULL
1806 || bfd_asymbol_value (sym) > addr
1807 || ((sym->flags & BSF_OBJECT) == 0
1808 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1809 == NULL)
1810 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1811 == NULL))
1812 || (sym->flags & BSF_FUNCTION) != 0)
1813 insns = TRUE;
1814 else
1815 insns = FALSE;
1817 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1818 addr_offset, nextstop_offset,
1819 rel_offset, &rel_pp, rel_ppend);
1821 addr_offset = nextstop_offset;
1822 sym = nextsym;
1825 free (data);
1827 if (rel_ppstart != NULL)
1828 free (rel_ppstart);
1831 /* Disassemble the contents of an object file. */
1833 static void
1834 disassemble_data (bfd *abfd)
1836 struct disassemble_info disasm_info;
1837 struct objdump_disasm_info aux;
1838 long i;
1840 print_files = NULL;
1841 prev_functionname = NULL;
1842 prev_line = -1;
1844 /* We make a copy of syms to sort. We don't want to sort syms
1845 because that will screw up the relocs. */
1846 sorted_symcount = symcount ? symcount : dynsymcount;
1847 sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
1848 memcpy (sorted_syms, symcount ? syms : dynsyms,
1849 sorted_symcount * sizeof (asymbol *));
1851 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
1853 for (i = 0; i < synthcount; ++i)
1855 sorted_syms[sorted_symcount] = synthsyms + i;
1856 ++sorted_symcount;
1859 /* Sort the symbols into section and symbol order. */
1860 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1862 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
1864 disasm_info.application_data = (void *) &aux;
1865 aux.abfd = abfd;
1866 aux.require_sec = FALSE;
1867 aux.dynrelbuf = NULL;
1868 aux.dynrelcount = 0;
1869 aux.reloc = NULL;
1871 disasm_info.print_address_func = objdump_print_address;
1872 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1874 if (machine != NULL)
1876 const bfd_arch_info_type *info = bfd_scan_arch (machine);
1878 if (info == NULL)
1879 fatal (_("Can't use supplied machine %s"), machine);
1881 abfd->arch_info = info;
1884 if (endian != BFD_ENDIAN_UNKNOWN)
1886 struct bfd_target *xvec;
1888 xvec = xmalloc (sizeof (struct bfd_target));
1889 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1890 xvec->byteorder = endian;
1891 abfd->xvec = xvec;
1894 /* Use libopcodes to locate a suitable disassembler. */
1895 aux.disassemble_fn = disassembler (abfd);
1896 if (!aux.disassemble_fn)
1898 non_fatal (_("Can't disassemble for architecture %s\n"),
1899 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1900 exit_status = 1;
1901 return;
1904 disasm_info.flavour = bfd_get_flavour (abfd);
1905 disasm_info.arch = bfd_get_arch (abfd);
1906 disasm_info.mach = bfd_get_mach (abfd);
1907 disasm_info.disassembler_options = disassembler_options;
1908 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
1909 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
1910 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
1911 disasm_info.disassembler_needs_relocs = FALSE;
1913 if (bfd_big_endian (abfd))
1914 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1915 else if (bfd_little_endian (abfd))
1916 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1917 else
1918 /* ??? Aborting here seems too drastic. We could default to big or little
1919 instead. */
1920 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1922 /* Allow the target to customize the info structure. */
1923 disassemble_init_for_target (& disasm_info);
1925 /* Pre-load the dynamic relocs if we are going
1926 to be dumping them along with the disassembly. */
1927 if (dump_dynamic_reloc_info)
1929 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
1931 if (relsize < 0)
1932 bfd_fatal (bfd_get_filename (abfd));
1934 if (relsize > 0)
1936 aux.dynrelbuf = xmalloc (relsize);
1937 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
1938 aux.dynrelbuf,
1939 dynsyms);
1940 if (aux.dynrelcount < 0)
1941 bfd_fatal (bfd_get_filename (abfd));
1943 /* Sort the relocs by address. */
1944 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
1945 compare_relocs);
1949 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
1951 if (aux.dynrelbuf != NULL)
1952 free (aux.dynrelbuf);
1953 free (sorted_syms);
1957 load_debug_section (enum dwarf_section_display_enum debug, void *file)
1959 struct dwarf_section *section = &debug_displays [debug].section;
1960 bfd *abfd = file;
1961 asection *sec;
1962 bfd_boolean ret;
1964 /* If it is already loaded, do nothing. */
1965 if (section->start != NULL)
1966 return 1;
1968 /* Locate the debug section. */
1969 sec = bfd_get_section_by_name (abfd, section->name);
1970 if (sec == NULL)
1971 return 0;
1973 section->address = bfd_get_section_vma (abfd, sec);
1974 section->size = bfd_get_section_size (sec);
1975 section->start = xmalloc (section->size);
1977 if (is_relocatable && debug_displays [debug].relocate)
1978 ret = bfd_simple_get_relocated_section_contents (abfd,
1979 sec,
1980 section->start,
1981 syms) != NULL;
1982 else
1983 ret = bfd_get_section_contents (abfd, sec, section->start, 0,
1984 section->size);
1986 if (!ret)
1988 free_debug_section (debug);
1989 printf (_("\nCan't get contents for section '%s'.\n"),
1990 section->name);
1993 return ret;
1996 void
1997 free_debug_section (enum dwarf_section_display_enum debug)
1999 struct dwarf_section *section = &debug_displays [debug].section;
2001 if (section->start == NULL)
2002 return;
2004 free ((char *) section->start);
2005 section->start = NULL;
2006 section->address = 0;
2007 section->size = 0;
2010 static void
2011 dump_dwarf_section (bfd *abfd, asection *section,
2012 void *arg ATTRIBUTE_UNUSED)
2014 const char *name = bfd_get_section_name (abfd, section);
2015 const char *match;
2016 enum dwarf_section_display_enum i;
2018 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
2019 match = ".debug_info";
2020 else
2021 match = name;
2023 for (i = 0; i < max; i++)
2024 if (strcmp (debug_displays[i].section.name, match) == 0)
2026 if (!debug_displays[i].eh_frame)
2028 struct dwarf_section *sec = &debug_displays [i].section;
2030 if (load_debug_section (i, abfd))
2032 debug_displays[i].display (sec, abfd);
2034 if (i != info && i != abbrev)
2035 free_debug_section (i);
2038 break;
2042 static const char *mach_o_dwarf_sections [] = {
2043 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2044 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2045 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2046 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2047 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2048 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2049 ".eh_frame", /* .eh_frame */
2050 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2051 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2052 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2053 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2054 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2055 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2056 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2057 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2058 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2061 static const char *generic_dwarf_sections [max];
2063 static void
2064 check_mach_o_dwarf (bfd *abfd)
2066 static enum bfd_flavour old_flavour = bfd_target_unknown_flavour;
2067 enum bfd_flavour current_flavour = bfd_get_flavour (abfd);
2068 enum dwarf_section_display_enum i;
2070 if (generic_dwarf_sections [0] == NULL)
2071 for (i = 0; i < max; i++)
2072 generic_dwarf_sections [i] = debug_displays[i].section.name;
2074 if (old_flavour != current_flavour)
2076 if (current_flavour == bfd_target_mach_o_flavour)
2077 for (i = 0; i < max; i++)
2078 debug_displays[i].section.name = mach_o_dwarf_sections [i];
2079 else if (old_flavour == bfd_target_mach_o_flavour)
2080 for (i = 0; i < max; i++)
2081 debug_displays[i].section.name = generic_dwarf_sections [i];
2083 old_flavour = current_flavour;
2087 /* Dump the dwarf debugging information. */
2089 static void
2090 dump_dwarf (bfd *abfd)
2092 is_relocatable = ((abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC))
2093 == HAS_RELOC);
2095 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2096 targets will return 64. */
2097 eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2099 if (bfd_big_endian (abfd))
2100 byte_get = byte_get_big_endian;
2101 else if (bfd_little_endian (abfd))
2102 byte_get = byte_get_little_endian;
2103 else
2104 abort ();
2106 check_mach_o_dwarf (abfd);
2108 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2110 free_debug_memory ();
2113 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2114 it. Return NULL on failure. */
2116 static char *
2117 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2119 asection *stabsect;
2120 bfd_size_type size;
2121 char *contents;
2123 stabsect = bfd_get_section_by_name (abfd, sect_name);
2124 if (stabsect == NULL)
2126 printf (_("No %s section present\n\n"), sect_name);
2127 return FALSE;
2130 size = bfd_section_size (abfd, stabsect);
2131 contents = xmalloc (size);
2133 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2135 non_fatal (_("Reading %s section of %s failed: %s"),
2136 sect_name, bfd_get_filename (abfd),
2137 bfd_errmsg (bfd_get_error ()));
2138 free (contents);
2139 exit_status = 1;
2140 return NULL;
2143 *size_ptr = size;
2145 return contents;
2148 /* Stabs entries use a 12 byte format:
2149 4 byte string table index
2150 1 byte stab type
2151 1 byte stab other field
2152 2 byte stab desc field
2153 4 byte stab value
2154 FIXME: This will have to change for a 64 bit object format. */
2156 #define STRDXOFF (0)
2157 #define TYPEOFF (4)
2158 #define OTHEROFF (5)
2159 #define DESCOFF (6)
2160 #define VALOFF (8)
2161 #define STABSIZE (12)
2163 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2164 using string table section STRSECT_NAME (in `strtab'). */
2166 static void
2167 print_section_stabs (bfd *abfd,
2168 const char *stabsect_name,
2169 unsigned *string_offset_ptr)
2171 int i;
2172 unsigned file_string_table_offset = 0;
2173 unsigned next_file_string_table_offset = *string_offset_ptr;
2174 bfd_byte *stabp, *stabs_end;
2176 stabp = stabs;
2177 stabs_end = stabp + stab_size;
2179 printf (_("Contents of %s section:\n\n"), stabsect_name);
2180 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2182 /* Loop through all symbols and print them.
2184 We start the index at -1 because there is a dummy symbol on
2185 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2186 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2188 const char *name;
2189 unsigned long strx;
2190 unsigned char type, other;
2191 unsigned short desc;
2192 bfd_vma value;
2194 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2195 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2196 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2197 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2198 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2200 printf ("\n%-6d ", i);
2201 /* Either print the stab name, or, if unnamed, print its number
2202 again (makes consistent formatting for tools like awk). */
2203 name = bfd_get_stab_name (type);
2204 if (name != NULL)
2205 printf ("%-6s", name);
2206 else if (type == N_UNDF)
2207 printf ("HdrSym");
2208 else
2209 printf ("%-6d", type);
2210 printf (" %-6d %-6d ", other, desc);
2211 bfd_printf_vma (abfd, value);
2212 printf (" %-6lu", strx);
2214 /* Symbols with type == 0 (N_UNDF) specify the length of the
2215 string table associated with this file. We use that info
2216 to know how to relocate the *next* file's string table indices. */
2217 if (type == N_UNDF)
2219 file_string_table_offset = next_file_string_table_offset;
2220 next_file_string_table_offset += value;
2222 else
2224 /* Using the (possibly updated) string table offset, print the
2225 string (if any) associated with this symbol. */
2226 if ((strx + file_string_table_offset) < stabstr_size)
2227 printf (" %s", &strtab[strx + file_string_table_offset]);
2228 else
2229 printf (" *");
2232 printf ("\n\n");
2233 *string_offset_ptr = next_file_string_table_offset;
2236 typedef struct
2238 const char * section_name;
2239 const char * string_section_name;
2240 unsigned string_offset;
2242 stab_section_names;
2244 static void
2245 find_stabs_section (bfd *abfd, asection *section, void *names)
2247 int len;
2248 stab_section_names * sought = (stab_section_names *) names;
2250 /* Check for section names for which stabsect_name is a prefix, to
2251 handle .stab.N, etc. */
2252 len = strlen (sought->section_name);
2254 /* If the prefix matches, and the files section name ends with a
2255 nul or a digit, then we match. I.e., we want either an exact
2256 match or a section followed by a number. */
2257 if (strncmp (sought->section_name, section->name, len) == 0
2258 && (section->name[len] == 0
2259 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2261 if (strtab == NULL)
2262 strtab = read_section_stabs (abfd, sought->string_section_name,
2263 &stabstr_size);
2265 if (strtab)
2267 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2268 &stab_size);
2269 if (stabs)
2270 print_section_stabs (abfd, section->name, &sought->string_offset);
2275 static void
2276 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2278 stab_section_names s;
2280 s.section_name = stabsect_name;
2281 s.string_section_name = strsect_name;
2282 s.string_offset = 0;
2284 bfd_map_over_sections (abfd, find_stabs_section, & s);
2286 free (strtab);
2287 strtab = NULL;
2290 /* Dump the any sections containing stabs debugging information. */
2292 static void
2293 dump_stabs (bfd *abfd)
2295 dump_stabs_section (abfd, ".stab", ".stabstr");
2296 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2297 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2298 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2301 static void
2302 dump_bfd_header (bfd *abfd)
2304 char *comma = "";
2306 printf (_("architecture: %s, "),
2307 bfd_printable_arch_mach (bfd_get_arch (abfd),
2308 bfd_get_mach (abfd)));
2309 printf (_("flags 0x%08x:\n"), abfd->flags);
2311 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2312 PF (HAS_RELOC, "HAS_RELOC");
2313 PF (EXEC_P, "EXEC_P");
2314 PF (HAS_LINENO, "HAS_LINENO");
2315 PF (HAS_DEBUG, "HAS_DEBUG");
2316 PF (HAS_SYMS, "HAS_SYMS");
2317 PF (HAS_LOCALS, "HAS_LOCALS");
2318 PF (DYNAMIC, "DYNAMIC");
2319 PF (WP_TEXT, "WP_TEXT");
2320 PF (D_PAGED, "D_PAGED");
2321 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2322 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2323 printf (_("\nstart address 0x"));
2324 bfd_printf_vma (abfd, abfd->start_address);
2325 printf ("\n");
2329 static void
2330 dump_bfd_private_header (bfd *abfd)
2332 bfd_print_private_bfd_data (abfd, stdout);
2336 /* Display a section in hexadecimal format with associated characters.
2337 Each line prefixed by the zero padded address. */
2339 static void
2340 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2342 bfd_byte *data = 0;
2343 bfd_size_type datasize;
2344 bfd_size_type addr_offset;
2345 bfd_size_type start_offset;
2346 bfd_size_type stop_offset;
2347 unsigned int opb = bfd_octets_per_byte (abfd);
2348 /* Bytes per line. */
2349 const int onaline = 16;
2350 char buf[64];
2351 int count;
2352 int width;
2354 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2355 return;
2357 if (! process_section_p (section))
2358 return;
2360 if ((datasize = bfd_section_size (abfd, section)) == 0)
2361 return;
2363 printf (_("Contents of section %s:\n"), section->name);
2365 data = xmalloc (datasize);
2367 bfd_get_section_contents (abfd, section, data, 0, datasize);
2369 /* Compute the address range to display. */
2370 if (start_address == (bfd_vma) -1
2371 || start_address < section->vma)
2372 start_offset = 0;
2373 else
2374 start_offset = start_address - section->vma;
2376 if (stop_address == (bfd_vma) -1)
2377 stop_offset = datasize / opb;
2378 else
2380 if (stop_address < section->vma)
2381 stop_offset = 0;
2382 else
2383 stop_offset = stop_address - section->vma;
2385 if (stop_offset > datasize / opb)
2386 stop_offset = datasize / opb;
2389 width = 4;
2391 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2392 if (strlen (buf) >= sizeof (buf))
2393 abort ();
2395 count = 0;
2396 while (buf[count] == '0' && buf[count+1] != '\0')
2397 count++;
2398 count = strlen (buf) - count;
2399 if (count > width)
2400 width = count;
2402 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2403 if (strlen (buf) >= sizeof (buf))
2404 abort ();
2406 count = 0;
2407 while (buf[count] == '0' && buf[count+1] != '\0')
2408 count++;
2409 count = strlen (buf) - count;
2410 if (count > width)
2411 width = count;
2413 for (addr_offset = start_offset;
2414 addr_offset < stop_offset; addr_offset += onaline / opb)
2416 bfd_size_type j;
2418 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2419 count = strlen (buf);
2420 if ((size_t) count >= sizeof (buf))
2421 abort ();
2423 putchar (' ');
2424 while (count < width)
2426 putchar ('0');
2427 count++;
2429 fputs (buf + count - width, stdout);
2430 putchar (' ');
2432 for (j = addr_offset * opb;
2433 j < addr_offset * opb + onaline; j++)
2435 if (j < stop_offset * opb)
2436 printf ("%02x", (unsigned) (data[j]));
2437 else
2438 printf (" ");
2439 if ((j & 3) == 3)
2440 printf (" ");
2443 printf (" ");
2444 for (j = addr_offset * opb;
2445 j < addr_offset * opb + onaline; j++)
2447 if (j >= stop_offset * opb)
2448 printf (" ");
2449 else
2450 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2452 putchar ('\n');
2454 free (data);
2457 /* Actually display the various requested regions. */
2459 static void
2460 dump_data (bfd *abfd)
2462 bfd_map_over_sections (abfd, dump_section, NULL);
2465 /* Should perhaps share code and display with nm? */
2467 static void
2468 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2470 asymbol **current;
2471 long max;
2472 long count;
2474 if (dynamic)
2476 current = dynsyms;
2477 max = dynsymcount;
2478 printf ("DYNAMIC SYMBOL TABLE:\n");
2480 else
2482 current = syms;
2483 max = symcount;
2484 printf ("SYMBOL TABLE:\n");
2487 if (max == 0)
2488 printf (_("no symbols\n"));
2490 for (count = 0; count < max; count++)
2492 bfd *cur_bfd;
2494 if (*current == NULL)
2495 printf (_("no information for symbol number %ld\n"), count);
2497 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2498 printf (_("could not determine the type of symbol number %ld\n"),
2499 count);
2501 else if (process_section_p ((* current)->section)
2502 && (dump_special_syms
2503 || !bfd_is_target_special_symbol (cur_bfd, *current)))
2505 const char *name = (*current)->name;
2507 if (do_demangle && name != NULL && *name != '\0')
2509 char *alloc;
2511 /* If we want to demangle the name, we demangle it
2512 here, and temporarily clobber it while calling
2513 bfd_print_symbol. FIXME: This is a gross hack. */
2514 alloc = demangle (cur_bfd, name);
2515 (*current)->name = alloc;
2516 bfd_print_symbol (cur_bfd, stdout, *current,
2517 bfd_print_symbol_all);
2518 (*current)->name = name;
2519 free (alloc);
2521 else
2522 bfd_print_symbol (cur_bfd, stdout, *current,
2523 bfd_print_symbol_all);
2524 printf ("\n");
2527 current++;
2529 printf ("\n\n");
2532 static void
2533 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2535 arelent **p;
2536 char *last_filename, *last_functionname;
2537 unsigned int last_line;
2539 /* Get column headers lined up reasonably. */
2541 static int width;
2543 if (width == 0)
2545 char buf[30];
2547 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2548 width = strlen (buf) - 7;
2550 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2553 last_filename = NULL;
2554 last_functionname = NULL;
2555 last_line = 0;
2557 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2559 arelent *q = *p;
2560 const char *filename, *functionname;
2561 unsigned int line;
2562 const char *sym_name;
2563 const char *section_name;
2565 if (start_address != (bfd_vma) -1
2566 && q->address < start_address)
2567 continue;
2568 if (stop_address != (bfd_vma) -1
2569 && q->address > stop_address)
2570 continue;
2572 if (with_line_numbers
2573 && sec != NULL
2574 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2575 &filename, &functionname, &line))
2577 if (functionname != NULL
2578 && (last_functionname == NULL
2579 || strcmp (functionname, last_functionname) != 0))
2581 printf ("%s():\n", functionname);
2582 if (last_functionname != NULL)
2583 free (last_functionname);
2584 last_functionname = xstrdup (functionname);
2587 if (line > 0
2588 && (line != last_line
2589 || (filename != NULL
2590 && last_filename != NULL
2591 && strcmp (filename, last_filename) != 0)))
2593 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2594 last_line = line;
2595 if (last_filename != NULL)
2596 free (last_filename);
2597 if (filename == NULL)
2598 last_filename = NULL;
2599 else
2600 last_filename = xstrdup (filename);
2604 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2606 sym_name = (*(q->sym_ptr_ptr))->name;
2607 section_name = (*(q->sym_ptr_ptr))->section->name;
2609 else
2611 sym_name = NULL;
2612 section_name = NULL;
2615 bfd_printf_vma (abfd, q->address);
2616 if (q->howto == NULL)
2617 printf (" *unknown* ");
2618 else if (q->howto->name)
2619 printf (" %-16s ", q->howto->name);
2620 else
2621 printf (" %-16d ", q->howto->type);
2622 if (sym_name)
2623 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2624 else
2626 if (section_name == NULL)
2627 section_name = "*unknown*";
2628 printf ("[%s]", section_name);
2631 if (q->addend)
2633 printf ("+0x");
2634 bfd_printf_vma (abfd, q->addend);
2637 printf ("\n");
2641 static void
2642 dump_relocs_in_section (bfd *abfd,
2643 asection *section,
2644 void *dummy ATTRIBUTE_UNUSED)
2646 arelent **relpp;
2647 long relcount;
2648 long relsize;
2650 if ( bfd_is_abs_section (section)
2651 || bfd_is_und_section (section)
2652 || bfd_is_com_section (section)
2653 || (! process_section_p (section))
2654 || ((section->flags & SEC_RELOC) == 0))
2655 return;
2657 relsize = bfd_get_reloc_upper_bound (abfd, section);
2658 if (relsize < 0)
2659 bfd_fatal (bfd_get_filename (abfd));
2661 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2663 if (relsize == 0)
2665 printf (" (none)\n\n");
2666 return;
2669 relpp = xmalloc (relsize);
2670 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2672 if (relcount < 0)
2673 bfd_fatal (bfd_get_filename (abfd));
2674 else if (relcount == 0)
2675 printf (" (none)\n\n");
2676 else
2678 printf ("\n");
2679 dump_reloc_set (abfd, section, relpp, relcount);
2680 printf ("\n\n");
2682 free (relpp);
2685 static void
2686 dump_relocs (bfd *abfd)
2688 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2691 static void
2692 dump_dynamic_relocs (bfd *abfd)
2694 long relsize;
2695 arelent **relpp;
2696 long relcount;
2698 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2699 if (relsize < 0)
2700 bfd_fatal (bfd_get_filename (abfd));
2702 printf ("DYNAMIC RELOCATION RECORDS");
2704 if (relsize == 0)
2705 printf (" (none)\n\n");
2706 else
2708 relpp = xmalloc (relsize);
2709 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2711 if (relcount < 0)
2712 bfd_fatal (bfd_get_filename (abfd));
2713 else if (relcount == 0)
2714 printf (" (none)\n\n");
2715 else
2717 printf ("\n");
2718 dump_reloc_set (abfd, NULL, relpp, relcount);
2719 printf ("\n\n");
2721 free (relpp);
2725 /* Creates a table of paths, to search for source files. */
2727 static void
2728 add_include_path (const char *path)
2730 if (path[0] == 0)
2731 return;
2732 include_path_count++;
2733 include_paths = xrealloc (include_paths,
2734 include_path_count * sizeof (*include_paths));
2735 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2736 if (path[1] == ':' && path[2] == 0)
2737 path = concat (path, ".", (const char *) 0);
2738 #endif
2739 include_paths[include_path_count - 1] = path;
2742 static void
2743 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2744 asection *section,
2745 void *arg)
2747 if ((section->flags & SEC_DEBUGGING) == 0)
2749 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2750 section->vma += adjust_section_vma;
2751 if (*has_reloc_p)
2752 section->lma += adjust_section_vma;
2756 /* Dump selected contents of ABFD. */
2758 static void
2759 dump_bfd (bfd *abfd)
2761 /* If we are adjusting section VMA's, change them all now. Changing
2762 the BFD information is a hack. However, we must do it, or
2763 bfd_find_nearest_line will not do the right thing. */
2764 if (adjust_section_vma != 0)
2766 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2767 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2770 if (! dump_debugging_tags)
2771 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2772 abfd->xvec->name);
2773 if (dump_ar_hdrs)
2774 print_arelt_descr (stdout, abfd, TRUE);
2775 if (dump_file_header)
2776 dump_bfd_header (abfd);
2777 if (dump_private_headers)
2778 dump_bfd_private_header (abfd);
2779 if (! dump_debugging_tags)
2780 putchar ('\n');
2781 if (dump_section_headers)
2782 dump_headers (abfd);
2784 if (dump_symtab
2785 || dump_reloc_info
2786 || disassemble
2787 || dump_debugging
2788 || dump_dwarf_section_info)
2789 syms = slurp_symtab (abfd);
2790 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2791 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2792 dynsyms = slurp_dynamic_symtab (abfd);
2793 if (disassemble)
2795 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2796 dynsymcount, dynsyms, &synthsyms);
2797 if (synthcount < 0)
2798 synthcount = 0;
2801 if (dump_symtab)
2802 dump_symbols (abfd, FALSE);
2803 if (dump_dynamic_symtab)
2804 dump_symbols (abfd, TRUE);
2805 if (dump_dwarf_section_info)
2806 dump_dwarf (abfd);
2807 if (dump_stab_section_info)
2808 dump_stabs (abfd);
2809 if (dump_reloc_info && ! disassemble)
2810 dump_relocs (abfd);
2811 if (dump_dynamic_reloc_info && ! disassemble)
2812 dump_dynamic_relocs (abfd);
2813 if (dump_section_contents)
2814 dump_data (abfd);
2815 if (disassemble)
2816 disassemble_data (abfd);
2818 if (dump_debugging)
2820 void *dhandle;
2822 dhandle = read_debugging_info (abfd, syms, symcount);
2823 if (dhandle != NULL)
2825 if (! print_debugging_info (stdout, dhandle, abfd, syms, demangle,
2826 dump_debugging_tags ? TRUE : FALSE))
2828 non_fatal (_("%s: printing debugging information failed"),
2829 bfd_get_filename (abfd));
2830 exit_status = 1;
2835 if (syms)
2837 free (syms);
2838 syms = NULL;
2841 if (dynsyms)
2843 free (dynsyms);
2844 dynsyms = NULL;
2847 if (synthsyms)
2849 free (synthsyms);
2850 synthsyms = NULL;
2853 symcount = 0;
2854 dynsymcount = 0;
2855 synthcount = 0;
2858 static void
2859 display_bfd (bfd *abfd)
2861 char **matching;
2863 if (bfd_check_format_matches (abfd, bfd_object, &matching))
2865 dump_bfd (abfd);
2866 return;
2869 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2871 nonfatal (bfd_get_filename (abfd));
2872 list_matching_formats (matching);
2873 free (matching);
2874 return;
2877 if (bfd_get_error () != bfd_error_file_not_recognized)
2879 nonfatal (bfd_get_filename (abfd));
2880 return;
2883 if (bfd_check_format_matches (abfd, bfd_core, &matching))
2885 dump_bfd (abfd);
2886 return;
2889 nonfatal (bfd_get_filename (abfd));
2891 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2893 list_matching_formats (matching);
2894 free (matching);
2898 static void
2899 display_file (char *filename, char *target)
2901 bfd *file;
2902 bfd *arfile = NULL;
2904 if (get_file_size (filename) < 1)
2905 return;
2907 file = bfd_openr (filename, target);
2908 if (file == NULL)
2910 nonfatal (filename);
2911 return;
2914 /* If the file is an archive, process all of its elements. */
2915 if (bfd_check_format (file, bfd_archive))
2917 bfd *last_arfile = NULL;
2919 printf (_("In archive %s:\n"), bfd_get_filename (file));
2920 for (;;)
2922 bfd_set_error (bfd_error_no_error);
2924 arfile = bfd_openr_next_archived_file (file, arfile);
2925 if (arfile == NULL)
2927 if (bfd_get_error () != bfd_error_no_more_archived_files)
2928 nonfatal (bfd_get_filename (file));
2929 break;
2932 display_bfd (arfile);
2934 if (last_arfile != NULL)
2935 bfd_close (last_arfile);
2936 last_arfile = arfile;
2939 if (last_arfile != NULL)
2940 bfd_close (last_arfile);
2942 else
2943 display_bfd (file);
2945 bfd_close (file);
2949 main (int argc, char **argv)
2951 int c;
2952 char *target = default_target;
2953 bfd_boolean seenflag = FALSE;
2955 #if defined (HAVE_SETLOCALE)
2956 #if defined (HAVE_LC_MESSAGES)
2957 setlocale (LC_MESSAGES, "");
2958 #endif
2959 setlocale (LC_CTYPE, "");
2960 #endif
2962 bindtextdomain (PACKAGE, LOCALEDIR);
2963 textdomain (PACKAGE);
2965 program_name = *argv;
2966 xmalloc_set_program_name (program_name);
2968 START_PROGRESS (program_name, 0);
2970 expandargv (&argc, &argv);
2972 bfd_init ();
2973 set_default_bfd_target ();
2975 while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
2976 long_options, (int *) 0))
2977 != EOF)
2979 switch (c)
2981 case 0:
2982 break; /* We've been given a long option. */
2983 case 'm':
2984 machine = optarg;
2985 break;
2986 case 'M':
2987 if (disassembler_options)
2988 /* Ignore potential memory leak for now. */
2989 disassembler_options = concat (disassembler_options, ",",
2990 optarg, NULL);
2991 else
2992 disassembler_options = optarg;
2993 break;
2994 case 'j':
2995 if (only_used == only_size)
2997 only_size += 8;
2998 only = xrealloc (only, only_size * sizeof (char *));
3000 only [only_used++] = optarg;
3001 break;
3002 case 'l':
3003 with_line_numbers = TRUE;
3004 break;
3005 case 'b':
3006 target = optarg;
3007 break;
3008 case 'C':
3009 do_demangle = TRUE;
3010 if (optarg != NULL)
3012 enum demangling_styles style;
3014 style = cplus_demangle_name_to_style (optarg);
3015 if (style == unknown_demangling)
3016 fatal (_("unknown demangling style `%s'"),
3017 optarg);
3019 cplus_demangle_set_style (style);
3021 break;
3022 case 'w':
3023 wide_output = TRUE;
3024 break;
3025 case OPTION_ADJUST_VMA:
3026 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3027 break;
3028 case OPTION_START_ADDRESS:
3029 start_address = parse_vma (optarg, "--start-address");
3030 break;
3031 case OPTION_STOP_ADDRESS:
3032 stop_address = parse_vma (optarg, "--stop-address");
3033 break;
3034 case 'E':
3035 if (strcmp (optarg, "B") == 0)
3036 endian = BFD_ENDIAN_BIG;
3037 else if (strcmp (optarg, "L") == 0)
3038 endian = BFD_ENDIAN_LITTLE;
3039 else
3041 non_fatal (_("unrecognized -E option"));
3042 usage (stderr, 1);
3044 break;
3045 case OPTION_ENDIAN:
3046 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3047 endian = BFD_ENDIAN_BIG;
3048 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3049 endian = BFD_ENDIAN_LITTLE;
3050 else
3052 non_fatal (_("unrecognized --endian type `%s'"), optarg);
3053 usage (stderr, 1);
3055 break;
3057 case 'f':
3058 dump_file_header = TRUE;
3059 seenflag = TRUE;
3060 break;
3061 case 'i':
3062 formats_info = TRUE;
3063 seenflag = TRUE;
3064 break;
3065 case 'I':
3066 add_include_path (optarg);
3067 break;
3068 case 'p':
3069 dump_private_headers = TRUE;
3070 seenflag = TRUE;
3071 break;
3072 case 'x':
3073 dump_private_headers = TRUE;
3074 dump_symtab = TRUE;
3075 dump_reloc_info = TRUE;
3076 dump_file_header = TRUE;
3077 dump_ar_hdrs = TRUE;
3078 dump_section_headers = TRUE;
3079 seenflag = TRUE;
3080 break;
3081 case 't':
3082 dump_symtab = TRUE;
3083 seenflag = TRUE;
3084 break;
3085 case 'T':
3086 dump_dynamic_symtab = TRUE;
3087 seenflag = TRUE;
3088 break;
3089 case 'd':
3090 disassemble = TRUE;
3091 seenflag = TRUE;
3092 break;
3093 case 'z':
3094 disassemble_zeroes = TRUE;
3095 break;
3096 case 'D':
3097 disassemble = TRUE;
3098 disassemble_all = TRUE;
3099 seenflag = TRUE;
3100 break;
3101 case 'S':
3102 disassemble = TRUE;
3103 with_source_code = TRUE;
3104 seenflag = TRUE;
3105 break;
3106 case 'g':
3107 dump_debugging = 1;
3108 seenflag = TRUE;
3109 break;
3110 case 'e':
3111 dump_debugging = 1;
3112 dump_debugging_tags = 1;
3113 do_demangle = TRUE;
3114 seenflag = TRUE;
3115 break;
3116 case 'W':
3117 dump_dwarf_section_info = TRUE;
3118 seenflag = TRUE;
3119 do_debug_info = 1;
3120 do_debug_abbrevs = 1;
3121 do_debug_lines = 1;
3122 do_debug_pubnames = 1;
3123 do_debug_aranges = 1;
3124 do_debug_ranges = 1;
3125 do_debug_frames = 1;
3126 do_debug_macinfo = 1;
3127 do_debug_str = 1;
3128 do_debug_loc = 1;
3129 break;
3130 case 'G':
3131 dump_stab_section_info = TRUE;
3132 seenflag = TRUE;
3133 break;
3134 case 's':
3135 dump_section_contents = TRUE;
3136 seenflag = TRUE;
3137 break;
3138 case 'r':
3139 dump_reloc_info = TRUE;
3140 seenflag = TRUE;
3141 break;
3142 case 'R':
3143 dump_dynamic_reloc_info = TRUE;
3144 seenflag = TRUE;
3145 break;
3146 case 'a':
3147 dump_ar_hdrs = TRUE;
3148 seenflag = TRUE;
3149 break;
3150 case 'h':
3151 dump_section_headers = TRUE;
3152 seenflag = TRUE;
3153 break;
3154 case 'H':
3155 usage (stdout, 0);
3156 seenflag = TRUE;
3157 case 'v':
3158 case 'V':
3159 show_version = TRUE;
3160 seenflag = TRUE;
3161 break;
3163 default:
3164 usage (stderr, 1);
3168 if (show_version)
3169 print_version ("objdump");
3171 if (!seenflag)
3172 usage (stderr, 2);
3174 if (formats_info)
3175 exit_status = display_info ();
3176 else
3178 if (optind == argc)
3179 display_file ("a.out", target);
3180 else
3181 for (; optind < argc;)
3182 display_file (argv[optind++], target);
3185 END_PROGRESS (program_name);
3187 return exit_status;