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