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