daily update
[binutils.git] / binutils / objdump.c
blob03bc4d60ae12a887bb202ffd461f41bd0fd87b9e
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, 2007
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 3, 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,
21 MA 02110-1301, USA. */
24 /* Objdump overview.
26 Objdump displays information about one or more object files, either on
27 their own, or inside libraries. It is commonly used as a disassembler,
28 but it can also display information about file headers, symbol tables,
29 relocations, debugging directives and more.
31 The flow of execution is as follows:
33 1. Command line arguments are checked for control switches and the
34 information to be displayed is selected.
36 2. Any remaining arguments are assumed to be object files, and they are
37 processed in order by display_bfd(). If the file is an archive each
38 of its elements is processed in turn.
40 3. The file's target architecture and binary file format are determined
41 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 called.
44 4. dump_bfd() in turn calls separate functions to display the requested
45 item(s) of information(s). For example disassemble_data() is called if
46 a disassembly has been requested.
48 When disassembling the code loops through blocks of instructions bounded
49 by symbols, calling disassemble_bytes() on each block. The actual
50 disassembling is done by the libopcodes library, via a function pointer
51 supplied by the disassembler() function. */
53 #include "sysdep.h"
54 #include "bfd.h"
55 #include "progress.h"
56 #include "bucomm.h"
57 #include "dwarf.h"
58 #include "getopt.h"
59 #include "safe-ctype.h"
60 #include "dis-asm.h"
61 #include "libiberty.h"
62 #include "demangle.h"
63 #include "debug.h"
64 #include "budbg.h"
66 #ifdef HAVE_MMAP
67 #include <sys/mman.h>
68 #endif
70 #include <sys/stat.h>
72 /* Internal headers for the ELF .stab-dump code - sorry. */
73 #define BYTES_IN_WORD 32
74 #include "aout/aout64.h"
76 /* Exit status. */
77 static int exit_status = 0;
79 static char *default_target = NULL; /* Default at runtime. */
81 /* The following variables are set based on arguments passed on the
82 command line. */
83 static int show_version = 0; /* Show the version number. */
84 static int dump_section_contents; /* -s */
85 static int dump_section_headers; /* -h */
86 static bfd_boolean dump_file_header; /* -f */
87 static int dump_symtab; /* -t */
88 static int dump_dynamic_symtab; /* -T */
89 static int dump_reloc_info; /* -r */
90 static int dump_dynamic_reloc_info; /* -R */
91 static int dump_ar_hdrs; /* -a */
92 static int dump_private_headers; /* -p */
93 static int prefix_addresses; /* --prefix-addresses */
94 static int with_line_numbers; /* -l */
95 static bfd_boolean with_source_code; /* -S */
96 static int show_raw_insn; /* --show-raw-insn */
97 static int dump_dwarf_section_info; /* --dwarf */
98 static int dump_stab_section_info; /* --stabs */
99 static int do_demangle; /* -C, --demangle */
100 static bfd_boolean disassemble; /* -d */
101 static bfd_boolean disassemble_all; /* -D */
102 static int disassemble_zeroes; /* --disassemble-zeroes */
103 static bfd_boolean formats_info; /* -i */
104 static int wide_output; /* -w */
105 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
106 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
107 static int dump_debugging; /* --debugging */
108 static int dump_debugging_tags; /* --debugging-tags */
109 static int dump_special_syms = 0; /* --special-syms */
110 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
111 static int file_start_context = 0; /* --file-start-context */
113 /* Pointer to an array of section names provided by
114 one or more "-j secname" command line options. */
115 static char **only;
116 /* The total number of slots in the only[] array. */
117 static size_t only_size = 0;
118 /* The number of occupied slots in the only[] array. */
119 static size_t only_used = 0;
121 /* Variables for handling include file path table. */
122 static const char **include_paths;
123 static int include_path_count;
125 /* Extra info to pass to the section disassembler and address printing
126 function. */
127 struct objdump_disasm_info
129 bfd * abfd;
130 asection * sec;
131 bfd_boolean require_sec;
132 arelent ** dynrelbuf;
133 long dynrelcount;
134 disassembler_ftype disassemble_fn;
135 arelent * reloc;
138 /* Architecture to disassemble for, or default if NULL. */
139 static char *machine = NULL;
141 /* Target specific options to the disassembler. */
142 static char *disassembler_options = NULL;
144 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
145 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
147 /* The symbol table. */
148 static asymbol **syms;
150 /* Number of symbols in `syms'. */
151 static long symcount = 0;
153 /* The sorted symbol table. */
154 static asymbol **sorted_syms;
156 /* Number of symbols in `sorted_syms'. */
157 static long sorted_symcount = 0;
159 /* The dynamic symbol table. */
160 static asymbol **dynsyms;
162 /* The synthetic symbol table. */
163 static asymbol *synthsyms;
164 static long synthcount = 0;
166 /* Number of symbols in `dynsyms'. */
167 static long dynsymcount = 0;
169 static bfd_byte *stabs;
170 static bfd_size_type stab_size;
172 static char *strtab;
173 static bfd_size_type stabstr_size;
175 static void
176 usage (FILE *stream, int status)
178 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
179 fprintf (stream, _(" Display information from object <file(s)>.\n"));
180 fprintf (stream, _(" At least one of the following switches must be given:\n"));
181 fprintf (stream, _("\
182 -a, --archive-headers Display archive header information\n\
183 -f, --file-headers Display the contents of the overall file header\n\
184 -p, --private-headers Display object format specific file header contents\n\
185 -h, --[section-]headers Display the contents of the section headers\n\
186 -x, --all-headers Display the contents of all headers\n\
187 -d, --disassemble Display assembler contents of executable sections\n\
188 -D, --disassemble-all Display assembler contents of all sections\n\
189 -S, --source Intermix source code with disassembly\n\
190 -s, --full-contents Display the full contents of all sections requested\n\
191 -g, --debugging Display debug information in object file\n\
192 -e, --debugging-tags Display debug information using ctags style\n\
193 -G, --stabs Display (in raw form) any STABS info in the file\n\
194 -W, --dwarf Display DWARF info in the file\n\
195 -t, --syms Display the contents of the symbol table(s)\n\
196 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
197 -r, --reloc Display the relocation entries in the file\n\
198 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
199 @<file> Read options from <file>\n\
200 -v, --version Display this program's version number\n\
201 -i, --info List object formats and architectures supported\n\
202 -H, --help Display this information\n\
203 "));
204 if (status != 2)
206 fprintf (stream, _("\n The following switches are optional:\n"));
207 fprintf (stream, _("\
208 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
209 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
210 -j, --section=NAME Only display information for section NAME\n\
211 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
212 -EB --endian=big Assume big endian format when disassembling\n\
213 -EL --endian=little Assume little endian format when disassembling\n\
214 --file-start-context Include context from start of file (with -S)\n\
215 -I, --include=DIR Add DIR to search list for source files\n\
216 -l, --line-numbers Include line numbers and filenames in output\n\
217 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
218 The STYLE, if specified, can be `auto', `gnu',\n\
219 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
220 or `gnat'\n\
221 -w, --wide Format output for more than 80 columns\n\
222 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
223 --start-address=ADDR Only process data whose address is >= ADDR\n\
224 --stop-address=ADDR Only process data whose address is <= ADDR\n\
225 --prefix-addresses Print complete address alongside disassembly\n\
226 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
227 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
228 --special-syms Include special symbols in symbol dumps\n\
229 \n"));
230 list_supported_targets (program_name, stream);
231 list_supported_architectures (program_name, stream);
233 disassembler_usage (stream);
235 if (REPORT_BUGS_TO[0] && status == 0)
236 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
237 exit (status);
240 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
241 enum option_values
243 OPTION_ENDIAN=150,
244 OPTION_START_ADDRESS,
245 OPTION_STOP_ADDRESS,
246 OPTION_ADJUST_VMA
249 static struct option long_options[]=
251 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
252 {"all-headers", no_argument, NULL, 'x'},
253 {"private-headers", no_argument, NULL, 'p'},
254 {"architecture", required_argument, NULL, 'm'},
255 {"archive-headers", no_argument, NULL, 'a'},
256 {"debugging", no_argument, NULL, 'g'},
257 {"debugging-tags", no_argument, NULL, 'e'},
258 {"demangle", optional_argument, NULL, 'C'},
259 {"disassemble", no_argument, NULL, 'd'},
260 {"disassemble-all", no_argument, NULL, 'D'},
261 {"disassembler-options", required_argument, NULL, 'M'},
262 {"disassemble-zeroes", no_argument, NULL, 'z'},
263 {"dynamic-reloc", no_argument, NULL, 'R'},
264 {"dynamic-syms", no_argument, NULL, 'T'},
265 {"endian", required_argument, NULL, OPTION_ENDIAN},
266 {"file-headers", no_argument, NULL, 'f'},
267 {"file-start-context", no_argument, &file_start_context, 1},
268 {"full-contents", no_argument, NULL, 's'},
269 {"headers", no_argument, NULL, 'h'},
270 {"help", no_argument, NULL, 'H'},
271 {"info", no_argument, NULL, 'i'},
272 {"line-numbers", no_argument, NULL, 'l'},
273 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
274 {"prefix-addresses", no_argument, &prefix_addresses, 1},
275 {"reloc", no_argument, NULL, 'r'},
276 {"section", required_argument, NULL, 'j'},
277 {"section-headers", no_argument, NULL, 'h'},
278 {"show-raw-insn", no_argument, &show_raw_insn, 1},
279 {"source", no_argument, NULL, 'S'},
280 {"special-syms", no_argument, &dump_special_syms, 1},
281 {"include", required_argument, NULL, 'I'},
282 {"dwarf", no_argument, NULL, 'W'},
283 {"stabs", no_argument, NULL, 'G'},
284 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
285 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
286 {"syms", no_argument, NULL, 't'},
287 {"target", required_argument, NULL, 'b'},
288 {"version", no_argument, NULL, 'V'},
289 {"wide", no_argument, NULL, 'w'},
290 {0, no_argument, 0, 0}
293 static void
294 nonfatal (const char *msg)
296 bfd_nonfatal (msg);
297 exit_status = 1;
300 static void
301 dump_section_header (bfd *abfd, asection *section,
302 void *ignored ATTRIBUTE_UNUSED)
304 char *comma = "";
305 unsigned int opb = bfd_octets_per_byte (abfd);
307 /* Ignore linker created section. See elfNN_ia64_object_p in
308 bfd/elfxx-ia64.c. */
309 if (section->flags & SEC_LINKER_CREATED)
310 return;
312 printf ("%3d %-13s %08lx ", section->index,
313 bfd_get_section_name (abfd, section),
314 (unsigned long) bfd_section_size (abfd, section) / opb);
315 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
316 printf (" ");
317 bfd_printf_vma (abfd, section->lma);
318 printf (" %08lx 2**%u", (unsigned long) section->filepos,
319 bfd_get_section_alignment (abfd, section));
320 if (! wide_output)
321 printf ("\n ");
322 printf (" ");
324 #define PF(x, y) \
325 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
327 PF (SEC_HAS_CONTENTS, "CONTENTS");
328 PF (SEC_ALLOC, "ALLOC");
329 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
330 PF (SEC_LOAD, "LOAD");
331 PF (SEC_RELOC, "RELOC");
332 PF (SEC_READONLY, "READONLY");
333 PF (SEC_CODE, "CODE");
334 PF (SEC_DATA, "DATA");
335 PF (SEC_ROM, "ROM");
336 PF (SEC_DEBUGGING, "DEBUGGING");
337 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
338 PF (SEC_EXCLUDE, "EXCLUDE");
339 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
340 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
342 PF (SEC_TIC54X_BLOCK, "BLOCK");
343 PF (SEC_TIC54X_CLINK, "CLINK");
345 PF (SEC_SMALL_DATA, "SMALL_DATA");
346 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
347 PF (SEC_COFF_SHARED, "SHARED");
348 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
349 PF (SEC_GROUP, "GROUP");
351 if ((section->flags & SEC_LINK_ONCE) != 0)
353 const char *ls;
354 struct coff_comdat_info *comdat;
356 switch (section->flags & SEC_LINK_DUPLICATES)
358 default:
359 abort ();
360 case SEC_LINK_DUPLICATES_DISCARD:
361 ls = "LINK_ONCE_DISCARD";
362 break;
363 case SEC_LINK_DUPLICATES_ONE_ONLY:
364 ls = "LINK_ONCE_ONE_ONLY";
365 break;
366 case SEC_LINK_DUPLICATES_SAME_SIZE:
367 ls = "LINK_ONCE_SAME_SIZE";
368 break;
369 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
370 ls = "LINK_ONCE_SAME_CONTENTS";
371 break;
373 printf ("%s%s", comma, ls);
375 comdat = bfd_coff_get_comdat_section (abfd, section);
376 if (comdat != NULL)
377 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
379 comma = ", ";
382 printf ("\n");
383 #undef PF
386 static void
387 dump_headers (bfd *abfd)
389 printf (_("Sections:\n"));
391 #ifndef BFD64
392 printf (_("Idx Name Size VMA LMA File off Algn"));
393 #else
394 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
395 if (bfd_get_arch_size (abfd) == 32)
396 printf (_("Idx Name Size VMA LMA File off Algn"));
397 else
398 printf (_("Idx Name Size VMA LMA File off Algn"));
399 #endif
401 if (wide_output)
402 printf (_(" Flags"));
403 if (abfd->flags & HAS_LOAD_PAGE)
404 printf (_(" Pg"));
405 printf ("\n");
407 bfd_map_over_sections (abfd, dump_section_header, NULL);
410 static asymbol **
411 slurp_symtab (bfd *abfd)
413 asymbol **sy = NULL;
414 long storage;
416 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
418 symcount = 0;
419 return NULL;
422 storage = bfd_get_symtab_upper_bound (abfd);
423 if (storage < 0)
424 bfd_fatal (bfd_get_filename (abfd));
425 if (storage)
426 sy = xmalloc (storage);
428 symcount = bfd_canonicalize_symtab (abfd, sy);
429 if (symcount < 0)
430 bfd_fatal (bfd_get_filename (abfd));
431 return sy;
434 /* Read in the dynamic symbols. */
436 static asymbol **
437 slurp_dynamic_symtab (bfd *abfd)
439 asymbol **sy = NULL;
440 long storage;
442 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
443 if (storage < 0)
445 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
447 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
448 dynsymcount = 0;
449 return NULL;
452 bfd_fatal (bfd_get_filename (abfd));
454 if (storage)
455 sy = xmalloc (storage);
457 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
458 if (dynsymcount < 0)
459 bfd_fatal (bfd_get_filename (abfd));
460 return sy;
463 /* Filter out (in place) symbols that are useless for disassembly.
464 COUNT is the number of elements in SYMBOLS.
465 Return the number of useful symbols. */
467 static long
468 remove_useless_symbols (asymbol **symbols, long count)
470 asymbol **in_ptr = symbols, **out_ptr = symbols;
472 while (--count >= 0)
474 asymbol *sym = *in_ptr++;
476 if (sym->name == NULL || sym->name[0] == '\0')
477 continue;
478 if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
479 continue;
480 if (bfd_is_und_section (sym->section)
481 || bfd_is_com_section (sym->section))
482 continue;
484 *out_ptr++ = sym;
486 return out_ptr - symbols;
489 /* Sort symbols into value order. */
491 static int
492 compare_symbols (const void *ap, const void *bp)
494 const asymbol *a = * (const asymbol **) ap;
495 const asymbol *b = * (const asymbol **) bp;
496 const char *an;
497 const char *bn;
498 size_t anl;
499 size_t bnl;
500 bfd_boolean af;
501 bfd_boolean bf;
502 flagword aflags;
503 flagword bflags;
505 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
506 return 1;
507 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
508 return -1;
510 if (a->section > b->section)
511 return 1;
512 else if (a->section < b->section)
513 return -1;
515 an = bfd_asymbol_name (a);
516 bn = bfd_asymbol_name (b);
517 anl = strlen (an);
518 bnl = strlen (bn);
520 /* The symbols gnu_compiled and gcc2_compiled convey no real
521 information, so put them after other symbols with the same value. */
522 af = (strstr (an, "gnu_compiled") != NULL
523 || strstr (an, "gcc2_compiled") != NULL);
524 bf = (strstr (bn, "gnu_compiled") != NULL
525 || strstr (bn, "gcc2_compiled") != NULL);
527 if (af && ! bf)
528 return 1;
529 if (! af && bf)
530 return -1;
532 /* We use a heuristic for the file name, to try to sort it after
533 more useful symbols. It may not work on non Unix systems, but it
534 doesn't really matter; the only difference is precisely which
535 symbol names get printed. */
537 #define file_symbol(s, sn, snl) \
538 (((s)->flags & BSF_FILE) != 0 \
539 || ((sn)[(snl) - 2] == '.' \
540 && ((sn)[(snl) - 1] == 'o' \
541 || (sn)[(snl) - 1] == 'a')))
543 af = file_symbol (a, an, anl);
544 bf = file_symbol (b, bn, bnl);
546 if (af && ! bf)
547 return 1;
548 if (! af && bf)
549 return -1;
551 /* Try to sort global symbols before local symbols before function
552 symbols before debugging symbols. */
554 aflags = a->flags;
555 bflags = b->flags;
557 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
559 if ((aflags & BSF_DEBUGGING) != 0)
560 return 1;
561 else
562 return -1;
564 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
566 if ((aflags & BSF_FUNCTION) != 0)
567 return -1;
568 else
569 return 1;
571 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
573 if ((aflags & BSF_LOCAL) != 0)
574 return 1;
575 else
576 return -1;
578 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
580 if ((aflags & BSF_GLOBAL) != 0)
581 return -1;
582 else
583 return 1;
586 /* Symbols that start with '.' might be section names, so sort them
587 after symbols that don't start with '.'. */
588 if (an[0] == '.' && bn[0] != '.')
589 return 1;
590 if (an[0] != '.' && bn[0] == '.')
591 return -1;
593 /* Finally, if we can't distinguish them in any other way, try to
594 get consistent results by sorting the symbols by name. */
595 return strcmp (an, bn);
598 /* Sort relocs into address order. */
600 static int
601 compare_relocs (const void *ap, const void *bp)
603 const arelent *a = * (const arelent **) ap;
604 const arelent *b = * (const arelent **) bp;
606 if (a->address > b->address)
607 return 1;
608 else if (a->address < b->address)
609 return -1;
611 /* So that associated relocations tied to the same address show up
612 in the correct order, we don't do any further sorting. */
613 if (a > b)
614 return 1;
615 else if (a < b)
616 return -1;
617 else
618 return 0;
621 /* Print an address (VMA) to the output stream in INFO.
622 If SKIP_ZEROES is TRUE, omit leading zeroes. */
624 static void
625 objdump_print_value (bfd_vma vma, struct disassemble_info *info,
626 bfd_boolean skip_zeroes)
628 char buf[30];
629 char *p;
630 struct objdump_disasm_info *aux;
632 aux = (struct objdump_disasm_info *) info->application_data;
633 bfd_sprintf_vma (aux->abfd, buf, vma);
634 if (! skip_zeroes)
635 p = buf;
636 else
638 for (p = buf; *p == '0'; ++p)
640 if (*p == '\0')
641 --p;
643 (*info->fprintf_func) (info->stream, "%s", p);
646 /* Print the name of a symbol. */
648 static void
649 objdump_print_symname (bfd *abfd, struct disassemble_info *info,
650 asymbol *sym)
652 char *alloc;
653 const char *name;
655 alloc = NULL;
656 name = bfd_asymbol_name (sym);
657 if (do_demangle && name[0] != '\0')
659 /* Demangle the name. */
660 alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
661 if (alloc != NULL)
662 name = alloc;
665 if (info != NULL)
666 (*info->fprintf_func) (info->stream, "%s", name);
667 else
668 printf ("%s", name);
670 if (alloc != NULL)
671 free (alloc);
674 /* Locate a symbol given a bfd and a section (from INFO->application_data),
675 and a VMA. If INFO->application_data->require_sec is TRUE, then always
676 require the symbol to be in the section. Returns NULL if there is no
677 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
678 of the symbol in sorted_syms. */
680 static asymbol *
681 find_symbol_for_address (bfd_vma vma,
682 struct disassemble_info *info,
683 long *place)
685 /* @@ Would it speed things up to cache the last two symbols returned,
686 and maybe their address ranges? For many processors, only one memory
687 operand can be present at a time, so the 2-entry cache wouldn't be
688 constantly churned by code doing heavy memory accesses. */
690 /* Indices in `sorted_syms'. */
691 long min = 0;
692 long max = sorted_symcount;
693 long thisplace;
694 struct objdump_disasm_info *aux;
695 bfd *abfd;
696 asection *sec;
697 unsigned int opb;
698 bfd_boolean want_section;
700 if (sorted_symcount < 1)
701 return NULL;
703 aux = (struct objdump_disasm_info *) info->application_data;
704 abfd = aux->abfd;
705 sec = aux->sec;
706 opb = bfd_octets_per_byte (abfd);
708 /* Perform a binary search looking for the closest symbol to the
709 required value. We are searching the range (min, max]. */
710 while (min + 1 < max)
712 asymbol *sym;
714 thisplace = (max + min) / 2;
715 sym = sorted_syms[thisplace];
717 if (bfd_asymbol_value (sym) > vma)
718 max = thisplace;
719 else if (bfd_asymbol_value (sym) < vma)
720 min = thisplace;
721 else
723 min = thisplace;
724 break;
728 /* The symbol we want is now in min, the low end of the range we
729 were searching. If there are several symbols with the same
730 value, we want the first one. */
731 thisplace = min;
732 while (thisplace > 0
733 && (bfd_asymbol_value (sorted_syms[thisplace])
734 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
735 --thisplace;
737 /* If the file is relocatable, and the symbol could be from this
738 section, prefer a symbol from this section over symbols from
739 others, even if the other symbol's value might be closer.
741 Note that this may be wrong for some symbol references if the
742 sections have overlapping memory ranges, but in that case there's
743 no way to tell what's desired without looking at the relocation
744 table.
746 Also give the target a chance to reject symbols. */
747 want_section = (aux->require_sec
748 || ((abfd->flags & HAS_RELOC) != 0
749 && vma >= bfd_get_section_vma (abfd, sec)
750 && vma < (bfd_get_section_vma (abfd, sec)
751 + bfd_section_size (abfd, sec) / opb)));
752 if ((sorted_syms[thisplace]->section != sec && want_section)
753 || !info->symbol_is_valid (sorted_syms[thisplace], info))
755 long i;
756 long newplace;
758 for (i = thisplace + 1; i < sorted_symcount; i++)
760 if (bfd_asymbol_value (sorted_syms[i])
761 != bfd_asymbol_value (sorted_syms[thisplace]))
762 break;
765 --i;
766 newplace = sorted_symcount;
768 for (; i >= 0; i--)
770 if ((sorted_syms[i]->section == sec || !want_section)
771 && info->symbol_is_valid (sorted_syms[i], info))
773 if (newplace == sorted_symcount)
774 newplace = i;
776 if (bfd_asymbol_value (sorted_syms[i])
777 != bfd_asymbol_value (sorted_syms[newplace]))
778 break;
780 /* Remember this symbol and keep searching until we reach
781 an earlier address. */
782 newplace = i;
786 if (newplace != sorted_symcount)
787 thisplace = newplace;
788 else
790 /* We didn't find a good symbol with a smaller value.
791 Look for one with a larger value. */
792 for (i = thisplace + 1; i < sorted_symcount; i++)
794 if ((sorted_syms[i]->section == sec || !want_section)
795 && info->symbol_is_valid (sorted_syms[i], info))
797 thisplace = i;
798 break;
803 if ((sorted_syms[thisplace]->section != sec && want_section)
804 || !info->symbol_is_valid (sorted_syms[thisplace], info))
805 /* There is no suitable symbol. */
806 return NULL;
809 if (place != NULL)
810 *place = thisplace;
812 return sorted_syms[thisplace];
815 /* Print an address and the offset to the nearest symbol. */
817 static void
818 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
819 bfd_vma vma, struct disassemble_info *info,
820 bfd_boolean skip_zeroes)
822 objdump_print_value (vma, info, skip_zeroes);
824 if (sym == NULL)
826 bfd_vma secaddr;
828 (*info->fprintf_func) (info->stream, " <%s",
829 bfd_get_section_name (abfd, sec));
830 secaddr = bfd_get_section_vma (abfd, sec);
831 if (vma < secaddr)
833 (*info->fprintf_func) (info->stream, "-0x");
834 objdump_print_value (secaddr - vma, info, TRUE);
836 else if (vma > secaddr)
838 (*info->fprintf_func) (info->stream, "+0x");
839 objdump_print_value (vma - secaddr, info, TRUE);
841 (*info->fprintf_func) (info->stream, ">");
843 else
845 (*info->fprintf_func) (info->stream, " <");
846 objdump_print_symname (abfd, info, sym);
847 if (bfd_asymbol_value (sym) > vma)
849 (*info->fprintf_func) (info->stream, "-0x");
850 objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
852 else if (vma > bfd_asymbol_value (sym))
854 (*info->fprintf_func) (info->stream, "+0x");
855 objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
857 (*info->fprintf_func) (info->stream, ">");
861 /* Print an address (VMA), symbolically if possible.
862 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
864 static void
865 objdump_print_addr (bfd_vma vma,
866 struct disassemble_info *info,
867 bfd_boolean skip_zeroes)
869 struct objdump_disasm_info *aux;
870 asymbol *sym = NULL; /* Initialize to avoid compiler warning. */
871 bfd_boolean skip_find = FALSE;
873 if (sorted_symcount < 1)
875 (*info->fprintf_func) (info->stream, "0x");
876 objdump_print_value (vma, info, skip_zeroes);
877 return;
880 aux = (struct objdump_disasm_info *) info->application_data;
882 if (aux->reloc != NULL
883 && aux->reloc->sym_ptr_ptr != NULL
884 && * aux->reloc->sym_ptr_ptr != NULL)
886 sym = * aux->reloc->sym_ptr_ptr;
888 /* Adjust the vma to the reloc. */
889 vma += bfd_asymbol_value (sym);
891 if (bfd_is_und_section (bfd_get_section (sym)))
892 skip_find = TRUE;
895 if (!skip_find)
896 sym = find_symbol_for_address (vma, info, NULL);
898 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
899 skip_zeroes);
902 /* Print VMA to INFO. This function is passed to the disassembler
903 routine. */
905 static void
906 objdump_print_address (bfd_vma vma, struct disassemble_info *info)
908 objdump_print_addr (vma, info, ! prefix_addresses);
911 /* Determine if the given address has a symbol associated with it. */
913 static int
914 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
916 asymbol * sym;
918 sym = find_symbol_for_address (vma, info, NULL);
920 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
923 /* Hold the last function name and the last line number we displayed
924 in a disassembly. */
926 static char *prev_functionname;
927 static unsigned int prev_line;
929 /* We keep a list of all files that we have seen when doing a
930 disassembly with source, so that we know how much of the file to
931 display. This can be important for inlined functions. */
933 struct print_file_list
935 struct print_file_list *next;
936 const char *filename;
937 const char *modname;
938 const char *map;
939 size_t mapsize;
940 const char **linemap;
941 unsigned maxline;
942 unsigned last_line;
943 int first;
946 static struct print_file_list *print_files;
948 /* The number of preceding context lines to show when we start
949 displaying a file for the first time. */
951 #define SHOW_PRECEDING_CONTEXT_LINES (5)
953 /* Read a complete file into memory. */
955 static const char *
956 slurp_file (const char *fn, size_t *size)
958 #ifdef HAVE_MMAP
959 int ps = getpagesize ();
960 size_t msize;
961 #endif
962 const char *map;
963 struct stat st;
964 int fd = open (fn, O_RDONLY);
966 if (fd < 0)
967 return NULL;
968 if (fstat (fd, &st) < 0)
969 return NULL;
970 *size = st.st_size;
971 #ifdef HAVE_MMAP
972 msize = (*size + ps - 1) & ~(ps - 1);
973 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
974 if (map != (char *)-1L)
976 close(fd);
977 return map;
979 #endif
980 map = malloc (*size);
981 if (!map || (size_t) read (fd, (char *)map, *size) != *size)
983 free ((void *)map);
984 map = NULL;
986 close (fd);
987 return map;
990 #define line_map_decrease 5
992 /* Precompute array of lines for a mapped file. */
994 static const char **
995 index_file (const char *map, size_t size, unsigned int *maxline)
997 const char *p, *lstart, *end;
998 int chars_per_line = 45; /* First iteration will use 40. */
999 unsigned int lineno;
1000 const char **linemap = NULL;
1001 unsigned long line_map_size = 0;
1003 lineno = 0;
1004 lstart = map;
1005 end = map + size;
1007 for (p = map; p < end; p++)
1009 if (*p == '\n')
1011 if (p + 1 < end && p[1] == '\r')
1012 p++;
1014 else if (*p == '\r')
1016 if (p + 1 < end && p[1] == '\n')
1017 p++;
1019 else
1020 continue;
1022 /* End of line found. */
1024 if (linemap == NULL || line_map_size < lineno + 1)
1026 unsigned long newsize;
1028 chars_per_line -= line_map_decrease;
1029 if (chars_per_line <= 1)
1030 chars_per_line = 1;
1031 line_map_size = size / chars_per_line + 1;
1032 if (line_map_size < lineno + 1)
1033 line_map_size = lineno + 1;
1034 newsize = line_map_size * sizeof (char *);
1035 linemap = xrealloc (linemap, newsize);
1038 linemap[lineno++] = lstart;
1039 lstart = p + 1;
1042 *maxline = lineno;
1043 return linemap;
1046 /* Tries to open MODNAME, and if successful adds a node to print_files
1047 linked list and returns that node. Returns NULL on failure. */
1049 static struct print_file_list *
1050 try_print_file_open (const char *origname, const char *modname)
1052 struct print_file_list *p;
1054 p = xmalloc (sizeof (struct print_file_list));
1056 p->map = slurp_file (modname, &p->mapsize);
1057 if (p->map == NULL)
1059 free (p);
1060 return NULL;
1063 p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1064 p->last_line = 0;
1065 p->filename = origname;
1066 p->modname = modname;
1067 p->next = print_files;
1068 p->first = 1;
1069 print_files = p;
1070 return p;
1073 /* If the the source file, as described in the symtab, is not found
1074 try to locate it in one of the paths specified with -I
1075 If found, add location to print_files linked list. */
1077 static struct print_file_list *
1078 update_source_path (const char *filename)
1080 struct print_file_list *p;
1081 const char *fname;
1082 int i;
1084 if (filename == NULL)
1085 return NULL;
1087 p = try_print_file_open (filename, filename);
1088 if (p != NULL)
1089 return p;
1091 if (include_path_count == 0)
1092 return NULL;
1094 /* Get the name of the file. */
1095 fname = strrchr (filename, '/');
1096 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1098 /* We could have a mixed forward/back slash case. */
1099 char *backslash = strrchr (filename, '\\');
1100 if (fname == NULL || (backslash != NULL && backslash > fname))
1101 fname = backslash;
1102 if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
1103 fname = filename + 1;
1105 #endif
1106 if (fname == NULL)
1107 fname = filename;
1108 else
1109 ++fname;
1111 /* If file exists under a new path, we need to add it to the list
1112 so that show_line knows about it. */
1113 for (i = 0; i < include_path_count; i++)
1115 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1117 p = try_print_file_open (filename, modname);
1118 if (p)
1119 return p;
1121 free (modname);
1124 return NULL;
1127 /* Print a source file line. */
1129 static void
1130 print_line (struct print_file_list *p, unsigned int line)
1132 const char *l;
1134 --line;
1135 if (line >= p->maxline)
1136 return;
1137 l = p->linemap [line];
1138 fwrite (l, 1, strcspn (l, "\n\r"), stdout);
1139 putchar ('\n');
1142 /* Print a range of source code lines. */
1144 static void
1145 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1147 if (p->map == NULL)
1148 return;
1149 while (start <= end)
1151 print_line (p, start);
1152 start++;
1156 /* Show the line number, or the source line, in a disassembly
1157 listing. */
1159 static void
1160 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1162 const char *filename;
1163 const char *functionname;
1164 unsigned int line;
1166 if (! with_line_numbers && ! with_source_code)
1167 return;
1169 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1170 &functionname, &line))
1171 return;
1173 if (filename != NULL && *filename == '\0')
1174 filename = NULL;
1175 if (functionname != NULL && *functionname == '\0')
1176 functionname = NULL;
1178 if (with_line_numbers)
1180 if (functionname != NULL
1181 && (prev_functionname == NULL
1182 || strcmp (functionname, prev_functionname) != 0))
1183 printf ("%s():\n", functionname);
1184 if (line > 0 && line != prev_line)
1185 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1188 if (with_source_code
1189 && filename != NULL
1190 && line > 0)
1192 struct print_file_list **pp, *p;
1193 unsigned l;
1195 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1196 if (strcmp ((*pp)->filename, filename) == 0)
1197 break;
1198 p = *pp;
1200 if (p == NULL)
1201 p = update_source_path (filename);
1203 if (p != NULL && line != p->last_line)
1205 if (file_start_context && p->first)
1206 l = 1;
1207 else
1209 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1210 if (l >= line)
1211 l = 1;
1212 if (p->last_line >= l && p->last_line <= line)
1213 l = p->last_line + 1;
1215 dump_lines (p, l, line);
1216 p->last_line = line;
1217 p->first = 0;
1221 if (functionname != NULL
1222 && (prev_functionname == NULL
1223 || strcmp (functionname, prev_functionname) != 0))
1225 if (prev_functionname != NULL)
1226 free (prev_functionname);
1227 prev_functionname = xmalloc (strlen (functionname) + 1);
1228 strcpy (prev_functionname, functionname);
1231 if (line > 0 && line != prev_line)
1232 prev_line = line;
1235 /* Pseudo FILE object for strings. */
1236 typedef struct
1238 char *buffer;
1239 size_t pos;
1240 size_t alloc;
1241 } SFILE;
1243 /* sprintf to a "stream". */
1245 static int ATTRIBUTE_PRINTF_2
1246 objdump_sprintf (SFILE *f, const char *format, ...)
1248 size_t n;
1249 va_list args;
1251 while (1)
1253 size_t space = f->alloc - f->pos;
1255 va_start (args, format);
1256 n = vsnprintf (f->buffer + f->pos, space, format, args);
1257 va_end (args);
1259 if (space > n)
1260 break;
1262 f->alloc = (f->alloc + n) * 2;
1263 f->buffer = xrealloc (f->buffer, f->alloc);
1265 f->pos += n;
1267 return n;
1270 /* Returns TRUE if the specified section should be dumped. */
1272 static bfd_boolean
1273 process_section_p (asection * section)
1275 size_t i;
1277 if (only == NULL)
1278 return TRUE;
1280 for (i = 0; i < only_used; i++)
1281 if (strcmp (only [i], section->name) == 0)
1282 return TRUE;
1284 return FALSE;
1288 /* The number of zeroes we want to see before we start skipping them.
1289 The number is arbitrarily chosen. */
1291 #define DEFAULT_SKIP_ZEROES 8
1293 /* The number of zeroes to skip at the end of a section. If the
1294 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1295 SKIP_ZEROES, they will be disassembled. If there are fewer than
1296 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1297 attempt to avoid disassembling zeroes inserted by section
1298 alignment. */
1300 #define DEFAULT_SKIP_ZEROES_AT_END 3
1302 /* Disassemble some data in memory between given values. */
1304 static void
1305 disassemble_bytes (struct disassemble_info * info,
1306 disassembler_ftype disassemble_fn,
1307 bfd_boolean insns,
1308 bfd_byte * data,
1309 bfd_vma start_offset,
1310 bfd_vma stop_offset,
1311 bfd_vma rel_offset,
1312 arelent *** relppp,
1313 arelent ** relppend)
1315 struct objdump_disasm_info *aux;
1316 asection *section;
1317 int octets_per_line;
1318 bfd_boolean done_dot;
1319 int skip_addr_chars;
1320 bfd_vma addr_offset;
1321 unsigned int opb = info->octets_per_byte;
1322 unsigned int skip_zeroes = info->skip_zeroes;
1323 unsigned int skip_zeroes_at_end = info->skip_zeroes_at_end;
1324 int octets = opb;
1325 SFILE sfile;
1327 aux = (struct objdump_disasm_info *) info->application_data;
1328 section = aux->sec;
1330 sfile.alloc = 120;
1331 sfile.buffer = xmalloc (sfile.alloc);
1332 sfile.pos = 0;
1334 if (insns)
1335 octets_per_line = 4;
1336 else
1337 octets_per_line = 16;
1339 /* Figure out how many characters to skip at the start of an
1340 address, to make the disassembly look nicer. We discard leading
1341 zeroes in chunks of 4, ensuring that there is always a leading
1342 zero remaining. */
1343 skip_addr_chars = 0;
1344 if (! prefix_addresses)
1346 char buf[30];
1347 char *s;
1349 bfd_sprintf_vma
1350 (aux->abfd, buf,
1351 (section->vma
1352 + bfd_section_size (section->owner, section) / opb));
1353 s = buf;
1354 while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1355 && s[4] == '0')
1357 skip_addr_chars += 4;
1358 s += 4;
1362 info->insn_info_valid = 0;
1364 done_dot = FALSE;
1365 addr_offset = start_offset;
1366 while (addr_offset < stop_offset)
1368 bfd_vma z;
1369 bfd_boolean need_nl = FALSE;
1370 int previous_octets;
1372 /* Remember the length of the previous instruction. */
1373 previous_octets = octets;
1374 octets = 0;
1376 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1377 print `...'. */
1378 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1379 if (data[z] != 0)
1380 break;
1381 if (! disassemble_zeroes
1382 && (info->insn_info_valid == 0
1383 || info->branch_delay_insns == 0)
1384 && (z - addr_offset * opb >= skip_zeroes
1385 || (z == stop_offset * opb &&
1386 z - addr_offset * opb < skip_zeroes_at_end)))
1388 printf ("\t...\n");
1390 /* If there are more nonzero octets to follow, we only skip
1391 zeroes in multiples of 4, to try to avoid running over
1392 the start of an instruction which happens to start with
1393 zero. */
1394 if (z != stop_offset * opb)
1395 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1397 octets = z - addr_offset * opb;
1399 else
1401 char buf[50];
1402 int bpc = 0;
1403 int pb = 0;
1405 done_dot = FALSE;
1407 if (with_line_numbers || with_source_code)
1408 show_line (aux->abfd, section, addr_offset);
1410 if (! prefix_addresses)
1412 char *s;
1414 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1415 for (s = buf + skip_addr_chars; *s == '0'; s++)
1416 *s = ' ';
1417 if (*s == '\0')
1418 *--s = '0';
1419 printf ("%s:\t", buf + skip_addr_chars);
1421 else
1423 aux->require_sec = TRUE;
1424 objdump_print_address (section->vma + addr_offset, info);
1425 aux->require_sec = FALSE;
1426 putchar (' ');
1429 if (insns)
1431 sfile.pos = 0;
1432 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1433 info->stream = &sfile;
1434 info->bytes_per_line = 0;
1435 info->bytes_per_chunk = 0;
1436 info->flags = 0;
1438 if (info->disassembler_needs_relocs
1439 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1440 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1441 && *relppp < relppend)
1443 bfd_signed_vma distance_to_rel;
1445 distance_to_rel = (**relppp)->address
1446 - (rel_offset + addr_offset);
1448 /* Check to see if the current reloc is associated with
1449 the instruction that we are about to disassemble. */
1450 if (distance_to_rel == 0
1451 /* FIXME: This is wrong. We are trying to catch
1452 relocs that are addressed part way through the
1453 current instruction, as might happen with a packed
1454 VLIW instruction. Unfortunately we do not know the
1455 length of the current instruction since we have not
1456 disassembled it yet. Instead we take a guess based
1457 upon the length of the previous instruction. The
1458 proper solution is to have a new target-specific
1459 disassembler function which just returns the length
1460 of an instruction at a given address without trying
1461 to display its disassembly. */
1462 || (distance_to_rel > 0
1463 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1465 info->flags = INSN_HAS_RELOC;
1466 aux->reloc = **relppp;
1468 else
1469 aux->reloc = NULL;
1472 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1473 info->fprintf_func = (fprintf_ftype) fprintf;
1474 info->stream = stdout;
1475 if (info->bytes_per_line != 0)
1476 octets_per_line = info->bytes_per_line;
1477 if (octets < 0)
1479 if (sfile.pos)
1480 printf ("%s\n", sfile.buffer);
1481 break;
1484 else
1486 bfd_vma j;
1488 octets = octets_per_line;
1489 if (addr_offset + octets / opb > stop_offset)
1490 octets = (stop_offset - addr_offset) * opb;
1492 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1494 if (ISPRINT (data[j]))
1495 buf[j - addr_offset * opb] = data[j];
1496 else
1497 buf[j - addr_offset * opb] = '.';
1499 buf[j - addr_offset * opb] = '\0';
1502 if (prefix_addresses
1503 ? show_raw_insn > 0
1504 : show_raw_insn >= 0)
1506 bfd_vma j;
1508 /* If ! prefix_addresses and ! wide_output, we print
1509 octets_per_line octets per line. */
1510 pb = octets;
1511 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1512 pb = octets_per_line;
1514 if (info->bytes_per_chunk)
1515 bpc = info->bytes_per_chunk;
1516 else
1517 bpc = 1;
1519 for (j = addr_offset * opb; 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 (' ');
1537 for (; pb < octets_per_line; pb += bpc)
1539 int k;
1541 for (k = 0; k < bpc; k++)
1542 printf (" ");
1543 putchar (' ');
1546 /* Separate raw data from instruction by extra space. */
1547 if (insns)
1548 putchar ('\t');
1549 else
1550 printf (" ");
1553 if (! insns)
1554 printf ("%s", buf);
1555 else if (sfile.pos)
1556 printf ("%s", sfile.buffer);
1558 if (prefix_addresses
1559 ? show_raw_insn > 0
1560 : show_raw_insn >= 0)
1562 while (pb < octets)
1564 bfd_vma j;
1565 char *s;
1567 putchar ('\n');
1568 j = addr_offset * opb + pb;
1570 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1571 for (s = buf + skip_addr_chars; *s == '0'; s++)
1572 *s = ' ';
1573 if (*s == '\0')
1574 *--s = '0';
1575 printf ("%s:\t", buf + skip_addr_chars);
1577 pb += octets_per_line;
1578 if (pb > octets)
1579 pb = octets;
1580 for (; j < addr_offset * opb + pb; j += bpc)
1582 int k;
1584 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1586 for (k = bpc - 1; k >= 0; k--)
1587 printf ("%02x", (unsigned) data[j + k]);
1588 putchar (' ');
1590 else
1592 for (k = 0; k < bpc; k++)
1593 printf ("%02x", (unsigned) data[j + k]);
1594 putchar (' ');
1600 if (!wide_output)
1601 putchar ('\n');
1602 else
1603 need_nl = TRUE;
1606 while ((*relppp) < relppend
1607 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1609 if (dump_reloc_info || dump_dynamic_reloc_info)
1611 arelent *q;
1613 q = **relppp;
1615 if (wide_output)
1616 putchar ('\t');
1617 else
1618 printf ("\t\t\t");
1620 objdump_print_value (section->vma - rel_offset + q->address,
1621 info, TRUE);
1623 if (q->howto == NULL)
1624 printf (": *unknown*\t");
1625 else if (q->howto->name)
1626 printf (": %s\t", q->howto->name);
1627 else
1628 printf (": %d\t", q->howto->type);
1630 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1631 printf ("*unknown*");
1632 else
1634 const char *sym_name;
1636 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1637 if (sym_name != NULL && *sym_name != '\0')
1638 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1639 else
1641 asection *sym_sec;
1643 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1644 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1645 if (sym_name == NULL || *sym_name == '\0')
1646 sym_name = "*unknown*";
1647 printf ("%s", sym_name);
1651 if (q->addend)
1653 printf ("+0x");
1654 objdump_print_value (q->addend, info, TRUE);
1657 printf ("\n");
1658 need_nl = FALSE;
1660 ++(*relppp);
1663 if (need_nl)
1664 printf ("\n");
1666 addr_offset += octets / opb;
1669 free (sfile.buffer);
1672 static void
1673 disassemble_section (bfd *abfd, asection *section, void *info)
1675 struct disassemble_info * pinfo = (struct disassemble_info *) info;
1676 struct objdump_disasm_info * paux;
1677 unsigned int opb = pinfo->octets_per_byte;
1678 bfd_byte * data = NULL;
1679 bfd_size_type datasize = 0;
1680 arelent ** rel_pp = NULL;
1681 arelent ** rel_ppstart = NULL;
1682 arelent ** rel_ppend;
1683 unsigned long stop_offset;
1684 asymbol * sym = NULL;
1685 long place = 0;
1686 long rel_count;
1687 bfd_vma rel_offset;
1688 unsigned long addr_offset;
1690 /* Sections that do not contain machine
1691 code are not normally disassembled. */
1692 if (! disassemble_all
1693 && only == NULL
1694 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1695 != (SEC_CODE | SEC_HAS_CONTENTS)))
1696 return;
1698 if (! process_section_p (section))
1699 return;
1701 datasize = bfd_get_section_size (section);
1702 if (datasize == 0)
1703 return;
1705 /* Decide which set of relocs to use. Load them if necessary. */
1706 paux = (struct objdump_disasm_info *) pinfo->application_data;
1707 if (paux->dynrelbuf)
1709 rel_pp = paux->dynrelbuf;
1710 rel_count = paux->dynrelcount;
1711 /* Dynamic reloc addresses are absolute, non-dynamic are section
1712 relative. REL_OFFSET specifies the reloc address corresponding
1713 to the start of this section. */
1714 rel_offset = section->vma;
1716 else
1718 rel_count = 0;
1719 rel_pp = NULL;
1720 rel_offset = 0;
1722 if ((section->flags & SEC_RELOC) != 0
1723 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1725 long relsize;
1727 relsize = bfd_get_reloc_upper_bound (abfd, section);
1728 if (relsize < 0)
1729 bfd_fatal (bfd_get_filename (abfd));
1731 if (relsize > 0)
1733 rel_ppstart = rel_pp = xmalloc (relsize);
1734 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1735 if (rel_count < 0)
1736 bfd_fatal (bfd_get_filename (abfd));
1738 /* Sort the relocs by address. */
1739 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1744 rel_ppend = rel_pp + rel_count;
1746 data = xmalloc (datasize);
1748 bfd_get_section_contents (abfd, section, data, 0, datasize);
1750 paux->sec = section;
1751 pinfo->buffer = data;
1752 pinfo->buffer_vma = section->vma;
1753 pinfo->buffer_length = datasize;
1754 pinfo->section = section;
1756 if (start_address == (bfd_vma) -1
1757 || start_address < pinfo->buffer_vma)
1758 addr_offset = 0;
1759 else
1760 addr_offset = start_address - pinfo->buffer_vma;
1762 if (stop_address == (bfd_vma) -1)
1763 stop_offset = datasize / opb;
1764 else
1766 if (stop_address < pinfo->buffer_vma)
1767 stop_offset = 0;
1768 else
1769 stop_offset = stop_address - pinfo->buffer_vma;
1770 if (stop_offset > pinfo->buffer_length / opb)
1771 stop_offset = pinfo->buffer_length / opb;
1774 /* Skip over the relocs belonging to addresses below the
1775 start address. */
1776 while (rel_pp < rel_ppend
1777 && (*rel_pp)->address < rel_offset + addr_offset)
1778 ++rel_pp;
1780 printf (_("Disassembly of section %s:\n"), section->name);
1782 /* Find the nearest symbol forwards from our current position. */
1783 paux->require_sec = TRUE;
1784 sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1785 paux->require_sec = FALSE;
1787 /* Disassemble a block of instructions up to the address associated with
1788 the symbol we have just found. Then print the symbol and find the
1789 next symbol on. Repeat until we have disassembled the entire section
1790 or we have reached the end of the address range we are interested in. */
1791 while (addr_offset < stop_offset)
1793 bfd_vma addr;
1794 asymbol *nextsym;
1795 unsigned long nextstop_offset;
1796 bfd_boolean insns;
1798 addr = section->vma + addr_offset;
1800 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1802 int x;
1804 for (x = place;
1805 (x < sorted_symcount
1806 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1807 ++x)
1808 continue;
1810 pinfo->symbols = sorted_syms + place;
1811 pinfo->num_symbols = x - place;
1812 pinfo->symtab_pos = place;
1814 else
1816 pinfo->symbols = NULL;
1817 pinfo->num_symbols = 0;
1818 pinfo->symtab_pos = -1;
1821 if (! prefix_addresses)
1823 pinfo->fprintf_func (pinfo->stream, "\n");
1824 objdump_print_addr_with_sym (abfd, section, sym, addr,
1825 pinfo, FALSE);
1826 pinfo->fprintf_func (pinfo->stream, ":\n");
1829 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1830 nextsym = sym;
1831 else if (sym == NULL)
1832 nextsym = NULL;
1833 else
1835 #define is_valid_next_sym(SYM) \
1836 ((SYM)->section == section \
1837 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1838 && pinfo->symbol_is_valid (SYM, pinfo))
1840 /* Search forward for the next appropriate symbol in
1841 SECTION. Note that all the symbols are sorted
1842 together into one big array, and that some sections
1843 may have overlapping addresses. */
1844 while (place < sorted_symcount
1845 && ! is_valid_next_sym (sorted_syms [place]))
1846 ++place;
1848 if (place >= sorted_symcount)
1849 nextsym = NULL;
1850 else
1851 nextsym = sorted_syms[place];
1854 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1855 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1856 else if (nextsym == NULL)
1857 nextstop_offset = stop_offset;
1858 else
1859 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1861 if (nextstop_offset > stop_offset)
1862 nextstop_offset = stop_offset;
1864 /* If a symbol is explicitly marked as being an object
1865 rather than a function, just dump the bytes without
1866 disassembling them. */
1867 if (disassemble_all
1868 || sym == NULL
1869 || bfd_asymbol_value (sym) > addr
1870 || ((sym->flags & BSF_OBJECT) == 0
1871 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1872 == NULL)
1873 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1874 == NULL))
1875 || (sym->flags & BSF_FUNCTION) != 0)
1876 insns = TRUE;
1877 else
1878 insns = FALSE;
1880 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1881 addr_offset, nextstop_offset,
1882 rel_offset, &rel_pp, rel_ppend);
1884 addr_offset = nextstop_offset;
1885 sym = nextsym;
1888 free (data);
1890 if (rel_ppstart != NULL)
1891 free (rel_ppstart);
1894 /* Disassemble the contents of an object file. */
1896 static void
1897 disassemble_data (bfd *abfd)
1899 struct disassemble_info disasm_info;
1900 struct objdump_disasm_info aux;
1901 long i;
1903 print_files = NULL;
1904 prev_functionname = NULL;
1905 prev_line = -1;
1907 /* We make a copy of syms to sort. We don't want to sort syms
1908 because that will screw up the relocs. */
1909 sorted_symcount = symcount ? symcount : dynsymcount;
1910 sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
1911 memcpy (sorted_syms, symcount ? syms : dynsyms,
1912 sorted_symcount * sizeof (asymbol *));
1914 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
1916 for (i = 0; i < synthcount; ++i)
1918 sorted_syms[sorted_symcount] = synthsyms + i;
1919 ++sorted_symcount;
1922 /* Sort the symbols into section and symbol order. */
1923 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1925 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
1927 disasm_info.application_data = (void *) &aux;
1928 aux.abfd = abfd;
1929 aux.require_sec = FALSE;
1930 aux.dynrelbuf = NULL;
1931 aux.dynrelcount = 0;
1932 aux.reloc = NULL;
1934 disasm_info.print_address_func = objdump_print_address;
1935 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1937 if (machine != NULL)
1939 const bfd_arch_info_type *info = bfd_scan_arch (machine);
1941 if (info == NULL)
1942 fatal (_("Can't use supplied machine %s"), machine);
1944 abfd->arch_info = info;
1947 if (endian != BFD_ENDIAN_UNKNOWN)
1949 struct bfd_target *xvec;
1951 xvec = xmalloc (sizeof (struct bfd_target));
1952 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1953 xvec->byteorder = endian;
1954 abfd->xvec = xvec;
1957 /* Use libopcodes to locate a suitable disassembler. */
1958 aux.disassemble_fn = disassembler (abfd);
1959 if (!aux.disassemble_fn)
1961 non_fatal (_("Can't disassemble for architecture %s\n"),
1962 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1963 exit_status = 1;
1964 return;
1967 disasm_info.flavour = bfd_get_flavour (abfd);
1968 disasm_info.arch = bfd_get_arch (abfd);
1969 disasm_info.mach = bfd_get_mach (abfd);
1970 disasm_info.disassembler_options = disassembler_options;
1971 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
1972 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
1973 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
1974 disasm_info.disassembler_needs_relocs = FALSE;
1976 if (bfd_big_endian (abfd))
1977 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1978 else if (bfd_little_endian (abfd))
1979 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1980 else
1981 /* ??? Aborting here seems too drastic. We could default to big or little
1982 instead. */
1983 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1985 /* Allow the target to customize the info structure. */
1986 disassemble_init_for_target (& disasm_info);
1988 /* Pre-load the dynamic relocs if we are going
1989 to be dumping them along with the disassembly. */
1990 if (dump_dynamic_reloc_info)
1992 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
1994 if (relsize < 0)
1995 bfd_fatal (bfd_get_filename (abfd));
1997 if (relsize > 0)
1999 aux.dynrelbuf = xmalloc (relsize);
2000 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2001 aux.dynrelbuf,
2002 dynsyms);
2003 if (aux.dynrelcount < 0)
2004 bfd_fatal (bfd_get_filename (abfd));
2006 /* Sort the relocs by address. */
2007 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2008 compare_relocs);
2011 disasm_info.symtab = sorted_syms;
2012 disasm_info.symtab_size = sorted_symcount;
2014 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2016 if (aux.dynrelbuf != NULL)
2017 free (aux.dynrelbuf);
2018 free (sorted_syms);
2022 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2024 struct dwarf_section *section = &debug_displays [debug].section;
2025 bfd *abfd = file;
2026 asection *sec;
2027 bfd_boolean ret;
2029 /* If it is already loaded, do nothing. */
2030 if (section->start != NULL)
2031 return 1;
2033 /* Locate the debug section. */
2034 sec = bfd_get_section_by_name (abfd, section->name);
2035 if (sec == NULL)
2036 return 0;
2038 /* Compute a bias to be added to offsets found within the DWARF debug
2039 information. These offsets are meant to be relative to the start of
2040 the dwarf section, and hence the bias should be 0. For MACH-O however
2041 a dwarf section is really just a region of a much larger section and so
2042 the bias is the address of the start of that area within the larger
2043 section. This test is important for PE and COFF based targets which
2044 use DWARF debug information, since unlike ELF, they do not allow the
2045 dwarf sections to be placed at address 0. */
2046 if (bfd_get_flavour (abfd) == bfd_target_mach_o_flavour)
2047 section->address = bfd_get_section_vma (abfd, sec);
2048 else
2049 section->address = 0;
2051 section->size = bfd_get_section_size (sec);
2052 section->start = xmalloc (section->size);
2054 if (is_relocatable && debug_displays [debug].relocate)
2055 ret = bfd_simple_get_relocated_section_contents (abfd,
2056 sec,
2057 section->start,
2058 syms) != NULL;
2059 else
2060 ret = bfd_get_section_contents (abfd, sec, section->start, 0,
2061 section->size);
2063 if (!ret)
2065 free_debug_section (debug);
2066 printf (_("\nCan't get contents for section '%s'.\n"),
2067 section->name);
2070 return ret;
2073 void
2074 free_debug_section (enum dwarf_section_display_enum debug)
2076 struct dwarf_section *section = &debug_displays [debug].section;
2078 if (section->start == NULL)
2079 return;
2081 free ((char *) section->start);
2082 section->start = NULL;
2083 section->address = 0;
2084 section->size = 0;
2087 static void
2088 dump_dwarf_section (bfd *abfd, asection *section,
2089 void *arg ATTRIBUTE_UNUSED)
2091 const char *name = bfd_get_section_name (abfd, section);
2092 const char *match;
2093 enum dwarf_section_display_enum i;
2095 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2096 match = ".debug_info";
2097 else
2098 match = name;
2100 for (i = 0; i < max; i++)
2101 if (strcmp (debug_displays[i].section.name, match) == 0)
2103 if (!debug_displays[i].eh_frame)
2105 struct dwarf_section *sec = &debug_displays [i].section;
2107 if (load_debug_section (i, abfd))
2109 debug_displays[i].display (sec, abfd);
2111 if (i != info && i != abbrev)
2112 free_debug_section (i);
2115 break;
2119 static const char *mach_o_dwarf_sections [] = {
2120 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2121 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2122 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2123 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2124 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2125 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2126 ".eh_frame", /* .eh_frame */
2127 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2128 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2129 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2130 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2131 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2132 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2133 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2134 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2135 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2138 static const char *generic_dwarf_sections [max];
2140 static void
2141 check_mach_o_dwarf (bfd *abfd)
2143 static enum bfd_flavour old_flavour = bfd_target_unknown_flavour;
2144 enum bfd_flavour current_flavour = bfd_get_flavour (abfd);
2145 enum dwarf_section_display_enum i;
2147 if (generic_dwarf_sections [0] == NULL)
2148 for (i = 0; i < max; i++)
2149 generic_dwarf_sections [i] = debug_displays[i].section.name;
2151 if (old_flavour != current_flavour)
2153 if (current_flavour == bfd_target_mach_o_flavour)
2154 for (i = 0; i < max; i++)
2155 debug_displays[i].section.name = mach_o_dwarf_sections [i];
2156 else if (old_flavour == bfd_target_mach_o_flavour)
2157 for (i = 0; i < max; i++)
2158 debug_displays[i].section.name = generic_dwarf_sections [i];
2160 old_flavour = current_flavour;
2164 /* Dump the dwarf debugging information. */
2166 static void
2167 dump_dwarf (bfd *abfd)
2169 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2171 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2172 targets will return 64. */
2173 eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2175 if (bfd_big_endian (abfd))
2176 byte_get = byte_get_big_endian;
2177 else if (bfd_little_endian (abfd))
2178 byte_get = byte_get_little_endian;
2179 else
2180 abort ();
2182 check_mach_o_dwarf (abfd);
2184 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2186 free_debug_memory ();
2189 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2190 it. Return NULL on failure. */
2192 static char *
2193 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2195 asection *stabsect;
2196 bfd_size_type size;
2197 char *contents;
2199 stabsect = bfd_get_section_by_name (abfd, sect_name);
2200 if (stabsect == NULL)
2202 printf (_("No %s section present\n\n"), sect_name);
2203 return FALSE;
2206 size = bfd_section_size (abfd, stabsect);
2207 contents = xmalloc (size);
2209 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2211 non_fatal (_("Reading %s section of %s failed: %s"),
2212 sect_name, bfd_get_filename (abfd),
2213 bfd_errmsg (bfd_get_error ()));
2214 free (contents);
2215 exit_status = 1;
2216 return NULL;
2219 *size_ptr = size;
2221 return contents;
2224 /* Stabs entries use a 12 byte format:
2225 4 byte string table index
2226 1 byte stab type
2227 1 byte stab other field
2228 2 byte stab desc field
2229 4 byte stab value
2230 FIXME: This will have to change for a 64 bit object format. */
2232 #define STRDXOFF (0)
2233 #define TYPEOFF (4)
2234 #define OTHEROFF (5)
2235 #define DESCOFF (6)
2236 #define VALOFF (8)
2237 #define STABSIZE (12)
2239 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2240 using string table section STRSECT_NAME (in `strtab'). */
2242 static void
2243 print_section_stabs (bfd *abfd,
2244 const char *stabsect_name,
2245 unsigned *string_offset_ptr)
2247 int i;
2248 unsigned file_string_table_offset = 0;
2249 unsigned next_file_string_table_offset = *string_offset_ptr;
2250 bfd_byte *stabp, *stabs_end;
2252 stabp = stabs;
2253 stabs_end = stabp + stab_size;
2255 printf (_("Contents of %s section:\n\n"), stabsect_name);
2256 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2258 /* Loop through all symbols and print them.
2260 We start the index at -1 because there is a dummy symbol on
2261 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2262 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2264 const char *name;
2265 unsigned long strx;
2266 unsigned char type, other;
2267 unsigned short desc;
2268 bfd_vma value;
2270 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2271 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2272 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2273 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2274 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2276 printf ("\n%-6d ", i);
2277 /* Either print the stab name, or, if unnamed, print its number
2278 again (makes consistent formatting for tools like awk). */
2279 name = bfd_get_stab_name (type);
2280 if (name != NULL)
2281 printf ("%-6s", name);
2282 else if (type == N_UNDF)
2283 printf ("HdrSym");
2284 else
2285 printf ("%-6d", type);
2286 printf (" %-6d %-6d ", other, desc);
2287 bfd_printf_vma (abfd, value);
2288 printf (" %-6lu", strx);
2290 /* Symbols with type == 0 (N_UNDF) specify the length of the
2291 string table associated with this file. We use that info
2292 to know how to relocate the *next* file's string table indices. */
2293 if (type == N_UNDF)
2295 file_string_table_offset = next_file_string_table_offset;
2296 next_file_string_table_offset += value;
2298 else
2300 /* Using the (possibly updated) string table offset, print the
2301 string (if any) associated with this symbol. */
2302 if ((strx + file_string_table_offset) < stabstr_size)
2303 printf (" %s", &strtab[strx + file_string_table_offset]);
2304 else
2305 printf (" *");
2308 printf ("\n\n");
2309 *string_offset_ptr = next_file_string_table_offset;
2312 typedef struct
2314 const char * section_name;
2315 const char * string_section_name;
2316 unsigned string_offset;
2318 stab_section_names;
2320 static void
2321 find_stabs_section (bfd *abfd, asection *section, void *names)
2323 int len;
2324 stab_section_names * sought = (stab_section_names *) names;
2326 /* Check for section names for which stabsect_name is a prefix, to
2327 handle .stab.N, etc. */
2328 len = strlen (sought->section_name);
2330 /* If the prefix matches, and the files section name ends with a
2331 nul or a digit, then we match. I.e., we want either an exact
2332 match or a section followed by a number. */
2333 if (strncmp (sought->section_name, section->name, len) == 0
2334 && (section->name[len] == 0
2335 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2337 if (strtab == NULL)
2338 strtab = read_section_stabs (abfd, sought->string_section_name,
2339 &stabstr_size);
2341 if (strtab)
2343 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2344 &stab_size);
2345 if (stabs)
2346 print_section_stabs (abfd, section->name, &sought->string_offset);
2351 static void
2352 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2354 stab_section_names s;
2356 s.section_name = stabsect_name;
2357 s.string_section_name = strsect_name;
2358 s.string_offset = 0;
2360 bfd_map_over_sections (abfd, find_stabs_section, & s);
2362 free (strtab);
2363 strtab = NULL;
2366 /* Dump the any sections containing stabs debugging information. */
2368 static void
2369 dump_stabs (bfd *abfd)
2371 dump_stabs_section (abfd, ".stab", ".stabstr");
2372 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2373 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2374 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2377 static void
2378 dump_bfd_header (bfd *abfd)
2380 char *comma = "";
2382 printf (_("architecture: %s, "),
2383 bfd_printable_arch_mach (bfd_get_arch (abfd),
2384 bfd_get_mach (abfd)));
2385 printf (_("flags 0x%08x:\n"), abfd->flags);
2387 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2388 PF (HAS_RELOC, "HAS_RELOC");
2389 PF (EXEC_P, "EXEC_P");
2390 PF (HAS_LINENO, "HAS_LINENO");
2391 PF (HAS_DEBUG, "HAS_DEBUG");
2392 PF (HAS_SYMS, "HAS_SYMS");
2393 PF (HAS_LOCALS, "HAS_LOCALS");
2394 PF (DYNAMIC, "DYNAMIC");
2395 PF (WP_TEXT, "WP_TEXT");
2396 PF (D_PAGED, "D_PAGED");
2397 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2398 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2399 printf (_("\nstart address 0x"));
2400 bfd_printf_vma (abfd, abfd->start_address);
2401 printf ("\n");
2405 static void
2406 dump_bfd_private_header (bfd *abfd)
2408 bfd_print_private_bfd_data (abfd, stdout);
2412 /* Display a section in hexadecimal format with associated characters.
2413 Each line prefixed by the zero padded address. */
2415 static void
2416 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2418 bfd_byte *data = 0;
2419 bfd_size_type datasize;
2420 bfd_size_type addr_offset;
2421 bfd_size_type start_offset;
2422 bfd_size_type stop_offset;
2423 unsigned int opb = bfd_octets_per_byte (abfd);
2424 /* Bytes per line. */
2425 const int onaline = 16;
2426 char buf[64];
2427 int count;
2428 int width;
2430 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2431 return;
2433 if (! process_section_p (section))
2434 return;
2436 if ((datasize = bfd_section_size (abfd, section)) == 0)
2437 return;
2439 printf (_("Contents of section %s:\n"), section->name);
2441 data = xmalloc (datasize);
2443 bfd_get_section_contents (abfd, section, data, 0, datasize);
2445 /* Compute the address range to display. */
2446 if (start_address == (bfd_vma) -1
2447 || start_address < section->vma)
2448 start_offset = 0;
2449 else
2450 start_offset = start_address - section->vma;
2452 if (stop_address == (bfd_vma) -1)
2453 stop_offset = datasize / opb;
2454 else
2456 if (stop_address < section->vma)
2457 stop_offset = 0;
2458 else
2459 stop_offset = stop_address - section->vma;
2461 if (stop_offset > datasize / opb)
2462 stop_offset = datasize / opb;
2465 width = 4;
2467 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2468 if (strlen (buf) >= sizeof (buf))
2469 abort ();
2471 count = 0;
2472 while (buf[count] == '0' && buf[count+1] != '\0')
2473 count++;
2474 count = strlen (buf) - count;
2475 if (count > width)
2476 width = count;
2478 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2479 if (strlen (buf) >= sizeof (buf))
2480 abort ();
2482 count = 0;
2483 while (buf[count] == '0' && buf[count+1] != '\0')
2484 count++;
2485 count = strlen (buf) - count;
2486 if (count > width)
2487 width = count;
2489 for (addr_offset = start_offset;
2490 addr_offset < stop_offset; addr_offset += onaline / opb)
2492 bfd_size_type j;
2494 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2495 count = strlen (buf);
2496 if ((size_t) count >= sizeof (buf))
2497 abort ();
2499 putchar (' ');
2500 while (count < width)
2502 putchar ('0');
2503 count++;
2505 fputs (buf + count - width, stdout);
2506 putchar (' ');
2508 for (j = addr_offset * opb;
2509 j < addr_offset * opb + onaline; j++)
2511 if (j < stop_offset * opb)
2512 printf ("%02x", (unsigned) (data[j]));
2513 else
2514 printf (" ");
2515 if ((j & 3) == 3)
2516 printf (" ");
2519 printf (" ");
2520 for (j = addr_offset * opb;
2521 j < addr_offset * opb + onaline; j++)
2523 if (j >= stop_offset * opb)
2524 printf (" ");
2525 else
2526 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2528 putchar ('\n');
2530 free (data);
2533 /* Actually display the various requested regions. */
2535 static void
2536 dump_data (bfd *abfd)
2538 bfd_map_over_sections (abfd, dump_section, NULL);
2541 /* Should perhaps share code and display with nm? */
2543 static void
2544 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2546 asymbol **current;
2547 long max;
2548 long count;
2550 if (dynamic)
2552 current = dynsyms;
2553 max = dynsymcount;
2554 printf ("DYNAMIC SYMBOL TABLE:\n");
2556 else
2558 current = syms;
2559 max = symcount;
2560 printf ("SYMBOL TABLE:\n");
2563 if (max == 0)
2564 printf (_("no symbols\n"));
2566 for (count = 0; count < max; count++)
2568 bfd *cur_bfd;
2570 if (*current == NULL)
2571 printf (_("no information for symbol number %ld\n"), count);
2573 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2574 printf (_("could not determine the type of symbol number %ld\n"),
2575 count);
2577 else if (process_section_p ((* current)->section)
2578 && (dump_special_syms
2579 || !bfd_is_target_special_symbol (cur_bfd, *current)))
2581 const char *name = (*current)->name;
2583 if (do_demangle && name != NULL && *name != '\0')
2585 char *alloc;
2587 /* If we want to demangle the name, we demangle it
2588 here, and temporarily clobber it while calling
2589 bfd_print_symbol. FIXME: This is a gross hack. */
2590 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2591 if (alloc != NULL)
2592 (*current)->name = alloc;
2593 bfd_print_symbol (cur_bfd, stdout, *current,
2594 bfd_print_symbol_all);
2595 if (alloc != NULL)
2597 (*current)->name = name;
2598 free (alloc);
2601 else
2602 bfd_print_symbol (cur_bfd, stdout, *current,
2603 bfd_print_symbol_all);
2604 printf ("\n");
2607 current++;
2609 printf ("\n\n");
2612 static void
2613 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2615 arelent **p;
2616 char *last_filename, *last_functionname;
2617 unsigned int last_line;
2619 /* Get column headers lined up reasonably. */
2621 static int width;
2623 if (width == 0)
2625 char buf[30];
2627 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2628 width = strlen (buf) - 7;
2630 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2633 last_filename = NULL;
2634 last_functionname = NULL;
2635 last_line = 0;
2637 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2639 arelent *q = *p;
2640 const char *filename, *functionname;
2641 unsigned int line;
2642 const char *sym_name;
2643 const char *section_name;
2645 if (start_address != (bfd_vma) -1
2646 && q->address < start_address)
2647 continue;
2648 if (stop_address != (bfd_vma) -1
2649 && q->address > stop_address)
2650 continue;
2652 if (with_line_numbers
2653 && sec != NULL
2654 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2655 &filename, &functionname, &line))
2657 if (functionname != NULL
2658 && (last_functionname == NULL
2659 || strcmp (functionname, last_functionname) != 0))
2661 printf ("%s():\n", functionname);
2662 if (last_functionname != NULL)
2663 free (last_functionname);
2664 last_functionname = xstrdup (functionname);
2667 if (line > 0
2668 && (line != last_line
2669 || (filename != NULL
2670 && last_filename != NULL
2671 && strcmp (filename, last_filename) != 0)))
2673 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2674 last_line = line;
2675 if (last_filename != NULL)
2676 free (last_filename);
2677 if (filename == NULL)
2678 last_filename = NULL;
2679 else
2680 last_filename = xstrdup (filename);
2684 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2686 sym_name = (*(q->sym_ptr_ptr))->name;
2687 section_name = (*(q->sym_ptr_ptr))->section->name;
2689 else
2691 sym_name = NULL;
2692 section_name = NULL;
2695 bfd_printf_vma (abfd, q->address);
2696 if (q->howto == NULL)
2697 printf (" *unknown* ");
2698 else if (q->howto->name)
2699 printf (" %-16s ", q->howto->name);
2700 else
2701 printf (" %-16d ", q->howto->type);
2702 if (sym_name)
2703 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2704 else
2706 if (section_name == NULL)
2707 section_name = "*unknown*";
2708 printf ("[%s]", section_name);
2711 if (q->addend)
2713 printf ("+0x");
2714 bfd_printf_vma (abfd, q->addend);
2717 printf ("\n");
2721 static void
2722 dump_relocs_in_section (bfd *abfd,
2723 asection *section,
2724 void *dummy ATTRIBUTE_UNUSED)
2726 arelent **relpp;
2727 long relcount;
2728 long relsize;
2730 if ( bfd_is_abs_section (section)
2731 || bfd_is_und_section (section)
2732 || bfd_is_com_section (section)
2733 || (! process_section_p (section))
2734 || ((section->flags & SEC_RELOC) == 0))
2735 return;
2737 relsize = bfd_get_reloc_upper_bound (abfd, section);
2738 if (relsize < 0)
2739 bfd_fatal (bfd_get_filename (abfd));
2741 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2743 if (relsize == 0)
2745 printf (" (none)\n\n");
2746 return;
2749 relpp = xmalloc (relsize);
2750 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2752 if (relcount < 0)
2753 bfd_fatal (bfd_get_filename (abfd));
2754 else if (relcount == 0)
2755 printf (" (none)\n\n");
2756 else
2758 printf ("\n");
2759 dump_reloc_set (abfd, section, relpp, relcount);
2760 printf ("\n\n");
2762 free (relpp);
2765 static void
2766 dump_relocs (bfd *abfd)
2768 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2771 static void
2772 dump_dynamic_relocs (bfd *abfd)
2774 long relsize;
2775 arelent **relpp;
2776 long relcount;
2778 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2779 if (relsize < 0)
2780 bfd_fatal (bfd_get_filename (abfd));
2782 printf ("DYNAMIC RELOCATION RECORDS");
2784 if (relsize == 0)
2785 printf (" (none)\n\n");
2786 else
2788 relpp = xmalloc (relsize);
2789 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2791 if (relcount < 0)
2792 bfd_fatal (bfd_get_filename (abfd));
2793 else if (relcount == 0)
2794 printf (" (none)\n\n");
2795 else
2797 printf ("\n");
2798 dump_reloc_set (abfd, NULL, relpp, relcount);
2799 printf ("\n\n");
2801 free (relpp);
2805 /* Creates a table of paths, to search for source files. */
2807 static void
2808 add_include_path (const char *path)
2810 if (path[0] == 0)
2811 return;
2812 include_path_count++;
2813 include_paths = xrealloc (include_paths,
2814 include_path_count * sizeof (*include_paths));
2815 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2816 if (path[1] == ':' && path[2] == 0)
2817 path = concat (path, ".", (const char *) 0);
2818 #endif
2819 include_paths[include_path_count - 1] = path;
2822 static void
2823 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2824 asection *section,
2825 void *arg)
2827 if ((section->flags & SEC_DEBUGGING) == 0)
2829 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2830 section->vma += adjust_section_vma;
2831 if (*has_reloc_p)
2832 section->lma += adjust_section_vma;
2836 /* Dump selected contents of ABFD. */
2838 static void
2839 dump_bfd (bfd *abfd)
2841 /* If we are adjusting section VMA's, change them all now. Changing
2842 the BFD information is a hack. However, we must do it, or
2843 bfd_find_nearest_line will not do the right thing. */
2844 if (adjust_section_vma != 0)
2846 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2847 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2850 if (! dump_debugging_tags)
2851 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2852 abfd->xvec->name);
2853 if (dump_ar_hdrs)
2854 print_arelt_descr (stdout, abfd, TRUE);
2855 if (dump_file_header)
2856 dump_bfd_header (abfd);
2857 if (dump_private_headers)
2858 dump_bfd_private_header (abfd);
2859 if (! dump_debugging_tags)
2860 putchar ('\n');
2861 if (dump_section_headers)
2862 dump_headers (abfd);
2864 if (dump_symtab
2865 || dump_reloc_info
2866 || disassemble
2867 || dump_debugging
2868 || dump_dwarf_section_info)
2869 syms = slurp_symtab (abfd);
2870 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2871 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2872 dynsyms = slurp_dynamic_symtab (abfd);
2873 if (disassemble)
2875 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2876 dynsymcount, dynsyms, &synthsyms);
2877 if (synthcount < 0)
2878 synthcount = 0;
2881 if (dump_symtab)
2882 dump_symbols (abfd, FALSE);
2883 if (dump_dynamic_symtab)
2884 dump_symbols (abfd, TRUE);
2885 if (dump_dwarf_section_info)
2886 dump_dwarf (abfd);
2887 if (dump_stab_section_info)
2888 dump_stabs (abfd);
2889 if (dump_reloc_info && ! disassemble)
2890 dump_relocs (abfd);
2891 if (dump_dynamic_reloc_info && ! disassemble)
2892 dump_dynamic_relocs (abfd);
2893 if (dump_section_contents)
2894 dump_data (abfd);
2895 if (disassemble)
2896 disassemble_data (abfd);
2898 if (dump_debugging)
2900 void *dhandle;
2902 dhandle = read_debugging_info (abfd, syms, symcount);
2903 if (dhandle != NULL)
2905 if (!print_debugging_info (stdout, dhandle, abfd, syms,
2906 bfd_demangle,
2907 dump_debugging_tags ? TRUE : FALSE))
2909 non_fatal (_("%s: printing debugging information failed"),
2910 bfd_get_filename (abfd));
2911 exit_status = 1;
2916 if (syms)
2918 free (syms);
2919 syms = NULL;
2922 if (dynsyms)
2924 free (dynsyms);
2925 dynsyms = NULL;
2928 if (synthsyms)
2930 free (synthsyms);
2931 synthsyms = NULL;
2934 symcount = 0;
2935 dynsymcount = 0;
2936 synthcount = 0;
2939 static void
2940 display_bfd (bfd *abfd)
2942 char **matching;
2944 if (bfd_check_format_matches (abfd, bfd_object, &matching))
2946 dump_bfd (abfd);
2947 return;
2950 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2952 nonfatal (bfd_get_filename (abfd));
2953 list_matching_formats (matching);
2954 free (matching);
2955 return;
2958 if (bfd_get_error () != bfd_error_file_not_recognized)
2960 nonfatal (bfd_get_filename (abfd));
2961 return;
2964 if (bfd_check_format_matches (abfd, bfd_core, &matching))
2966 dump_bfd (abfd);
2967 return;
2970 nonfatal (bfd_get_filename (abfd));
2972 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2974 list_matching_formats (matching);
2975 free (matching);
2979 static void
2980 display_file (char *filename, char *target)
2982 bfd *file;
2983 bfd *arfile = NULL;
2985 if (get_file_size (filename) < 1)
2987 exit_status = 1;
2988 return;
2991 file = bfd_openr (filename, target);
2992 if (file == NULL)
2994 nonfatal (filename);
2995 return;
2998 /* If the file is an archive, process all of its elements. */
2999 if (bfd_check_format (file, bfd_archive))
3001 bfd *last_arfile = NULL;
3003 printf (_("In archive %s:\n"), bfd_get_filename (file));
3004 for (;;)
3006 bfd_set_error (bfd_error_no_error);
3008 arfile = bfd_openr_next_archived_file (file, arfile);
3009 if (arfile == NULL)
3011 if (bfd_get_error () != bfd_error_no_more_archived_files)
3012 nonfatal (bfd_get_filename (file));
3013 break;
3016 display_bfd (arfile);
3018 if (last_arfile != NULL)
3019 bfd_close (last_arfile);
3020 last_arfile = arfile;
3023 if (last_arfile != NULL)
3024 bfd_close (last_arfile);
3026 else
3027 display_bfd (file);
3029 bfd_close (file);
3033 main (int argc, char **argv)
3035 int c;
3036 char *target = default_target;
3037 bfd_boolean seenflag = FALSE;
3039 #if defined (HAVE_SETLOCALE)
3040 #if defined (HAVE_LC_MESSAGES)
3041 setlocale (LC_MESSAGES, "");
3042 #endif
3043 setlocale (LC_CTYPE, "");
3044 #endif
3046 bindtextdomain (PACKAGE, LOCALEDIR);
3047 textdomain (PACKAGE);
3049 program_name = *argv;
3050 xmalloc_set_program_name (program_name);
3052 START_PROGRESS (program_name, 0);
3054 expandargv (&argc, &argv);
3056 bfd_init ();
3057 set_default_bfd_target ();
3059 while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
3060 long_options, (int *) 0))
3061 != EOF)
3063 switch (c)
3065 case 0:
3066 break; /* We've been given a long option. */
3067 case 'm':
3068 machine = optarg;
3069 break;
3070 case 'M':
3071 if (disassembler_options)
3072 /* Ignore potential memory leak for now. */
3073 disassembler_options = concat (disassembler_options, ",",
3074 optarg, NULL);
3075 else
3076 disassembler_options = optarg;
3077 break;
3078 case 'j':
3079 if (only_used == only_size)
3081 only_size += 8;
3082 only = xrealloc (only, only_size * sizeof (char *));
3084 only [only_used++] = optarg;
3085 break;
3086 case 'l':
3087 with_line_numbers = TRUE;
3088 break;
3089 case 'b':
3090 target = optarg;
3091 break;
3092 case 'C':
3093 do_demangle = TRUE;
3094 if (optarg != NULL)
3096 enum demangling_styles style;
3098 style = cplus_demangle_name_to_style (optarg);
3099 if (style == unknown_demangling)
3100 fatal (_("unknown demangling style `%s'"),
3101 optarg);
3103 cplus_demangle_set_style (style);
3105 break;
3106 case 'w':
3107 wide_output = TRUE;
3108 break;
3109 case OPTION_ADJUST_VMA:
3110 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3111 break;
3112 case OPTION_START_ADDRESS:
3113 start_address = parse_vma (optarg, "--start-address");
3114 break;
3115 case OPTION_STOP_ADDRESS:
3116 stop_address = parse_vma (optarg, "--stop-address");
3117 break;
3118 case 'E':
3119 if (strcmp (optarg, "B") == 0)
3120 endian = BFD_ENDIAN_BIG;
3121 else if (strcmp (optarg, "L") == 0)
3122 endian = BFD_ENDIAN_LITTLE;
3123 else
3125 non_fatal (_("unrecognized -E option"));
3126 usage (stderr, 1);
3128 break;
3129 case OPTION_ENDIAN:
3130 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3131 endian = BFD_ENDIAN_BIG;
3132 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3133 endian = BFD_ENDIAN_LITTLE;
3134 else
3136 non_fatal (_("unrecognized --endian type `%s'"), optarg);
3137 usage (stderr, 1);
3139 break;
3141 case 'f':
3142 dump_file_header = TRUE;
3143 seenflag = TRUE;
3144 break;
3145 case 'i':
3146 formats_info = TRUE;
3147 seenflag = TRUE;
3148 break;
3149 case 'I':
3150 add_include_path (optarg);
3151 break;
3152 case 'p':
3153 dump_private_headers = TRUE;
3154 seenflag = TRUE;
3155 break;
3156 case 'x':
3157 dump_private_headers = TRUE;
3158 dump_symtab = TRUE;
3159 dump_reloc_info = TRUE;
3160 dump_file_header = TRUE;
3161 dump_ar_hdrs = TRUE;
3162 dump_section_headers = TRUE;
3163 seenflag = TRUE;
3164 break;
3165 case 't':
3166 dump_symtab = TRUE;
3167 seenflag = TRUE;
3168 break;
3169 case 'T':
3170 dump_dynamic_symtab = TRUE;
3171 seenflag = TRUE;
3172 break;
3173 case 'd':
3174 disassemble = TRUE;
3175 seenflag = TRUE;
3176 break;
3177 case 'z':
3178 disassemble_zeroes = TRUE;
3179 break;
3180 case 'D':
3181 disassemble = TRUE;
3182 disassemble_all = TRUE;
3183 seenflag = TRUE;
3184 break;
3185 case 'S':
3186 disassemble = TRUE;
3187 with_source_code = TRUE;
3188 seenflag = TRUE;
3189 break;
3190 case 'g':
3191 dump_debugging = 1;
3192 seenflag = TRUE;
3193 break;
3194 case 'e':
3195 dump_debugging = 1;
3196 dump_debugging_tags = 1;
3197 do_demangle = TRUE;
3198 seenflag = TRUE;
3199 break;
3200 case 'W':
3201 dump_dwarf_section_info = TRUE;
3202 seenflag = TRUE;
3203 do_debug_info = 1;
3204 do_debug_abbrevs = 1;
3205 do_debug_lines = 1;
3206 do_debug_pubnames = 1;
3207 do_debug_aranges = 1;
3208 do_debug_ranges = 1;
3209 do_debug_frames = 1;
3210 do_debug_macinfo = 1;
3211 do_debug_str = 1;
3212 do_debug_loc = 1;
3213 break;
3214 case 'G':
3215 dump_stab_section_info = TRUE;
3216 seenflag = TRUE;
3217 break;
3218 case 's':
3219 dump_section_contents = TRUE;
3220 seenflag = TRUE;
3221 break;
3222 case 'r':
3223 dump_reloc_info = TRUE;
3224 seenflag = TRUE;
3225 break;
3226 case 'R':
3227 dump_dynamic_reloc_info = TRUE;
3228 seenflag = TRUE;
3229 break;
3230 case 'a':
3231 dump_ar_hdrs = TRUE;
3232 seenflag = TRUE;
3233 break;
3234 case 'h':
3235 dump_section_headers = TRUE;
3236 seenflag = TRUE;
3237 break;
3238 case 'H':
3239 usage (stdout, 0);
3240 seenflag = TRUE;
3241 case 'v':
3242 case 'V':
3243 show_version = TRUE;
3244 seenflag = TRUE;
3245 break;
3247 default:
3248 usage (stderr, 1);
3252 if (show_version)
3253 print_version ("objdump");
3255 if (!seenflag)
3256 usage (stderr, 2);
3258 if (formats_info)
3259 exit_status = display_info ();
3260 else
3262 if (optind == argc)
3263 display_file ("a.out", target);
3264 else
3265 for (; optind < argc;)
3266 display_file (argv[optind++], target);
3269 END_PROGRESS (program_name);
3271 return exit_status;