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