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