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