2009-07-02 Tristan Gingold <gingold@adacore.com>
[binutils.git] / binutils / objdump.c
blobdfe6a57e16e1339178461f71a4bb8227030cc006
1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
24 /* Objdump overview.
26 Objdump displays information about one or more object files, either on
27 their own, or inside libraries. It is commonly used as a disassembler,
28 but it can also display information about file headers, symbol tables,
29 relocations, debugging directives and more.
31 The flow of execution is as follows:
33 1. Command line arguments are checked for control switches and the
34 information to be displayed is selected.
36 2. Any remaining arguments are assumed to be object files, and they are
37 processed in order by display_bfd(). If the file is an archive each
38 of its elements is processed in turn.
40 3. The file's target architecture and binary file format are determined
41 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 called.
44 4. dump_bfd() in turn calls separate functions to display the requested
45 item(s) of information(s). For example disassemble_data() is called if
46 a disassembly has been requested.
48 When disassembling the code loops through blocks of instructions bounded
49 by symbols, calling disassemble_bytes() on each block. The actual
50 disassembling is done by the libopcodes library, via a function pointer
51 supplied by the disassembler() function. */
53 #include "sysdep.h"
54 #include "bfd.h"
55 #include "elf-bfd.h"
56 #include "progress.h"
57 #include "bucomm.h"
58 #include "dwarf.h"
59 #include "getopt.h"
60 #include "safe-ctype.h"
61 #include "dis-asm.h"
62 #include "libiberty.h"
63 #include "demangle.h"
64 #include "filenames.h"
65 #include "debug.h"
66 #include "budbg.h"
68 #ifdef HAVE_MMAP
69 #include <sys/mman.h>
70 #endif
72 #include <sys/stat.h>
74 /* Internal headers for the ELF .stab-dump code - sorry. */
75 #define BYTES_IN_WORD 32
76 #include "aout/aout64.h"
78 /* Exit status. */
79 static int exit_status = 0;
81 static char *default_target = NULL; /* Default at runtime. */
83 /* The following variables are set based on arguments passed on the
84 command line. */
85 static int show_version = 0; /* Show the version number. */
86 static int dump_section_contents; /* -s */
87 static int dump_section_headers; /* -h */
88 static bfd_boolean dump_file_header; /* -f */
89 static int dump_symtab; /* -t */
90 static int dump_dynamic_symtab; /* -T */
91 static int dump_reloc_info; /* -r */
92 static int dump_dynamic_reloc_info; /* -R */
93 static int dump_ar_hdrs; /* -a */
94 static int dump_private_headers; /* -p */
95 static int prefix_addresses; /* --prefix-addresses */
96 static int with_line_numbers; /* -l */
97 static bfd_boolean with_source_code; /* -S */
98 static int show_raw_insn; /* --show-raw-insn */
99 static int dump_dwarf_section_info; /* --dwarf */
100 static int dump_stab_section_info; /* --stabs */
101 static int do_demangle; /* -C, --demangle */
102 static bfd_boolean disassemble; /* -d */
103 static bfd_boolean disassemble_all; /* -D */
104 static int disassemble_zeroes; /* --disassemble-zeroes */
105 static bfd_boolean formats_info; /* -i */
106 static int wide_output; /* -w */
107 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
108 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
109 static int dump_debugging; /* --debugging */
110 static int dump_debugging_tags; /* --debugging-tags */
111 static int dump_special_syms = 0; /* --special-syms */
112 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
113 static int file_start_context = 0; /* --file-start-context */
114 static bfd_boolean display_file_offsets;/* -F */
115 static const char *prefix; /* --prefix */
116 static int prefix_strip; /* --prefix-strip */
117 static size_t prefix_length;
119 /* Pointer to an array of section names provided by
120 one or more "-j secname" command line options. */
121 static char **only;
122 /* The total number of slots in the only[] array. */
123 static size_t only_size = 0;
124 /* The number of occupied slots in the only[] array. */
125 static size_t only_used = 0;
127 /* Variables for handling include file path table. */
128 static const char **include_paths;
129 static int include_path_count;
131 /* Extra info to pass to the section disassembler and address printing
132 function. */
133 struct objdump_disasm_info
135 bfd * abfd;
136 asection * sec;
137 bfd_boolean require_sec;
138 arelent ** dynrelbuf;
139 long dynrelcount;
140 disassembler_ftype disassemble_fn;
141 arelent * reloc;
144 /* Architecture to disassemble for, or default if NULL. */
145 static char *machine = NULL;
147 /* Target specific options to the disassembler. */
148 static char *disassembler_options = NULL;
150 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
151 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
153 /* The symbol table. */
154 static asymbol **syms;
156 /* Number of symbols in `syms'. */
157 static long symcount = 0;
159 /* The sorted symbol table. */
160 static asymbol **sorted_syms;
162 /* Number of symbols in `sorted_syms'. */
163 static long sorted_symcount = 0;
165 /* The dynamic symbol table. */
166 static asymbol **dynsyms;
168 /* The synthetic symbol table. */
169 static asymbol *synthsyms;
170 static long synthcount = 0;
172 /* Number of symbols in `dynsyms'. */
173 static long dynsymcount = 0;
175 static bfd_byte *stabs;
176 static bfd_size_type stab_size;
178 static char *strtab;
179 static bfd_size_type stabstr_size;
181 static bfd_boolean is_relocatable = FALSE;
183 static void
184 usage (FILE *stream, int status)
186 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
187 fprintf (stream, _(" Display information from object <file(s)>.\n"));
188 fprintf (stream, _(" At least one of the following switches must be given:\n"));
189 fprintf (stream, _("\
190 -a, --archive-headers Display archive header information\n\
191 -f, --file-headers Display the contents of the overall file header\n\
192 -p, --private-headers Display object format specific file header contents\n\
193 -h, --[section-]headers Display the contents of the section headers\n\
194 -x, --all-headers Display the contents of all headers\n\
195 -d, --disassemble Display assembler contents of executable sections\n\
196 -D, --disassemble-all Display assembler contents of all sections\n\
197 -S, --source Intermix source code with disassembly\n\
198 -s, --full-contents Display the full contents of all sections requested\n\
199 -g, --debugging Display debug information in object file\n\
200 -e, --debugging-tags Display debug information using ctags style\n\
201 -G, --stabs Display (in raw form) any STABS info in the file\n\
202 -W[lLiaprmfFsoR] or\n\
203 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
204 Display DWARF info in the file\n\
205 -t, --syms Display the contents of the symbol table(s)\n\
206 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
207 -r, --reloc Display the relocation entries in the file\n\
208 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
209 @<file> Read options from <file>\n\
210 -v, --version Display this program's version number\n\
211 -i, --info List object formats and architectures supported\n\
212 -H, --help Display this information\n\
213 "));
214 if (status != 2)
216 fprintf (stream, _("\n The following switches are optional:\n"));
217 fprintf (stream, _("\
218 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
219 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
220 -j, --section=NAME Only display information for section NAME\n\
221 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
222 -EB --endian=big Assume big endian format when disassembling\n\
223 -EL --endian=little Assume little endian format when disassembling\n\
224 --file-start-context Include context from start of file (with -S)\n\
225 -I, --include=DIR Add DIR to search list for source files\n\
226 -l, --line-numbers Include line numbers and filenames in output\n\
227 -F, --file-offsets Include file offsets when displaying information\n\
228 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
229 The STYLE, if specified, can be `auto', `gnu',\n\
230 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
231 or `gnat'\n\
232 -w, --wide Format output for more than 80 columns\n\
233 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
234 --start-address=ADDR Only process data whose address is >= ADDR\n\
235 --stop-address=ADDR Only process data whose address is <= ADDR\n\
236 --prefix-addresses Print complete address alongside disassembly\n\
237 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
238 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
239 --special-syms Include special symbols in symbol dumps\n\
240 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
241 --prefix-strip=LEVEL Strip initial directory names for -S\n\
242 \n"));
243 list_supported_targets (program_name, stream);
244 list_supported_architectures (program_name, stream);
246 disassembler_usage (stream);
248 if (REPORT_BUGS_TO[0] && status == 0)
249 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
250 exit (status);
253 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
254 enum option_values
256 OPTION_ENDIAN=150,
257 OPTION_START_ADDRESS,
258 OPTION_STOP_ADDRESS,
259 OPTION_DWARF,
260 OPTION_PREFIX,
261 OPTION_PREFIX_STRIP,
262 OPTION_ADJUST_VMA
265 static struct option long_options[]=
267 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
268 {"all-headers", no_argument, NULL, 'x'},
269 {"private-headers", no_argument, NULL, 'p'},
270 {"architecture", required_argument, NULL, 'm'},
271 {"archive-headers", no_argument, NULL, 'a'},
272 {"debugging", no_argument, NULL, 'g'},
273 {"debugging-tags", no_argument, NULL, 'e'},
274 {"demangle", optional_argument, NULL, 'C'},
275 {"disassemble", no_argument, NULL, 'd'},
276 {"disassemble-all", no_argument, NULL, 'D'},
277 {"disassembler-options", required_argument, NULL, 'M'},
278 {"disassemble-zeroes", no_argument, NULL, 'z'},
279 {"dynamic-reloc", no_argument, NULL, 'R'},
280 {"dynamic-syms", no_argument, NULL, 'T'},
281 {"endian", required_argument, NULL, OPTION_ENDIAN},
282 {"file-headers", no_argument, NULL, 'f'},
283 {"file-offsets", no_argument, NULL, 'F'},
284 {"file-start-context", no_argument, &file_start_context, 1},
285 {"full-contents", no_argument, NULL, 's'},
286 {"headers", no_argument, NULL, 'h'},
287 {"help", no_argument, NULL, 'H'},
288 {"info", no_argument, NULL, 'i'},
289 {"line-numbers", no_argument, NULL, 'l'},
290 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
291 {"prefix-addresses", no_argument, &prefix_addresses, 1},
292 {"reloc", no_argument, NULL, 'r'},
293 {"section", required_argument, NULL, 'j'},
294 {"section-headers", no_argument, NULL, 'h'},
295 {"show-raw-insn", no_argument, &show_raw_insn, 1},
296 {"source", no_argument, NULL, 'S'},
297 {"special-syms", no_argument, &dump_special_syms, 1},
298 {"include", required_argument, NULL, 'I'},
299 {"dwarf", optional_argument, NULL, OPTION_DWARF},
300 {"stabs", no_argument, NULL, 'G'},
301 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
302 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
303 {"syms", no_argument, NULL, 't'},
304 {"target", required_argument, NULL, 'b'},
305 {"version", no_argument, NULL, 'V'},
306 {"wide", no_argument, NULL, 'w'},
307 {"prefix", required_argument, NULL, OPTION_PREFIX},
308 {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
309 {0, no_argument, 0, 0}
312 static void
313 nonfatal (const char *msg)
315 bfd_nonfatal (msg);
316 exit_status = 1;
319 static void
320 dump_section_header (bfd *abfd, asection *section,
321 void *ignored ATTRIBUTE_UNUSED)
323 char *comma = "";
324 unsigned int opb = bfd_octets_per_byte (abfd);
326 /* Ignore linker created section. See elfNN_ia64_object_p in
327 bfd/elfxx-ia64.c. */
328 if (section->flags & SEC_LINKER_CREATED)
329 return;
331 printf ("%3d %-13s %08lx ", section->index,
332 bfd_get_section_name (abfd, section),
333 (unsigned long) bfd_section_size (abfd, section) / opb);
334 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
335 printf (" ");
336 bfd_printf_vma (abfd, section->lma);
337 printf (" %08lx 2**%u", (unsigned long) section->filepos,
338 bfd_get_section_alignment (abfd, section));
339 if (! wide_output)
340 printf ("\n ");
341 printf (" ");
343 #define PF(x, y) \
344 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
346 PF (SEC_HAS_CONTENTS, "CONTENTS");
347 PF (SEC_ALLOC, "ALLOC");
348 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
349 PF (SEC_LOAD, "LOAD");
350 PF (SEC_RELOC, "RELOC");
351 PF (SEC_READONLY, "READONLY");
352 PF (SEC_CODE, "CODE");
353 PF (SEC_DATA, "DATA");
354 PF (SEC_ROM, "ROM");
355 PF (SEC_DEBUGGING, "DEBUGGING");
356 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
357 PF (SEC_EXCLUDE, "EXCLUDE");
358 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
359 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
361 PF (SEC_TIC54X_BLOCK, "BLOCK");
362 PF (SEC_TIC54X_CLINK, "CLINK");
364 PF (SEC_SMALL_DATA, "SMALL_DATA");
365 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
366 PF (SEC_COFF_SHARED, "SHARED");
367 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
368 PF (SEC_GROUP, "GROUP");
370 if ((section->flags & SEC_LINK_ONCE) != 0)
372 const char *ls;
373 struct coff_comdat_info *comdat;
375 switch (section->flags & SEC_LINK_DUPLICATES)
377 default:
378 abort ();
379 case SEC_LINK_DUPLICATES_DISCARD:
380 ls = "LINK_ONCE_DISCARD";
381 break;
382 case SEC_LINK_DUPLICATES_ONE_ONLY:
383 ls = "LINK_ONCE_ONE_ONLY";
384 break;
385 case SEC_LINK_DUPLICATES_SAME_SIZE:
386 ls = "LINK_ONCE_SAME_SIZE";
387 break;
388 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
389 ls = "LINK_ONCE_SAME_CONTENTS";
390 break;
392 printf ("%s%s", comma, ls);
394 comdat = bfd_coff_get_comdat_section (abfd, section);
395 if (comdat != NULL)
396 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
398 comma = ", ";
401 printf ("\n");
402 #undef PF
405 static void
406 dump_headers (bfd *abfd)
408 printf (_("Sections:\n"));
410 #ifndef BFD64
411 printf (_("Idx Name Size VMA LMA File off Algn"));
412 #else
413 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
414 if (bfd_get_arch_size (abfd) == 32)
415 printf (_("Idx Name Size VMA LMA File off Algn"));
416 else
417 printf (_("Idx Name Size VMA LMA File off Algn"));
418 #endif
420 if (wide_output)
421 printf (_(" Flags"));
422 if (abfd->flags & HAS_LOAD_PAGE)
423 printf (_(" Pg"));
424 printf ("\n");
426 bfd_map_over_sections (abfd, dump_section_header, NULL);
429 static asymbol **
430 slurp_symtab (bfd *abfd)
432 asymbol **sy = NULL;
433 long storage;
435 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
437 symcount = 0;
438 return NULL;
441 storage = bfd_get_symtab_upper_bound (abfd);
442 if (storage < 0)
443 bfd_fatal (bfd_get_filename (abfd));
444 if (storage)
445 sy = xmalloc (storage);
447 symcount = bfd_canonicalize_symtab (abfd, sy);
448 if (symcount < 0)
449 bfd_fatal (bfd_get_filename (abfd));
450 return sy;
453 /* Read in the dynamic symbols. */
455 static asymbol **
456 slurp_dynamic_symtab (bfd *abfd)
458 asymbol **sy = NULL;
459 long storage;
461 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
462 if (storage < 0)
464 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
466 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
467 dynsymcount = 0;
468 return NULL;
471 bfd_fatal (bfd_get_filename (abfd));
473 if (storage)
474 sy = xmalloc (storage);
476 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
477 if (dynsymcount < 0)
478 bfd_fatal (bfd_get_filename (abfd));
479 return sy;
482 /* Filter out (in place) symbols that are useless for disassembly.
483 COUNT is the number of elements in SYMBOLS.
484 Return the number of useful symbols. */
486 static long
487 remove_useless_symbols (asymbol **symbols, long count)
489 asymbol **in_ptr = symbols, **out_ptr = symbols;
491 while (--count >= 0)
493 asymbol *sym = *in_ptr++;
495 if (sym->name == NULL || sym->name[0] == '\0')
496 continue;
497 if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
498 continue;
499 if (bfd_is_und_section (sym->section)
500 || bfd_is_com_section (sym->section))
501 continue;
503 *out_ptr++ = sym;
505 return out_ptr - symbols;
508 /* Sort symbols into value order. */
510 static int
511 compare_symbols (const void *ap, const void *bp)
513 const asymbol *a = * (const asymbol **) ap;
514 const asymbol *b = * (const asymbol **) bp;
515 const char *an;
516 const char *bn;
517 size_t anl;
518 size_t bnl;
519 bfd_boolean af;
520 bfd_boolean bf;
521 flagword aflags;
522 flagword bflags;
524 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
525 return 1;
526 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
527 return -1;
529 if (a->section > b->section)
530 return 1;
531 else if (a->section < b->section)
532 return -1;
534 an = bfd_asymbol_name (a);
535 bn = bfd_asymbol_name (b);
536 anl = strlen (an);
537 bnl = strlen (bn);
539 /* The symbols gnu_compiled and gcc2_compiled convey no real
540 information, so put them after other symbols with the same value. */
541 af = (strstr (an, "gnu_compiled") != NULL
542 || strstr (an, "gcc2_compiled") != NULL);
543 bf = (strstr (bn, "gnu_compiled") != NULL
544 || strstr (bn, "gcc2_compiled") != NULL);
546 if (af && ! bf)
547 return 1;
548 if (! af && bf)
549 return -1;
551 /* We use a heuristic for the file name, to try to sort it after
552 more useful symbols. It may not work on non Unix systems, but it
553 doesn't really matter; the only difference is precisely which
554 symbol names get printed. */
556 #define file_symbol(s, sn, snl) \
557 (((s)->flags & BSF_FILE) != 0 \
558 || ((sn)[(snl) - 2] == '.' \
559 && ((sn)[(snl) - 1] == 'o' \
560 || (sn)[(snl) - 1] == 'a')))
562 af = file_symbol (a, an, anl);
563 bf = file_symbol (b, bn, bnl);
565 if (af && ! bf)
566 return 1;
567 if (! af && bf)
568 return -1;
570 /* Try to sort global symbols before local symbols before function
571 symbols before debugging symbols. */
573 aflags = a->flags;
574 bflags = b->flags;
576 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
578 if ((aflags & BSF_DEBUGGING) != 0)
579 return 1;
580 else
581 return -1;
583 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
585 if ((aflags & BSF_FUNCTION) != 0)
586 return -1;
587 else
588 return 1;
590 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
592 if ((aflags & BSF_LOCAL) != 0)
593 return 1;
594 else
595 return -1;
597 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
599 if ((aflags & BSF_GLOBAL) != 0)
600 return -1;
601 else
602 return 1;
605 /* Symbols that start with '.' might be section names, so sort them
606 after symbols that don't start with '.'. */
607 if (an[0] == '.' && bn[0] != '.')
608 return 1;
609 if (an[0] != '.' && bn[0] == '.')
610 return -1;
612 /* Finally, if we can't distinguish them in any other way, try to
613 get consistent results by sorting the symbols by name. */
614 return strcmp (an, bn);
617 /* Sort relocs into address order. */
619 static int
620 compare_relocs (const void *ap, const void *bp)
622 const arelent *a = * (const arelent **) ap;
623 const arelent *b = * (const arelent **) bp;
625 if (a->address > b->address)
626 return 1;
627 else if (a->address < b->address)
628 return -1;
630 /* So that associated relocations tied to the same address show up
631 in the correct order, we don't do any further sorting. */
632 if (a > b)
633 return 1;
634 else if (a < b)
635 return -1;
636 else
637 return 0;
640 /* Print an address (VMA) to the output stream in INFO.
641 If SKIP_ZEROES is TRUE, omit leading zeroes. */
643 static void
644 objdump_print_value (bfd_vma vma, struct disassemble_info *info,
645 bfd_boolean skip_zeroes)
647 char buf[30];
648 char *p;
649 struct objdump_disasm_info *aux;
651 aux = (struct objdump_disasm_info *) info->application_data;
652 bfd_sprintf_vma (aux->abfd, buf, vma);
653 if (! skip_zeroes)
654 p = buf;
655 else
657 for (p = buf; *p == '0'; ++p)
659 if (*p == '\0')
660 --p;
662 (*info->fprintf_func) (info->stream, "%s", p);
665 /* Print the name of a symbol. */
667 static void
668 objdump_print_symname (bfd *abfd, struct disassemble_info *info,
669 asymbol *sym)
671 char *alloc;
672 const char *name;
674 alloc = NULL;
675 name = bfd_asymbol_name (sym);
676 if (do_demangle && name[0] != '\0')
678 /* Demangle the name. */
679 alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
680 if (alloc != NULL)
681 name = alloc;
684 if (info != NULL)
685 (*info->fprintf_func) (info->stream, "%s", name);
686 else
687 printf ("%s", name);
689 if (alloc != NULL)
690 free (alloc);
693 /* Locate a symbol given a bfd and a section (from INFO->application_data),
694 and a VMA. If INFO->application_data->require_sec is TRUE, then always
695 require the symbol to be in the section. Returns NULL if there is no
696 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
697 of the symbol in sorted_syms. */
699 static asymbol *
700 find_symbol_for_address (bfd_vma vma,
701 struct disassemble_info *info,
702 long *place)
704 /* @@ Would it speed things up to cache the last two symbols returned,
705 and maybe their address ranges? For many processors, only one memory
706 operand can be present at a time, so the 2-entry cache wouldn't be
707 constantly churned by code doing heavy memory accesses. */
709 /* Indices in `sorted_syms'. */
710 long min = 0;
711 long max = sorted_symcount;
712 long thisplace;
713 struct objdump_disasm_info *aux;
714 bfd *abfd;
715 asection *sec;
716 unsigned int opb;
717 bfd_boolean want_section;
719 if (sorted_symcount < 1)
720 return NULL;
722 aux = (struct objdump_disasm_info *) info->application_data;
723 abfd = aux->abfd;
724 sec = aux->sec;
725 opb = bfd_octets_per_byte (abfd);
727 /* Perform a binary search looking for the closest symbol to the
728 required value. We are searching the range (min, max]. */
729 while (min + 1 < max)
731 asymbol *sym;
733 thisplace = (max + min) / 2;
734 sym = sorted_syms[thisplace];
736 if (bfd_asymbol_value (sym) > vma)
737 max = thisplace;
738 else if (bfd_asymbol_value (sym) < vma)
739 min = thisplace;
740 else
742 min = thisplace;
743 break;
747 /* The symbol we want is now in min, the low end of the range we
748 were searching. If there are several symbols with the same
749 value, we want the first one. */
750 thisplace = min;
751 while (thisplace > 0
752 && (bfd_asymbol_value (sorted_syms[thisplace])
753 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
754 --thisplace;
756 /* Prefer a symbol in the current section if we have multple symbols
757 with the same value, as can occur with overlays or zero size
758 sections. */
759 min = thisplace;
760 while (min < max
761 && (bfd_asymbol_value (sorted_syms[min])
762 == bfd_asymbol_value (sorted_syms[thisplace])))
764 if (sorted_syms[min]->section == sec
765 && info->symbol_is_valid (sorted_syms[min], info))
767 thisplace = min;
769 if (place != NULL)
770 *place = thisplace;
772 return sorted_syms[thisplace];
774 ++min;
777 /* If the file is relocatable, and the symbol could be from this
778 section, prefer a symbol from this section over symbols from
779 others, even if the other symbol's value might be closer.
781 Note that this may be wrong for some symbol references if the
782 sections have overlapping memory ranges, but in that case there's
783 no way to tell what's desired without looking at the relocation
784 table.
786 Also give the target a chance to reject symbols. */
787 want_section = (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) / opb)));
792 if ((sorted_syms[thisplace]->section != sec && want_section)
793 || !info->symbol_is_valid (sorted_syms[thisplace], info))
795 long i;
796 long newplace = sorted_symcount;
798 for (i = min - 1; i >= 0; i--)
800 if ((sorted_syms[i]->section == sec || !want_section)
801 && info->symbol_is_valid (sorted_syms[i], info))
803 if (newplace == sorted_symcount)
804 newplace = i;
806 if (bfd_asymbol_value (sorted_syms[i])
807 != bfd_asymbol_value (sorted_syms[newplace]))
808 break;
810 /* Remember this symbol and keep searching until we reach
811 an earlier address. */
812 newplace = i;
816 if (newplace != sorted_symcount)
817 thisplace = newplace;
818 else
820 /* We didn't find a good symbol with a smaller value.
821 Look for one with a larger value. */
822 for (i = thisplace + 1; i < sorted_symcount; i++)
824 if ((sorted_syms[i]->section == sec || !want_section)
825 && info->symbol_is_valid (sorted_syms[i], info))
827 thisplace = i;
828 break;
833 if ((sorted_syms[thisplace]->section != sec && want_section)
834 || !info->symbol_is_valid (sorted_syms[thisplace], info))
835 /* There is no suitable symbol. */
836 return NULL;
839 if (place != NULL)
840 *place = thisplace;
842 return sorted_syms[thisplace];
845 /* Print an address and the offset to the nearest symbol. */
847 static void
848 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
849 bfd_vma vma, struct disassemble_info *info,
850 bfd_boolean skip_zeroes)
852 objdump_print_value (vma, info, skip_zeroes);
854 if (sym == NULL)
856 bfd_vma secaddr;
858 (*info->fprintf_func) (info->stream, " <%s",
859 bfd_get_section_name (abfd, sec));
860 secaddr = bfd_get_section_vma (abfd, sec);
861 if (vma < secaddr)
863 (*info->fprintf_func) (info->stream, "-0x");
864 objdump_print_value (secaddr - vma, info, TRUE);
866 else if (vma > secaddr)
868 (*info->fprintf_func) (info->stream, "+0x");
869 objdump_print_value (vma - secaddr, info, TRUE);
871 (*info->fprintf_func) (info->stream, ">");
873 else
875 (*info->fprintf_func) (info->stream, " <");
876 objdump_print_symname (abfd, info, sym);
877 if (bfd_asymbol_value (sym) > vma)
879 (*info->fprintf_func) (info->stream, "-0x");
880 objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
882 else if (vma > bfd_asymbol_value (sym))
884 (*info->fprintf_func) (info->stream, "+0x");
885 objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
887 (*info->fprintf_func) (info->stream, ">");
890 if (display_file_offsets)
891 info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"),
892 (long int)(sec->filepos + (vma - sec->vma)));
895 /* Print an address (VMA), symbolically if possible.
896 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
898 static void
899 objdump_print_addr (bfd_vma vma,
900 struct disassemble_info *info,
901 bfd_boolean skip_zeroes)
903 struct objdump_disasm_info *aux;
904 asymbol *sym = NULL;
905 bfd_boolean skip_find = FALSE;
907 aux = (struct objdump_disasm_info *) info->application_data;
909 if (sorted_symcount < 1)
911 (*info->fprintf_func) (info->stream, "0x");
912 objdump_print_value (vma, info, skip_zeroes);
914 if (display_file_offsets)
915 info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"),
916 (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
917 return;
920 if (aux->reloc != NULL
921 && aux->reloc->sym_ptr_ptr != NULL
922 && * aux->reloc->sym_ptr_ptr != NULL)
924 sym = * aux->reloc->sym_ptr_ptr;
926 /* Adjust the vma to the reloc. */
927 vma += bfd_asymbol_value (sym);
929 if (bfd_is_und_section (bfd_get_section (sym)))
930 skip_find = TRUE;
933 if (!skip_find)
934 sym = find_symbol_for_address (vma, info, NULL);
936 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
937 skip_zeroes);
940 /* Print VMA to INFO. This function is passed to the disassembler
941 routine. */
943 static void
944 objdump_print_address (bfd_vma vma, struct disassemble_info *info)
946 objdump_print_addr (vma, info, ! prefix_addresses);
949 /* Determine if the given address has a symbol associated with it. */
951 static int
952 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
954 asymbol * sym;
956 sym = find_symbol_for_address (vma, info, NULL);
958 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
961 /* Hold the last function name and the last line number we displayed
962 in a disassembly. */
964 static char *prev_functionname;
965 static unsigned int prev_line;
967 /* We keep a list of all files that we have seen when doing a
968 disassembly with source, so that we know how much of the file to
969 display. This can be important for inlined functions. */
971 struct print_file_list
973 struct print_file_list *next;
974 const char *filename;
975 const char *modname;
976 const char *map;
977 size_t mapsize;
978 const char **linemap;
979 unsigned maxline;
980 unsigned last_line;
981 int first;
984 static struct print_file_list *print_files;
986 /* The number of preceding context lines to show when we start
987 displaying a file for the first time. */
989 #define SHOW_PRECEDING_CONTEXT_LINES (5)
991 /* Read a complete file into memory. */
993 static const char *
994 slurp_file (const char *fn, size_t *size)
996 #ifdef HAVE_MMAP
997 int ps = getpagesize ();
998 size_t msize;
999 #endif
1000 const char *map;
1001 struct stat st;
1002 int fd = open (fn, O_RDONLY | O_BINARY);
1004 if (fd < 0)
1005 return NULL;
1006 if (fstat (fd, &st) < 0)
1007 return NULL;
1008 *size = st.st_size;
1009 #ifdef HAVE_MMAP
1010 msize = (*size + ps - 1) & ~(ps - 1);
1011 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
1012 if (map != (char *)-1L)
1014 close(fd);
1015 return map;
1017 #endif
1018 map = malloc (*size);
1019 if (!map || (size_t) read (fd, (char *)map, *size) != *size)
1021 free ((void *)map);
1022 map = NULL;
1024 close (fd);
1025 return map;
1028 #define line_map_decrease 5
1030 /* Precompute array of lines for a mapped file. */
1032 static const char **
1033 index_file (const char *map, size_t size, unsigned int *maxline)
1035 const char *p, *lstart, *end;
1036 int chars_per_line = 45; /* First iteration will use 40. */
1037 unsigned int lineno;
1038 const char **linemap = NULL;
1039 unsigned long line_map_size = 0;
1041 lineno = 0;
1042 lstart = map;
1043 end = map + size;
1045 for (p = map; p < end; p++)
1047 if (*p == '\n')
1049 if (p + 1 < end && p[1] == '\r')
1050 p++;
1052 else if (*p == '\r')
1054 if (p + 1 < end && p[1] == '\n')
1055 p++;
1057 else
1058 continue;
1060 /* End of line found. */
1062 if (linemap == NULL || line_map_size < lineno + 1)
1064 unsigned long newsize;
1066 chars_per_line -= line_map_decrease;
1067 if (chars_per_line <= 1)
1068 chars_per_line = 1;
1069 line_map_size = size / chars_per_line + 1;
1070 if (line_map_size < lineno + 1)
1071 line_map_size = lineno + 1;
1072 newsize = line_map_size * sizeof (char *);
1073 linemap = xrealloc (linemap, newsize);
1076 linemap[lineno++] = lstart;
1077 lstart = p + 1;
1080 *maxline = lineno;
1081 return linemap;
1084 /* Tries to open MODNAME, and if successful adds a node to print_files
1085 linked list and returns that node. Returns NULL on failure. */
1087 static struct print_file_list *
1088 try_print_file_open (const char *origname, const char *modname)
1090 struct print_file_list *p;
1092 p = xmalloc (sizeof (struct print_file_list));
1094 p->map = slurp_file (modname, &p->mapsize);
1095 if (p->map == NULL)
1097 free (p);
1098 return NULL;
1101 p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1102 p->last_line = 0;
1103 p->filename = origname;
1104 p->modname = modname;
1105 p->next = print_files;
1106 p->first = 1;
1107 print_files = p;
1108 return p;
1111 /* If the the source file, as described in the symtab, is not found
1112 try to locate it in one of the paths specified with -I
1113 If found, add location to print_files linked list. */
1115 static struct print_file_list *
1116 update_source_path (const char *filename)
1118 struct print_file_list *p;
1119 const char *fname;
1120 int i;
1122 if (filename == NULL)
1123 return NULL;
1125 p = try_print_file_open (filename, filename);
1126 if (p != NULL)
1127 return p;
1129 if (include_path_count == 0)
1130 return NULL;
1132 /* Get the name of the file. */
1133 fname = strrchr (filename, '/');
1134 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1136 /* We could have a mixed forward/back slash case. */
1137 char *backslash = strrchr (filename, '\\');
1138 if (fname == NULL || (backslash != NULL && backslash > fname))
1139 fname = backslash;
1140 if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
1141 fname = filename + 1;
1143 #endif
1144 if (fname == NULL)
1145 fname = filename;
1146 else
1147 ++fname;
1149 /* If file exists under a new path, we need to add it to the list
1150 so that show_line knows about it. */
1151 for (i = 0; i < include_path_count; i++)
1153 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1155 p = try_print_file_open (filename, modname);
1156 if (p)
1157 return p;
1159 free (modname);
1162 return NULL;
1165 /* Print a source file line. */
1167 static void
1168 print_line (struct print_file_list *p, unsigned int line)
1170 const char *l;
1171 size_t len;
1173 --line;
1174 if (line >= p->maxline)
1175 return;
1176 l = p->linemap [line];
1177 /* Test fwrite return value to quiet glibc warning. */
1178 len = strcspn (l, "\n\r");
1179 if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1180 putchar ('\n');
1183 /* Print a range of source code lines. */
1185 static void
1186 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1188 if (p->map == NULL)
1189 return;
1190 while (start <= end)
1192 print_line (p, start);
1193 start++;
1197 /* Show the line number, or the source line, in a disassembly
1198 listing. */
1200 static void
1201 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1203 const char *filename;
1204 const char *functionname;
1205 unsigned int line;
1206 bfd_boolean reloc;
1208 if (! with_line_numbers && ! with_source_code)
1209 return;
1211 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1212 &functionname, &line))
1213 return;
1215 if (filename != NULL && *filename == '\0')
1216 filename = NULL;
1217 if (functionname != NULL && *functionname == '\0')
1218 functionname = NULL;
1220 if (filename
1221 && IS_ABSOLUTE_PATH (filename)
1222 && prefix)
1224 char *path_up;
1225 const char *fname = filename;
1226 char *path = (char *) alloca (prefix_length + PATH_MAX + 1);
1228 if (prefix_length)
1229 memcpy (path, prefix, prefix_length);
1230 path_up = path + prefix_length;
1232 /* Build relocated filename, stripping off leading directories
1233 from the initial filename if requested. */
1234 if (prefix_strip > 0)
1236 int level = 0;
1237 const char *s;
1239 /* Skip selected directory levels. */
1240 for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1241 if (IS_DIR_SEPARATOR(*s))
1243 fname = s;
1244 level++;
1248 /* Update complete filename. */
1249 strncpy (path_up, fname, PATH_MAX);
1250 path_up[PATH_MAX] = '\0';
1252 filename = path;
1253 reloc = TRUE;
1255 else
1256 reloc = FALSE;
1258 if (with_line_numbers)
1260 if (functionname != NULL
1261 && (prev_functionname == NULL
1262 || strcmp (functionname, prev_functionname) != 0))
1263 printf ("%s():\n", functionname);
1264 if (line > 0 && line != prev_line)
1265 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1268 if (with_source_code
1269 && filename != NULL
1270 && line > 0)
1272 struct print_file_list **pp, *p;
1273 unsigned l;
1275 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1276 if (strcmp ((*pp)->filename, filename) == 0)
1277 break;
1278 p = *pp;
1280 if (p == NULL)
1282 if (reloc)
1283 filename = xstrdup (filename);
1284 p = update_source_path (filename);
1287 if (p != NULL && line != p->last_line)
1289 if (file_start_context && p->first)
1290 l = 1;
1291 else
1293 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1294 if (l >= line)
1295 l = 1;
1296 if (p->last_line >= l && p->last_line <= line)
1297 l = p->last_line + 1;
1299 dump_lines (p, l, line);
1300 p->last_line = line;
1301 p->first = 0;
1305 if (functionname != NULL
1306 && (prev_functionname == NULL
1307 || strcmp (functionname, prev_functionname) != 0))
1309 if (prev_functionname != NULL)
1310 free (prev_functionname);
1311 prev_functionname = xmalloc (strlen (functionname) + 1);
1312 strcpy (prev_functionname, functionname);
1315 if (line > 0 && line != prev_line)
1316 prev_line = line;
1319 /* Pseudo FILE object for strings. */
1320 typedef struct
1322 char *buffer;
1323 size_t pos;
1324 size_t alloc;
1325 } SFILE;
1327 /* sprintf to a "stream". */
1329 static int ATTRIBUTE_PRINTF_2
1330 objdump_sprintf (SFILE *f, const char *format, ...)
1332 size_t n;
1333 va_list args;
1335 while (1)
1337 size_t space = f->alloc - f->pos;
1339 va_start (args, format);
1340 n = vsnprintf (f->buffer + f->pos, space, format, args);
1341 va_end (args);
1343 if (space > n)
1344 break;
1346 f->alloc = (f->alloc + n) * 2;
1347 f->buffer = xrealloc (f->buffer, f->alloc);
1349 f->pos += n;
1351 return n;
1354 /* Returns TRUE if the specified section should be dumped. */
1356 static bfd_boolean
1357 process_section_p (asection * section)
1359 size_t i;
1361 if (only == NULL)
1362 return TRUE;
1364 for (i = 0; i < only_used; i++)
1365 if (strcmp (only [i], section->name) == 0)
1366 return TRUE;
1368 return FALSE;
1372 /* The number of zeroes we want to see before we start skipping them.
1373 The number is arbitrarily chosen. */
1375 #define DEFAULT_SKIP_ZEROES 8
1377 /* The number of zeroes to skip at the end of a section. If the
1378 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1379 SKIP_ZEROES, they will be disassembled. If there are fewer than
1380 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1381 attempt to avoid disassembling zeroes inserted by section
1382 alignment. */
1384 #define DEFAULT_SKIP_ZEROES_AT_END 3
1386 /* Disassemble some data in memory between given values. */
1388 static void
1389 disassemble_bytes (struct disassemble_info * info,
1390 disassembler_ftype disassemble_fn,
1391 bfd_boolean insns,
1392 bfd_byte * data,
1393 bfd_vma start_offset,
1394 bfd_vma stop_offset,
1395 bfd_vma rel_offset,
1396 arelent *** relppp,
1397 arelent ** relppend)
1399 struct objdump_disasm_info *aux;
1400 asection *section;
1401 int octets_per_line;
1402 bfd_boolean done_dot;
1403 int skip_addr_chars;
1404 bfd_vma addr_offset;
1405 unsigned int opb = info->octets_per_byte;
1406 unsigned int skip_zeroes = info->skip_zeroes;
1407 unsigned int skip_zeroes_at_end = info->skip_zeroes_at_end;
1408 int octets = opb;
1409 SFILE sfile;
1411 aux = (struct objdump_disasm_info *) info->application_data;
1412 section = aux->sec;
1414 sfile.alloc = 120;
1415 sfile.buffer = xmalloc (sfile.alloc);
1416 sfile.pos = 0;
1418 if (insns)
1419 octets_per_line = 4;
1420 else
1421 octets_per_line = 16;
1423 /* Figure out how many characters to skip at the start of an
1424 address, to make the disassembly look nicer. We discard leading
1425 zeroes in chunks of 4, ensuring that there is always a leading
1426 zero remaining. */
1427 skip_addr_chars = 0;
1428 if (! prefix_addresses)
1430 char buf[30];
1432 bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1434 while (buf[skip_addr_chars] == '0')
1435 ++skip_addr_chars;
1437 /* Don't discard zeros on overflow. */
1438 if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1439 skip_addr_chars = 0;
1441 if (skip_addr_chars != 0)
1442 skip_addr_chars = (skip_addr_chars - 1) & -4;
1445 info->insn_info_valid = 0;
1447 done_dot = FALSE;
1448 addr_offset = start_offset;
1449 while (addr_offset < stop_offset)
1451 bfd_vma z;
1452 bfd_boolean need_nl = FALSE;
1453 int previous_octets;
1455 /* Remember the length of the previous instruction. */
1456 previous_octets = octets;
1457 octets = 0;
1459 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1460 print `...'. */
1461 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1462 if (data[z] != 0)
1463 break;
1464 if (! disassemble_zeroes
1465 && (info->insn_info_valid == 0
1466 || info->branch_delay_insns == 0)
1467 && (z - addr_offset * opb >= skip_zeroes
1468 || (z == stop_offset * opb &&
1469 z - addr_offset * opb < skip_zeroes_at_end)))
1471 /* If there are more nonzero octets to follow, we only skip
1472 zeroes in multiples of 4, to try to avoid running over
1473 the start of an instruction which happens to start with
1474 zero. */
1475 if (z != stop_offset * opb)
1476 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1478 octets = z - addr_offset * opb;
1480 /* If we are going to display more data, and we are displaying
1481 file offsets, then tell the user how many zeroes we skip
1482 and the file offset from where we resume dumping. */
1483 if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1484 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1485 octets / opb,
1486 (unsigned long) (section->filepos
1487 + (addr_offset + (octets / opb))));
1488 else
1489 printf ("\t...\n");
1491 else
1493 char buf[50];
1494 int bpc = 0;
1495 int pb = 0;
1497 done_dot = FALSE;
1499 if (with_line_numbers || with_source_code)
1500 show_line (aux->abfd, section, addr_offset);
1502 if (! prefix_addresses)
1504 char *s;
1506 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1507 for (s = buf + skip_addr_chars; *s == '0'; s++)
1508 *s = ' ';
1509 if (*s == '\0')
1510 *--s = '0';
1511 printf ("%s:\t", buf + skip_addr_chars);
1513 else
1515 aux->require_sec = TRUE;
1516 objdump_print_address (section->vma + addr_offset, info);
1517 aux->require_sec = FALSE;
1518 putchar (' ');
1521 if (insns)
1523 sfile.pos = 0;
1524 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1525 info->stream = &sfile;
1526 info->bytes_per_line = 0;
1527 info->bytes_per_chunk = 0;
1528 info->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
1529 if (machine)
1530 info->flags |= USER_SPECIFIED_MACHINE_TYPE;
1532 if (info->disassembler_needs_relocs
1533 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1534 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1535 && *relppp < relppend)
1537 bfd_signed_vma distance_to_rel;
1539 distance_to_rel = (**relppp)->address
1540 - (rel_offset + addr_offset);
1542 /* Check to see if the current reloc is associated with
1543 the instruction that we are about to disassemble. */
1544 if (distance_to_rel == 0
1545 /* FIXME: This is wrong. We are trying to catch
1546 relocs that are addressed part way through the
1547 current instruction, as might happen with a packed
1548 VLIW instruction. Unfortunately we do not know the
1549 length of the current instruction since we have not
1550 disassembled it yet. Instead we take a guess based
1551 upon the length of the previous instruction. The
1552 proper solution is to have a new target-specific
1553 disassembler function which just returns the length
1554 of an instruction at a given address without trying
1555 to display its disassembly. */
1556 || (distance_to_rel > 0
1557 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1559 info->flags |= INSN_HAS_RELOC;
1560 aux->reloc = **relppp;
1562 else
1563 aux->reloc = NULL;
1566 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1567 info->fprintf_func = (fprintf_ftype) fprintf;
1568 info->stream = stdout;
1569 if (info->bytes_per_line != 0)
1570 octets_per_line = info->bytes_per_line;
1571 if (octets < 0)
1573 if (sfile.pos)
1574 printf ("%s\n", sfile.buffer);
1575 break;
1578 else
1580 bfd_vma j;
1582 octets = octets_per_line;
1583 if (addr_offset + octets / opb > stop_offset)
1584 octets = (stop_offset - addr_offset) * opb;
1586 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1588 if (ISPRINT (data[j]))
1589 buf[j - addr_offset * opb] = data[j];
1590 else
1591 buf[j - addr_offset * opb] = '.';
1593 buf[j - addr_offset * opb] = '\0';
1596 if (prefix_addresses
1597 ? show_raw_insn > 0
1598 : show_raw_insn >= 0)
1600 bfd_vma j;
1602 /* If ! prefix_addresses and ! wide_output, we print
1603 octets_per_line octets per line. */
1604 pb = octets;
1605 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1606 pb = octets_per_line;
1608 if (info->bytes_per_chunk)
1609 bpc = info->bytes_per_chunk;
1610 else
1611 bpc = 1;
1613 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1615 int k;
1617 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1619 for (k = bpc - 1; k >= 0; k--)
1620 printf ("%02x", (unsigned) data[j + k]);
1621 putchar (' ');
1623 else
1625 for (k = 0; k < bpc; k++)
1626 printf ("%02x", (unsigned) data[j + k]);
1627 putchar (' ');
1631 for (; pb < octets_per_line; pb += bpc)
1633 int k;
1635 for (k = 0; k < bpc; k++)
1636 printf (" ");
1637 putchar (' ');
1640 /* Separate raw data from instruction by extra space. */
1641 if (insns)
1642 putchar ('\t');
1643 else
1644 printf (" ");
1647 if (! insns)
1648 printf ("%s", buf);
1649 else if (sfile.pos)
1650 printf ("%s", sfile.buffer);
1652 if (prefix_addresses
1653 ? show_raw_insn > 0
1654 : show_raw_insn >= 0)
1656 while (pb < octets)
1658 bfd_vma j;
1659 char *s;
1661 putchar ('\n');
1662 j = addr_offset * opb + pb;
1664 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1665 for (s = buf + skip_addr_chars; *s == '0'; s++)
1666 *s = ' ';
1667 if (*s == '\0')
1668 *--s = '0';
1669 printf ("%s:\t", buf + skip_addr_chars);
1671 pb += octets_per_line;
1672 if (pb > octets)
1673 pb = octets;
1674 for (; j < addr_offset * opb + pb; j += bpc)
1676 int k;
1678 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1680 for (k = bpc - 1; k >= 0; k--)
1681 printf ("%02x", (unsigned) data[j + k]);
1682 putchar (' ');
1684 else
1686 for (k = 0; k < bpc; k++)
1687 printf ("%02x", (unsigned) data[j + k]);
1688 putchar (' ');
1694 if (!wide_output)
1695 putchar ('\n');
1696 else
1697 need_nl = TRUE;
1700 while ((*relppp) < relppend
1701 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1703 if (dump_reloc_info || dump_dynamic_reloc_info)
1705 arelent *q;
1707 q = **relppp;
1709 if (wide_output)
1710 putchar ('\t');
1711 else
1712 printf ("\t\t\t");
1714 objdump_print_value (section->vma - rel_offset + q->address,
1715 info, TRUE);
1717 if (q->howto == NULL)
1718 printf (": *unknown*\t");
1719 else if (q->howto->name)
1720 printf (": %s\t", q->howto->name);
1721 else
1722 printf (": %d\t", q->howto->type);
1724 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1725 printf ("*unknown*");
1726 else
1728 const char *sym_name;
1730 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1731 if (sym_name != NULL && *sym_name != '\0')
1732 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1733 else
1735 asection *sym_sec;
1737 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1738 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1739 if (sym_name == NULL || *sym_name == '\0')
1740 sym_name = "*unknown*";
1741 printf ("%s", sym_name);
1745 if (q->addend)
1747 printf ("+0x");
1748 objdump_print_value (q->addend, info, TRUE);
1751 printf ("\n");
1752 need_nl = FALSE;
1754 ++(*relppp);
1757 if (need_nl)
1758 printf ("\n");
1760 addr_offset += octets / opb;
1763 free (sfile.buffer);
1766 static void
1767 disassemble_section (bfd *abfd, asection *section, void *info)
1769 const struct elf_backend_data * bed;
1770 bfd_vma sign_adjust = 0;
1771 struct disassemble_info * pinfo = (struct disassemble_info *) info;
1772 struct objdump_disasm_info * paux;
1773 unsigned int opb = pinfo->octets_per_byte;
1774 bfd_byte * data = NULL;
1775 bfd_size_type datasize = 0;
1776 arelent ** rel_pp = NULL;
1777 arelent ** rel_ppstart = NULL;
1778 arelent ** rel_ppend;
1779 unsigned long stop_offset;
1780 asymbol * sym = NULL;
1781 long place = 0;
1782 long rel_count;
1783 bfd_vma rel_offset;
1784 unsigned long addr_offset;
1786 /* Sections that do not contain machine
1787 code are not normally disassembled. */
1788 if (! disassemble_all
1789 && only == NULL
1790 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1791 != (SEC_CODE | SEC_HAS_CONTENTS)))
1792 return;
1794 if (! process_section_p (section))
1795 return;
1797 datasize = bfd_get_section_size (section);
1798 if (datasize == 0)
1799 return;
1801 /* Decide which set of relocs to use. Load them if necessary. */
1802 paux = (struct objdump_disasm_info *) pinfo->application_data;
1803 if (paux->dynrelbuf)
1805 rel_pp = paux->dynrelbuf;
1806 rel_count = paux->dynrelcount;
1807 /* Dynamic reloc addresses are absolute, non-dynamic are section
1808 relative. REL_OFFSET specifies the reloc address corresponding
1809 to the start of this section. */
1810 rel_offset = section->vma;
1812 else
1814 rel_count = 0;
1815 rel_pp = NULL;
1816 rel_offset = 0;
1818 if ((section->flags & SEC_RELOC) != 0
1819 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1821 long relsize;
1823 relsize = bfd_get_reloc_upper_bound (abfd, section);
1824 if (relsize < 0)
1825 bfd_fatal (bfd_get_filename (abfd));
1827 if (relsize > 0)
1829 rel_ppstart = rel_pp = xmalloc (relsize);
1830 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1831 if (rel_count < 0)
1832 bfd_fatal (bfd_get_filename (abfd));
1834 /* Sort the relocs by address. */
1835 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1839 rel_ppend = rel_pp + rel_count;
1841 data = xmalloc (datasize);
1843 bfd_get_section_contents (abfd, section, data, 0, datasize);
1845 paux->sec = section;
1846 pinfo->buffer = data;
1847 pinfo->buffer_vma = section->vma;
1848 pinfo->buffer_length = datasize;
1849 pinfo->section = section;
1851 if (start_address == (bfd_vma) -1
1852 || start_address < pinfo->buffer_vma)
1853 addr_offset = 0;
1854 else
1855 addr_offset = start_address - pinfo->buffer_vma;
1857 if (stop_address == (bfd_vma) -1)
1858 stop_offset = datasize / opb;
1859 else
1861 if (stop_address < pinfo->buffer_vma)
1862 stop_offset = 0;
1863 else
1864 stop_offset = stop_address - pinfo->buffer_vma;
1865 if (stop_offset > pinfo->buffer_length / opb)
1866 stop_offset = pinfo->buffer_length / opb;
1869 /* Skip over the relocs belonging to addresses below the
1870 start address. */
1871 while (rel_pp < rel_ppend
1872 && (*rel_pp)->address < rel_offset + addr_offset)
1873 ++rel_pp;
1875 if (addr_offset < stop_offset)
1876 printf (_("\nDisassembly of section %s:\n"), section->name);
1878 /* Find the nearest symbol forwards from our current position. */
1879 paux->require_sec = TRUE;
1880 sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1881 paux->require_sec = FALSE;
1883 /* PR 9774: If the target used signed 32-bit addresses then we must make
1884 sure that we sign extend the value that we calculate for 'addr' in the
1885 loop below. */
1886 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1887 && (bed = get_elf_backend_data (abfd)) != NULL
1888 && bed->sign_extend_vma)
1889 sign_adjust = 0x80000000;
1891 /* Disassemble a block of instructions up to the address associated with
1892 the symbol we have just found. Then print the symbol and find the
1893 next symbol on. Repeat until we have disassembled the entire section
1894 or we have reached the end of the address range we are interested in. */
1895 while (addr_offset < stop_offset)
1897 bfd_vma addr;
1898 asymbol *nextsym;
1899 unsigned long nextstop_offset;
1900 bfd_boolean insns;
1902 addr = section->vma + addr_offset;
1903 addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
1905 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1907 int x;
1909 for (x = place;
1910 (x < sorted_symcount
1911 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1912 ++x)
1913 continue;
1915 pinfo->symbols = sorted_syms + place;
1916 pinfo->num_symbols = x - place;
1917 pinfo->symtab_pos = place;
1919 else
1921 pinfo->symbols = NULL;
1922 pinfo->num_symbols = 0;
1923 pinfo->symtab_pos = -1;
1926 if (! prefix_addresses)
1928 pinfo->fprintf_func (pinfo->stream, "\n");
1929 objdump_print_addr_with_sym (abfd, section, sym, addr,
1930 pinfo, FALSE);
1931 pinfo->fprintf_func (pinfo->stream, ":\n");
1934 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1935 nextsym = sym;
1936 else if (sym == NULL)
1937 nextsym = NULL;
1938 else
1940 #define is_valid_next_sym(SYM) \
1941 ((SYM)->section == section \
1942 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1943 && pinfo->symbol_is_valid (SYM, pinfo))
1945 /* Search forward for the next appropriate symbol in
1946 SECTION. Note that all the symbols are sorted
1947 together into one big array, and that some sections
1948 may have overlapping addresses. */
1949 while (place < sorted_symcount
1950 && ! is_valid_next_sym (sorted_syms [place]))
1951 ++place;
1953 if (place >= sorted_symcount)
1954 nextsym = NULL;
1955 else
1956 nextsym = sorted_syms[place];
1959 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1960 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1961 else if (nextsym == NULL)
1962 nextstop_offset = stop_offset;
1963 else
1964 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1966 if (nextstop_offset > stop_offset
1967 || nextstop_offset <= addr_offset)
1968 nextstop_offset = stop_offset;
1970 /* If a symbol is explicitly marked as being an object
1971 rather than a function, just dump the bytes without
1972 disassembling them. */
1973 if (disassemble_all
1974 || sym == NULL
1975 || sym->section != section
1976 || bfd_asymbol_value (sym) > addr
1977 || ((sym->flags & BSF_OBJECT) == 0
1978 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1979 == NULL)
1980 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1981 == NULL))
1982 || (sym->flags & BSF_FUNCTION) != 0)
1983 insns = TRUE;
1984 else
1985 insns = FALSE;
1987 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1988 addr_offset, nextstop_offset,
1989 rel_offset, &rel_pp, rel_ppend);
1991 addr_offset = nextstop_offset;
1992 sym = nextsym;
1995 free (data);
1997 if (rel_ppstart != NULL)
1998 free (rel_ppstart);
2001 /* Disassemble the contents of an object file. */
2003 static void
2004 disassemble_data (bfd *abfd)
2006 struct disassemble_info disasm_info;
2007 struct objdump_disasm_info aux;
2008 long i;
2010 print_files = NULL;
2011 prev_functionname = NULL;
2012 prev_line = -1;
2014 /* We make a copy of syms to sort. We don't want to sort syms
2015 because that will screw up the relocs. */
2016 sorted_symcount = symcount ? symcount : dynsymcount;
2017 sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
2018 memcpy (sorted_syms, symcount ? syms : dynsyms,
2019 sorted_symcount * sizeof (asymbol *));
2021 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2023 for (i = 0; i < synthcount; ++i)
2025 sorted_syms[sorted_symcount] = synthsyms + i;
2026 ++sorted_symcount;
2029 /* Sort the symbols into section and symbol order. */
2030 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2032 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2034 disasm_info.application_data = (void *) &aux;
2035 aux.abfd = abfd;
2036 aux.require_sec = FALSE;
2037 aux.dynrelbuf = NULL;
2038 aux.dynrelcount = 0;
2039 aux.reloc = NULL;
2041 disasm_info.print_address_func = objdump_print_address;
2042 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2044 if (machine != NULL)
2046 const bfd_arch_info_type *info = bfd_scan_arch (machine);
2048 if (info == NULL)
2049 fatal (_("Can't use supplied machine %s"), machine);
2051 abfd->arch_info = info;
2054 if (endian != BFD_ENDIAN_UNKNOWN)
2056 struct bfd_target *xvec;
2058 xvec = xmalloc (sizeof (struct bfd_target));
2059 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2060 xvec->byteorder = endian;
2061 abfd->xvec = xvec;
2064 /* Use libopcodes to locate a suitable disassembler. */
2065 aux.disassemble_fn = disassembler (abfd);
2066 if (!aux.disassemble_fn)
2068 non_fatal (_("Can't disassemble for architecture %s\n"),
2069 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2070 exit_status = 1;
2071 return;
2074 disasm_info.flavour = bfd_get_flavour (abfd);
2075 disasm_info.arch = bfd_get_arch (abfd);
2076 disasm_info.mach = bfd_get_mach (abfd);
2077 disasm_info.disassembler_options = disassembler_options;
2078 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2079 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2080 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2081 disasm_info.disassembler_needs_relocs = FALSE;
2083 if (bfd_big_endian (abfd))
2084 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2085 else if (bfd_little_endian (abfd))
2086 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2087 else
2088 /* ??? Aborting here seems too drastic. We could default to big or little
2089 instead. */
2090 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2092 /* Allow the target to customize the info structure. */
2093 disassemble_init_for_target (& disasm_info);
2095 /* Pre-load the dynamic relocs if we are going
2096 to be dumping them along with the disassembly. */
2097 if (dump_dynamic_reloc_info)
2099 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2101 if (relsize < 0)
2102 bfd_fatal (bfd_get_filename (abfd));
2104 if (relsize > 0)
2106 aux.dynrelbuf = xmalloc (relsize);
2107 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2108 aux.dynrelbuf,
2109 dynsyms);
2110 if (aux.dynrelcount < 0)
2111 bfd_fatal (bfd_get_filename (abfd));
2113 /* Sort the relocs by address. */
2114 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2115 compare_relocs);
2118 disasm_info.symtab = sorted_syms;
2119 disasm_info.symtab_size = sorted_symcount;
2121 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2123 if (aux.dynrelbuf != NULL)
2124 free (aux.dynrelbuf);
2125 free (sorted_syms);
2128 static int
2129 load_specific_debug_section (enum dwarf_section_display_enum debug,
2130 asection *sec, void *file)
2132 struct dwarf_section *section = &debug_displays [debug].section;
2133 bfd *abfd = file;
2134 bfd_boolean ret;
2135 int section_is_compressed;
2137 /* If it is already loaded, do nothing. */
2138 if (section->start != NULL)
2139 return 1;
2141 section_is_compressed = section->name == section->compressed_name;
2143 section->address = 0;
2144 section->size = bfd_get_section_size (sec);
2145 section->start = xmalloc (section->size);
2147 if (is_relocatable && debug_displays [debug].relocate)
2148 ret = bfd_simple_get_relocated_section_contents (abfd,
2149 sec,
2150 section->start,
2151 syms) != NULL;
2152 else
2153 ret = bfd_get_section_contents (abfd, sec, section->start, 0,
2154 section->size);
2156 if (! ret)
2158 free_debug_section (debug);
2159 printf (_("\nCan't get contents for section '%s'.\n"),
2160 section->name);
2161 return 0;
2164 if (section_is_compressed)
2166 bfd_size_type size = section->size;
2167 if (! bfd_uncompress_section_contents (&section->start, &size))
2169 free_debug_section (debug);
2170 printf (_("\nCan't uncompress section '%s'.\n"), section->name);
2171 return 0;
2173 section->size = size;
2176 return 1;
2180 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2182 struct dwarf_section *section = &debug_displays [debug].section;
2183 bfd *abfd = file;
2184 asection *sec;
2186 /* If it is already loaded, do nothing. */
2187 if (section->start != NULL)
2188 return 1;
2190 /* Locate the debug section. */
2191 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2192 if (sec != NULL)
2193 section->name = section->uncompressed_name;
2194 else
2196 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2197 if (sec != NULL)
2198 section->name = section->compressed_name;
2200 if (sec == NULL)
2201 return 0;
2203 return load_specific_debug_section (debug, sec, file);
2206 void
2207 free_debug_section (enum dwarf_section_display_enum debug)
2209 struct dwarf_section *section = &debug_displays [debug].section;
2211 if (section->start == NULL)
2212 return;
2214 free ((char *) section->start);
2215 section->start = NULL;
2216 section->address = 0;
2217 section->size = 0;
2220 static void
2221 dump_dwarf_section (bfd *abfd, asection *section,
2222 void *arg ATTRIBUTE_UNUSED)
2224 const char *name = bfd_get_section_name (abfd, section);
2225 const char *match;
2226 enum dwarf_section_display_enum i;
2228 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2229 match = ".debug_info";
2230 else
2231 match = name;
2233 for (i = 0; i < max; i++)
2234 if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2235 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2236 && debug_displays [i].enabled != NULL
2237 && *debug_displays [i].enabled)
2239 if (!debug_displays [i].eh_frame)
2241 struct dwarf_section *sec = &debug_displays [i].section;
2243 if (strcmp (sec->uncompressed_name, match) == 0)
2244 sec->name = sec->uncompressed_name;
2245 else
2246 sec->name = sec->compressed_name;
2247 if (load_specific_debug_section (i, section, abfd))
2249 debug_displays [i].display (sec, abfd);
2251 if (i != info && i != abbrev)
2252 free_debug_section (i);
2255 break;
2259 /* Dump the dwarf debugging information. */
2261 static void
2262 dump_dwarf (bfd *abfd)
2264 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2266 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2267 targets will return 64. */
2268 eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2270 if (bfd_big_endian (abfd))
2271 byte_get = byte_get_big_endian;
2272 else if (bfd_little_endian (abfd))
2273 byte_get = byte_get_little_endian;
2274 else
2275 abort ();
2277 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2279 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2280 init_dwarf_regnames (bed->elf_machine_code);
2283 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2285 free_debug_memory ();
2288 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2289 it. Return NULL on failure. */
2291 static char *
2292 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2294 asection *stabsect;
2295 bfd_size_type size;
2296 char *contents;
2298 stabsect = bfd_get_section_by_name (abfd, sect_name);
2299 if (stabsect == NULL)
2301 printf (_("No %s section present\n\n"), sect_name);
2302 return FALSE;
2305 size = bfd_section_size (abfd, stabsect);
2306 contents = xmalloc (size);
2308 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2310 non_fatal (_("Reading %s section of %s failed: %s"),
2311 sect_name, bfd_get_filename (abfd),
2312 bfd_errmsg (bfd_get_error ()));
2313 free (contents);
2314 exit_status = 1;
2315 return NULL;
2318 *size_ptr = size;
2320 return contents;
2323 /* Stabs entries use a 12 byte format:
2324 4 byte string table index
2325 1 byte stab type
2326 1 byte stab other field
2327 2 byte stab desc field
2328 4 byte stab value
2329 FIXME: This will have to change for a 64 bit object format. */
2331 #define STRDXOFF (0)
2332 #define TYPEOFF (4)
2333 #define OTHEROFF (5)
2334 #define DESCOFF (6)
2335 #define VALOFF (8)
2336 #define STABSIZE (12)
2338 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2339 using string table section STRSECT_NAME (in `strtab'). */
2341 static void
2342 print_section_stabs (bfd *abfd,
2343 const char *stabsect_name,
2344 unsigned *string_offset_ptr)
2346 int i;
2347 unsigned file_string_table_offset = 0;
2348 unsigned next_file_string_table_offset = *string_offset_ptr;
2349 bfd_byte *stabp, *stabs_end;
2351 stabp = stabs;
2352 stabs_end = stabp + stab_size;
2354 printf (_("Contents of %s section:\n\n"), stabsect_name);
2355 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2357 /* Loop through all symbols and print them.
2359 We start the index at -1 because there is a dummy symbol on
2360 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2361 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2363 const char *name;
2364 unsigned long strx;
2365 unsigned char type, other;
2366 unsigned short desc;
2367 bfd_vma value;
2369 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2370 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2371 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2372 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2373 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2375 printf ("\n%-6d ", i);
2376 /* Either print the stab name, or, if unnamed, print its number
2377 again (makes consistent formatting for tools like awk). */
2378 name = bfd_get_stab_name (type);
2379 if (name != NULL)
2380 printf ("%-6s", name);
2381 else if (type == N_UNDF)
2382 printf ("HdrSym");
2383 else
2384 printf ("%-6d", type);
2385 printf (" %-6d %-6d ", other, desc);
2386 bfd_printf_vma (abfd, value);
2387 printf (" %-6lu", strx);
2389 /* Symbols with type == 0 (N_UNDF) specify the length of the
2390 string table associated with this file. We use that info
2391 to know how to relocate the *next* file's string table indices. */
2392 if (type == N_UNDF)
2394 file_string_table_offset = next_file_string_table_offset;
2395 next_file_string_table_offset += value;
2397 else
2399 /* Using the (possibly updated) string table offset, print the
2400 string (if any) associated with this symbol. */
2401 if ((strx + file_string_table_offset) < stabstr_size)
2402 printf (" %s", &strtab[strx + file_string_table_offset]);
2403 else
2404 printf (" *");
2407 printf ("\n\n");
2408 *string_offset_ptr = next_file_string_table_offset;
2411 typedef struct
2413 const char * section_name;
2414 const char * string_section_name;
2415 unsigned string_offset;
2417 stab_section_names;
2419 static void
2420 find_stabs_section (bfd *abfd, asection *section, void *names)
2422 int len;
2423 stab_section_names * sought = (stab_section_names *) names;
2425 /* Check for section names for which stabsect_name is a prefix, to
2426 handle .stab.N, etc. */
2427 len = strlen (sought->section_name);
2429 /* If the prefix matches, and the files section name ends with a
2430 nul or a digit, then we match. I.e., we want either an exact
2431 match or a section followed by a number. */
2432 if (strncmp (sought->section_name, section->name, len) == 0
2433 && (section->name[len] == 0
2434 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2436 if (strtab == NULL)
2437 strtab = read_section_stabs (abfd, sought->string_section_name,
2438 &stabstr_size);
2440 if (strtab)
2442 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2443 &stab_size);
2444 if (stabs)
2445 print_section_stabs (abfd, section->name, &sought->string_offset);
2450 static void
2451 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2453 stab_section_names s;
2455 s.section_name = stabsect_name;
2456 s.string_section_name = strsect_name;
2457 s.string_offset = 0;
2459 bfd_map_over_sections (abfd, find_stabs_section, & s);
2461 free (strtab);
2462 strtab = NULL;
2465 /* Dump the any sections containing stabs debugging information. */
2467 static void
2468 dump_stabs (bfd *abfd)
2470 dump_stabs_section (abfd, ".stab", ".stabstr");
2471 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2472 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2474 /* For Darwin. */
2475 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2477 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2480 static void
2481 dump_bfd_header (bfd *abfd)
2483 char *comma = "";
2485 printf (_("architecture: %s, "),
2486 bfd_printable_arch_mach (bfd_get_arch (abfd),
2487 bfd_get_mach (abfd)));
2488 printf (_("flags 0x%08x:\n"), abfd->flags);
2490 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2491 PF (HAS_RELOC, "HAS_RELOC");
2492 PF (EXEC_P, "EXEC_P");
2493 PF (HAS_LINENO, "HAS_LINENO");
2494 PF (HAS_DEBUG, "HAS_DEBUG");
2495 PF (HAS_SYMS, "HAS_SYMS");
2496 PF (HAS_LOCALS, "HAS_LOCALS");
2497 PF (DYNAMIC, "DYNAMIC");
2498 PF (WP_TEXT, "WP_TEXT");
2499 PF (D_PAGED, "D_PAGED");
2500 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2501 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2502 printf (_("\nstart address 0x"));
2503 bfd_printf_vma (abfd, abfd->start_address);
2504 printf ("\n");
2508 static void
2509 dump_bfd_private_header (bfd *abfd)
2511 bfd_print_private_bfd_data (abfd, stdout);
2515 /* Display a section in hexadecimal format with associated characters.
2516 Each line prefixed by the zero padded address. */
2518 static void
2519 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2521 bfd_byte *data = 0;
2522 bfd_size_type datasize;
2523 bfd_size_type addr_offset;
2524 bfd_size_type start_offset;
2525 bfd_size_type stop_offset;
2526 unsigned int opb = bfd_octets_per_byte (abfd);
2527 /* Bytes per line. */
2528 const int onaline = 16;
2529 char buf[64];
2530 int count;
2531 int width;
2533 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2534 return;
2536 if (! process_section_p (section))
2537 return;
2539 if ((datasize = bfd_section_size (abfd, section)) == 0)
2540 return;
2542 /* Compute the address range to display. */
2543 if (start_address == (bfd_vma) -1
2544 || start_address < section->vma)
2545 start_offset = 0;
2546 else
2547 start_offset = start_address - section->vma;
2549 if (stop_address == (bfd_vma) -1)
2550 stop_offset = datasize / opb;
2551 else
2553 if (stop_address < section->vma)
2554 stop_offset = 0;
2555 else
2556 stop_offset = stop_address - section->vma;
2558 if (stop_offset > datasize / opb)
2559 stop_offset = datasize / opb;
2562 if (start_offset >= stop_offset)
2563 return;
2565 printf (_("Contents of section %s:"), section->name);
2566 if (display_file_offsets)
2567 printf (_(" (Starting at file offset: 0x%lx)"),
2568 (unsigned long) (section->filepos + start_offset));
2569 printf ("\n");
2571 data = xmalloc (datasize);
2573 bfd_get_section_contents (abfd, section, data, 0, datasize);
2575 width = 4;
2577 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2578 if (strlen (buf) >= sizeof (buf))
2579 abort ();
2581 count = 0;
2582 while (buf[count] == '0' && buf[count+1] != '\0')
2583 count++;
2584 count = strlen (buf) - count;
2585 if (count > width)
2586 width = count;
2588 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2589 if (strlen (buf) >= sizeof (buf))
2590 abort ();
2592 count = 0;
2593 while (buf[count] == '0' && buf[count+1] != '\0')
2594 count++;
2595 count = strlen (buf) - count;
2596 if (count > width)
2597 width = count;
2599 for (addr_offset = start_offset;
2600 addr_offset < stop_offset; addr_offset += onaline / opb)
2602 bfd_size_type j;
2604 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2605 count = strlen (buf);
2606 if ((size_t) count >= sizeof (buf))
2607 abort ();
2609 putchar (' ');
2610 while (count < width)
2612 putchar ('0');
2613 count++;
2615 fputs (buf + count - width, stdout);
2616 putchar (' ');
2618 for (j = addr_offset * opb;
2619 j < addr_offset * opb + onaline; j++)
2621 if (j < stop_offset * opb)
2622 printf ("%02x", (unsigned) (data[j]));
2623 else
2624 printf (" ");
2625 if ((j & 3) == 3)
2626 printf (" ");
2629 printf (" ");
2630 for (j = addr_offset * opb;
2631 j < addr_offset * opb + onaline; j++)
2633 if (j >= stop_offset * opb)
2634 printf (" ");
2635 else
2636 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2638 putchar ('\n');
2640 free (data);
2643 /* Actually display the various requested regions. */
2645 static void
2646 dump_data (bfd *abfd)
2648 bfd_map_over_sections (abfd, dump_section, NULL);
2651 /* Should perhaps share code and display with nm? */
2653 static void
2654 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2656 asymbol **current;
2657 long max;
2658 long count;
2660 if (dynamic)
2662 current = dynsyms;
2663 max = dynsymcount;
2664 printf ("DYNAMIC SYMBOL TABLE:\n");
2666 else
2668 current = syms;
2669 max = symcount;
2670 printf ("SYMBOL TABLE:\n");
2673 if (max == 0)
2674 printf (_("no symbols\n"));
2676 for (count = 0; count < max; count++)
2678 bfd *cur_bfd;
2680 if (*current == NULL)
2681 printf (_("no information for symbol number %ld\n"), count);
2683 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2684 printf (_("could not determine the type of symbol number %ld\n"),
2685 count);
2687 else if (process_section_p ((* current)->section)
2688 && (dump_special_syms
2689 || !bfd_is_target_special_symbol (cur_bfd, *current)))
2691 const char *name = (*current)->name;
2693 if (do_demangle && name != NULL && *name != '\0')
2695 char *alloc;
2697 /* If we want to demangle the name, we demangle it
2698 here, and temporarily clobber it while calling
2699 bfd_print_symbol. FIXME: This is a gross hack. */
2700 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2701 if (alloc != NULL)
2702 (*current)->name = alloc;
2703 bfd_print_symbol (cur_bfd, stdout, *current,
2704 bfd_print_symbol_all);
2705 if (alloc != NULL)
2707 (*current)->name = name;
2708 free (alloc);
2711 else
2712 bfd_print_symbol (cur_bfd, stdout, *current,
2713 bfd_print_symbol_all);
2714 printf ("\n");
2717 current++;
2719 printf ("\n\n");
2722 static void
2723 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2725 arelent **p;
2726 char *last_filename, *last_functionname;
2727 unsigned int last_line;
2729 /* Get column headers lined up reasonably. */
2731 static int width;
2733 if (width == 0)
2735 char buf[30];
2737 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2738 width = strlen (buf) - 7;
2740 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2743 last_filename = NULL;
2744 last_functionname = NULL;
2745 last_line = 0;
2747 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2749 arelent *q = *p;
2750 const char *filename, *functionname;
2751 unsigned int line;
2752 const char *sym_name;
2753 const char *section_name;
2755 if (start_address != (bfd_vma) -1
2756 && q->address < start_address)
2757 continue;
2758 if (stop_address != (bfd_vma) -1
2759 && q->address > stop_address)
2760 continue;
2762 if (with_line_numbers
2763 && sec != NULL
2764 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2765 &filename, &functionname, &line))
2767 if (functionname != NULL
2768 && (last_functionname == NULL
2769 || strcmp (functionname, last_functionname) != 0))
2771 printf ("%s():\n", functionname);
2772 if (last_functionname != NULL)
2773 free (last_functionname);
2774 last_functionname = xstrdup (functionname);
2777 if (line > 0
2778 && (line != last_line
2779 || (filename != NULL
2780 && last_filename != NULL
2781 && strcmp (filename, last_filename) != 0)))
2783 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2784 last_line = line;
2785 if (last_filename != NULL)
2786 free (last_filename);
2787 if (filename == NULL)
2788 last_filename = NULL;
2789 else
2790 last_filename = xstrdup (filename);
2794 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2796 sym_name = (*(q->sym_ptr_ptr))->name;
2797 section_name = (*(q->sym_ptr_ptr))->section->name;
2799 else
2801 sym_name = NULL;
2802 section_name = NULL;
2805 bfd_printf_vma (abfd, q->address);
2806 if (q->howto == NULL)
2807 printf (" *unknown* ");
2808 else if (q->howto->name)
2809 printf (" %-16s ", q->howto->name);
2810 else
2811 printf (" %-16d ", q->howto->type);
2813 if (sym_name)
2815 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2817 else
2819 if (section_name == NULL)
2820 section_name = "*unknown*";
2821 printf ("[%s]", section_name);
2824 if (q->addend)
2826 printf ("+0x");
2827 bfd_printf_vma (abfd, q->addend);
2830 printf ("\n");
2834 static void
2835 dump_relocs_in_section (bfd *abfd,
2836 asection *section,
2837 void *dummy ATTRIBUTE_UNUSED)
2839 arelent **relpp;
2840 long relcount;
2841 long relsize;
2843 if ( bfd_is_abs_section (section)
2844 || bfd_is_und_section (section)
2845 || bfd_is_com_section (section)
2846 || (! process_section_p (section))
2847 || ((section->flags & SEC_RELOC) == 0))
2848 return;
2850 relsize = bfd_get_reloc_upper_bound (abfd, section);
2851 if (relsize < 0)
2852 bfd_fatal (bfd_get_filename (abfd));
2854 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2856 if (relsize == 0)
2858 printf (" (none)\n\n");
2859 return;
2862 relpp = xmalloc (relsize);
2863 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2865 if (relcount < 0)
2866 bfd_fatal (bfd_get_filename (abfd));
2867 else if (relcount == 0)
2868 printf (" (none)\n\n");
2869 else
2871 printf ("\n");
2872 dump_reloc_set (abfd, section, relpp, relcount);
2873 printf ("\n\n");
2875 free (relpp);
2878 static void
2879 dump_relocs (bfd *abfd)
2881 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2884 static void
2885 dump_dynamic_relocs (bfd *abfd)
2887 long relsize;
2888 arelent **relpp;
2889 long relcount;
2891 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2892 if (relsize < 0)
2893 bfd_fatal (bfd_get_filename (abfd));
2895 printf ("DYNAMIC RELOCATION RECORDS");
2897 if (relsize == 0)
2898 printf (" (none)\n\n");
2899 else
2901 relpp = xmalloc (relsize);
2902 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2904 if (relcount < 0)
2905 bfd_fatal (bfd_get_filename (abfd));
2906 else if (relcount == 0)
2907 printf (" (none)\n\n");
2908 else
2910 printf ("\n");
2911 dump_reloc_set (abfd, NULL, relpp, relcount);
2912 printf ("\n\n");
2914 free (relpp);
2918 /* Creates a table of paths, to search for source files. */
2920 static void
2921 add_include_path (const char *path)
2923 if (path[0] == 0)
2924 return;
2925 include_path_count++;
2926 include_paths = xrealloc (include_paths,
2927 include_path_count * sizeof (*include_paths));
2928 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2929 if (path[1] == ':' && path[2] == 0)
2930 path = concat (path, ".", (const char *) 0);
2931 #endif
2932 include_paths[include_path_count - 1] = path;
2935 static void
2936 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2937 asection *section,
2938 void *arg)
2940 if ((section->flags & SEC_DEBUGGING) == 0)
2942 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2943 section->vma += adjust_section_vma;
2944 if (*has_reloc_p)
2945 section->lma += adjust_section_vma;
2949 /* Dump selected contents of ABFD. */
2951 static void
2952 dump_bfd (bfd *abfd)
2954 /* If we are adjusting section VMA's, change them all now. Changing
2955 the BFD information is a hack. However, we must do it, or
2956 bfd_find_nearest_line will not do the right thing. */
2957 if (adjust_section_vma != 0)
2959 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2960 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2963 if (! dump_debugging_tags)
2964 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2965 abfd->xvec->name);
2966 if (dump_ar_hdrs)
2967 print_arelt_descr (stdout, abfd, TRUE);
2968 if (dump_file_header)
2969 dump_bfd_header (abfd);
2970 if (dump_private_headers)
2971 dump_bfd_private_header (abfd);
2972 if (! dump_debugging_tags)
2973 putchar ('\n');
2974 if (dump_section_headers)
2975 dump_headers (abfd);
2977 if (dump_symtab
2978 || dump_reloc_info
2979 || disassemble
2980 || dump_debugging
2981 || dump_dwarf_section_info)
2982 syms = slurp_symtab (abfd);
2983 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2984 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2985 dynsyms = slurp_dynamic_symtab (abfd);
2986 if (disassemble)
2988 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2989 dynsymcount, dynsyms, &synthsyms);
2990 if (synthcount < 0)
2991 synthcount = 0;
2994 if (dump_symtab)
2995 dump_symbols (abfd, FALSE);
2996 if (dump_dynamic_symtab)
2997 dump_symbols (abfd, TRUE);
2998 if (dump_dwarf_section_info)
2999 dump_dwarf (abfd);
3000 if (dump_stab_section_info)
3001 dump_stabs (abfd);
3002 if (dump_reloc_info && ! disassemble)
3003 dump_relocs (abfd);
3004 if (dump_dynamic_reloc_info && ! disassemble)
3005 dump_dynamic_relocs (abfd);
3006 if (dump_section_contents)
3007 dump_data (abfd);
3008 if (disassemble)
3009 disassemble_data (abfd);
3011 if (dump_debugging)
3013 void *dhandle;
3015 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3016 if (dhandle != NULL)
3018 if (!print_debugging_info (stdout, dhandle, abfd, syms,
3019 bfd_demangle,
3020 dump_debugging_tags ? TRUE : FALSE))
3022 non_fatal (_("%s: printing debugging information failed"),
3023 bfd_get_filename (abfd));
3024 exit_status = 1;
3027 /* PR 6483: If there was no STABS or IEEE debug
3028 info in the file, try DWARF instead. */
3029 else if (! dump_dwarf_section_info)
3031 dump_dwarf (abfd);
3035 if (syms)
3037 free (syms);
3038 syms = NULL;
3041 if (dynsyms)
3043 free (dynsyms);
3044 dynsyms = NULL;
3047 if (synthsyms)
3049 free (synthsyms);
3050 synthsyms = NULL;
3053 symcount = 0;
3054 dynsymcount = 0;
3055 synthcount = 0;
3058 static void
3059 display_bfd (bfd *abfd)
3061 char **matching;
3063 if (bfd_check_format_matches (abfd, bfd_object, &matching))
3065 dump_bfd (abfd);
3066 return;
3069 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3071 nonfatal (bfd_get_filename (abfd));
3072 list_matching_formats (matching);
3073 free (matching);
3074 return;
3077 if (bfd_get_error () != bfd_error_file_not_recognized)
3079 nonfatal (bfd_get_filename (abfd));
3080 return;
3083 if (bfd_check_format_matches (abfd, bfd_core, &matching))
3085 dump_bfd (abfd);
3086 return;
3089 nonfatal (bfd_get_filename (abfd));
3091 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3093 list_matching_formats (matching);
3094 free (matching);
3098 static void
3099 display_file (char *filename, char *target)
3101 bfd *file;
3102 bfd *arfile = NULL;
3104 if (get_file_size (filename) < 1)
3106 exit_status = 1;
3107 return;
3110 file = bfd_openr (filename, target);
3111 if (file == NULL)
3113 nonfatal (filename);
3114 return;
3117 /* If the file is an archive, process all of its elements. */
3118 if (bfd_check_format (file, bfd_archive))
3120 bfd *last_arfile = NULL;
3122 printf (_("In archive %s:\n"), bfd_get_filename (file));
3123 for (;;)
3125 bfd_set_error (bfd_error_no_error);
3127 arfile = bfd_openr_next_archived_file (file, arfile);
3128 if (arfile == NULL)
3130 if (bfd_get_error () != bfd_error_no_more_archived_files)
3131 nonfatal (bfd_get_filename (file));
3132 break;
3135 display_bfd (arfile);
3137 if (last_arfile != NULL)
3138 bfd_close (last_arfile);
3139 last_arfile = arfile;
3142 if (last_arfile != NULL)
3143 bfd_close (last_arfile);
3145 else
3146 display_bfd (file);
3148 bfd_close (file);
3152 main (int argc, char **argv)
3154 int c;
3155 char *target = default_target;
3156 bfd_boolean seenflag = FALSE;
3158 #if defined (HAVE_SETLOCALE)
3159 #if defined (HAVE_LC_MESSAGES)
3160 setlocale (LC_MESSAGES, "");
3161 #endif
3162 setlocale (LC_CTYPE, "");
3163 #endif
3165 bindtextdomain (PACKAGE, LOCALEDIR);
3166 textdomain (PACKAGE);
3168 program_name = *argv;
3169 xmalloc_set_program_name (program_name);
3171 START_PROGRESS (program_name, 0);
3173 expandargv (&argc, &argv);
3175 bfd_init ();
3176 set_default_bfd_target ();
3178 while ((c = getopt_long (argc, argv,
3179 "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3180 long_options, (int *) 0))
3181 != EOF)
3183 switch (c)
3185 case 0:
3186 break; /* We've been given a long option. */
3187 case 'm':
3188 machine = optarg;
3189 break;
3190 case 'M':
3191 if (disassembler_options)
3192 /* Ignore potential memory leak for now. */
3193 disassembler_options = concat (disassembler_options, ",",
3194 optarg, (const char *) NULL);
3195 else
3196 disassembler_options = optarg;
3197 break;
3198 case 'j':
3199 if (only_used == only_size)
3201 only_size += 8;
3202 only = xrealloc (only, only_size * sizeof (char *));
3204 only [only_used++] = optarg;
3205 break;
3206 case 'F':
3207 display_file_offsets = TRUE;
3208 break;
3209 case 'l':
3210 with_line_numbers = TRUE;
3211 break;
3212 case 'b':
3213 target = optarg;
3214 break;
3215 case 'C':
3216 do_demangle = TRUE;
3217 if (optarg != NULL)
3219 enum demangling_styles style;
3221 style = cplus_demangle_name_to_style (optarg);
3222 if (style == unknown_demangling)
3223 fatal (_("unknown demangling style `%s'"),
3224 optarg);
3226 cplus_demangle_set_style (style);
3228 break;
3229 case 'w':
3230 wide_output = TRUE;
3231 break;
3232 case OPTION_ADJUST_VMA:
3233 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3234 break;
3235 case OPTION_START_ADDRESS:
3236 start_address = parse_vma (optarg, "--start-address");
3237 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3238 fatal (_("error: the start address should be before the end address"));
3239 break;
3240 case OPTION_STOP_ADDRESS:
3241 stop_address = parse_vma (optarg, "--stop-address");
3242 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3243 fatal (_("error: the stop address should be after the start address"));
3244 break;
3245 case OPTION_PREFIX:
3246 prefix = optarg;
3247 prefix_length = strlen (prefix);
3248 /* Remove an unnecessary trailing '/' */
3249 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3250 prefix_length--;
3251 break;
3252 case OPTION_PREFIX_STRIP:
3253 prefix_strip = atoi (optarg);
3254 if (prefix_strip < 0)
3255 fatal (_("error: prefix strip must be non-negative"));
3256 break;
3257 case 'E':
3258 if (strcmp (optarg, "B") == 0)
3259 endian = BFD_ENDIAN_BIG;
3260 else if (strcmp (optarg, "L") == 0)
3261 endian = BFD_ENDIAN_LITTLE;
3262 else
3264 non_fatal (_("unrecognized -E option"));
3265 usage (stderr, 1);
3267 break;
3268 case OPTION_ENDIAN:
3269 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3270 endian = BFD_ENDIAN_BIG;
3271 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3272 endian = BFD_ENDIAN_LITTLE;
3273 else
3275 non_fatal (_("unrecognized --endian type `%s'"), optarg);
3276 usage (stderr, 1);
3278 break;
3280 case 'f':
3281 dump_file_header = TRUE;
3282 seenflag = TRUE;
3283 break;
3284 case 'i':
3285 formats_info = TRUE;
3286 seenflag = TRUE;
3287 break;
3288 case 'I':
3289 add_include_path (optarg);
3290 break;
3291 case 'p':
3292 dump_private_headers = TRUE;
3293 seenflag = TRUE;
3294 break;
3295 case 'x':
3296 dump_private_headers = TRUE;
3297 dump_symtab = TRUE;
3298 dump_reloc_info = TRUE;
3299 dump_file_header = TRUE;
3300 dump_ar_hdrs = TRUE;
3301 dump_section_headers = TRUE;
3302 seenflag = TRUE;
3303 break;
3304 case 't':
3305 dump_symtab = TRUE;
3306 seenflag = TRUE;
3307 break;
3308 case 'T':
3309 dump_dynamic_symtab = TRUE;
3310 seenflag = TRUE;
3311 break;
3312 case 'd':
3313 disassemble = TRUE;
3314 seenflag = TRUE;
3315 break;
3316 case 'z':
3317 disassemble_zeroes = TRUE;
3318 break;
3319 case 'D':
3320 disassemble = TRUE;
3321 disassemble_all = TRUE;
3322 seenflag = TRUE;
3323 break;
3324 case 'S':
3325 disassemble = TRUE;
3326 with_source_code = TRUE;
3327 seenflag = TRUE;
3328 break;
3329 case 'g':
3330 dump_debugging = 1;
3331 seenflag = TRUE;
3332 break;
3333 case 'e':
3334 dump_debugging = 1;
3335 dump_debugging_tags = 1;
3336 do_demangle = TRUE;
3337 seenflag = TRUE;
3338 break;
3339 case 'W':
3340 dump_dwarf_section_info = TRUE;
3341 seenflag = TRUE;
3342 if (optarg)
3343 dwarf_select_sections_by_letters (optarg);
3344 else
3345 dwarf_select_sections_all ();
3346 break;
3347 case OPTION_DWARF:
3348 dump_dwarf_section_info = TRUE;
3349 seenflag = TRUE;
3350 if (optarg)
3351 dwarf_select_sections_by_names (optarg);
3352 else
3353 dwarf_select_sections_all ();
3354 break;
3355 case 'G':
3356 dump_stab_section_info = TRUE;
3357 seenflag = TRUE;
3358 break;
3359 case 's':
3360 dump_section_contents = TRUE;
3361 seenflag = TRUE;
3362 break;
3363 case 'r':
3364 dump_reloc_info = TRUE;
3365 seenflag = TRUE;
3366 break;
3367 case 'R':
3368 dump_dynamic_reloc_info = TRUE;
3369 seenflag = TRUE;
3370 break;
3371 case 'a':
3372 dump_ar_hdrs = TRUE;
3373 seenflag = TRUE;
3374 break;
3375 case 'h':
3376 dump_section_headers = TRUE;
3377 seenflag = TRUE;
3378 break;
3379 case 'H':
3380 usage (stdout, 0);
3381 seenflag = TRUE;
3382 case 'v':
3383 case 'V':
3384 show_version = TRUE;
3385 seenflag = TRUE;
3386 break;
3388 default:
3389 usage (stderr, 1);
3393 if (show_version)
3394 print_version ("objdump");
3396 if (!seenflag)
3397 usage (stderr, 2);
3399 if (formats_info)
3400 exit_status = display_info ();
3401 else
3403 if (optind == argc)
3404 display_file ("a.out", target);
3405 else
3406 for (; optind < argc;)
3407 display_file (argv[optind++], target);
3410 END_PROGRESS (program_name);
3412 return exit_status;