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