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