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