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