Set CPU type in BFD backend for x86_64-nacl* and i?86-nacl* targets
[external/binutils.git] / binutils / objdump.c
1 /* objdump.c -- dump information about an object file.
2    Copyright 1990-2013 Free Software Foundation, Inc.
3
4    This file is part of GNU Binutils.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3, or (at your option)
9    any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, 51 Franklin Street - Fifth Floor, Boston,
19    MA 02110-1301, USA.  */
20
21
22 /* Objdump overview.
23
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.
28
29    The flow of execution is as follows:
30  
31    1. Command line arguments are checked for control switches and the
32       information to be displayed is selected.
33       
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.
37       
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.
41
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.
45
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.  */
50
51 #include "sysdep.h"
52 #include "bfd.h"
53 #include "elf-bfd.h"
54 #include "progress.h"
55 #include "bucomm.h"
56 #include "elfcomm.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 "filenames.h"
64 #include "debug.h"
65 #include "budbg.h"
66 #include "objdump.h"
67
68 #ifdef HAVE_MMAP
69 #include <sys/mman.h>
70 #endif
71
72 /* Internal headers for the ELF .stab-dump code - sorry.  */
73 #define BYTES_IN_WORD   32
74 #include "aout/aout64.h"
75
76 /* Exit status.  */
77 static int exit_status = 0;
78
79 static char *default_target = NULL;     /* Default at runtime.  */
80
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 char *dump_private_options;      /* -P */
94 static int prefix_addresses;            /* --prefix-addresses */
95 static int with_line_numbers;           /* -l */
96 static bfd_boolean with_source_code;    /* -S */
97 static int show_raw_insn;               /* --show-raw-insn */
98 static int dump_dwarf_section_info;     /* --dwarf */
99 static int dump_stab_section_info;      /* --stabs */
100 static int do_demangle;                 /* -C, --demangle */
101 static bfd_boolean disassemble;         /* -d */
102 static bfd_boolean disassemble_all;     /* -D */
103 static int disassemble_zeroes;          /* --disassemble-zeroes */
104 static bfd_boolean formats_info;        /* -i */
105 static int wide_output;                 /* -w */
106 static int insn_width;                  /* --insn-width */
107 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
108 static bfd_vma stop_address = (bfd_vma) -1;  /* --stop-address */
109 static int dump_debugging;              /* --debugging */
110 static int dump_debugging_tags;         /* --debugging-tags */
111 static int suppress_bfd_header;
112 static int dump_special_syms = 0;       /* --special-syms */
113 static bfd_vma adjust_section_vma = 0;  /* --adjust-vma */
114 static int file_start_context = 0;      /* --file-start-context */
115 static bfd_boolean display_file_offsets;/* -F */
116 static const char *prefix;              /* --prefix */
117 static int prefix_strip;                /* --prefix-strip */
118 static size_t prefix_length;
119
120 /* A structure to record the sections mentioned in -j switches.  */
121 struct only
122 {
123   const char * name; /* The name of the section.  */
124   bfd_boolean  seen; /* A flag to indicate that the section has been found in one or more input files.  */
125   struct only * next; /* Pointer to the next structure in the list.  */
126 };
127 /* Pointer to an array of 'only' structures.
128    This pointer is NULL if the -j switch has not been used.  */
129 static struct only * only_list = NULL;
130
131 /* Variables for handling include file path table.  */
132 static const char **include_paths;
133 static int include_path_count;
134
135 /* Extra info to pass to the section disassembler and address printing
136    function.  */
137 struct objdump_disasm_info
138 {
139   bfd *              abfd;
140   asection *         sec;
141   bfd_boolean        require_sec;
142   arelent **         dynrelbuf;
143   long               dynrelcount;
144   disassembler_ftype disassemble_fn;
145   arelent *          reloc;
146 };
147
148 /* Architecture to disassemble for, or default if NULL.  */
149 static char *machine = NULL;
150
151 /* Target specific options to the disassembler.  */
152 static char *disassembler_options = NULL;
153
154 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN.  */
155 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
156
157 /* The symbol table.  */
158 static asymbol **syms;
159
160 /* Number of symbols in `syms'.  */
161 static long symcount = 0;
162
163 /* The sorted symbol table.  */
164 static asymbol **sorted_syms;
165
166 /* Number of symbols in `sorted_syms'.  */
167 static long sorted_symcount = 0;
168
169 /* The dynamic symbol table.  */
170 static asymbol **dynsyms;
171
172 /* The synthetic symbol table.  */
173 static asymbol *synthsyms;
174 static long synthcount = 0;
175
176 /* Number of symbols in `dynsyms'.  */
177 static long dynsymcount = 0;
178
179 static bfd_byte *stabs;
180 static bfd_size_type stab_size;
181
182 static char *strtab;
183 static bfd_size_type stabstr_size;
184
185 static bfd_boolean is_relocatable = FALSE;
186
187 /* Handlers for -P/--private.  */
188 static const struct objdump_private_desc * const objdump_private_vectors[] =
189   {
190     OBJDUMP_PRIVATE_VECTORS
191     NULL
192   };
193 \f
194 static void usage (FILE *, int) ATTRIBUTE_NORETURN;
195 static void
196 usage (FILE *stream, int status)
197 {
198   fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
199   fprintf (stream, _(" Display information from object <file(s)>.\n"));
200   fprintf (stream, _(" At least one of the following switches must be given:\n"));
201   fprintf (stream, _("\
202   -a, --archive-headers    Display archive header information\n\
203   -f, --file-headers       Display the contents of the overall file header\n\
204   -p, --private-headers    Display object format specific file header contents\n\
205   -P, --private=OPT,OPT... Display object format specific contents\n\
206   -h, --[section-]headers  Display the contents of the section headers\n\
207   -x, --all-headers        Display the contents of all headers\n\
208   -d, --disassemble        Display assembler contents of executable sections\n\
209   -D, --disassemble-all    Display assembler contents of all sections\n\
210   -S, --source             Intermix source code with disassembly\n\
211   -s, --full-contents      Display the full contents of all sections requested\n\
212   -g, --debugging          Display debug information in object file\n\
213   -e, --debugging-tags     Display debug information using ctags style\n\
214   -G, --stabs              Display (in raw form) any STABS info in the file\n\
215   -W[lLiaprmfFsoRt] or\n\
216   --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
217           =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
218           =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
219           =addr,=cu_index]\n\
220                            Display DWARF info in the file\n\
221   -t, --syms               Display the contents of the symbol table(s)\n\
222   -T, --dynamic-syms       Display the contents of the dynamic symbol table\n\
223   -r, --reloc              Display the relocation entries in the file\n\
224   -R, --dynamic-reloc      Display the dynamic relocation entries in the file\n\
225   @<file>                  Read options from <file>\n\
226   -v, --version            Display this program's version number\n\
227   -i, --info               List object formats and architectures supported\n\
228   -H, --help               Display this information\n\
229 "));
230   if (status != 2)
231     {
232       const struct objdump_private_desc * const *desc;
233
234       fprintf (stream, _("\n The following switches are optional:\n"));
235       fprintf (stream, _("\
236   -b, --target=BFDNAME           Specify the target object format as BFDNAME\n\
237   -m, --architecture=MACHINE     Specify the target architecture as MACHINE\n\
238   -j, --section=NAME             Only display information for section NAME\n\
239   -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
240   -EB --endian=big               Assume big endian format when disassembling\n\
241   -EL --endian=little            Assume little endian format when disassembling\n\
242       --file-start-context       Include context from start of file (with -S)\n\
243   -I, --include=DIR              Add DIR to search list for source files\n\
244   -l, --line-numbers             Include line numbers and filenames in output\n\
245   -F, --file-offsets             Include file offsets when displaying information\n\
246   -C, --demangle[=STYLE]         Decode mangled/processed symbol names\n\
247                                   The STYLE, if specified, can be `auto', `gnu',\n\
248                                   `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
249                                   or `gnat'\n\
250   -w, --wide                     Format output for more than 80 columns\n\
251   -z, --disassemble-zeroes       Do not skip blocks of zeroes when disassembling\n\
252       --start-address=ADDR       Only process data whose address is >= ADDR\n\
253       --stop-address=ADDR        Only process data whose address is <= ADDR\n\
254       --prefix-addresses         Print complete address alongside disassembly\n\
255       --[no-]show-raw-insn       Display hex alongside symbolic disassembly\n\
256       --insn-width=WIDTH         Display WIDTH bytes on a single line for -d\n\
257       --adjust-vma=OFFSET        Add OFFSET to all displayed section addresses\n\
258       --special-syms             Include special symbols in symbol dumps\n\
259       --prefix=PREFIX            Add PREFIX to absolute paths for -S\n\
260       --prefix-strip=LEVEL       Strip initial directory names for -S\n"));
261       fprintf (stream, _("\
262       --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
263       --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
264                              or deeper\n\
265       --dwarf-check          Make additional dwarf internal consistency checks.\
266       \n\n"));
267       list_supported_targets (program_name, stream);
268       list_supported_architectures (program_name, stream);
269
270       disassembler_usage (stream);
271
272       if (objdump_private_vectors[0] != NULL)
273         {
274           fprintf (stream,
275                    _("\nOptions supported for -P/--private switch:\n"));
276           for (desc = objdump_private_vectors; *desc != NULL; desc++)
277             (*desc)->help (stream);
278         }
279     }
280   if (REPORT_BUGS_TO[0] && status == 0)
281     fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
282   exit (status);
283 }
284
285 /* 150 isn't special; it's just an arbitrary non-ASCII char value.  */
286 enum option_values
287   {
288     OPTION_ENDIAN=150,
289     OPTION_START_ADDRESS,
290     OPTION_STOP_ADDRESS,
291     OPTION_DWARF,
292     OPTION_PREFIX,
293     OPTION_PREFIX_STRIP,
294     OPTION_INSN_WIDTH,
295     OPTION_ADJUST_VMA,
296     OPTION_DWARF_DEPTH,
297     OPTION_DWARF_CHECK,
298     OPTION_DWARF_START
299   };
300
301 static struct option long_options[]=
302 {
303   {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
304   {"all-headers", no_argument, NULL, 'x'},
305   {"private-headers", no_argument, NULL, 'p'},
306   {"private", required_argument, NULL, 'P'},
307   {"architecture", required_argument, NULL, 'm'},
308   {"archive-headers", no_argument, NULL, 'a'},
309   {"debugging", no_argument, NULL, 'g'},
310   {"debugging-tags", no_argument, NULL, 'e'},
311   {"demangle", optional_argument, NULL, 'C'},
312   {"disassemble", no_argument, NULL, 'd'},
313   {"disassemble-all", no_argument, NULL, 'D'},
314   {"disassembler-options", required_argument, NULL, 'M'},
315   {"disassemble-zeroes", no_argument, NULL, 'z'},
316   {"dynamic-reloc", no_argument, NULL, 'R'},
317   {"dynamic-syms", no_argument, NULL, 'T'},
318   {"endian", required_argument, NULL, OPTION_ENDIAN},
319   {"file-headers", no_argument, NULL, 'f'},
320   {"file-offsets", no_argument, NULL, 'F'},
321   {"file-start-context", no_argument, &file_start_context, 1},
322   {"full-contents", no_argument, NULL, 's'},
323   {"headers", no_argument, NULL, 'h'},
324   {"help", no_argument, NULL, 'H'},
325   {"info", no_argument, NULL, 'i'},
326   {"line-numbers", no_argument, NULL, 'l'},
327   {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
328   {"prefix-addresses", no_argument, &prefix_addresses, 1},
329   {"reloc", no_argument, NULL, 'r'},
330   {"section", required_argument, NULL, 'j'},
331   {"section-headers", no_argument, NULL, 'h'},
332   {"show-raw-insn", no_argument, &show_raw_insn, 1},
333   {"source", no_argument, NULL, 'S'},
334   {"special-syms", no_argument, &dump_special_syms, 1},
335   {"include", required_argument, NULL, 'I'},
336   {"dwarf", optional_argument, NULL, OPTION_DWARF},
337   {"stabs", no_argument, NULL, 'G'},
338   {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
339   {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
340   {"syms", no_argument, NULL, 't'},
341   {"target", required_argument, NULL, 'b'},
342   {"version", no_argument, NULL, 'V'},
343   {"wide", no_argument, NULL, 'w'},
344   {"prefix", required_argument, NULL, OPTION_PREFIX},
345   {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
346   {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
347   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
348   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
349   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
350   {0, no_argument, 0, 0}
351 };
352 \f
353 static void
354 nonfatal (const char *msg)
355 {
356   bfd_nonfatal (msg);
357   exit_status = 1;
358 }
359 \f
360 /* Returns TRUE if the specified section should be dumped.  */
361
362 static bfd_boolean
363 process_section_p (asection * section)
364 {
365   struct only * only;
366
367   if (only_list == NULL)
368     return TRUE;
369
370   for (only = only_list; only; only = only->next)
371     if (strcmp (only->name, section->name) == 0)
372       {
373         only->seen = TRUE;
374         return TRUE;
375       }
376
377   return FALSE;
378 }
379
380 /* Add an entry to the 'only' list.  */
381
382 static void
383 add_only (char * name)
384 {
385   struct only * only;
386
387   /* First check to make sure that we do not
388      already have an entry for this name.  */
389   for (only = only_list; only; only = only->next)
390     if (strcmp (only->name, name) == 0)
391       return;
392
393   only = xmalloc (sizeof * only);
394   only->name = name;
395   only->seen = FALSE;
396   only->next = only_list;
397   only_list = only;
398 }
399
400 /* Release the memory used by the 'only' list.
401    PR 11225: Issue a warning message for unseen sections.
402    Only do this if none of the sections were seen.  This is mainly to support
403    tools like the GAS testsuite where an object file is dumped with a list of
404    generic section names known to be present in a range of different file
405    formats.  */
406
407 static void
408 free_only_list (void)
409 {
410   bfd_boolean at_least_one_seen = FALSE;
411   struct only * only;
412   struct only * next;
413
414   if (only_list == NULL)
415     return;
416
417   for (only = only_list; only; only = only->next)
418     if (only->seen)
419       {
420         at_least_one_seen = TRUE;
421         break;
422       }
423
424   for (only = only_list; only; only = next)
425     {
426       if (! at_least_one_seen)
427         {
428           non_fatal (_("section '%s' mentioned in a -j option, "
429                        "but not found in any input file"),
430                      only->name);
431           exit_status = 1;
432         }
433       next = only->next;
434       free (only);
435     }
436 }
437
438 \f
439 static void
440 dump_section_header (bfd *abfd, asection *section,
441                      void *ignored ATTRIBUTE_UNUSED)
442 {
443   char *comma = "";
444   unsigned int opb = bfd_octets_per_byte (abfd);
445
446   /* Ignore linker created section.  See elfNN_ia64_object_p in
447      bfd/elfxx-ia64.c.  */
448   if (section->flags & SEC_LINKER_CREATED)
449     return;
450
451   /* PR 10413: Skip sections that we are ignoring.  */
452   if (! process_section_p (section))
453     return;
454
455   printf ("%3d %-13s %08lx  ", section->index,
456           bfd_get_section_name (abfd, section),
457           (unsigned long) bfd_section_size (abfd, section) / opb);
458   bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
459   printf ("  ");
460   bfd_printf_vma (abfd, section->lma);
461   printf ("  %08lx  2**%u", (unsigned long) section->filepos,
462           bfd_get_section_alignment (abfd, section));
463   if (! wide_output)
464     printf ("\n                ");
465   printf ("  ");
466
467 #define PF(x, y) \
468   if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
469
470   PF (SEC_HAS_CONTENTS, "CONTENTS");
471   PF (SEC_ALLOC, "ALLOC");
472   PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
473   PF (SEC_LOAD, "LOAD");
474   PF (SEC_RELOC, "RELOC");
475   PF (SEC_READONLY, "READONLY");
476   PF (SEC_CODE, "CODE");
477   PF (SEC_DATA, "DATA");
478   PF (SEC_ROM, "ROM");
479   PF (SEC_DEBUGGING, "DEBUGGING");
480   PF (SEC_NEVER_LOAD, "NEVER_LOAD");
481   PF (SEC_EXCLUDE, "EXCLUDE");
482   PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
483   if (bfd_get_arch (abfd) == bfd_arch_tic54x)
484     {
485       PF (SEC_TIC54X_BLOCK, "BLOCK");
486       PF (SEC_TIC54X_CLINK, "CLINK");
487     }
488   PF (SEC_SMALL_DATA, "SMALL_DATA");
489   if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
490     PF (SEC_COFF_SHARED, "SHARED");
491   PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
492   PF (SEC_GROUP, "GROUP");
493
494   if ((section->flags & SEC_LINK_ONCE) != 0)
495     {
496       const char *ls;
497       struct coff_comdat_info *comdat;
498
499       switch (section->flags & SEC_LINK_DUPLICATES)
500         {
501         default:
502           abort ();
503         case SEC_LINK_DUPLICATES_DISCARD:
504           ls = "LINK_ONCE_DISCARD";
505           break;
506         case SEC_LINK_DUPLICATES_ONE_ONLY:
507           ls = "LINK_ONCE_ONE_ONLY";
508           break;
509         case SEC_LINK_DUPLICATES_SAME_SIZE:
510           ls = "LINK_ONCE_SAME_SIZE";
511           break;
512         case SEC_LINK_DUPLICATES_SAME_CONTENTS:
513           ls = "LINK_ONCE_SAME_CONTENTS";
514           break;
515         }
516       printf ("%s%s", comma, ls);
517
518       comdat = bfd_coff_get_comdat_section (abfd, section);
519       if (comdat != NULL)
520         printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
521
522       comma = ", ";
523     }
524
525   printf ("\n");
526 #undef PF
527 }
528
529 static void
530 dump_headers (bfd *abfd)
531 {
532   printf (_("Sections:\n"));
533
534 #ifndef BFD64
535   printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));
536 #else
537   /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses.  */
538   if (bfd_get_arch_size (abfd) == 32)
539     printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));
540   else
541     printf (_("Idx Name          Size      VMA               LMA               File off  Algn"));
542 #endif
543
544   if (wide_output)
545     printf (_("  Flags"));
546   printf ("\n");
547
548   bfd_map_over_sections (abfd, dump_section_header, NULL);
549 }
550 \f
551 static asymbol **
552 slurp_symtab (bfd *abfd)
553 {
554   asymbol **sy = NULL;
555   long storage;
556
557   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
558     {
559       symcount = 0;
560       return NULL;
561     }
562
563   storage = bfd_get_symtab_upper_bound (abfd);
564   if (storage < 0)
565     bfd_fatal (bfd_get_filename (abfd));
566   if (storage)
567     sy = (asymbol **) xmalloc (storage);
568
569   symcount = bfd_canonicalize_symtab (abfd, sy);
570   if (symcount < 0)
571     bfd_fatal (bfd_get_filename (abfd));
572   return sy;
573 }
574
575 /* Read in the dynamic symbols.  */
576
577 static asymbol **
578 slurp_dynamic_symtab (bfd *abfd)
579 {
580   asymbol **sy = NULL;
581   long storage;
582
583   storage = bfd_get_dynamic_symtab_upper_bound (abfd);
584   if (storage < 0)
585     {
586       if (!(bfd_get_file_flags (abfd) & DYNAMIC))
587         {
588           non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
589           exit_status = 1;
590           dynsymcount = 0;
591           return NULL;
592         }
593
594       bfd_fatal (bfd_get_filename (abfd));
595     }
596   if (storage)
597     sy = (asymbol **) xmalloc (storage);
598
599   dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
600   if (dynsymcount < 0)
601     bfd_fatal (bfd_get_filename (abfd));
602   return sy;
603 }
604
605 /* Filter out (in place) symbols that are useless for disassembly.
606    COUNT is the number of elements in SYMBOLS.
607    Return the number of useful symbols.  */
608
609 static long
610 remove_useless_symbols (asymbol **symbols, long count)
611 {
612   asymbol **in_ptr = symbols, **out_ptr = symbols;
613
614   while (--count >= 0)
615     {
616       asymbol *sym = *in_ptr++;
617
618       if (sym->name == NULL || sym->name[0] == '\0')
619         continue;
620       if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
621         continue;
622       if (bfd_is_und_section (sym->section)
623           || bfd_is_com_section (sym->section))
624         continue;
625
626       *out_ptr++ = sym;
627     }
628   return out_ptr - symbols;
629 }
630
631 /* Sort symbols into value order.  */
632
633 static int
634 compare_symbols (const void *ap, const void *bp)
635 {
636   const asymbol *a = * (const asymbol **) ap;
637   const asymbol *b = * (const asymbol **) bp;
638   const char *an;
639   const char *bn;
640   size_t anl;
641   size_t bnl;
642   bfd_boolean af;
643   bfd_boolean bf;
644   flagword aflags;
645   flagword bflags;
646
647   if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
648     return 1;
649   else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
650     return -1;
651
652   if (a->section > b->section)
653     return 1;
654   else if (a->section < b->section)
655     return -1;
656
657   an = bfd_asymbol_name (a);
658   bn = bfd_asymbol_name (b);
659   anl = strlen (an);
660   bnl = strlen (bn);
661
662   /* The symbols gnu_compiled and gcc2_compiled convey no real
663      information, so put them after other symbols with the same value.  */
664   af = (strstr (an, "gnu_compiled") != NULL
665         || strstr (an, "gcc2_compiled") != NULL);
666   bf = (strstr (bn, "gnu_compiled") != NULL
667         || strstr (bn, "gcc2_compiled") != NULL);
668
669   if (af && ! bf)
670     return 1;
671   if (! af && bf)
672     return -1;
673
674   /* We use a heuristic for the file name, to try to sort it after
675      more useful symbols.  It may not work on non Unix systems, but it
676      doesn't really matter; the only difference is precisely which
677      symbol names get printed.  */
678
679 #define file_symbol(s, sn, snl)                 \
680   (((s)->flags & BSF_FILE) != 0                 \
681    || ((sn)[(snl) - 2] == '.'                   \
682        && ((sn)[(snl) - 1] == 'o'               \
683            || (sn)[(snl) - 1] == 'a')))
684
685   af = file_symbol (a, an, anl);
686   bf = file_symbol (b, bn, bnl);
687
688   if (af && ! bf)
689     return 1;
690   if (! af && bf)
691     return -1;
692
693   /* Try to sort global symbols before local symbols before function
694      symbols before debugging symbols.  */
695
696   aflags = a->flags;
697   bflags = b->flags;
698
699   if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
700     {
701       if ((aflags & BSF_DEBUGGING) != 0)
702         return 1;
703       else
704         return -1;
705     }
706   if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
707     {
708       if ((aflags & BSF_FUNCTION) != 0)
709         return -1;
710       else
711         return 1;
712     }
713   if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
714     {
715       if ((aflags & BSF_LOCAL) != 0)
716         return 1;
717       else
718         return -1;
719     }
720   if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
721     {
722       if ((aflags & BSF_GLOBAL) != 0)
723         return -1;
724       else
725         return 1;
726     }
727
728   /* Symbols that start with '.' might be section names, so sort them
729      after symbols that don't start with '.'.  */
730   if (an[0] == '.' && bn[0] != '.')
731     return 1;
732   if (an[0] != '.' && bn[0] == '.')
733     return -1;
734
735   /* Finally, if we can't distinguish them in any other way, try to
736      get consistent results by sorting the symbols by name.  */
737   return strcmp (an, bn);
738 }
739
740 /* Sort relocs into address order.  */
741
742 static int
743 compare_relocs (const void *ap, const void *bp)
744 {
745   const arelent *a = * (const arelent **) ap;
746   const arelent *b = * (const arelent **) bp;
747
748   if (a->address > b->address)
749     return 1;
750   else if (a->address < b->address)
751     return -1;
752
753   /* So that associated relocations tied to the same address show up
754      in the correct order, we don't do any further sorting.  */
755   if (a > b)
756     return 1;
757   else if (a < b)
758     return -1;
759   else
760     return 0;
761 }
762
763 /* Print an address (VMA) to the output stream in INFO.
764    If SKIP_ZEROES is TRUE, omit leading zeroes.  */
765
766 static void
767 objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
768                      bfd_boolean skip_zeroes)
769 {
770   char buf[30];
771   char *p;
772   struct objdump_disasm_info *aux;
773
774   aux = (struct objdump_disasm_info *) inf->application_data;
775   bfd_sprintf_vma (aux->abfd, buf, vma);
776   if (! skip_zeroes)
777     p = buf;
778   else
779     {
780       for (p = buf; *p == '0'; ++p)
781         ;
782       if (*p == '\0')
783         --p;
784     }
785   (*inf->fprintf_func) (inf->stream, "%s", p);
786 }
787
788 /* Print the name of a symbol.  */
789
790 static void
791 objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
792                        asymbol *sym)
793 {
794   char *alloc;
795   const char *name;
796
797   alloc = NULL;
798   name = bfd_asymbol_name (sym);
799   if (do_demangle && name[0] != '\0')
800     {
801       /* Demangle the name.  */
802       alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
803       if (alloc != NULL)
804         name = alloc;
805     }
806
807   if (inf != NULL)
808     (*inf->fprintf_func) (inf->stream, "%s", name);
809   else
810     printf ("%s", name);
811
812   if (alloc != NULL)
813     free (alloc);
814 }
815
816 /* Locate a symbol given a bfd and a section (from INFO->application_data),
817    and a VMA.  If INFO->application_data->require_sec is TRUE, then always
818    require the symbol to be in the section.  Returns NULL if there is no
819    suitable symbol.  If PLACE is not NULL, then *PLACE is set to the index
820    of the symbol in sorted_syms.  */
821
822 static asymbol *
823 find_symbol_for_address (bfd_vma vma,
824                          struct disassemble_info *inf,
825                          long *place)
826 {
827   /* @@ Would it speed things up to cache the last two symbols returned,
828      and maybe their address ranges?  For many processors, only one memory
829      operand can be present at a time, so the 2-entry cache wouldn't be
830      constantly churned by code doing heavy memory accesses.  */
831
832   /* Indices in `sorted_syms'.  */
833   long min = 0;
834   long max_count = sorted_symcount;
835   long thisplace;
836   struct objdump_disasm_info *aux;
837   bfd *abfd;
838   asection *sec;
839   unsigned int opb;
840   bfd_boolean want_section;
841
842   if (sorted_symcount < 1)
843     return NULL;
844
845   aux = (struct objdump_disasm_info *) inf->application_data;
846   abfd = aux->abfd;
847   sec = aux->sec;
848   opb = inf->octets_per_byte;
849
850   /* Perform a binary search looking for the closest symbol to the
851      required value.  We are searching the range (min, max_count].  */
852   while (min + 1 < max_count)
853     {
854       asymbol *sym;
855
856       thisplace = (max_count + min) / 2;
857       sym = sorted_syms[thisplace];
858
859       if (bfd_asymbol_value (sym) > vma)
860         max_count = thisplace;
861       else if (bfd_asymbol_value (sym) < vma)
862         min = thisplace;
863       else
864         {
865           min = thisplace;
866           break;
867         }
868     }
869
870   /* The symbol we want is now in min, the low end of the range we
871      were searching.  If there are several symbols with the same
872      value, we want the first one.  */
873   thisplace = min;
874   while (thisplace > 0
875          && (bfd_asymbol_value (sorted_syms[thisplace])
876              == bfd_asymbol_value (sorted_syms[thisplace - 1])))
877     --thisplace;
878
879   /* Prefer a symbol in the current section if we have multple symbols
880      with the same value, as can occur with overlays or zero size
881      sections.  */
882   min = thisplace;
883   while (min < max_count
884          && (bfd_asymbol_value (sorted_syms[min])
885              == bfd_asymbol_value (sorted_syms[thisplace])))
886     {
887       if (sorted_syms[min]->section == sec
888           && inf->symbol_is_valid (sorted_syms[min], inf))
889         {
890           thisplace = min;
891
892           if (place != NULL)
893             *place = thisplace;
894
895           return sorted_syms[thisplace];
896         }
897       ++min;
898     }
899
900   /* If the file is relocatable, and the symbol could be from this
901      section, prefer a symbol from this section over symbols from
902      others, even if the other symbol's value might be closer.
903
904      Note that this may be wrong for some symbol references if the
905      sections have overlapping memory ranges, but in that case there's
906      no way to tell what's desired without looking at the relocation
907      table.
908      
909      Also give the target a chance to reject symbols.  */
910   want_section = (aux->require_sec
911                   || ((abfd->flags & HAS_RELOC) != 0
912                       && vma >= bfd_get_section_vma (abfd, sec)
913                       && vma < (bfd_get_section_vma (abfd, sec)
914                                 + bfd_section_size (abfd, sec) / opb)));
915   if ((sorted_syms[thisplace]->section != sec && want_section)
916       || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
917     {
918       long i;
919       long newplace = sorted_symcount;
920
921       for (i = min - 1; i >= 0; i--)
922         {
923           if ((sorted_syms[i]->section == sec || !want_section)
924               && inf->symbol_is_valid (sorted_syms[i], inf))
925             {
926               if (newplace == sorted_symcount)
927                 newplace = i;
928
929               if (bfd_asymbol_value (sorted_syms[i])
930                   != bfd_asymbol_value (sorted_syms[newplace]))
931                 break;
932
933               /* Remember this symbol and keep searching until we reach
934                  an earlier address.  */
935               newplace = i;
936             }
937         }
938
939       if (newplace != sorted_symcount)
940         thisplace = newplace;
941       else
942         {
943           /* We didn't find a good symbol with a smaller value.
944              Look for one with a larger value.  */
945           for (i = thisplace + 1; i < sorted_symcount; i++)
946             {
947               if ((sorted_syms[i]->section == sec || !want_section)
948                   && inf->symbol_is_valid (sorted_syms[i], inf))
949                 {
950                   thisplace = i;
951                   break;
952                 }
953             }
954         }
955
956       if ((sorted_syms[thisplace]->section != sec && want_section)
957           || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
958         /* There is no suitable symbol.  */
959         return NULL;
960     }
961
962   if (place != NULL)
963     *place = thisplace;
964
965   return sorted_syms[thisplace];
966 }
967
968 /* Print an address and the offset to the nearest symbol.  */
969
970 static void
971 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
972                              bfd_vma vma, struct disassemble_info *inf,
973                              bfd_boolean skip_zeroes)
974 {
975   objdump_print_value (vma, inf, skip_zeroes);
976
977   if (sym == NULL)
978     {
979       bfd_vma secaddr;
980
981       (*inf->fprintf_func) (inf->stream, " <%s",
982                             bfd_get_section_name (abfd, sec));
983       secaddr = bfd_get_section_vma (abfd, sec);
984       if (vma < secaddr)
985         {
986           (*inf->fprintf_func) (inf->stream, "-0x");
987           objdump_print_value (secaddr - vma, inf, TRUE);
988         }
989       else if (vma > secaddr)
990         {
991           (*inf->fprintf_func) (inf->stream, "+0x");
992           objdump_print_value (vma - secaddr, inf, TRUE);
993         }
994       (*inf->fprintf_func) (inf->stream, ">");
995     }
996   else
997     {
998       (*inf->fprintf_func) (inf->stream, " <");
999       objdump_print_symname (abfd, inf, sym);
1000       if (bfd_asymbol_value (sym) > vma)
1001         {
1002           (*inf->fprintf_func) (inf->stream, "-0x");
1003           objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
1004         }
1005       else if (vma > bfd_asymbol_value (sym))
1006         {
1007           (*inf->fprintf_func) (inf->stream, "+0x");
1008           objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
1009         }
1010       (*inf->fprintf_func) (inf->stream, ">");
1011     }
1012
1013   if (display_file_offsets)
1014     inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1015                         (long int)(sec->filepos + (vma - sec->vma)));
1016 }
1017
1018 /* Print an address (VMA), symbolically if possible.
1019    If SKIP_ZEROES is TRUE, don't output leading zeroes.  */
1020
1021 static void
1022 objdump_print_addr (bfd_vma vma,
1023                     struct disassemble_info *inf,
1024                     bfd_boolean skip_zeroes)
1025 {
1026   struct objdump_disasm_info *aux;
1027   asymbol *sym = NULL;
1028   bfd_boolean skip_find = FALSE;
1029
1030   aux = (struct objdump_disasm_info *) inf->application_data;
1031
1032   if (sorted_symcount < 1)
1033     {
1034       (*inf->fprintf_func) (inf->stream, "0x");
1035       objdump_print_value (vma, inf, skip_zeroes);
1036
1037       if (display_file_offsets)
1038         inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1039                            (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
1040       return;
1041     }
1042
1043   if (aux->reloc != NULL
1044       && aux->reloc->sym_ptr_ptr != NULL
1045       && * aux->reloc->sym_ptr_ptr != NULL)
1046     {
1047       sym = * aux->reloc->sym_ptr_ptr;
1048
1049       /* Adjust the vma to the reloc.  */
1050       vma += bfd_asymbol_value (sym);
1051
1052       if (bfd_is_und_section (bfd_get_section (sym)))
1053         skip_find = TRUE;
1054     }
1055
1056   if (!skip_find)
1057     sym = find_symbol_for_address (vma, inf, NULL);
1058
1059   objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf,
1060                                skip_zeroes);
1061 }
1062
1063 /* Print VMA to INFO.  This function is passed to the disassembler
1064    routine.  */
1065
1066 static void
1067 objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
1068 {
1069   objdump_print_addr (vma, inf, ! prefix_addresses);
1070 }
1071
1072 /* Determine if the given address has a symbol associated with it.  */
1073
1074 static int
1075 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
1076 {
1077   asymbol * sym;
1078
1079   sym = find_symbol_for_address (vma, inf, NULL);
1080
1081   return (sym != NULL && (bfd_asymbol_value (sym) == vma));
1082 }
1083
1084 /* Hold the last function name and the last line number we displayed
1085    in a disassembly.  */
1086
1087 static char *prev_functionname;
1088 static unsigned int prev_line;
1089 static unsigned int prev_discriminator;
1090
1091 /* We keep a list of all files that we have seen when doing a
1092    disassembly with source, so that we know how much of the file to
1093    display.  This can be important for inlined functions.  */
1094
1095 struct print_file_list
1096 {
1097   struct print_file_list *next;
1098   const char *filename;
1099   const char *modname;
1100   const char *map; 
1101   size_t mapsize;
1102   const char **linemap; 
1103   unsigned maxline;
1104   unsigned last_line;
1105   int first;
1106 };
1107
1108 static struct print_file_list *print_files;
1109
1110 /* The number of preceding context lines to show when we start
1111    displaying a file for the first time.  */
1112
1113 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1114
1115 /* Read a complete file into memory.  */
1116
1117 static const char *
1118 slurp_file (const char *fn, size_t *size)
1119 {
1120 #ifdef HAVE_MMAP
1121   int ps = getpagesize ();
1122   size_t msize;
1123 #endif
1124   const char *map;
1125   struct stat st;
1126   int fd = open (fn, O_RDONLY | O_BINARY);
1127
1128   if (fd < 0)
1129     return NULL;
1130   if (fstat (fd, &st) < 0)
1131     {
1132       close (fd);
1133       return NULL;
1134     }
1135   *size = st.st_size;
1136 #ifdef HAVE_MMAP
1137   msize = (*size + ps - 1) & ~(ps - 1);
1138   map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
1139   if (map != (char *) -1L)
1140     {
1141       close (fd);
1142       return map;
1143     }
1144 #endif
1145   map = (const char *) malloc (*size);
1146   if (!map || (size_t) read (fd, (char *) map, *size) != *size)
1147     {
1148       free ((void *) map);
1149       map = NULL;
1150     }
1151   close (fd);
1152   return map;
1153 }
1154
1155 #define line_map_decrease 5
1156
1157 /* Precompute array of lines for a mapped file. */
1158
1159 static const char ** 
1160 index_file (const char *map, size_t size, unsigned int *maxline) 
1161 {
1162   const char *p, *lstart, *end;
1163   int chars_per_line = 45; /* First iteration will use 40.  */
1164   unsigned int lineno;
1165   const char **linemap = NULL; 
1166   unsigned long line_map_size = 0;
1167  
1168   lineno = 0;
1169   lstart = map;
1170   end = map + size;
1171
1172   for (p = map; p < end; p++) 
1173     { 
1174       if (*p == '\n') 
1175         { 
1176           if (p + 1 < end && p[1] == '\r') 
1177             p++;  
1178         } 
1179       else if (*p == '\r') 
1180         { 
1181           if (p + 1 < end && p[1] == '\n')
1182             p++;
1183         }
1184       else
1185         continue;
1186       
1187       /* End of line found.  */
1188
1189       if (linemap == NULL || line_map_size < lineno + 1) 
1190         { 
1191           unsigned long newsize;
1192
1193           chars_per_line -= line_map_decrease;
1194           if (chars_per_line <= 1)
1195             chars_per_line = 1;
1196           line_map_size = size / chars_per_line + 1;
1197           if (line_map_size < lineno + 1)
1198             line_map_size = lineno + 1;
1199           newsize = line_map_size * sizeof (char *);
1200           linemap = (const char **) xrealloc (linemap, newsize);
1201         }
1202
1203       linemap[lineno++] = lstart; 
1204       lstart = p + 1; 
1205     }
1206   
1207   *maxline = lineno; 
1208   return linemap;
1209 }
1210
1211 /* Tries to open MODNAME, and if successful adds a node to print_files
1212    linked list and returns that node.  Returns NULL on failure.  */
1213
1214 static struct print_file_list *
1215 try_print_file_open (const char *origname, const char *modname)
1216 {
1217   struct print_file_list *p;
1218
1219   p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
1220
1221   p->map = slurp_file (modname, &p->mapsize);
1222   if (p->map == NULL)
1223     {
1224       free (p);
1225       return NULL;
1226     }
1227   
1228   p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1229   p->last_line = 0;
1230   p->filename = origname;
1231   p->modname = modname;
1232   p->next = print_files;
1233   p->first = 1;
1234   print_files = p;
1235   return p;
1236 }
1237
1238 /* If the source file, as described in the symtab, is not found
1239    try to locate it in one of the paths specified with -I
1240    If found, add location to print_files linked list.  */
1241
1242 static struct print_file_list *
1243 update_source_path (const char *filename)
1244 {
1245   struct print_file_list *p;
1246   const char *fname;
1247   int i;
1248
1249   p = try_print_file_open (filename, filename);
1250   if (p != NULL)
1251     return p;
1252
1253   if (include_path_count == 0)
1254     return NULL;
1255
1256   /* Get the name of the file.  */
1257   fname = lbasename (filename);
1258
1259   /* If file exists under a new path, we need to add it to the list
1260      so that show_line knows about it.  */
1261   for (i = 0; i < include_path_count; i++)
1262     {
1263       char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1264
1265       p = try_print_file_open (filename, modname);
1266       if (p)
1267         return p;
1268
1269       free (modname);
1270     }
1271
1272   return NULL;
1273 }
1274
1275 /* Print a source file line.  */
1276
1277 static void 
1278 print_line (struct print_file_list *p, unsigned int linenum)
1279 {
1280   const char *l;
1281   size_t len;
1282  
1283   --linenum; 
1284   if (linenum >= p->maxline)
1285     return;
1286   l = p->linemap [linenum];
1287   /* Test fwrite return value to quiet glibc warning.  */
1288   len = strcspn (l, "\n\r");
1289   if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1290     putchar ('\n');
1291 }
1292
1293 /* Print a range of source code lines. */
1294
1295 static void
1296 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1297 {
1298   if (p->map == NULL)
1299     return;
1300   while (start <= end) 
1301     {
1302       print_line (p, start);
1303       start++;
1304     }
1305 }
1306
1307 /* Show the line number, or the source line, in a disassembly
1308    listing.  */
1309
1310 static void
1311 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1312 {
1313   const char *filename;
1314   const char *functionname;
1315   unsigned int linenumber;
1316   unsigned int discriminator;
1317   bfd_boolean reloc;
1318
1319   if (! with_line_numbers && ! with_source_code)
1320     return;
1321
1322   if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset,
1323                                              &filename, &functionname,
1324                                              &linenumber, &discriminator))
1325     return;
1326
1327   if (filename != NULL && *filename == '\0')
1328     filename = NULL;
1329   if (functionname != NULL && *functionname == '\0')
1330     functionname = NULL;
1331
1332   if (filename
1333       && IS_ABSOLUTE_PATH (filename)
1334       && prefix)
1335     {
1336       char *path_up;
1337       const char *fname = filename;
1338       char *path = (char *) alloca (prefix_length + PATH_MAX + 1);
1339
1340       if (prefix_length)
1341         memcpy (path, prefix, prefix_length);
1342       path_up = path + prefix_length;
1343
1344       /* Build relocated filename, stripping off leading directories
1345          from the initial filename if requested. */
1346       if (prefix_strip > 0)
1347         {
1348           int level = 0;
1349           const char *s;
1350
1351           /* Skip selected directory levels. */
1352           for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1353             if (IS_DIR_SEPARATOR(*s))
1354               {
1355                 fname = s;
1356                 level++;
1357               }
1358         }
1359
1360       /* Update complete filename. */
1361       strncpy (path_up, fname, PATH_MAX);
1362       path_up[PATH_MAX] = '\0';
1363
1364       filename = path;
1365       reloc = TRUE;
1366     }
1367   else
1368     reloc = FALSE;
1369
1370   if (with_line_numbers)
1371     {
1372       if (functionname != NULL
1373           && (prev_functionname == NULL
1374               || strcmp (functionname, prev_functionname) != 0))
1375         printf ("%s():\n", functionname);
1376       if (linenumber > 0 && (linenumber != prev_line || 
1377                              (discriminator != prev_discriminator)))
1378         { 
1379           if (discriminator > 0)
1380             printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename,
1381                     linenumber, discriminator);
1382           else
1383             printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
1384         }
1385     }
1386
1387   if (with_source_code
1388       && filename != NULL
1389       && linenumber > 0)
1390     {
1391       struct print_file_list **pp, *p;
1392       unsigned l;
1393
1394       for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1395         if (filename_cmp ((*pp)->filename, filename) == 0)
1396           break;
1397       p = *pp;
1398
1399       if (p == NULL)
1400         {
1401           if (reloc)
1402             filename = xstrdup (filename);
1403           p = update_source_path (filename);
1404         }
1405
1406       if (p != NULL && linenumber != p->last_line)
1407         {
1408           if (file_start_context && p->first) 
1409             l = 1;
1410           else 
1411             {
1412               l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
1413               if (l >= linenumber) 
1414                 l = 1;
1415               if (p->last_line >= l && p->last_line <= linenumber)
1416                 l = p->last_line + 1;
1417             }
1418           dump_lines (p, l, linenumber);
1419           p->last_line = linenumber;
1420           p->first = 0;
1421         }
1422     }
1423
1424   if (functionname != NULL
1425       && (prev_functionname == NULL
1426           || strcmp (functionname, prev_functionname) != 0))
1427     {
1428       if (prev_functionname != NULL)
1429         free (prev_functionname);
1430       prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
1431       strcpy (prev_functionname, functionname);
1432     }
1433
1434   if (linenumber > 0 && linenumber != prev_line)
1435     prev_line = linenumber;
1436
1437   if (discriminator != prev_discriminator)
1438     prev_discriminator = discriminator;
1439 }
1440
1441 /* Pseudo FILE object for strings.  */
1442 typedef struct
1443 {
1444   char *buffer;
1445   size_t pos;
1446   size_t alloc;
1447 } SFILE;
1448
1449 /* sprintf to a "stream".  */
1450
1451 static int ATTRIBUTE_PRINTF_2
1452 objdump_sprintf (SFILE *f, const char *format, ...)
1453 {
1454   size_t n;
1455   va_list args;
1456
1457   while (1)
1458     {
1459       size_t space = f->alloc - f->pos;
1460   
1461       va_start (args, format);
1462       n = vsnprintf (f->buffer + f->pos, space, format, args);
1463       va_end (args);
1464
1465       if (space > n)
1466         break;
1467       
1468       f->alloc = (f->alloc + n) * 2;
1469       f->buffer = (char *) xrealloc (f->buffer, f->alloc);
1470     }
1471   f->pos += n;
1472   
1473   return n;
1474 }
1475
1476 /* The number of zeroes we want to see before we start skipping them.
1477    The number is arbitrarily chosen.  */
1478
1479 #define DEFAULT_SKIP_ZEROES 8
1480
1481 /* The number of zeroes to skip at the end of a section.  If the
1482    number of zeroes at the end is between SKIP_ZEROES_AT_END and
1483    SKIP_ZEROES, they will be disassembled.  If there are fewer than
1484    SKIP_ZEROES_AT_END, they will be skipped.  This is a heuristic
1485    attempt to avoid disassembling zeroes inserted by section
1486    alignment.  */
1487
1488 #define DEFAULT_SKIP_ZEROES_AT_END 3
1489
1490 /* Disassemble some data in memory between given values.  */
1491
1492 static void
1493 disassemble_bytes (struct disassemble_info * inf,
1494                    disassembler_ftype        disassemble_fn,
1495                    bfd_boolean               insns,
1496                    bfd_byte *                data,
1497                    bfd_vma                   start_offset,
1498                    bfd_vma                   stop_offset,
1499                    bfd_vma                   rel_offset,
1500                    arelent ***               relppp,
1501                    arelent **                relppend)
1502 {
1503   struct objdump_disasm_info *aux;
1504   asection *section;
1505   int octets_per_line;
1506   int skip_addr_chars;
1507   bfd_vma addr_offset;
1508   unsigned int opb = inf->octets_per_byte;
1509   unsigned int skip_zeroes = inf->skip_zeroes;
1510   unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
1511   int octets = opb;
1512   SFILE sfile;
1513
1514   aux = (struct objdump_disasm_info *) inf->application_data;
1515   section = aux->sec;
1516
1517   sfile.alloc = 120;
1518   sfile.buffer = (char *) xmalloc (sfile.alloc);
1519   sfile.pos = 0;
1520   
1521   if (insn_width)
1522     octets_per_line = insn_width;
1523   else if (insns)
1524     octets_per_line = 4;
1525   else
1526     octets_per_line = 16;
1527
1528   /* Figure out how many characters to skip at the start of an
1529      address, to make the disassembly look nicer.  We discard leading
1530      zeroes in chunks of 4, ensuring that there is always a leading
1531      zero remaining.  */
1532   skip_addr_chars = 0;
1533   if (! prefix_addresses)
1534     {
1535       char buf[30];
1536
1537       bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1538
1539       while (buf[skip_addr_chars] == '0')
1540         ++skip_addr_chars;
1541
1542       /* Don't discard zeros on overflow.  */
1543       if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1544         skip_addr_chars = 0;
1545
1546       if (skip_addr_chars != 0)
1547         skip_addr_chars = (skip_addr_chars - 1) & -4;
1548     }
1549
1550   inf->insn_info_valid = 0;
1551
1552   addr_offset = start_offset;
1553   while (addr_offset < stop_offset)
1554     {
1555       bfd_vma z;
1556       bfd_boolean need_nl = FALSE;
1557       int previous_octets;
1558
1559       /* Remember the length of the previous instruction.  */
1560       previous_octets = octets;
1561       octets = 0;
1562
1563       /* Make sure we don't use relocs from previous instructions.  */
1564       aux->reloc = NULL;
1565
1566       /* If we see more than SKIP_ZEROES octets of zeroes, we just
1567          print `...'.  */
1568       for (z = addr_offset * opb; z < stop_offset * opb; z++)
1569         if (data[z] != 0)
1570           break;
1571       if (! disassemble_zeroes
1572           && (inf->insn_info_valid == 0
1573               || inf->branch_delay_insns == 0)
1574           && (z - addr_offset * opb >= skip_zeroes
1575               || (z == stop_offset * opb &&
1576                   z - addr_offset * opb < skip_zeroes_at_end)))
1577         {
1578           /* If there are more nonzero octets to follow, we only skip
1579              zeroes in multiples of 4, to try to avoid running over
1580              the start of an instruction which happens to start with
1581              zero.  */
1582           if (z != stop_offset * opb)
1583             z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1584
1585           octets = z - addr_offset * opb;
1586
1587           /* If we are going to display more data, and we are displaying
1588              file offsets, then tell the user how many zeroes we skip
1589              and the file offset from where we resume dumping.  */
1590           if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1591             printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1592                     octets / opb,
1593                     (unsigned long) (section->filepos
1594                                      + (addr_offset + (octets / opb))));
1595           else
1596             printf ("\t...\n");
1597         }
1598       else
1599         {
1600           char buf[50];
1601           int bpc = 0;
1602           int pb = 0;
1603
1604           if (with_line_numbers || with_source_code)
1605             show_line (aux->abfd, section, addr_offset);
1606
1607           if (! prefix_addresses)
1608             {
1609               char *s;
1610
1611               bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1612               for (s = buf + skip_addr_chars; *s == '0'; s++)
1613                 *s = ' ';
1614               if (*s == '\0')
1615                 *--s = '0';
1616               printf ("%s:\t", buf + skip_addr_chars);
1617             }
1618           else
1619             {
1620               aux->require_sec = TRUE;
1621               objdump_print_address (section->vma + addr_offset, inf);
1622               aux->require_sec = FALSE;
1623               putchar (' ');
1624             }
1625
1626           if (insns)
1627             {
1628               sfile.pos = 0;
1629               inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
1630               inf->stream = &sfile;
1631               inf->bytes_per_line = 0;
1632               inf->bytes_per_chunk = 0;
1633               inf->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
1634               if (machine)
1635                 inf->flags |= USER_SPECIFIED_MACHINE_TYPE;
1636
1637               if (inf->disassembler_needs_relocs
1638                   && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1639                   && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1640                   && *relppp < relppend)
1641                 {
1642                   bfd_signed_vma distance_to_rel;
1643
1644                   distance_to_rel = (**relppp)->address
1645                     - (rel_offset + addr_offset);
1646
1647                   /* Check to see if the current reloc is associated with
1648                      the instruction that we are about to disassemble.  */
1649                   if (distance_to_rel == 0
1650                       /* FIXME: This is wrong.  We are trying to catch
1651                          relocs that are addressed part way through the
1652                          current instruction, as might happen with a packed
1653                          VLIW instruction.  Unfortunately we do not know the
1654                          length of the current instruction since we have not
1655                          disassembled it yet.  Instead we take a guess based
1656                          upon the length of the previous instruction.  The
1657                          proper solution is to have a new target-specific
1658                          disassembler function which just returns the length
1659                          of an instruction at a given address without trying
1660                          to display its disassembly. */
1661                       || (distance_to_rel > 0
1662                           && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1663                     {
1664                       inf->flags |= INSN_HAS_RELOC;
1665                       aux->reloc = **relppp;
1666                     }
1667                 }
1668
1669               octets = (*disassemble_fn) (section->vma + addr_offset, inf);
1670               inf->fprintf_func = (fprintf_ftype) fprintf;
1671               inf->stream = stdout;
1672               if (insn_width == 0 && inf->bytes_per_line != 0)
1673                 octets_per_line = inf->bytes_per_line;
1674               if (octets < (int) opb)
1675                 {
1676                   if (sfile.pos)
1677                     printf ("%s\n", sfile.buffer);
1678                   if (octets >= 0)
1679                     {
1680                       non_fatal (_("disassemble_fn returned length %d"),
1681                                  octets);
1682                       exit_status = 1;
1683                     }
1684                   break;
1685                 }
1686             }
1687           else
1688             {
1689               bfd_vma j;
1690
1691               octets = octets_per_line;
1692               if (addr_offset + octets / opb > stop_offset)
1693                 octets = (stop_offset - addr_offset) * opb;
1694
1695               for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1696                 {
1697                   if (ISPRINT (data[j]))
1698                     buf[j - addr_offset * opb] = data[j];
1699                   else
1700                     buf[j - addr_offset * opb] = '.';
1701                 }
1702               buf[j - addr_offset * opb] = '\0';
1703             }
1704
1705           if (prefix_addresses
1706               ? show_raw_insn > 0
1707               : show_raw_insn >= 0)
1708             {
1709               bfd_vma j;
1710
1711               /* If ! prefix_addresses and ! wide_output, we print
1712                  octets_per_line octets per line.  */
1713               pb = octets;
1714               if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1715                 pb = octets_per_line;
1716
1717               if (inf->bytes_per_chunk)
1718                 bpc = inf->bytes_per_chunk;
1719               else
1720                 bpc = 1;
1721
1722               for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1723                 {
1724                   int k;
1725
1726                   if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1727                     {
1728                       for (k = bpc - 1; k >= 0; k--)
1729                         printf ("%02x", (unsigned) data[j + k]);
1730                       putchar (' ');
1731                     }
1732                   else
1733                     {
1734                       for (k = 0; k < bpc; k++)
1735                         printf ("%02x", (unsigned) data[j + k]);
1736                       putchar (' ');
1737                     }
1738                 }
1739
1740               for (; pb < octets_per_line; pb += bpc)
1741                 {
1742                   int k;
1743
1744                   for (k = 0; k < bpc; k++)
1745                     printf ("  ");
1746                   putchar (' ');
1747                 }
1748
1749               /* Separate raw data from instruction by extra space.  */
1750               if (insns)
1751                 putchar ('\t');
1752               else
1753                 printf ("    ");
1754             }
1755
1756           if (! insns)
1757             printf ("%s", buf);
1758           else if (sfile.pos)
1759             printf ("%s", sfile.buffer);
1760
1761           if (prefix_addresses
1762               ? show_raw_insn > 0
1763               : show_raw_insn >= 0)
1764             {
1765               while (pb < octets)
1766                 {
1767                   bfd_vma j;
1768                   char *s;
1769
1770                   putchar ('\n');
1771                   j = addr_offset * opb + pb;
1772
1773                   bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1774                   for (s = buf + skip_addr_chars; *s == '0'; s++)
1775                     *s = ' ';
1776                   if (*s == '\0')
1777                     *--s = '0';
1778                   printf ("%s:\t", buf + skip_addr_chars);
1779
1780                   pb += octets_per_line;
1781                   if (pb > octets)
1782                     pb = octets;
1783                   for (; j < addr_offset * opb + pb; j += bpc)
1784                     {
1785                       int k;
1786
1787                       if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1788                         {
1789                           for (k = bpc - 1; k >= 0; k--)
1790                             printf ("%02x", (unsigned) data[j + k]);
1791                           putchar (' ');
1792                         }
1793                       else
1794                         {
1795                           for (k = 0; k < bpc; k++)
1796                             printf ("%02x", (unsigned) data[j + k]);
1797                           putchar (' ');
1798                         }
1799                     }
1800                 }
1801             }
1802
1803           if (!wide_output)
1804             putchar ('\n');
1805           else
1806             need_nl = TRUE;
1807         }
1808
1809       while ((*relppp) < relppend
1810              && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1811         {
1812           if (dump_reloc_info || dump_dynamic_reloc_info)
1813             {
1814               arelent *q;
1815
1816               q = **relppp;
1817
1818               if (wide_output)
1819                 putchar ('\t');
1820               else
1821                 printf ("\t\t\t");
1822
1823               objdump_print_value (section->vma - rel_offset + q->address,
1824                                    inf, TRUE);
1825
1826               if (q->howto == NULL)
1827                 printf (": *unknown*\t");
1828               else if (q->howto->name)
1829                 printf (": %s\t", q->howto->name);
1830               else
1831                 printf (": %d\t", q->howto->type);
1832
1833               if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1834                 printf ("*unknown*");
1835               else
1836                 {
1837                   const char *sym_name;
1838
1839                   sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1840                   if (sym_name != NULL && *sym_name != '\0')
1841                     objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
1842                   else
1843                     {
1844                       asection *sym_sec;
1845
1846                       sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1847                       sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1848                       if (sym_name == NULL || *sym_name == '\0')
1849                         sym_name = "*unknown*";
1850                       printf ("%s", sym_name);
1851                     }
1852                 }
1853
1854               if (q->addend)
1855                 {
1856                   bfd_signed_vma addend = q->addend;
1857                   if (addend < 0)
1858                     {
1859                       printf ("-0x");
1860                       addend = -addend;
1861                     }
1862                   else
1863                     printf ("+0x");
1864                   objdump_print_value (addend, inf, TRUE);
1865                 }
1866
1867               printf ("\n");
1868               need_nl = FALSE;
1869             }
1870           ++(*relppp);
1871         }
1872
1873       if (need_nl)
1874         printf ("\n");
1875
1876       addr_offset += octets / opb;
1877     }
1878
1879   free (sfile.buffer);
1880 }
1881
1882 static void
1883 disassemble_section (bfd *abfd, asection *section, void *inf)
1884 {
1885   const struct elf_backend_data * bed;
1886   bfd_vma                      sign_adjust = 0;
1887   struct disassemble_info *    pinfo = (struct disassemble_info *) inf;
1888   struct objdump_disasm_info * paux;
1889   unsigned int                 opb = pinfo->octets_per_byte;
1890   bfd_byte *                   data = NULL;
1891   bfd_size_type                datasize = 0;
1892   arelent **                   rel_pp = NULL;
1893   arelent **                   rel_ppstart = NULL;
1894   arelent **                   rel_ppend;
1895   unsigned long                stop_offset;
1896   asymbol *                    sym = NULL;
1897   long                         place = 0;
1898   long                         rel_count;
1899   bfd_vma                      rel_offset;
1900   unsigned long                addr_offset;
1901
1902   /* Sections that do not contain machine
1903      code are not normally disassembled.  */
1904   if (! disassemble_all
1905       && only_list == NULL
1906       && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1907           != (SEC_CODE | SEC_HAS_CONTENTS)))
1908     return;
1909
1910   if (! process_section_p (section))
1911     return;
1912
1913   datasize = bfd_get_section_size (section);
1914   if (datasize == 0)
1915     return;
1916
1917   if (start_address == (bfd_vma) -1
1918       || start_address < section->vma)
1919     addr_offset = 0;
1920   else
1921     addr_offset = start_address - section->vma;
1922
1923   if (stop_address == (bfd_vma) -1)
1924     stop_offset = datasize / opb;
1925   else
1926     {
1927       if (stop_address < section->vma)
1928         stop_offset = 0;
1929       else
1930         stop_offset = stop_address - section->vma;
1931       if (stop_offset > datasize / opb)
1932         stop_offset = datasize / opb;
1933     }
1934
1935   if (addr_offset >= stop_offset)
1936     return;
1937
1938   /* Decide which set of relocs to use.  Load them if necessary.  */
1939   paux = (struct objdump_disasm_info *) pinfo->application_data;
1940   if (paux->dynrelbuf)
1941     {
1942       rel_pp = paux->dynrelbuf;
1943       rel_count = paux->dynrelcount;
1944       /* Dynamic reloc addresses are absolute, non-dynamic are section
1945          relative.  REL_OFFSET specifies the reloc address corresponding
1946          to the start of this section.  */
1947       rel_offset = section->vma;
1948     }
1949   else
1950     {
1951       rel_count = 0;
1952       rel_pp = NULL;
1953       rel_offset = 0;
1954
1955       if ((section->flags & SEC_RELOC) != 0
1956           && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1957         {
1958           long relsize;
1959
1960           relsize = bfd_get_reloc_upper_bound (abfd, section);
1961           if (relsize < 0)
1962             bfd_fatal (bfd_get_filename (abfd));
1963
1964           if (relsize > 0)
1965             {
1966               rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
1967               rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1968               if (rel_count < 0)
1969                 bfd_fatal (bfd_get_filename (abfd));
1970
1971               /* Sort the relocs by address.  */
1972               qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1973             }
1974         }
1975     }
1976   rel_ppend = rel_pp + rel_count;
1977
1978   data = (bfd_byte *) xmalloc (datasize);
1979
1980   bfd_get_section_contents (abfd, section, data, 0, datasize);
1981
1982   paux->sec = section;
1983   pinfo->buffer = data;
1984   pinfo->buffer_vma = section->vma;
1985   pinfo->buffer_length = datasize;
1986   pinfo->section = section;
1987
1988   /* Skip over the relocs belonging to addresses below the
1989      start address.  */
1990   while (rel_pp < rel_ppend
1991          && (*rel_pp)->address < rel_offset + addr_offset)
1992     ++rel_pp;
1993
1994   printf (_("\nDisassembly of section %s:\n"), section->name);
1995
1996   /* Find the nearest symbol forwards from our current position.  */
1997   paux->require_sec = TRUE;
1998   sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
1999                                              (struct disassemble_info *) inf,
2000                                              &place);
2001   paux->require_sec = FALSE;
2002
2003   /* PR 9774: If the target used signed addresses then we must make
2004      sure that we sign extend the value that we calculate for 'addr'
2005      in the loop below.  */
2006   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2007       && (bed = get_elf_backend_data (abfd)) != NULL
2008       && bed->sign_extend_vma)
2009     sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
2010
2011   /* Disassemble a block of instructions up to the address associated with
2012      the symbol we have just found.  Then print the symbol and find the
2013      next symbol on.  Repeat until we have disassembled the entire section
2014      or we have reached the end of the address range we are interested in.  */
2015   while (addr_offset < stop_offset)
2016     {
2017       bfd_vma addr;
2018       asymbol *nextsym;
2019       unsigned long nextstop_offset;
2020       bfd_boolean insns;
2021
2022       addr = section->vma + addr_offset;
2023       addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
2024
2025       if (sym != NULL && bfd_asymbol_value (sym) <= addr)
2026         {
2027           int x;
2028
2029           for (x = place;
2030                (x < sorted_symcount
2031                 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
2032                ++x)
2033             continue;
2034
2035           pinfo->symbols = sorted_syms + place;
2036           pinfo->num_symbols = x - place;
2037           pinfo->symtab_pos = place;
2038         }
2039       else
2040         {
2041           pinfo->symbols = NULL;
2042           pinfo->num_symbols = 0;
2043           pinfo->symtab_pos = -1;
2044         }
2045
2046       if (! prefix_addresses)
2047         {
2048           pinfo->fprintf_func (pinfo->stream, "\n");
2049           objdump_print_addr_with_sym (abfd, section, sym, addr,
2050                                        pinfo, FALSE);
2051           pinfo->fprintf_func (pinfo->stream, ":\n");
2052         }
2053
2054       if (sym != NULL && bfd_asymbol_value (sym) > addr)
2055         nextsym = sym;
2056       else if (sym == NULL)
2057         nextsym = NULL;
2058       else
2059         {
2060 #define is_valid_next_sym(SYM) \
2061   ((SYM)->section == section \
2062    && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2063    && pinfo->symbol_is_valid (SYM, pinfo))
2064             
2065           /* Search forward for the next appropriate symbol in
2066              SECTION.  Note that all the symbols are sorted
2067              together into one big array, and that some sections
2068              may have overlapping addresses.  */
2069           while (place < sorted_symcount
2070                  && ! is_valid_next_sym (sorted_syms [place]))
2071             ++place;
2072
2073           if (place >= sorted_symcount)
2074             nextsym = NULL;
2075           else
2076             nextsym = sorted_syms[place];
2077         }
2078
2079       if (sym != NULL && bfd_asymbol_value (sym) > addr)
2080         nextstop_offset = bfd_asymbol_value (sym) - section->vma;
2081       else if (nextsym == NULL)
2082         nextstop_offset = stop_offset;
2083       else
2084         nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
2085
2086       if (nextstop_offset > stop_offset
2087           || nextstop_offset <= addr_offset)
2088         nextstop_offset = stop_offset;
2089
2090       /* If a symbol is explicitly marked as being an object
2091          rather than a function, just dump the bytes without
2092          disassembling them.  */
2093       if (disassemble_all
2094           || sym == NULL
2095           || sym->section != section
2096           || bfd_asymbol_value (sym) > addr
2097           || ((sym->flags & BSF_OBJECT) == 0
2098               && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
2099                   == NULL)
2100               && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
2101                   == NULL))
2102           || (sym->flags & BSF_FUNCTION) != 0)
2103         insns = TRUE;
2104       else
2105         insns = FALSE;
2106
2107       disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2108                          addr_offset, nextstop_offset,
2109                          rel_offset, &rel_pp, rel_ppend);
2110       
2111       addr_offset = nextstop_offset;
2112       sym = nextsym;
2113     }
2114
2115   free (data);
2116
2117   if (rel_ppstart != NULL)
2118     free (rel_ppstart);
2119 }
2120
2121 /* Disassemble the contents of an object file.  */
2122
2123 static void
2124 disassemble_data (bfd *abfd)
2125 {
2126   struct disassemble_info disasm_info;
2127   struct objdump_disasm_info aux;
2128   long i;
2129
2130   print_files = NULL;
2131   prev_functionname = NULL;
2132   prev_line = -1;
2133   prev_discriminator = 0;
2134
2135   /* We make a copy of syms to sort.  We don't want to sort syms
2136      because that will screw up the relocs.  */
2137   sorted_symcount = symcount ? symcount : dynsymcount;
2138   sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2139                                       * sizeof (asymbol *));
2140   memcpy (sorted_syms, symcount ? syms : dynsyms,
2141           sorted_symcount * sizeof (asymbol *));
2142
2143   sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2144
2145   for (i = 0; i < synthcount; ++i)
2146     {
2147       sorted_syms[sorted_symcount] = synthsyms + i;
2148       ++sorted_symcount;
2149     }
2150
2151   /* Sort the symbols into section and symbol order.  */
2152   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2153
2154   init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2155
2156   disasm_info.application_data = (void *) &aux;
2157   aux.abfd = abfd;
2158   aux.require_sec = FALSE;
2159   aux.dynrelbuf = NULL;
2160   aux.dynrelcount = 0;
2161   aux.reloc = NULL;
2162
2163   disasm_info.print_address_func = objdump_print_address;
2164   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2165
2166   if (machine != NULL)
2167     {
2168       const bfd_arch_info_type *inf = bfd_scan_arch (machine);
2169
2170       if (inf == NULL)
2171         fatal (_("can't use supplied machine %s"), machine);
2172
2173       abfd->arch_info = inf;
2174     }
2175
2176   if (endian != BFD_ENDIAN_UNKNOWN)
2177     {
2178       struct bfd_target *xvec;
2179
2180       xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
2181       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2182       xvec->byteorder = endian;
2183       abfd->xvec = xvec;
2184     }
2185
2186   /* Use libopcodes to locate a suitable disassembler.  */
2187   aux.disassemble_fn = disassembler (abfd);
2188   if (!aux.disassemble_fn)
2189     {
2190       non_fatal (_("can't disassemble for architecture %s\n"),
2191                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2192       exit_status = 1;
2193       return;
2194     }
2195
2196   disasm_info.flavour = bfd_get_flavour (abfd);
2197   disasm_info.arch = bfd_get_arch (abfd);
2198   disasm_info.mach = bfd_get_mach (abfd);
2199   disasm_info.disassembler_options = disassembler_options;
2200   disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2201   disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2202   disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2203   disasm_info.disassembler_needs_relocs = FALSE;
2204
2205   if (bfd_big_endian (abfd))
2206     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2207   else if (bfd_little_endian (abfd))
2208     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2209   else
2210     /* ??? Aborting here seems too drastic.  We could default to big or little
2211        instead.  */
2212     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2213
2214   /* Allow the target to customize the info structure.  */
2215   disassemble_init_for_target (& disasm_info);
2216
2217   /* Pre-load the dynamic relocs if we are going
2218      to be dumping them along with the disassembly.  */
2219   if (dump_dynamic_reloc_info)
2220     {
2221       long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2222   
2223       if (relsize < 0)
2224         bfd_fatal (bfd_get_filename (abfd));
2225
2226       if (relsize > 0)
2227         {
2228           aux.dynrelbuf = (arelent **) xmalloc (relsize);
2229           aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2230                                                             aux.dynrelbuf,
2231                                                             dynsyms);
2232           if (aux.dynrelcount < 0)
2233             bfd_fatal (bfd_get_filename (abfd));
2234
2235           /* Sort the relocs by address.  */
2236           qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2237                  compare_relocs);
2238         }
2239     }
2240   disasm_info.symtab = sorted_syms;
2241   disasm_info.symtab_size = sorted_symcount;
2242
2243   bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2244
2245   if (aux.dynrelbuf != NULL)
2246     free (aux.dynrelbuf);
2247   free (sorted_syms);
2248 }
2249 \f
2250 static int
2251 load_specific_debug_section (enum dwarf_section_display_enum debug,
2252                              asection *sec, void *file)
2253 {
2254   struct dwarf_section *section = &debug_displays [debug].section;
2255   bfd *abfd = (bfd *) file;
2256   bfd_boolean ret;
2257
2258   /* If it is already loaded, do nothing.  */
2259   if (section->start != NULL)
2260     return 1;
2261
2262   section->address = 0;
2263   section->size = bfd_get_section_size (sec);
2264   section->start = NULL;
2265   ret = bfd_get_full_section_contents (abfd, sec, &section->start);
2266
2267   if (! ret)
2268     {
2269       free_debug_section (debug);
2270       printf (_("\nCan't get contents for section '%s'.\n"),
2271               section->name);
2272       return 0;
2273     }
2274
2275   if (is_relocatable && debug_displays [debug].relocate)
2276     {
2277       bfd_cache_section_contents (sec, section->start);
2278
2279       ret = bfd_simple_get_relocated_section_contents (abfd,
2280                                                        sec,
2281                                                        section->start,
2282                                                        syms) != NULL;
2283
2284       if (! ret)
2285         {
2286           free_debug_section (debug);
2287           printf (_("\nCan't get contents for section '%s'.\n"),
2288                   section->name);
2289           return 0;
2290         }
2291     }
2292
2293   return 1;
2294 }
2295
2296 int
2297 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2298 {
2299   struct dwarf_section *section = &debug_displays [debug].section;
2300   bfd *abfd = (bfd *) file;
2301   asection *sec;
2302
2303   /* If it is already loaded, do nothing.  */
2304   if (section->start != NULL)
2305     return 1;
2306
2307   /* Locate the debug section.  */
2308   sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2309   if (sec != NULL)
2310     section->name = section->uncompressed_name;
2311   else
2312     {
2313       sec = bfd_get_section_by_name (abfd, section->compressed_name);
2314       if (sec != NULL)
2315         section->name = section->compressed_name;
2316     }
2317   if (sec == NULL)
2318     return 0;
2319
2320   return load_specific_debug_section (debug, sec, file);
2321 }
2322
2323 void
2324 free_debug_section (enum dwarf_section_display_enum debug)
2325 {
2326   struct dwarf_section *section = &debug_displays [debug].section;
2327
2328   if (section->start == NULL)
2329     return;
2330
2331   free ((char *) section->start);
2332   section->start = NULL;
2333   section->address = 0;
2334   section->size = 0;
2335 }
2336
2337 static void
2338 dump_dwarf_section (bfd *abfd, asection *section,
2339                     void *arg ATTRIBUTE_UNUSED)
2340 {
2341   const char *name = bfd_get_section_name (abfd, section);
2342   const char *match;
2343   int i;
2344
2345   if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2346     match = ".debug_info";
2347   else
2348     match = name;
2349
2350   for (i = 0; i < max; i++)
2351     if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2352          || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2353         && debug_displays [i].enabled != NULL
2354         && *debug_displays [i].enabled)
2355       {
2356         struct dwarf_section *sec = &debug_displays [i].section;
2357
2358         if (strcmp (sec->uncompressed_name, match) == 0)
2359           sec->name = sec->uncompressed_name;
2360         else
2361           sec->name = sec->compressed_name;
2362         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2363                                          section, abfd))
2364           {
2365             debug_displays [i].display (sec, abfd);
2366             
2367             if (i != info && i != abbrev)
2368               free_debug_section ((enum dwarf_section_display_enum) i);
2369           }
2370         break;
2371       }
2372 }
2373
2374 /* Dump the dwarf debugging information.  */
2375
2376 static void
2377 dump_dwarf (bfd *abfd)
2378 {
2379   is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2380
2381   eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
2382
2383   if (bfd_big_endian (abfd))
2384     byte_get = byte_get_big_endian;
2385   else if (bfd_little_endian (abfd))
2386     byte_get = byte_get_little_endian;
2387   else
2388     abort ();
2389
2390   switch (bfd_get_arch (abfd))
2391     {
2392     case bfd_arch_i386:
2393       switch (bfd_get_mach (abfd))
2394         {
2395         case bfd_mach_x86_64:
2396         case bfd_mach_x86_64_intel_syntax:
2397         case bfd_mach_x86_64_nacl:
2398         case bfd_mach_x64_32:
2399         case bfd_mach_x64_32_intel_syntax:
2400         case bfd_mach_x64_32_nacl:
2401           init_dwarf_regnames_x86_64 ();
2402           break;
2403
2404         default:
2405           init_dwarf_regnames_i386 ();
2406           break;
2407         }
2408       break;
2409
2410     default:
2411       break;
2412     }
2413
2414   bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2415
2416   free_debug_memory ();
2417 }
2418 \f
2419 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2420    it.  Return NULL on failure.   */
2421
2422 static char *
2423 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2424 {
2425   asection *stabsect;
2426   bfd_size_type size;
2427   char *contents;
2428
2429   stabsect = bfd_get_section_by_name (abfd, sect_name);
2430   if (stabsect == NULL)
2431     {
2432       printf (_("No %s section present\n\n"), sect_name);
2433       return FALSE;
2434     }
2435
2436   size = bfd_section_size (abfd, stabsect);
2437   contents  = (char *) xmalloc (size);
2438
2439   if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2440     {
2441       non_fatal (_("reading %s section of %s failed: %s"),
2442                  sect_name, bfd_get_filename (abfd),
2443                  bfd_errmsg (bfd_get_error ()));
2444       exit_status = 1;
2445       free (contents);
2446       return NULL;
2447     }
2448
2449   *size_ptr = size;
2450
2451   return contents;
2452 }
2453
2454 /* Stabs entries use a 12 byte format:
2455      4 byte string table index
2456      1 byte stab type
2457      1 byte stab other field
2458      2 byte stab desc field
2459      4 byte stab value
2460    FIXME: This will have to change for a 64 bit object format.  */
2461
2462 #define STRDXOFF  (0)
2463 #define TYPEOFF   (4)
2464 #define OTHEROFF  (5)
2465 #define DESCOFF   (6)
2466 #define VALOFF    (8)
2467 #define STABSIZE (12)
2468
2469 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2470    using string table section STRSECT_NAME (in `strtab').  */
2471
2472 static void
2473 print_section_stabs (bfd *abfd,
2474                      const char *stabsect_name,
2475                      unsigned *string_offset_ptr)
2476 {
2477   int i;
2478   unsigned file_string_table_offset = 0;
2479   unsigned next_file_string_table_offset = *string_offset_ptr;
2480   bfd_byte *stabp, *stabs_end;
2481
2482   stabp = stabs;
2483   stabs_end = stabp + stab_size;
2484
2485   printf (_("Contents of %s section:\n\n"), stabsect_name);
2486   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
2487
2488   /* Loop through all symbols and print them.
2489
2490      We start the index at -1 because there is a dummy symbol on
2491      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
2492   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2493     {
2494       const char *name;
2495       unsigned long strx;
2496       unsigned char type, other;
2497       unsigned short desc;
2498       bfd_vma value;
2499
2500       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2501       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2502       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2503       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2504       value = bfd_h_get_32 (abfd, stabp + VALOFF);
2505
2506       printf ("\n%-6d ", i);
2507       /* Either print the stab name, or, if unnamed, print its number
2508          again (makes consistent formatting for tools like awk).  */
2509       name = bfd_get_stab_name (type);
2510       if (name != NULL)
2511         printf ("%-6s", name);
2512       else if (type == N_UNDF)
2513         printf ("HdrSym");
2514       else
2515         printf ("%-6d", type);
2516       printf (" %-6d %-6d ", other, desc);
2517       bfd_printf_vma (abfd, value);
2518       printf (" %-6lu", strx);
2519
2520       /* Symbols with type == 0 (N_UNDF) specify the length of the
2521          string table associated with this file.  We use that info
2522          to know how to relocate the *next* file's string table indices.  */
2523       if (type == N_UNDF)
2524         {
2525           file_string_table_offset = next_file_string_table_offset;
2526           next_file_string_table_offset += value;
2527         }
2528       else
2529         {
2530           /* Using the (possibly updated) string table offset, print the
2531              string (if any) associated with this symbol.  */
2532           if ((strx + file_string_table_offset) < stabstr_size)
2533             printf (" %s", &strtab[strx + file_string_table_offset]);
2534           else
2535             printf (" *");
2536         }
2537     }
2538   printf ("\n\n");
2539   *string_offset_ptr = next_file_string_table_offset;
2540 }
2541
2542 typedef struct
2543 {
2544   const char * section_name;
2545   const char * string_section_name;
2546   unsigned string_offset;
2547 }
2548 stab_section_names;
2549
2550 static void
2551 find_stabs_section (bfd *abfd, asection *section, void *names)
2552 {
2553   int len;
2554   stab_section_names * sought = (stab_section_names *) names;
2555
2556   /* Check for section names for which stabsect_name is a prefix, to
2557      handle .stab.N, etc.  */
2558   len = strlen (sought->section_name);
2559
2560   /* If the prefix matches, and the files section name ends with a
2561      nul or a digit, then we match.  I.e., we want either an exact
2562      match or a section followed by a number.  */
2563   if (strncmp (sought->section_name, section->name, len) == 0
2564       && (section->name[len] == 0
2565           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2566     {
2567       if (strtab == NULL)
2568         strtab = read_section_stabs (abfd, sought->string_section_name,
2569                                      &stabstr_size);
2570       
2571       if (strtab)
2572         {
2573           stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2574                                                    &stab_size);
2575           if (stabs)
2576             print_section_stabs (abfd, section->name, &sought->string_offset);
2577         }
2578     }
2579 }
2580
2581 static void
2582 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2583 {
2584   stab_section_names s;
2585
2586   s.section_name = stabsect_name;
2587   s.string_section_name = strsect_name;
2588   s.string_offset = 0;
2589
2590   bfd_map_over_sections (abfd, find_stabs_section, & s);
2591
2592   free (strtab);
2593   strtab = NULL;
2594 }
2595
2596 /* Dump the any sections containing stabs debugging information.  */
2597
2598 static void
2599 dump_stabs (bfd *abfd)
2600 {
2601   dump_stabs_section (abfd, ".stab", ".stabstr");
2602   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2603   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2604
2605   /* For Darwin.  */
2606   dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2607
2608   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2609 }
2610 \f
2611 static void
2612 dump_bfd_header (bfd *abfd)
2613 {
2614   char *comma = "";
2615
2616   printf (_("architecture: %s, "),
2617           bfd_printable_arch_mach (bfd_get_arch (abfd),
2618                                    bfd_get_mach (abfd)));
2619   printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
2620
2621 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2622   PF (HAS_RELOC, "HAS_RELOC");
2623   PF (EXEC_P, "EXEC_P");
2624   PF (HAS_LINENO, "HAS_LINENO");
2625   PF (HAS_DEBUG, "HAS_DEBUG");
2626   PF (HAS_SYMS, "HAS_SYMS");
2627   PF (HAS_LOCALS, "HAS_LOCALS");
2628   PF (DYNAMIC, "DYNAMIC");
2629   PF (WP_TEXT, "WP_TEXT");
2630   PF (D_PAGED, "D_PAGED");
2631   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2632   PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2633   printf (_("\nstart address 0x"));
2634   bfd_printf_vma (abfd, abfd->start_address);
2635   printf ("\n");
2636 }
2637
2638 \f
2639 static void
2640 dump_bfd_private_header (bfd *abfd)
2641 {
2642   bfd_print_private_bfd_data (abfd, stdout);
2643 }
2644
2645 static void
2646 dump_target_specific (bfd *abfd)
2647 {
2648   const struct objdump_private_desc * const *desc;
2649   struct objdump_private_option *opt;
2650   char *e, *b;
2651
2652   /* Find the desc.  */
2653   for (desc = objdump_private_vectors; *desc != NULL; desc++)
2654     if ((*desc)->filter (abfd))
2655       break;
2656
2657   if (*desc == NULL)
2658     {
2659       non_fatal (_("option -P/--private not supported by this file"));
2660       return;
2661     }
2662
2663   /* Clear all options.  */
2664   for (opt = (*desc)->options; opt->name; opt++)
2665     opt->selected = FALSE;
2666
2667   /* Decode options.  */
2668   b = dump_private_options;
2669   do
2670     {
2671       e = strchr (b, ',');
2672
2673       if (e)
2674         *e = 0;
2675
2676       for (opt = (*desc)->options; opt->name; opt++)
2677         if (strcmp (opt->name, b) == 0)
2678           {
2679             opt->selected = TRUE;
2680             break;
2681           }
2682       if (opt->name == NULL)
2683         non_fatal (_("target specific dump '%s' not supported"), b);
2684
2685       if (e)
2686         {
2687           *e = ',';
2688           b = e + 1;
2689         }
2690     }
2691   while (e != NULL);
2692
2693   /* Dump.  */
2694   (*desc)->dump (abfd);
2695 }
2696 \f
2697 /* Display a section in hexadecimal format with associated characters.
2698    Each line prefixed by the zero padded address.  */
2699
2700 static void
2701 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2702 {
2703   bfd_byte *data = 0;
2704   bfd_size_type datasize;
2705   bfd_size_type addr_offset;
2706   bfd_size_type start_offset;
2707   bfd_size_type stop_offset;
2708   unsigned int opb = bfd_octets_per_byte (abfd);
2709   /* Bytes per line.  */
2710   const int onaline = 16;
2711   char buf[64];
2712   int count;
2713   int width;
2714
2715   if ((section->flags & SEC_HAS_CONTENTS) == 0)
2716     return;
2717
2718   if (! process_section_p (section))
2719     return;
2720   
2721   if ((datasize = bfd_section_size (abfd, section)) == 0)
2722     return;
2723
2724   /* Compute the address range to display.  */
2725   if (start_address == (bfd_vma) -1
2726       || start_address < section->vma)
2727     start_offset = 0;
2728   else
2729     start_offset = start_address - section->vma;
2730
2731   if (stop_address == (bfd_vma) -1)
2732     stop_offset = datasize / opb;
2733   else
2734     {
2735       if (stop_address < section->vma)
2736         stop_offset = 0;
2737       else
2738         stop_offset = stop_address - section->vma;
2739
2740       if (stop_offset > datasize / opb)
2741         stop_offset = datasize / opb;
2742     }
2743
2744   if (start_offset >= stop_offset)
2745     return;
2746   
2747   printf (_("Contents of section %s:"), section->name);
2748   if (display_file_offsets)
2749     printf (_("  (Starting at file offset: 0x%lx)"),
2750             (unsigned long) (section->filepos + start_offset));
2751   printf ("\n");
2752
2753   if (!bfd_get_full_section_contents (abfd, section, &data))
2754     {
2755       non_fatal (_("Reading section failed"));
2756       return;
2757     }
2758
2759   width = 4;
2760
2761   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2762   if (strlen (buf) >= sizeof (buf))
2763     abort ();
2764
2765   count = 0;
2766   while (buf[count] == '0' && buf[count+1] != '\0')
2767     count++;
2768   count = strlen (buf) - count;
2769   if (count > width)
2770     width = count;
2771
2772   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2773   if (strlen (buf) >= sizeof (buf))
2774     abort ();
2775
2776   count = 0;
2777   while (buf[count] == '0' && buf[count+1] != '\0')
2778     count++;
2779   count = strlen (buf) - count;
2780   if (count > width)
2781     width = count;
2782
2783   for (addr_offset = start_offset;
2784        addr_offset < stop_offset; addr_offset += onaline / opb)
2785     {
2786       bfd_size_type j;
2787
2788       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2789       count = strlen (buf);
2790       if ((size_t) count >= sizeof (buf))
2791         abort ();
2792
2793       putchar (' ');
2794       while (count < width)
2795         {
2796           putchar ('0');
2797           count++;
2798         }
2799       fputs (buf + count - width, stdout);
2800       putchar (' ');
2801
2802       for (j = addr_offset * opb;
2803            j < addr_offset * opb + onaline; j++)
2804         {
2805           if (j < stop_offset * opb)
2806             printf ("%02x", (unsigned) (data[j]));
2807           else
2808             printf ("  ");
2809           if ((j & 3) == 3)
2810             printf (" ");
2811         }
2812
2813       printf (" ");
2814       for (j = addr_offset * opb;
2815            j < addr_offset * opb + onaline; j++)
2816         {
2817           if (j >= stop_offset * opb)
2818             printf (" ");
2819           else
2820             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2821         }
2822       putchar ('\n');
2823     }
2824   free (data);
2825 }
2826
2827 /* Actually display the various requested regions.  */
2828
2829 static void
2830 dump_data (bfd *abfd)
2831 {
2832   bfd_map_over_sections (abfd, dump_section, NULL);
2833 }
2834
2835 /* Should perhaps share code and display with nm?  */
2836
2837 static void
2838 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2839 {
2840   asymbol **current;
2841   long max_count;
2842   long count;
2843
2844   if (dynamic)
2845     {
2846       current = dynsyms;
2847       max_count = dynsymcount;
2848       printf ("DYNAMIC SYMBOL TABLE:\n");
2849     }
2850   else
2851     {
2852       current = syms;
2853       max_count = symcount;
2854       printf ("SYMBOL TABLE:\n");
2855     }
2856
2857   if (max_count == 0)
2858     printf (_("no symbols\n"));
2859
2860   for (count = 0; count < max_count; count++)
2861     {
2862       bfd *cur_bfd;
2863
2864       if (*current == NULL)
2865         printf (_("no information for symbol number %ld\n"), count);
2866
2867       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2868         printf (_("could not determine the type of symbol number %ld\n"),
2869                 count);
2870
2871       else if (process_section_p ((* current)->section)
2872                && (dump_special_syms
2873                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
2874         {
2875           const char *name = (*current)->name;
2876
2877           if (do_demangle && name != NULL && *name != '\0')
2878             {
2879               char *alloc;
2880
2881               /* If we want to demangle the name, we demangle it
2882                  here, and temporarily clobber it while calling
2883                  bfd_print_symbol.  FIXME: This is a gross hack.  */
2884               alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2885               if (alloc != NULL)
2886                 (*current)->name = alloc;
2887               bfd_print_symbol (cur_bfd, stdout, *current,
2888                                 bfd_print_symbol_all);
2889               if (alloc != NULL)
2890                 {
2891                   (*current)->name = name;
2892                   free (alloc);
2893                 }
2894             }
2895           else
2896             bfd_print_symbol (cur_bfd, stdout, *current,
2897                               bfd_print_symbol_all);
2898           printf ("\n");
2899         }
2900
2901       current++;
2902     }
2903   printf ("\n\n");
2904 }
2905 \f
2906 static void
2907 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2908 {
2909   arelent **p;
2910   char *last_filename, *last_functionname;
2911   unsigned int last_line;
2912   unsigned int last_discriminator;
2913
2914   /* Get column headers lined up reasonably.  */
2915   {
2916     static int width;
2917
2918     if (width == 0)
2919       {
2920         char buf[30];
2921
2922         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2923         width = strlen (buf) - 7;
2924       }
2925     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2926   }
2927
2928   last_filename = NULL;
2929   last_functionname = NULL;
2930   last_line = 0;
2931   last_discriminator = 0;
2932
2933   for (p = relpp; relcount && *p != NULL; p++, relcount--)
2934     {
2935       arelent *q = *p;
2936       const char *filename, *functionname;
2937       unsigned int linenumber;
2938       unsigned int discriminator;
2939       const char *sym_name;
2940       const char *section_name;
2941       bfd_vma addend2 = 0;
2942
2943       if (start_address != (bfd_vma) -1
2944           && q->address < start_address)
2945         continue;
2946       if (stop_address != (bfd_vma) -1
2947           && q->address > stop_address)
2948         continue;
2949
2950       if (with_line_numbers
2951           && sec != NULL
2952           && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
2953                                                   &filename, &functionname,
2954                                                   &linenumber, &discriminator))
2955         {
2956           if (functionname != NULL
2957               && (last_functionname == NULL
2958                   || strcmp (functionname, last_functionname) != 0))
2959             {
2960               printf ("%s():\n", functionname);
2961               if (last_functionname != NULL)
2962                 free (last_functionname);
2963               last_functionname = xstrdup (functionname);
2964             }
2965
2966           if (linenumber > 0
2967               && (linenumber != last_line
2968                   || (filename != NULL
2969                       && last_filename != NULL
2970                       && filename_cmp (filename, last_filename) != 0)
2971                   || (discriminator != last_discriminator)))
2972             {
2973               if (discriminator > 0)
2974                 printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
2975               else
2976                 printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename,
2977                         linenumber, discriminator);
2978               last_line = linenumber;
2979               last_discriminator = discriminator;
2980               if (last_filename != NULL)
2981                 free (last_filename);
2982               if (filename == NULL)
2983                 last_filename = NULL;
2984               else
2985                 last_filename = xstrdup (filename);
2986             }
2987         }
2988
2989       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2990         {
2991           sym_name = (*(q->sym_ptr_ptr))->name;
2992           section_name = (*(q->sym_ptr_ptr))->section->name;
2993         }
2994       else
2995         {
2996           sym_name = NULL;
2997           section_name = NULL;
2998         }
2999
3000       bfd_printf_vma (abfd, q->address);
3001       if (q->howto == NULL)
3002         printf (" *unknown*         ");
3003       else if (q->howto->name)
3004         {
3005           const char *name = q->howto->name;
3006
3007           /* R_SPARC_OLO10 relocations contain two addends.
3008              But because 'arelent' lacks enough storage to
3009              store them both, the 64-bit ELF Sparc backend
3010              records this as two relocations.  One R_SPARC_LO10
3011              and one R_SPARC_13, both pointing to the same
3012              address.  This is merely so that we have some
3013              place to store both addend fields.
3014
3015              Undo this transformation, otherwise the output
3016              will be confusing.  */
3017           if (abfd->xvec->flavour == bfd_target_elf_flavour
3018               && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
3019               && relcount > 1
3020               && !strcmp (q->howto->name, "R_SPARC_LO10"))
3021             {
3022               arelent *q2 = *(p + 1);
3023               if (q2 != NULL
3024                   && q2->howto
3025                   && q->address == q2->address
3026                   && !strcmp (q2->howto->name, "R_SPARC_13"))
3027                 {
3028                   name = "R_SPARC_OLO10";
3029                   addend2 = q2->addend;
3030                   p++;
3031                 }
3032             }
3033           printf (" %-16s  ", name);
3034         }
3035       else
3036         printf (" %-16d  ", q->howto->type);
3037
3038       if (sym_name)
3039         {
3040           objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
3041         }
3042       else
3043         {
3044           if (section_name == NULL)
3045             section_name = "*unknown*";
3046           printf ("[%s]", section_name);
3047         }
3048
3049       if (q->addend)
3050         {
3051           bfd_signed_vma addend = q->addend;
3052           if (addend < 0)
3053             {
3054               printf ("-0x");
3055               addend = -addend;
3056             }
3057           else
3058             printf ("+0x");
3059           bfd_printf_vma (abfd, addend);
3060         }
3061       if (addend2)
3062         {
3063           printf ("+0x");
3064           bfd_printf_vma (abfd, addend2);
3065         }
3066
3067       printf ("\n");
3068     }
3069
3070   if (last_filename != NULL)
3071     free (last_filename);
3072   if (last_functionname != NULL)
3073     free (last_functionname);
3074 }
3075
3076 static void
3077 dump_relocs_in_section (bfd *abfd,
3078                         asection *section,
3079                         void *dummy ATTRIBUTE_UNUSED)
3080 {
3081   arelent **relpp;
3082   long relcount;
3083   long relsize;
3084
3085   if (   bfd_is_abs_section (section)
3086       || bfd_is_und_section (section)
3087       || bfd_is_com_section (section)
3088       || (! process_section_p (section))
3089       || ((section->flags & SEC_RELOC) == 0))
3090     return;
3091
3092   relsize = bfd_get_reloc_upper_bound (abfd, section);
3093   if (relsize < 0)
3094     bfd_fatal (bfd_get_filename (abfd));
3095
3096   printf ("RELOCATION RECORDS FOR [%s]:", section->name);
3097
3098   if (relsize == 0)
3099     {
3100       printf (" (none)\n\n");
3101       return;
3102     }
3103
3104   relpp = (arelent **) xmalloc (relsize);
3105   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
3106
3107   if (relcount < 0)
3108     bfd_fatal (bfd_get_filename (abfd));
3109   else if (relcount == 0)
3110     printf (" (none)\n\n");
3111   else
3112     {
3113       printf ("\n");
3114       dump_reloc_set (abfd, section, relpp, relcount);
3115       printf ("\n\n");
3116     }
3117   free (relpp);
3118 }
3119
3120 static void
3121 dump_relocs (bfd *abfd)
3122 {
3123   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3124 }
3125
3126 static void
3127 dump_dynamic_relocs (bfd *abfd)
3128 {
3129   long relsize;
3130   arelent **relpp;
3131   long relcount;
3132
3133   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3134   if (relsize < 0)
3135     bfd_fatal (bfd_get_filename (abfd));
3136
3137   printf ("DYNAMIC RELOCATION RECORDS");
3138
3139   if (relsize == 0)
3140     printf (" (none)\n\n");
3141   else
3142     {
3143       relpp = (arelent **) xmalloc (relsize);
3144       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3145
3146       if (relcount < 0)
3147         bfd_fatal (bfd_get_filename (abfd));
3148       else if (relcount == 0)
3149         printf (" (none)\n\n");
3150       else
3151         {
3152           printf ("\n");
3153           dump_reloc_set (abfd, NULL, relpp, relcount);
3154           printf ("\n\n");
3155         }
3156       free (relpp);
3157     }
3158 }
3159
3160 /* Creates a table of paths, to search for source files.  */
3161
3162 static void
3163 add_include_path (const char *path)
3164 {
3165   if (path[0] == 0)
3166     return;
3167   include_path_count++;
3168   include_paths = (const char **)
3169       xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3170 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3171   if (path[1] == ':' && path[2] == 0)
3172     path = concat (path, ".", (const char *) 0);
3173 #endif
3174   include_paths[include_path_count - 1] = path;
3175 }
3176
3177 static void
3178 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3179                   asection *section,
3180                   void *arg)
3181 {
3182   if ((section->flags & SEC_DEBUGGING) == 0)
3183     {
3184       bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3185       section->vma += adjust_section_vma;
3186       if (*has_reloc_p)
3187         section->lma += adjust_section_vma;
3188     }
3189 }
3190
3191 /* Dump selected contents of ABFD.  */
3192
3193 static void
3194 dump_bfd (bfd *abfd)
3195 {
3196   /* If we are adjusting section VMA's, change them all now.  Changing
3197      the BFD information is a hack.  However, we must do it, or
3198      bfd_find_nearest_line will not do the right thing.  */
3199   if (adjust_section_vma != 0)
3200     {
3201       bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3202       bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3203     }
3204
3205   if (! dump_debugging_tags && ! suppress_bfd_header)
3206     printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
3207             abfd->xvec->name);
3208   if (dump_ar_hdrs)
3209     print_arelt_descr (stdout, abfd, TRUE);
3210   if (dump_file_header)
3211     dump_bfd_header (abfd);
3212   if (dump_private_headers)
3213     dump_bfd_private_header (abfd);
3214   if (dump_private_options != NULL)
3215     dump_target_specific (abfd);
3216   if (! dump_debugging_tags && ! suppress_bfd_header)
3217     putchar ('\n');
3218
3219   if (dump_symtab
3220       || dump_reloc_info
3221       || disassemble
3222       || dump_debugging
3223       || dump_dwarf_section_info)
3224     syms = slurp_symtab (abfd);
3225
3226   if (dump_section_headers)
3227     dump_headers (abfd);
3228
3229   if (dump_dynamic_symtab || dump_dynamic_reloc_info
3230       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
3231     dynsyms = slurp_dynamic_symtab (abfd);
3232   if (disassemble)
3233     {
3234       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
3235                                              dynsymcount, dynsyms, &synthsyms);
3236       if (synthcount < 0)
3237         synthcount = 0;
3238     }
3239
3240   if (dump_symtab)
3241     dump_symbols (abfd, FALSE);
3242   if (dump_dynamic_symtab)
3243     dump_symbols (abfd, TRUE);
3244   if (dump_dwarf_section_info)
3245     dump_dwarf (abfd);
3246   if (dump_stab_section_info)
3247     dump_stabs (abfd);
3248   if (dump_reloc_info && ! disassemble)
3249     dump_relocs (abfd);
3250   if (dump_dynamic_reloc_info && ! disassemble)
3251     dump_dynamic_relocs (abfd);
3252   if (dump_section_contents)
3253     dump_data (abfd);
3254   if (disassemble)
3255     disassemble_data (abfd);
3256
3257   if (dump_debugging)
3258     {
3259       void *dhandle;
3260
3261       dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3262       if (dhandle != NULL)
3263         {
3264           if (!print_debugging_info (stdout, dhandle, abfd, syms,
3265                                      bfd_demangle,
3266                                      dump_debugging_tags ? TRUE : FALSE))
3267             {
3268               non_fatal (_("%s: printing debugging information failed"),
3269                          bfd_get_filename (abfd));
3270               exit_status = 1;
3271             }
3272         }
3273       /* PR 6483: If there was no STABS or IEEE debug
3274          info in the file, try DWARF instead.  */
3275       else if (! dump_dwarf_section_info)
3276         {
3277           dwarf_select_sections_all (); 
3278           dump_dwarf (abfd);
3279         }
3280     }
3281
3282   if (syms)
3283     {
3284       free (syms);
3285       syms = NULL;
3286     }
3287
3288   if (dynsyms)
3289     {
3290       free (dynsyms);
3291       dynsyms = NULL;
3292     }
3293
3294   if (synthsyms)
3295     {
3296       free (synthsyms);
3297       synthsyms = NULL;
3298     }
3299
3300   symcount = 0;
3301   dynsymcount = 0;
3302   synthcount = 0;
3303 }
3304
3305 static void
3306 display_object_bfd (bfd *abfd)
3307 {
3308   char **matching;
3309
3310   if (bfd_check_format_matches (abfd, bfd_object, &matching))
3311     {
3312       dump_bfd (abfd);
3313       return;
3314     }
3315
3316   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3317     {
3318       nonfatal (bfd_get_filename (abfd));
3319       list_matching_formats (matching);
3320       free (matching);
3321       return;
3322     }
3323
3324   if (bfd_get_error () != bfd_error_file_not_recognized)
3325     {
3326       nonfatal (bfd_get_filename (abfd));
3327       return;
3328     }
3329
3330   if (bfd_check_format_matches (abfd, bfd_core, &matching))
3331     {
3332       dump_bfd (abfd);
3333       return;
3334     }
3335
3336   nonfatal (bfd_get_filename (abfd));
3337
3338   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3339     {
3340       list_matching_formats (matching);
3341       free (matching);
3342     }
3343 }
3344
3345 static void
3346 display_any_bfd (bfd *file, int level)
3347 {
3348   /* Decompress sections unless dumping the section contents.  */
3349   if (!dump_section_contents)
3350     file->flags |= BFD_DECOMPRESS;
3351
3352   /* If the file is an archive, process all of its elements.  */
3353   if (bfd_check_format (file, bfd_archive))
3354     {
3355       bfd *arfile = NULL;
3356       bfd *last_arfile = NULL;
3357
3358       if (level == 0)
3359         printf (_("In archive %s:\n"), bfd_get_filename (file));
3360       else
3361         printf (_("In nested archive %s:\n"), bfd_get_filename (file));
3362
3363       for (;;)
3364         {
3365           bfd_set_error (bfd_error_no_error);
3366
3367           arfile = bfd_openr_next_archived_file (file, arfile);
3368           if (arfile == NULL)
3369             {
3370               if (bfd_get_error () != bfd_error_no_more_archived_files)
3371                 nonfatal (bfd_get_filename (file));
3372               break;
3373             }
3374
3375           display_any_bfd (arfile, level + 1);
3376
3377           if (last_arfile != NULL)
3378             bfd_close (last_arfile);
3379           last_arfile = arfile;
3380         }
3381
3382       if (last_arfile != NULL)
3383         bfd_close (last_arfile);
3384     }
3385   else
3386     display_object_bfd (file);
3387 }
3388
3389 static void
3390 display_file (char *filename, char *target)
3391 {
3392   bfd *file;
3393
3394   if (get_file_size (filename) < 1)
3395     {
3396       exit_status = 1;
3397       return;
3398     }
3399
3400   file = bfd_openr (filename, target);
3401   if (file == NULL)
3402     {
3403       nonfatal (filename);
3404       return;
3405     }
3406
3407   display_any_bfd (file, 0);
3408
3409   bfd_close (file);
3410 }
3411 \f
3412 int
3413 main (int argc, char **argv)
3414 {
3415   int c;
3416   char *target = default_target;
3417   bfd_boolean seenflag = FALSE;
3418
3419 #if defined (HAVE_SETLOCALE)
3420 #if defined (HAVE_LC_MESSAGES)
3421   setlocale (LC_MESSAGES, "");
3422 #endif
3423   setlocale (LC_CTYPE, "");
3424 #endif
3425
3426   bindtextdomain (PACKAGE, LOCALEDIR);
3427   textdomain (PACKAGE);
3428
3429   program_name = *argv;
3430   xmalloc_set_program_name (program_name);
3431
3432   START_PROGRESS (program_name, 0);
3433
3434   expandargv (&argc, &argv);
3435
3436   bfd_init ();
3437   set_default_bfd_target ();
3438
3439   while ((c = getopt_long (argc, argv,
3440                            "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3441                            long_options, (int *) 0))
3442          != EOF)
3443     {
3444       switch (c)
3445         {
3446         case 0:
3447           break;                /* We've been given a long option.  */
3448         case 'm':
3449           machine = optarg;
3450           break;
3451         case 'M':
3452           if (disassembler_options)
3453             /* Ignore potential memory leak for now.  */
3454             disassembler_options = concat (disassembler_options, ",",
3455                                            optarg, (const char *) NULL);
3456           else
3457             disassembler_options = optarg;
3458           break;
3459         case 'j':
3460           add_only (optarg);
3461           break;
3462         case 'F':
3463           display_file_offsets = TRUE;
3464           break;
3465         case 'l':
3466           with_line_numbers = TRUE;
3467           break;
3468         case 'b':
3469           target = optarg;
3470           break;
3471         case 'C':
3472           do_demangle = TRUE;
3473           if (optarg != NULL)
3474             {
3475               enum demangling_styles style;
3476
3477               style = cplus_demangle_name_to_style (optarg);
3478               if (style == unknown_demangling)
3479                 fatal (_("unknown demangling style `%s'"),
3480                        optarg);
3481
3482               cplus_demangle_set_style (style);
3483             }
3484           break;
3485         case 'w':
3486           wide_output = TRUE;
3487           break;
3488         case OPTION_ADJUST_VMA:
3489           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3490           break;
3491         case OPTION_START_ADDRESS:
3492           start_address = parse_vma (optarg, "--start-address");
3493           if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3494             fatal (_("error: the start address should be before the end address"));
3495           break;
3496         case OPTION_STOP_ADDRESS:
3497           stop_address = parse_vma (optarg, "--stop-address");
3498           if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3499             fatal (_("error: the stop address should be after the start address"));
3500           break;
3501         case OPTION_PREFIX:
3502           prefix = optarg;
3503           prefix_length = strlen (prefix);
3504           /* Remove an unnecessary trailing '/' */
3505           while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3506             prefix_length--;
3507           break;
3508         case OPTION_PREFIX_STRIP:
3509           prefix_strip = atoi (optarg);
3510           if (prefix_strip < 0)
3511             fatal (_("error: prefix strip must be non-negative"));
3512           break;
3513         case OPTION_INSN_WIDTH:
3514           insn_width = strtoul (optarg, NULL, 0);
3515           if (insn_width <= 0)
3516             fatal (_("error: instruction width must be positive"));
3517           break;
3518         case 'E':
3519           if (strcmp (optarg, "B") == 0)
3520             endian = BFD_ENDIAN_BIG;
3521           else if (strcmp (optarg, "L") == 0)
3522             endian = BFD_ENDIAN_LITTLE;
3523           else
3524             {
3525               nonfatal (_("unrecognized -E option"));
3526               usage (stderr, 1);
3527             }
3528           break;
3529         case OPTION_ENDIAN:
3530           if (strncmp (optarg, "big", strlen (optarg)) == 0)
3531             endian = BFD_ENDIAN_BIG;
3532           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3533             endian = BFD_ENDIAN_LITTLE;
3534           else
3535             {
3536               non_fatal (_("unrecognized --endian type `%s'"), optarg);
3537               exit_status = 1;
3538               usage (stderr, 1);
3539             }
3540           break;
3541
3542         case 'f':
3543           dump_file_header = TRUE;
3544           seenflag = TRUE;
3545           break;
3546         case 'i':
3547           formats_info = TRUE;
3548           seenflag = TRUE;
3549           break;
3550         case 'I':
3551           add_include_path (optarg);
3552           break;
3553         case 'p':
3554           dump_private_headers = TRUE;
3555           seenflag = TRUE;
3556           break;
3557         case 'P':
3558           dump_private_options = optarg;
3559           seenflag = TRUE;
3560           break;
3561         case 'x':
3562           dump_private_headers = TRUE;
3563           dump_symtab = TRUE;
3564           dump_reloc_info = TRUE;
3565           dump_file_header = TRUE;
3566           dump_ar_hdrs = TRUE;
3567           dump_section_headers = TRUE;
3568           seenflag = TRUE;
3569           break;
3570         case 't':
3571           dump_symtab = TRUE;
3572           seenflag = TRUE;
3573           break;
3574         case 'T':
3575           dump_dynamic_symtab = TRUE;
3576           seenflag = TRUE;
3577           break;
3578         case 'd':
3579           disassemble = TRUE;
3580           seenflag = TRUE;
3581           break;
3582         case 'z':
3583           disassemble_zeroes = TRUE;
3584           break;
3585         case 'D':
3586           disassemble = TRUE;
3587           disassemble_all = TRUE;
3588           seenflag = TRUE;
3589           break;
3590         case 'S':
3591           disassemble = TRUE;
3592           with_source_code = TRUE;
3593           seenflag = TRUE;
3594           break;
3595         case 'g':
3596           dump_debugging = 1;
3597           seenflag = TRUE;
3598           break;
3599         case 'e':
3600           dump_debugging = 1;
3601           dump_debugging_tags = 1;
3602           do_demangle = TRUE;
3603           seenflag = TRUE;
3604           break;
3605         case 'W':
3606           dump_dwarf_section_info = TRUE;
3607           seenflag = TRUE;
3608           if (optarg)
3609             dwarf_select_sections_by_letters (optarg);
3610           else
3611             dwarf_select_sections_all ();
3612           break;
3613         case OPTION_DWARF:
3614           dump_dwarf_section_info = TRUE;
3615           seenflag = TRUE;
3616           if (optarg)
3617             dwarf_select_sections_by_names (optarg);
3618           else
3619             dwarf_select_sections_all ();
3620           break;
3621         case OPTION_DWARF_DEPTH:
3622           {
3623             char *cp;
3624             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3625           }
3626           break;
3627         case OPTION_DWARF_START:
3628           {
3629             char *cp;
3630             dwarf_start_die = strtoul (optarg, & cp, 0);
3631             suppress_bfd_header = 1;
3632           }
3633           break;
3634         case OPTION_DWARF_CHECK:
3635           dwarf_check = TRUE;
3636           break;
3637         case 'G':
3638           dump_stab_section_info = TRUE;
3639           seenflag = TRUE;
3640           break;
3641         case 's':
3642           dump_section_contents = TRUE;
3643           seenflag = TRUE;
3644           break;
3645         case 'r':
3646           dump_reloc_info = TRUE;
3647           seenflag = TRUE;
3648           break;
3649         case 'R':
3650           dump_dynamic_reloc_info = TRUE;
3651           seenflag = TRUE;
3652           break;
3653         case 'a':
3654           dump_ar_hdrs = TRUE;
3655           seenflag = TRUE;
3656           break;
3657         case 'h':
3658           dump_section_headers = TRUE;
3659           seenflag = TRUE;
3660           break;
3661         case 'v':
3662         case 'V':
3663           show_version = TRUE;
3664           seenflag = TRUE;
3665           break;
3666
3667         case 'H':
3668           usage (stdout, 0);
3669           /* No need to set seenflag or to break - usage() does not return.  */
3670         default:
3671           usage (stderr, 1);
3672         }
3673     }
3674
3675   if (show_version)
3676     print_version ("objdump");
3677
3678   if (!seenflag)
3679     usage (stderr, 2);
3680
3681   if (formats_info)
3682     exit_status = display_info ();
3683   else
3684     {
3685       if (optind == argc)
3686         display_file ("a.out", target);
3687       else
3688         for (; optind < argc;)
3689           display_file (argv[optind++], target);
3690     }
3691
3692   free_only_list ();
3693
3694   END_PROGRESS (program_name);
3695
3696   return exit_status;
3697 }