Remove CheckRegSize from instructions with 0, 1 or fixed operands.
[binutils.git] / binutils / objdump.c
blobce87a5f36a9a2d426362d2557d6a5143230724b1
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, 2010
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 int insn_width; /* --insn-width */
108 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
109 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
110 static int dump_debugging; /* --debugging */
111 static int dump_debugging_tags; /* --debugging-tags */
112 static int dump_special_syms = 0; /* --special-syms */
113 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
114 static int file_start_context = 0; /* --file-start-context */
115 static bfd_boolean display_file_offsets;/* -F */
116 static const char *prefix; /* --prefix */
117 static int prefix_strip; /* --prefix-strip */
118 static size_t prefix_length;
120 /* A structure to record the sections mentioned in -j switches. */
121 struct only
123 const char * name; /* The name of the section. */
124 bfd_boolean seen; /* A flag to indicate that the section has been found in one or more input files. */
125 struct only * next; /* Pointer to the next structure in the list. */
127 /* Pointer to an array of 'only' structures.
128 This pointer is NULL if the -j switch has not been used. */
129 static struct only * only_list = NULL;
131 /* Variables for handling include file path table. */
132 static const char **include_paths;
133 static int include_path_count;
135 /* Extra info to pass to the section disassembler and address printing
136 function. */
137 struct objdump_disasm_info
139 bfd * abfd;
140 asection * sec;
141 bfd_boolean require_sec;
142 arelent ** dynrelbuf;
143 long dynrelcount;
144 disassembler_ftype disassemble_fn;
145 arelent * reloc;
148 /* Architecture to disassemble for, or default if NULL. */
149 static char *machine = NULL;
151 /* Target specific options to the disassembler. */
152 static char *disassembler_options = NULL;
154 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
155 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
157 /* The symbol table. */
158 static asymbol **syms;
160 /* Number of symbols in `syms'. */
161 static long symcount = 0;
163 /* The sorted symbol table. */
164 static asymbol **sorted_syms;
166 /* Number of symbols in `sorted_syms'. */
167 static long sorted_symcount = 0;
169 /* The dynamic symbol table. */
170 static asymbol **dynsyms;
172 /* The synthetic symbol table. */
173 static asymbol *synthsyms;
174 static long synthcount = 0;
176 /* Number of symbols in `dynsyms'. */
177 static long dynsymcount = 0;
179 static bfd_byte *stabs;
180 static bfd_size_type stab_size;
182 static char *strtab;
183 static bfd_size_type stabstr_size;
185 static bfd_boolean is_relocatable = FALSE;
187 static void
188 usage (FILE *stream, int status)
190 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
191 fprintf (stream, _(" Display information from object <file(s)>.\n"));
192 fprintf (stream, _(" At least one of the following switches must be given:\n"));
193 fprintf (stream, _("\
194 -a, --archive-headers Display archive header information\n\
195 -f, --file-headers Display the contents of the overall file header\n\
196 -p, --private-headers Display object format specific file header contents\n\
197 -h, --[section-]headers Display the contents of the section headers\n\
198 -x, --all-headers Display the contents of all headers\n\
199 -d, --disassemble Display assembler contents of executable sections\n\
200 -D, --disassemble-all Display assembler contents of all sections\n\
201 -S, --source Intermix source code with disassembly\n\
202 -s, --full-contents Display the full contents of all sections requested\n\
203 -g, --debugging Display debug information in object file\n\
204 -e, --debugging-tags Display debug information using ctags style\n\
205 -G, --stabs Display (in raw form) any STABS info in the file\n\
206 -W[lLiaprmfFsoRt] or\n\
207 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
208 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
209 =trace_info,=trace_abbrev,=trace_aranges]\n\
210 Display DWARF info in the file\n\
211 -t, --syms Display the contents of the symbol table(s)\n\
212 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
213 -r, --reloc Display the relocation entries in the file\n\
214 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
215 @<file> Read options from <file>\n\
216 -v, --version Display this program's version number\n\
217 -i, --info List object formats and architectures supported\n\
218 -H, --help Display this information\n\
219 "));
220 if (status != 2)
222 fprintf (stream, _("\n The following switches are optional:\n"));
223 fprintf (stream, _("\
224 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
225 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
226 -j, --section=NAME Only display information for section NAME\n\
227 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
228 -EB --endian=big Assume big endian format when disassembling\n\
229 -EL --endian=little Assume little endian format when disassembling\n\
230 --file-start-context Include context from start of file (with -S)\n\
231 -I, --include=DIR Add DIR to search list for source files\n\
232 -l, --line-numbers Include line numbers and filenames in output\n\
233 -F, --file-offsets Include file offsets when displaying information\n\
234 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
235 The STYLE, if specified, can be `auto', `gnu',\n\
236 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
237 or `gnat'\n\
238 -w, --wide Format output for more than 80 columns\n\
239 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
240 --start-address=ADDR Only process data whose address is >= ADDR\n\
241 --stop-address=ADDR Only process data whose address is <= ADDR\n\
242 --prefix-addresses Print complete address alongside disassembly\n\
243 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
244 --insn-width=WIDTH Display WIDTH bytes on a signle line for -d\n\
245 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
246 --special-syms Include special symbols in symbol dumps\n\
247 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
248 --prefix-strip=LEVEL Strip initial directory names for -S\n\
249 \n"));
250 list_supported_targets (program_name, stream);
251 list_supported_architectures (program_name, stream);
253 disassembler_usage (stream);
255 if (REPORT_BUGS_TO[0] && status == 0)
256 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
257 exit (status);
260 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
261 enum option_values
263 OPTION_ENDIAN=150,
264 OPTION_START_ADDRESS,
265 OPTION_STOP_ADDRESS,
266 OPTION_DWARF,
267 OPTION_PREFIX,
268 OPTION_PREFIX_STRIP,
269 OPTION_INSN_WIDTH,
270 OPTION_ADJUST_VMA
273 static struct option long_options[]=
275 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
276 {"all-headers", no_argument, NULL, 'x'},
277 {"private-headers", no_argument, NULL, 'p'},
278 {"architecture", required_argument, NULL, 'm'},
279 {"archive-headers", no_argument, NULL, 'a'},
280 {"debugging", no_argument, NULL, 'g'},
281 {"debugging-tags", no_argument, NULL, 'e'},
282 {"demangle", optional_argument, NULL, 'C'},
283 {"disassemble", no_argument, NULL, 'd'},
284 {"disassemble-all", no_argument, NULL, 'D'},
285 {"disassembler-options", required_argument, NULL, 'M'},
286 {"disassemble-zeroes", no_argument, NULL, 'z'},
287 {"dynamic-reloc", no_argument, NULL, 'R'},
288 {"dynamic-syms", no_argument, NULL, 'T'},
289 {"endian", required_argument, NULL, OPTION_ENDIAN},
290 {"file-headers", no_argument, NULL, 'f'},
291 {"file-offsets", no_argument, NULL, 'F'},
292 {"file-start-context", no_argument, &file_start_context, 1},
293 {"full-contents", no_argument, NULL, 's'},
294 {"headers", no_argument, NULL, 'h'},
295 {"help", no_argument, NULL, 'H'},
296 {"info", no_argument, NULL, 'i'},
297 {"line-numbers", no_argument, NULL, 'l'},
298 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
299 {"prefix-addresses", no_argument, &prefix_addresses, 1},
300 {"reloc", no_argument, NULL, 'r'},
301 {"section", required_argument, NULL, 'j'},
302 {"section-headers", no_argument, NULL, 'h'},
303 {"show-raw-insn", no_argument, &show_raw_insn, 1},
304 {"source", no_argument, NULL, 'S'},
305 {"special-syms", no_argument, &dump_special_syms, 1},
306 {"include", required_argument, NULL, 'I'},
307 {"dwarf", optional_argument, NULL, OPTION_DWARF},
308 {"stabs", no_argument, NULL, 'G'},
309 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
310 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
311 {"syms", no_argument, NULL, 't'},
312 {"target", required_argument, NULL, 'b'},
313 {"version", no_argument, NULL, 'V'},
314 {"wide", no_argument, NULL, 'w'},
315 {"prefix", required_argument, NULL, OPTION_PREFIX},
316 {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
317 {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
318 {0, no_argument, 0, 0}
321 static void
322 nonfatal (const char *msg)
324 bfd_nonfatal (msg);
325 exit_status = 1;
328 /* Returns TRUE if the specified section should be dumped. */
330 static bfd_boolean
331 process_section_p (asection * section)
333 struct only * only;
335 if (only_list == NULL)
336 return TRUE;
338 for (only = only_list; only; only = only->next)
339 if (strcmp (only->name, section->name) == 0)
341 only->seen = TRUE;
342 return TRUE;
345 return FALSE;
348 /* Add an entry to the 'only' list. */
350 static void
351 add_only (char * name)
353 struct only * only;
355 /* First check to make sure that we do not
356 already have an entry for this name. */
357 for (only = only_list; only; only = only->next)
358 if (strcmp (only->name, name) == 0)
359 return;
361 only = xmalloc (sizeof * only);
362 only->name = name;
363 only->seen = FALSE;
364 only->next = only_list;
365 only_list = only;
368 /* Release the memory used by the 'only' list.
369 PR 11225: Issue a warning message for unseen sections.
370 Only do this if none of the sections were seen. This is mainly to support
371 tools like the GAS testsuite where an object file is dumped with a list of
372 generic section names known to be present in a range of different file
373 formats. */
375 static void
376 free_only_list (void)
378 bfd_boolean at_least_one_seen = FALSE;
379 struct only * only;
380 struct only * next;
382 if (only_list == NULL)
383 return;
385 for (only = only_list; only; only = only->next)
386 if (only->seen)
388 at_least_one_seen = TRUE;
389 break;
392 for (only = only_list; only; only = next)
394 if (! at_least_one_seen)
396 non_fatal (_("section '%s' mentioned in a -j option, "
397 "but not found in any input file"),
398 only->name);
399 exit_status = 1;
401 next = only->next;
402 free (only);
407 static void
408 dump_section_header (bfd *abfd, asection *section,
409 void *ignored ATTRIBUTE_UNUSED)
411 char *comma = "";
412 unsigned int opb = bfd_octets_per_byte (abfd);
414 /* Ignore linker created section. See elfNN_ia64_object_p in
415 bfd/elfxx-ia64.c. */
416 if (section->flags & SEC_LINKER_CREATED)
417 return;
419 /* PR 10413: Skip sections that we are ignoring. */
420 if (! process_section_p (section))
421 return;
423 printf ("%3d %-13s %08lx ", section->index,
424 bfd_get_section_name (abfd, section),
425 (unsigned long) bfd_section_size (abfd, section) / opb);
426 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
427 printf (" ");
428 bfd_printf_vma (abfd, section->lma);
429 printf (" %08lx 2**%u", (unsigned long) section->filepos,
430 bfd_get_section_alignment (abfd, section));
431 if (! wide_output)
432 printf ("\n ");
433 printf (" ");
435 #define PF(x, y) \
436 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
438 PF (SEC_HAS_CONTENTS, "CONTENTS");
439 PF (SEC_ALLOC, "ALLOC");
440 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
441 PF (SEC_LOAD, "LOAD");
442 PF (SEC_RELOC, "RELOC");
443 PF (SEC_READONLY, "READONLY");
444 PF (SEC_CODE, "CODE");
445 PF (SEC_DATA, "DATA");
446 PF (SEC_ROM, "ROM");
447 PF (SEC_DEBUGGING, "DEBUGGING");
448 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
449 PF (SEC_EXCLUDE, "EXCLUDE");
450 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
451 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
453 PF (SEC_TIC54X_BLOCK, "BLOCK");
454 PF (SEC_TIC54X_CLINK, "CLINK");
456 PF (SEC_SMALL_DATA, "SMALL_DATA");
457 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
458 PF (SEC_COFF_SHARED, "SHARED");
459 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
460 PF (SEC_GROUP, "GROUP");
462 if ((section->flags & SEC_LINK_ONCE) != 0)
464 const char *ls;
465 struct coff_comdat_info *comdat;
467 switch (section->flags & SEC_LINK_DUPLICATES)
469 default:
470 abort ();
471 case SEC_LINK_DUPLICATES_DISCARD:
472 ls = "LINK_ONCE_DISCARD";
473 break;
474 case SEC_LINK_DUPLICATES_ONE_ONLY:
475 ls = "LINK_ONCE_ONE_ONLY";
476 break;
477 case SEC_LINK_DUPLICATES_SAME_SIZE:
478 ls = "LINK_ONCE_SAME_SIZE";
479 break;
480 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
481 ls = "LINK_ONCE_SAME_CONTENTS";
482 break;
484 printf ("%s%s", comma, ls);
486 comdat = bfd_coff_get_comdat_section (abfd, section);
487 if (comdat != NULL)
488 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
490 comma = ", ";
493 printf ("\n");
494 #undef PF
497 static void
498 dump_headers (bfd *abfd)
500 printf (_("Sections:\n"));
502 #ifndef BFD64
503 printf (_("Idx Name Size VMA LMA File off Algn"));
504 #else
505 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
506 if (bfd_get_arch_size (abfd) == 32)
507 printf (_("Idx Name Size VMA LMA File off Algn"));
508 else
509 printf (_("Idx Name Size VMA LMA File off Algn"));
510 #endif
512 if (wide_output)
513 printf (_(" Flags"));
514 if (abfd->flags & HAS_LOAD_PAGE)
515 printf (_(" Pg"));
516 printf ("\n");
518 bfd_map_over_sections (abfd, dump_section_header, NULL);
521 static asymbol **
522 slurp_symtab (bfd *abfd)
524 asymbol **sy = NULL;
525 long storage;
527 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
529 symcount = 0;
530 return NULL;
533 storage = bfd_get_symtab_upper_bound (abfd);
534 if (storage < 0)
535 bfd_fatal (bfd_get_filename (abfd));
536 if (storage)
537 sy = (asymbol **) xmalloc (storage);
539 symcount = bfd_canonicalize_symtab (abfd, sy);
540 if (symcount < 0)
541 bfd_fatal (bfd_get_filename (abfd));
542 return sy;
545 /* Read in the dynamic symbols. */
547 static asymbol **
548 slurp_dynamic_symtab (bfd *abfd)
550 asymbol **sy = NULL;
551 long storage;
553 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
554 if (storage < 0)
556 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
558 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
559 exit_status = 1;
560 dynsymcount = 0;
561 return NULL;
564 bfd_fatal (bfd_get_filename (abfd));
566 if (storage)
567 sy = (asymbol **) xmalloc (storage);
569 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
570 if (dynsymcount < 0)
571 bfd_fatal (bfd_get_filename (abfd));
572 return sy;
575 /* Filter out (in place) symbols that are useless for disassembly.
576 COUNT is the number of elements in SYMBOLS.
577 Return the number of useful symbols. */
579 static long
580 remove_useless_symbols (asymbol **symbols, long count)
582 asymbol **in_ptr = symbols, **out_ptr = symbols;
584 while (--count >= 0)
586 asymbol *sym = *in_ptr++;
588 if (sym->name == NULL || sym->name[0] == '\0')
589 continue;
590 if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
591 continue;
592 if (bfd_is_und_section (sym->section)
593 || bfd_is_com_section (sym->section))
594 continue;
596 *out_ptr++ = sym;
598 return out_ptr - symbols;
601 /* Sort symbols into value order. */
603 static int
604 compare_symbols (const void *ap, const void *bp)
606 const asymbol *a = * (const asymbol **) ap;
607 const asymbol *b = * (const asymbol **) bp;
608 const char *an;
609 const char *bn;
610 size_t anl;
611 size_t bnl;
612 bfd_boolean af;
613 bfd_boolean bf;
614 flagword aflags;
615 flagword bflags;
617 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
618 return 1;
619 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
620 return -1;
622 if (a->section > b->section)
623 return 1;
624 else if (a->section < b->section)
625 return -1;
627 an = bfd_asymbol_name (a);
628 bn = bfd_asymbol_name (b);
629 anl = strlen (an);
630 bnl = strlen (bn);
632 /* The symbols gnu_compiled and gcc2_compiled convey no real
633 information, so put them after other symbols with the same value. */
634 af = (strstr (an, "gnu_compiled") != NULL
635 || strstr (an, "gcc2_compiled") != NULL);
636 bf = (strstr (bn, "gnu_compiled") != NULL
637 || strstr (bn, "gcc2_compiled") != NULL);
639 if (af && ! bf)
640 return 1;
641 if (! af && bf)
642 return -1;
644 /* We use a heuristic for the file name, to try to sort it after
645 more useful symbols. It may not work on non Unix systems, but it
646 doesn't really matter; the only difference is precisely which
647 symbol names get printed. */
649 #define file_symbol(s, sn, snl) \
650 (((s)->flags & BSF_FILE) != 0 \
651 || ((sn)[(snl) - 2] == '.' \
652 && ((sn)[(snl) - 1] == 'o' \
653 || (sn)[(snl) - 1] == 'a')))
655 af = file_symbol (a, an, anl);
656 bf = file_symbol (b, bn, bnl);
658 if (af && ! bf)
659 return 1;
660 if (! af && bf)
661 return -1;
663 /* Try to sort global symbols before local symbols before function
664 symbols before debugging symbols. */
666 aflags = a->flags;
667 bflags = b->flags;
669 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
671 if ((aflags & BSF_DEBUGGING) != 0)
672 return 1;
673 else
674 return -1;
676 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
678 if ((aflags & BSF_FUNCTION) != 0)
679 return -1;
680 else
681 return 1;
683 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
685 if ((aflags & BSF_LOCAL) != 0)
686 return 1;
687 else
688 return -1;
690 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
692 if ((aflags & BSF_GLOBAL) != 0)
693 return -1;
694 else
695 return 1;
698 /* Symbols that start with '.' might be section names, so sort them
699 after symbols that don't start with '.'. */
700 if (an[0] == '.' && bn[0] != '.')
701 return 1;
702 if (an[0] != '.' && bn[0] == '.')
703 return -1;
705 /* Finally, if we can't distinguish them in any other way, try to
706 get consistent results by sorting the symbols by name. */
707 return strcmp (an, bn);
710 /* Sort relocs into address order. */
712 static int
713 compare_relocs (const void *ap, const void *bp)
715 const arelent *a = * (const arelent **) ap;
716 const arelent *b = * (const arelent **) bp;
718 if (a->address > b->address)
719 return 1;
720 else if (a->address < b->address)
721 return -1;
723 /* So that associated relocations tied to the same address show up
724 in the correct order, we don't do any further sorting. */
725 if (a > b)
726 return 1;
727 else if (a < b)
728 return -1;
729 else
730 return 0;
733 /* Print an address (VMA) to the output stream in INFO.
734 If SKIP_ZEROES is TRUE, omit leading zeroes. */
736 static void
737 objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
738 bfd_boolean skip_zeroes)
740 char buf[30];
741 char *p;
742 struct objdump_disasm_info *aux;
744 aux = (struct objdump_disasm_info *) inf->application_data;
745 bfd_sprintf_vma (aux->abfd, buf, vma);
746 if (! skip_zeroes)
747 p = buf;
748 else
750 for (p = buf; *p == '0'; ++p)
752 if (*p == '\0')
753 --p;
755 (*inf->fprintf_func) (inf->stream, "%s", p);
758 /* Print the name of a symbol. */
760 static void
761 objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
762 asymbol *sym)
764 char *alloc;
765 const char *name;
767 alloc = NULL;
768 name = bfd_asymbol_name (sym);
769 if (do_demangle && name[0] != '\0')
771 /* Demangle the name. */
772 alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
773 if (alloc != NULL)
774 name = alloc;
777 if (inf != NULL)
778 (*inf->fprintf_func) (inf->stream, "%s", name);
779 else
780 printf ("%s", name);
782 if (alloc != NULL)
783 free (alloc);
786 /* Locate a symbol given a bfd and a section (from INFO->application_data),
787 and a VMA. If INFO->application_data->require_sec is TRUE, then always
788 require the symbol to be in the section. Returns NULL if there is no
789 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
790 of the symbol in sorted_syms. */
792 static asymbol *
793 find_symbol_for_address (bfd_vma vma,
794 struct disassemble_info *inf,
795 long *place)
797 /* @@ Would it speed things up to cache the last two symbols returned,
798 and maybe their address ranges? For many processors, only one memory
799 operand can be present at a time, so the 2-entry cache wouldn't be
800 constantly churned by code doing heavy memory accesses. */
802 /* Indices in `sorted_syms'. */
803 long min = 0;
804 long max_count = sorted_symcount;
805 long thisplace;
806 struct objdump_disasm_info *aux;
807 bfd *abfd;
808 asection *sec;
809 unsigned int opb;
810 bfd_boolean want_section;
812 if (sorted_symcount < 1)
813 return NULL;
815 aux = (struct objdump_disasm_info *) inf->application_data;
816 abfd = aux->abfd;
817 sec = aux->sec;
818 opb = inf->octets_per_byte;
820 /* Perform a binary search looking for the closest symbol to the
821 required value. We are searching the range (min, max_count]. */
822 while (min + 1 < max_count)
824 asymbol *sym;
826 thisplace = (max_count + min) / 2;
827 sym = sorted_syms[thisplace];
829 if (bfd_asymbol_value (sym) > vma)
830 max_count = thisplace;
831 else if (bfd_asymbol_value (sym) < vma)
832 min = thisplace;
833 else
835 min = thisplace;
836 break;
840 /* The symbol we want is now in min, the low end of the range we
841 were searching. If there are several symbols with the same
842 value, we want the first one. */
843 thisplace = min;
844 while (thisplace > 0
845 && (bfd_asymbol_value (sorted_syms[thisplace])
846 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
847 --thisplace;
849 /* Prefer a symbol in the current section if we have multple symbols
850 with the same value, as can occur with overlays or zero size
851 sections. */
852 min = thisplace;
853 while (min < max_count
854 && (bfd_asymbol_value (sorted_syms[min])
855 == bfd_asymbol_value (sorted_syms[thisplace])))
857 if (sorted_syms[min]->section == sec
858 && inf->symbol_is_valid (sorted_syms[min], inf))
860 thisplace = min;
862 if (place != NULL)
863 *place = thisplace;
865 return sorted_syms[thisplace];
867 ++min;
870 /* If the file is relocatable, and the symbol could be from this
871 section, prefer a symbol from this section over symbols from
872 others, even if the other symbol's value might be closer.
874 Note that this may be wrong for some symbol references if the
875 sections have overlapping memory ranges, but in that case there's
876 no way to tell what's desired without looking at the relocation
877 table.
879 Also give the target a chance to reject symbols. */
880 want_section = (aux->require_sec
881 || ((abfd->flags & HAS_RELOC) != 0
882 && vma >= bfd_get_section_vma (abfd, sec)
883 && vma < (bfd_get_section_vma (abfd, sec)
884 + bfd_section_size (abfd, sec) / opb)));
885 if ((sorted_syms[thisplace]->section != sec && want_section)
886 || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
888 long i;
889 long newplace = sorted_symcount;
891 for (i = min - 1; i >= 0; i--)
893 if ((sorted_syms[i]->section == sec || !want_section)
894 && inf->symbol_is_valid (sorted_syms[i], inf))
896 if (newplace == sorted_symcount)
897 newplace = i;
899 if (bfd_asymbol_value (sorted_syms[i])
900 != bfd_asymbol_value (sorted_syms[newplace]))
901 break;
903 /* Remember this symbol and keep searching until we reach
904 an earlier address. */
905 newplace = i;
909 if (newplace != sorted_symcount)
910 thisplace = newplace;
911 else
913 /* We didn't find a good symbol with a smaller value.
914 Look for one with a larger value. */
915 for (i = thisplace + 1; i < sorted_symcount; i++)
917 if ((sorted_syms[i]->section == sec || !want_section)
918 && inf->symbol_is_valid (sorted_syms[i], inf))
920 thisplace = i;
921 break;
926 if ((sorted_syms[thisplace]->section != sec && want_section)
927 || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
928 /* There is no suitable symbol. */
929 return NULL;
932 if (place != NULL)
933 *place = thisplace;
935 return sorted_syms[thisplace];
938 /* Print an address and the offset to the nearest symbol. */
940 static void
941 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
942 bfd_vma vma, struct disassemble_info *inf,
943 bfd_boolean skip_zeroes)
945 objdump_print_value (vma, inf, skip_zeroes);
947 if (sym == NULL)
949 bfd_vma secaddr;
951 (*inf->fprintf_func) (inf->stream, " <%s",
952 bfd_get_section_name (abfd, sec));
953 secaddr = bfd_get_section_vma (abfd, sec);
954 if (vma < secaddr)
956 (*inf->fprintf_func) (inf->stream, "-0x");
957 objdump_print_value (secaddr - vma, inf, TRUE);
959 else if (vma > secaddr)
961 (*inf->fprintf_func) (inf->stream, "+0x");
962 objdump_print_value (vma - secaddr, inf, TRUE);
964 (*inf->fprintf_func) (inf->stream, ">");
966 else
968 (*inf->fprintf_func) (inf->stream, " <");
969 objdump_print_symname (abfd, inf, sym);
970 if (bfd_asymbol_value (sym) > vma)
972 (*inf->fprintf_func) (inf->stream, "-0x");
973 objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
975 else if (vma > bfd_asymbol_value (sym))
977 (*inf->fprintf_func) (inf->stream, "+0x");
978 objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
980 (*inf->fprintf_func) (inf->stream, ">");
983 if (display_file_offsets)
984 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
985 (long int)(sec->filepos + (vma - sec->vma)));
988 /* Print an address (VMA), symbolically if possible.
989 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
991 static void
992 objdump_print_addr (bfd_vma vma,
993 struct disassemble_info *inf,
994 bfd_boolean skip_zeroes)
996 struct objdump_disasm_info *aux;
997 asymbol *sym = NULL;
998 bfd_boolean skip_find = FALSE;
1000 aux = (struct objdump_disasm_info *) inf->application_data;
1002 if (sorted_symcount < 1)
1004 (*inf->fprintf_func) (inf->stream, "0x");
1005 objdump_print_value (vma, inf, skip_zeroes);
1007 if (display_file_offsets)
1008 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1009 (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
1010 return;
1013 if (aux->reloc != NULL
1014 && aux->reloc->sym_ptr_ptr != NULL
1015 && * aux->reloc->sym_ptr_ptr != NULL)
1017 sym = * aux->reloc->sym_ptr_ptr;
1019 /* Adjust the vma to the reloc. */
1020 vma += bfd_asymbol_value (sym);
1022 if (bfd_is_und_section (bfd_get_section (sym)))
1023 skip_find = TRUE;
1026 if (!skip_find)
1027 sym = find_symbol_for_address (vma, inf, NULL);
1029 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf,
1030 skip_zeroes);
1033 /* Print VMA to INFO. This function is passed to the disassembler
1034 routine. */
1036 static void
1037 objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
1039 objdump_print_addr (vma, inf, ! prefix_addresses);
1042 /* Determine if the given address has a symbol associated with it. */
1044 static int
1045 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
1047 asymbol * sym;
1049 sym = find_symbol_for_address (vma, inf, NULL);
1051 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
1054 /* Hold the last function name and the last line number we displayed
1055 in a disassembly. */
1057 static char *prev_functionname;
1058 static unsigned int prev_line;
1060 /* We keep a list of all files that we have seen when doing a
1061 disassembly with source, so that we know how much of the file to
1062 display. This can be important for inlined functions. */
1064 struct print_file_list
1066 struct print_file_list *next;
1067 const char *filename;
1068 const char *modname;
1069 const char *map;
1070 size_t mapsize;
1071 const char **linemap;
1072 unsigned maxline;
1073 unsigned last_line;
1074 int first;
1077 static struct print_file_list *print_files;
1079 /* The number of preceding context lines to show when we start
1080 displaying a file for the first time. */
1082 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1084 /* Read a complete file into memory. */
1086 static const char *
1087 slurp_file (const char *fn, size_t *size)
1089 #ifdef HAVE_MMAP
1090 int ps = getpagesize ();
1091 size_t msize;
1092 #endif
1093 const char *map;
1094 struct stat st;
1095 int fd = open (fn, O_RDONLY | O_BINARY);
1097 if (fd < 0)
1098 return NULL;
1099 if (fstat (fd, &st) < 0)
1100 return NULL;
1101 *size = st.st_size;
1102 #ifdef HAVE_MMAP
1103 msize = (*size + ps - 1) & ~(ps - 1);
1104 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
1105 if (map != (char *)-1L)
1107 close(fd);
1108 return map;
1110 #endif
1111 map = (const char *) malloc (*size);
1112 if (!map || (size_t) read (fd, (char *)map, *size) != *size)
1114 free ((void *)map);
1115 map = NULL;
1117 close (fd);
1118 return map;
1121 #define line_map_decrease 5
1123 /* Precompute array of lines for a mapped file. */
1125 static const char **
1126 index_file (const char *map, size_t size, unsigned int *maxline)
1128 const char *p, *lstart, *end;
1129 int chars_per_line = 45; /* First iteration will use 40. */
1130 unsigned int lineno;
1131 const char **linemap = NULL;
1132 unsigned long line_map_size = 0;
1134 lineno = 0;
1135 lstart = map;
1136 end = map + size;
1138 for (p = map; p < end; p++)
1140 if (*p == '\n')
1142 if (p + 1 < end && p[1] == '\r')
1143 p++;
1145 else if (*p == '\r')
1147 if (p + 1 < end && p[1] == '\n')
1148 p++;
1150 else
1151 continue;
1153 /* End of line found. */
1155 if (linemap == NULL || line_map_size < lineno + 1)
1157 unsigned long newsize;
1159 chars_per_line -= line_map_decrease;
1160 if (chars_per_line <= 1)
1161 chars_per_line = 1;
1162 line_map_size = size / chars_per_line + 1;
1163 if (line_map_size < lineno + 1)
1164 line_map_size = lineno + 1;
1165 newsize = line_map_size * sizeof (char *);
1166 linemap = (const char **) xrealloc (linemap, newsize);
1169 linemap[lineno++] = lstart;
1170 lstart = p + 1;
1173 *maxline = lineno;
1174 return linemap;
1177 /* Tries to open MODNAME, and if successful adds a node to print_files
1178 linked list and returns that node. Returns NULL on failure. */
1180 static struct print_file_list *
1181 try_print_file_open (const char *origname, const char *modname)
1183 struct print_file_list *p;
1185 p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
1187 p->map = slurp_file (modname, &p->mapsize);
1188 if (p->map == NULL)
1190 free (p);
1191 return NULL;
1194 p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1195 p->last_line = 0;
1196 p->filename = origname;
1197 p->modname = modname;
1198 p->next = print_files;
1199 p->first = 1;
1200 print_files = p;
1201 return p;
1204 /* If the the source file, as described in the symtab, is not found
1205 try to locate it in one of the paths specified with -I
1206 If found, add location to print_files linked list. */
1208 static struct print_file_list *
1209 update_source_path (const char *filename)
1211 struct print_file_list *p;
1212 const char *fname;
1213 int i;
1215 p = try_print_file_open (filename, filename);
1216 if (p != NULL)
1217 return p;
1219 if (include_path_count == 0)
1220 return NULL;
1222 /* Get the name of the file. */
1223 fname = lbasename (filename);
1225 /* If file exists under a new path, we need to add it to the list
1226 so that show_line knows about it. */
1227 for (i = 0; i < include_path_count; i++)
1229 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1231 p = try_print_file_open (filename, modname);
1232 if (p)
1233 return p;
1235 free (modname);
1238 return NULL;
1241 /* Print a source file line. */
1243 static void
1244 print_line (struct print_file_list *p, unsigned int linenum)
1246 const char *l;
1247 size_t len;
1249 --linenum;
1250 if (linenum >= p->maxline)
1251 return;
1252 l = p->linemap [linenum];
1253 /* Test fwrite return value to quiet glibc warning. */
1254 len = strcspn (l, "\n\r");
1255 if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1256 putchar ('\n');
1259 /* Print a range of source code lines. */
1261 static void
1262 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1264 if (p->map == NULL)
1265 return;
1266 while (start <= end)
1268 print_line (p, start);
1269 start++;
1273 /* Show the line number, or the source line, in a disassembly
1274 listing. */
1276 static void
1277 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1279 const char *filename;
1280 const char *functionname;
1281 unsigned int linenumber;
1282 bfd_boolean reloc;
1284 if (! with_line_numbers && ! with_source_code)
1285 return;
1287 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1288 &functionname, &linenumber))
1289 return;
1291 if (filename != NULL && *filename == '\0')
1292 filename = NULL;
1293 if (functionname != NULL && *functionname == '\0')
1294 functionname = NULL;
1296 if (filename
1297 && IS_ABSOLUTE_PATH (filename)
1298 && prefix)
1300 char *path_up;
1301 const char *fname = filename;
1302 char *path = (char *) alloca (prefix_length + PATH_MAX + 1);
1304 if (prefix_length)
1305 memcpy (path, prefix, prefix_length);
1306 path_up = path + prefix_length;
1308 /* Build relocated filename, stripping off leading directories
1309 from the initial filename if requested. */
1310 if (prefix_strip > 0)
1312 int level = 0;
1313 const char *s;
1315 /* Skip selected directory levels. */
1316 for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1317 if (IS_DIR_SEPARATOR(*s))
1319 fname = s;
1320 level++;
1324 /* Update complete filename. */
1325 strncpy (path_up, fname, PATH_MAX);
1326 path_up[PATH_MAX] = '\0';
1328 filename = path;
1329 reloc = TRUE;
1331 else
1332 reloc = FALSE;
1334 if (with_line_numbers)
1336 if (functionname != NULL
1337 && (prev_functionname == NULL
1338 || strcmp (functionname, prev_functionname) != 0))
1339 printf ("%s():\n", functionname);
1340 if (linenumber > 0 && linenumber != prev_line)
1341 printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
1344 if (with_source_code
1345 && filename != NULL
1346 && linenumber > 0)
1348 struct print_file_list **pp, *p;
1349 unsigned l;
1351 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1352 if (strcmp ((*pp)->filename, filename) == 0)
1353 break;
1354 p = *pp;
1356 if (p == NULL)
1358 if (reloc)
1359 filename = xstrdup (filename);
1360 p = update_source_path (filename);
1363 if (p != NULL && linenumber != p->last_line)
1365 if (file_start_context && p->first)
1366 l = 1;
1367 else
1369 l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
1370 if (l >= linenumber)
1371 l = 1;
1372 if (p->last_line >= l && p->last_line <= linenumber)
1373 l = p->last_line + 1;
1375 dump_lines (p, l, linenumber);
1376 p->last_line = linenumber;
1377 p->first = 0;
1381 if (functionname != NULL
1382 && (prev_functionname == NULL
1383 || strcmp (functionname, prev_functionname) != 0))
1385 if (prev_functionname != NULL)
1386 free (prev_functionname);
1387 prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
1388 strcpy (prev_functionname, functionname);
1391 if (linenumber > 0 && linenumber != prev_line)
1392 prev_line = linenumber;
1395 /* Pseudo FILE object for strings. */
1396 typedef struct
1398 char *buffer;
1399 size_t pos;
1400 size_t alloc;
1401 } SFILE;
1403 /* sprintf to a "stream". */
1405 static int ATTRIBUTE_PRINTF_2
1406 objdump_sprintf (SFILE *f, const char *format, ...)
1408 size_t n;
1409 va_list args;
1411 while (1)
1413 size_t space = f->alloc - f->pos;
1415 va_start (args, format);
1416 n = vsnprintf (f->buffer + f->pos, space, format, args);
1417 va_end (args);
1419 if (space > n)
1420 break;
1422 f->alloc = (f->alloc + n) * 2;
1423 f->buffer = (char *) xrealloc (f->buffer, f->alloc);
1425 f->pos += n;
1427 return n;
1430 /* The number of zeroes we want to see before we start skipping them.
1431 The number is arbitrarily chosen. */
1433 #define DEFAULT_SKIP_ZEROES 8
1435 /* The number of zeroes to skip at the end of a section. If the
1436 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1437 SKIP_ZEROES, they will be disassembled. If there are fewer than
1438 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1439 attempt to avoid disassembling zeroes inserted by section
1440 alignment. */
1442 #define DEFAULT_SKIP_ZEROES_AT_END 3
1444 /* Disassemble some data in memory between given values. */
1446 static void
1447 disassemble_bytes (struct disassemble_info * inf,
1448 disassembler_ftype disassemble_fn,
1449 bfd_boolean insns,
1450 bfd_byte * data,
1451 bfd_vma start_offset,
1452 bfd_vma stop_offset,
1453 bfd_vma rel_offset,
1454 arelent *** relppp,
1455 arelent ** relppend)
1457 struct objdump_disasm_info *aux;
1458 asection *section;
1459 int octets_per_line;
1460 int skip_addr_chars;
1461 bfd_vma addr_offset;
1462 unsigned int opb = inf->octets_per_byte;
1463 unsigned int skip_zeroes = inf->skip_zeroes;
1464 unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
1465 int octets = opb;
1466 SFILE sfile;
1468 aux = (struct objdump_disasm_info *) inf->application_data;
1469 section = aux->sec;
1471 sfile.alloc = 120;
1472 sfile.buffer = (char *) xmalloc (sfile.alloc);
1473 sfile.pos = 0;
1475 if (insn_width)
1476 octets_per_line = insn_width;
1477 else if (insns)
1478 octets_per_line = 4;
1479 else
1480 octets_per_line = 16;
1482 /* Figure out how many characters to skip at the start of an
1483 address, to make the disassembly look nicer. We discard leading
1484 zeroes in chunks of 4, ensuring that there is always a leading
1485 zero remaining. */
1486 skip_addr_chars = 0;
1487 if (! prefix_addresses)
1489 char buf[30];
1491 bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1493 while (buf[skip_addr_chars] == '0')
1494 ++skip_addr_chars;
1496 /* Don't discard zeros on overflow. */
1497 if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1498 skip_addr_chars = 0;
1500 if (skip_addr_chars != 0)
1501 skip_addr_chars = (skip_addr_chars - 1) & -4;
1504 inf->insn_info_valid = 0;
1506 addr_offset = start_offset;
1507 while (addr_offset < stop_offset)
1509 bfd_vma z;
1510 bfd_boolean need_nl = FALSE;
1511 int previous_octets;
1513 /* Remember the length of the previous instruction. */
1514 previous_octets = octets;
1515 octets = 0;
1517 /* Make sure we don't use relocs from previous instructions. */
1518 aux->reloc = NULL;
1520 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1521 print `...'. */
1522 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1523 if (data[z] != 0)
1524 break;
1525 if (! disassemble_zeroes
1526 && (inf->insn_info_valid == 0
1527 || inf->branch_delay_insns == 0)
1528 && (z - addr_offset * opb >= skip_zeroes
1529 || (z == stop_offset * opb &&
1530 z - addr_offset * opb < skip_zeroes_at_end)))
1532 /* If there are more nonzero octets to follow, we only skip
1533 zeroes in multiples of 4, to try to avoid running over
1534 the start of an instruction which happens to start with
1535 zero. */
1536 if (z != stop_offset * opb)
1537 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1539 octets = z - addr_offset * opb;
1541 /* If we are going to display more data, and we are displaying
1542 file offsets, then tell the user how many zeroes we skip
1543 and the file offset from where we resume dumping. */
1544 if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1545 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1546 octets / opb,
1547 (unsigned long) (section->filepos
1548 + (addr_offset + (octets / opb))));
1549 else
1550 printf ("\t...\n");
1552 else
1554 char buf[50];
1555 int bpc = 0;
1556 int pb = 0;
1558 if (with_line_numbers || with_source_code)
1559 show_line (aux->abfd, section, addr_offset);
1561 if (! prefix_addresses)
1563 char *s;
1565 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1566 for (s = buf + skip_addr_chars; *s == '0'; s++)
1567 *s = ' ';
1568 if (*s == '\0')
1569 *--s = '0';
1570 printf ("%s:\t", buf + skip_addr_chars);
1572 else
1574 aux->require_sec = TRUE;
1575 objdump_print_address (section->vma + addr_offset, inf);
1576 aux->require_sec = FALSE;
1577 putchar (' ');
1580 if (insns)
1582 sfile.pos = 0;
1583 inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
1584 inf->stream = &sfile;
1585 inf->bytes_per_line = 0;
1586 inf->bytes_per_chunk = 0;
1587 inf->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
1588 if (machine)
1589 inf->flags |= USER_SPECIFIED_MACHINE_TYPE;
1591 if (inf->disassembler_needs_relocs
1592 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1593 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1594 && *relppp < relppend)
1596 bfd_signed_vma distance_to_rel;
1598 distance_to_rel = (**relppp)->address
1599 - (rel_offset + addr_offset);
1601 /* Check to see if the current reloc is associated with
1602 the instruction that we are about to disassemble. */
1603 if (distance_to_rel == 0
1604 /* FIXME: This is wrong. We are trying to catch
1605 relocs that are addressed part way through the
1606 current instruction, as might happen with a packed
1607 VLIW instruction. Unfortunately we do not know the
1608 length of the current instruction since we have not
1609 disassembled it yet. Instead we take a guess based
1610 upon the length of the previous instruction. The
1611 proper solution is to have a new target-specific
1612 disassembler function which just returns the length
1613 of an instruction at a given address without trying
1614 to display its disassembly. */
1615 || (distance_to_rel > 0
1616 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1618 inf->flags |= INSN_HAS_RELOC;
1619 aux->reloc = **relppp;
1623 octets = (*disassemble_fn) (section->vma + addr_offset, inf);
1624 inf->fprintf_func = (fprintf_ftype) fprintf;
1625 inf->stream = stdout;
1626 if (insn_width == 0 && inf->bytes_per_line != 0)
1627 octets_per_line = inf->bytes_per_line;
1628 if (octets < (int) opb)
1630 if (sfile.pos)
1631 printf ("%s\n", sfile.buffer);
1632 if (octets >= 0)
1634 non_fatal (_("disassemble_fn returned length %d"),
1635 octets);
1636 exit_status = 1;
1638 break;
1641 else
1643 bfd_vma j;
1645 octets = octets_per_line;
1646 if (addr_offset + octets / opb > stop_offset)
1647 octets = (stop_offset - addr_offset) * opb;
1649 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1651 if (ISPRINT (data[j]))
1652 buf[j - addr_offset * opb] = data[j];
1653 else
1654 buf[j - addr_offset * opb] = '.';
1656 buf[j - addr_offset * opb] = '\0';
1659 if (prefix_addresses
1660 ? show_raw_insn > 0
1661 : show_raw_insn >= 0)
1663 bfd_vma j;
1665 /* If ! prefix_addresses and ! wide_output, we print
1666 octets_per_line octets per line. */
1667 pb = octets;
1668 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1669 pb = octets_per_line;
1671 if (inf->bytes_per_chunk)
1672 bpc = inf->bytes_per_chunk;
1673 else
1674 bpc = 1;
1676 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1678 int k;
1680 if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1682 for (k = bpc - 1; k >= 0; k--)
1683 printf ("%02x", (unsigned) data[j + k]);
1684 putchar (' ');
1686 else
1688 for (k = 0; k < bpc; k++)
1689 printf ("%02x", (unsigned) data[j + k]);
1690 putchar (' ');
1694 for (; pb < octets_per_line; pb += bpc)
1696 int k;
1698 for (k = 0; k < bpc; k++)
1699 printf (" ");
1700 putchar (' ');
1703 /* Separate raw data from instruction by extra space. */
1704 if (insns)
1705 putchar ('\t');
1706 else
1707 printf (" ");
1710 if (! insns)
1711 printf ("%s", buf);
1712 else if (sfile.pos)
1713 printf ("%s", sfile.buffer);
1715 if (prefix_addresses
1716 ? show_raw_insn > 0
1717 : show_raw_insn >= 0)
1719 while (pb < octets)
1721 bfd_vma j;
1722 char *s;
1724 putchar ('\n');
1725 j = addr_offset * opb + pb;
1727 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1728 for (s = buf + skip_addr_chars; *s == '0'; s++)
1729 *s = ' ';
1730 if (*s == '\0')
1731 *--s = '0';
1732 printf ("%s:\t", buf + skip_addr_chars);
1734 pb += octets_per_line;
1735 if (pb > octets)
1736 pb = octets;
1737 for (; j < addr_offset * opb + pb; j += bpc)
1739 int k;
1741 if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1743 for (k = bpc - 1; k >= 0; k--)
1744 printf ("%02x", (unsigned) data[j + k]);
1745 putchar (' ');
1747 else
1749 for (k = 0; k < bpc; k++)
1750 printf ("%02x", (unsigned) data[j + k]);
1751 putchar (' ');
1757 if (!wide_output)
1758 putchar ('\n');
1759 else
1760 need_nl = TRUE;
1763 while ((*relppp) < relppend
1764 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1766 if (dump_reloc_info || dump_dynamic_reloc_info)
1768 arelent *q;
1770 q = **relppp;
1772 if (wide_output)
1773 putchar ('\t');
1774 else
1775 printf ("\t\t\t");
1777 objdump_print_value (section->vma - rel_offset + q->address,
1778 inf, TRUE);
1780 if (q->howto == NULL)
1781 printf (": *unknown*\t");
1782 else if (q->howto->name)
1783 printf (": %s\t", q->howto->name);
1784 else
1785 printf (": %d\t", q->howto->type);
1787 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1788 printf ("*unknown*");
1789 else
1791 const char *sym_name;
1793 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1794 if (sym_name != NULL && *sym_name != '\0')
1795 objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
1796 else
1798 asection *sym_sec;
1800 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1801 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1802 if (sym_name == NULL || *sym_name == '\0')
1803 sym_name = "*unknown*";
1804 printf ("%s", sym_name);
1808 if (q->addend)
1810 printf ("+0x");
1811 objdump_print_value (q->addend, inf, TRUE);
1814 printf ("\n");
1815 need_nl = FALSE;
1817 ++(*relppp);
1820 if (need_nl)
1821 printf ("\n");
1823 addr_offset += octets / opb;
1826 free (sfile.buffer);
1829 static void
1830 disassemble_section (bfd *abfd, asection *section, void *inf)
1832 const struct elf_backend_data * bed;
1833 bfd_vma sign_adjust = 0;
1834 struct disassemble_info * pinfo = (struct disassemble_info *) inf;
1835 struct objdump_disasm_info * paux;
1836 unsigned int opb = pinfo->octets_per_byte;
1837 bfd_byte * data = NULL;
1838 bfd_size_type datasize = 0;
1839 arelent ** rel_pp = NULL;
1840 arelent ** rel_ppstart = NULL;
1841 arelent ** rel_ppend;
1842 unsigned long stop_offset;
1843 asymbol * sym = NULL;
1844 long place = 0;
1845 long rel_count;
1846 bfd_vma rel_offset;
1847 unsigned long addr_offset;
1849 /* Sections that do not contain machine
1850 code are not normally disassembled. */
1851 if (! disassemble_all
1852 && only_list == NULL
1853 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1854 != (SEC_CODE | SEC_HAS_CONTENTS)))
1855 return;
1857 if (! process_section_p (section))
1858 return;
1860 datasize = bfd_get_section_size (section);
1861 if (datasize == 0)
1862 return;
1864 /* Decide which set of relocs to use. Load them if necessary. */
1865 paux = (struct objdump_disasm_info *) pinfo->application_data;
1866 if (paux->dynrelbuf)
1868 rel_pp = paux->dynrelbuf;
1869 rel_count = paux->dynrelcount;
1870 /* Dynamic reloc addresses are absolute, non-dynamic are section
1871 relative. REL_OFFSET specifies the reloc address corresponding
1872 to the start of this section. */
1873 rel_offset = section->vma;
1875 else
1877 rel_count = 0;
1878 rel_pp = NULL;
1879 rel_offset = 0;
1881 if ((section->flags & SEC_RELOC) != 0
1882 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1884 long relsize;
1886 relsize = bfd_get_reloc_upper_bound (abfd, section);
1887 if (relsize < 0)
1888 bfd_fatal (bfd_get_filename (abfd));
1890 if (relsize > 0)
1892 rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
1893 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1894 if (rel_count < 0)
1895 bfd_fatal (bfd_get_filename (abfd));
1897 /* Sort the relocs by address. */
1898 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1902 rel_ppend = rel_pp + rel_count;
1904 data = (bfd_byte *) xmalloc (datasize);
1906 bfd_get_section_contents (abfd, section, data, 0, datasize);
1908 paux->sec = section;
1909 pinfo->buffer = data;
1910 pinfo->buffer_vma = section->vma;
1911 pinfo->buffer_length = datasize;
1912 pinfo->section = section;
1914 if (start_address == (bfd_vma) -1
1915 || start_address < pinfo->buffer_vma)
1916 addr_offset = 0;
1917 else
1918 addr_offset = start_address - pinfo->buffer_vma;
1920 if (stop_address == (bfd_vma) -1)
1921 stop_offset = datasize / opb;
1922 else
1924 if (stop_address < pinfo->buffer_vma)
1925 stop_offset = 0;
1926 else
1927 stop_offset = stop_address - pinfo->buffer_vma;
1928 if (stop_offset > pinfo->buffer_length / opb)
1929 stop_offset = pinfo->buffer_length / opb;
1932 /* Skip over the relocs belonging to addresses below the
1933 start address. */
1934 while (rel_pp < rel_ppend
1935 && (*rel_pp)->address < rel_offset + addr_offset)
1936 ++rel_pp;
1938 if (addr_offset < stop_offset)
1939 printf (_("\nDisassembly of section %s:\n"), section->name);
1941 /* Find the nearest symbol forwards from our current position. */
1942 paux->require_sec = TRUE;
1943 sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
1944 (struct disassemble_info *) inf,
1945 &place);
1946 paux->require_sec = FALSE;
1948 /* PR 9774: If the target used signed addresses then we must make
1949 sure that we sign extend the value that we calculate for 'addr'
1950 in the loop below. */
1951 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1952 && (bed = get_elf_backend_data (abfd)) != NULL
1953 && bed->sign_extend_vma)
1954 sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
1956 /* Disassemble a block of instructions up to the address associated with
1957 the symbol we have just found. Then print the symbol and find the
1958 next symbol on. Repeat until we have disassembled the entire section
1959 or we have reached the end of the address range we are interested in. */
1960 while (addr_offset < stop_offset)
1962 bfd_vma addr;
1963 asymbol *nextsym;
1964 unsigned long nextstop_offset;
1965 bfd_boolean insns;
1967 addr = section->vma + addr_offset;
1968 addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
1970 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1972 int x;
1974 for (x = place;
1975 (x < sorted_symcount
1976 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1977 ++x)
1978 continue;
1980 pinfo->symbols = sorted_syms + place;
1981 pinfo->num_symbols = x - place;
1982 pinfo->symtab_pos = place;
1984 else
1986 pinfo->symbols = NULL;
1987 pinfo->num_symbols = 0;
1988 pinfo->symtab_pos = -1;
1991 if (! prefix_addresses)
1993 pinfo->fprintf_func (pinfo->stream, "\n");
1994 objdump_print_addr_with_sym (abfd, section, sym, addr,
1995 pinfo, FALSE);
1996 pinfo->fprintf_func (pinfo->stream, ":\n");
1999 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2000 nextsym = sym;
2001 else if (sym == NULL)
2002 nextsym = NULL;
2003 else
2005 #define is_valid_next_sym(SYM) \
2006 ((SYM)->section == section \
2007 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2008 && pinfo->symbol_is_valid (SYM, pinfo))
2010 /* Search forward for the next appropriate symbol in
2011 SECTION. Note that all the symbols are sorted
2012 together into one big array, and that some sections
2013 may have overlapping addresses. */
2014 while (place < sorted_symcount
2015 && ! is_valid_next_sym (sorted_syms [place]))
2016 ++place;
2018 if (place >= sorted_symcount)
2019 nextsym = NULL;
2020 else
2021 nextsym = sorted_syms[place];
2024 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2025 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
2026 else if (nextsym == NULL)
2027 nextstop_offset = stop_offset;
2028 else
2029 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
2031 if (nextstop_offset > stop_offset
2032 || nextstop_offset <= addr_offset)
2033 nextstop_offset = stop_offset;
2035 /* If a symbol is explicitly marked as being an object
2036 rather than a function, just dump the bytes without
2037 disassembling them. */
2038 if (disassemble_all
2039 || sym == NULL
2040 || sym->section != section
2041 || bfd_asymbol_value (sym) > addr
2042 || ((sym->flags & BSF_OBJECT) == 0
2043 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
2044 == NULL)
2045 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
2046 == NULL))
2047 || (sym->flags & BSF_FUNCTION) != 0)
2048 insns = TRUE;
2049 else
2050 insns = FALSE;
2052 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2053 addr_offset, nextstop_offset,
2054 rel_offset, &rel_pp, rel_ppend);
2056 addr_offset = nextstop_offset;
2057 sym = nextsym;
2060 free (data);
2062 if (rel_ppstart != NULL)
2063 free (rel_ppstart);
2066 /* Disassemble the contents of an object file. */
2068 static void
2069 disassemble_data (bfd *abfd)
2071 struct disassemble_info disasm_info;
2072 struct objdump_disasm_info aux;
2073 long i;
2075 print_files = NULL;
2076 prev_functionname = NULL;
2077 prev_line = -1;
2079 /* We make a copy of syms to sort. We don't want to sort syms
2080 because that will screw up the relocs. */
2081 sorted_symcount = symcount ? symcount : dynsymcount;
2082 sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2083 * sizeof (asymbol *));
2084 memcpy (sorted_syms, symcount ? syms : dynsyms,
2085 sorted_symcount * sizeof (asymbol *));
2087 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2089 for (i = 0; i < synthcount; ++i)
2091 sorted_syms[sorted_symcount] = synthsyms + i;
2092 ++sorted_symcount;
2095 /* Sort the symbols into section and symbol order. */
2096 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2098 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2100 disasm_info.application_data = (void *) &aux;
2101 aux.abfd = abfd;
2102 aux.require_sec = FALSE;
2103 aux.dynrelbuf = NULL;
2104 aux.dynrelcount = 0;
2105 aux.reloc = NULL;
2107 disasm_info.print_address_func = objdump_print_address;
2108 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2110 if (machine != NULL)
2112 const bfd_arch_info_type *inf = bfd_scan_arch (machine);
2114 if (inf == NULL)
2115 fatal (_("can't use supplied machine %s"), machine);
2117 abfd->arch_info = inf;
2120 if (endian != BFD_ENDIAN_UNKNOWN)
2122 struct bfd_target *xvec;
2124 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
2125 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2126 xvec->byteorder = endian;
2127 abfd->xvec = xvec;
2130 /* Use libopcodes to locate a suitable disassembler. */
2131 aux.disassemble_fn = disassembler (abfd);
2132 if (!aux.disassemble_fn)
2134 non_fatal (_("can't disassemble for architecture %s\n"),
2135 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2136 exit_status = 1;
2137 return;
2140 disasm_info.flavour = bfd_get_flavour (abfd);
2141 disasm_info.arch = bfd_get_arch (abfd);
2142 disasm_info.mach = bfd_get_mach (abfd);
2143 disasm_info.disassembler_options = disassembler_options;
2144 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2145 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2146 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2147 disasm_info.disassembler_needs_relocs = FALSE;
2149 if (bfd_big_endian (abfd))
2150 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2151 else if (bfd_little_endian (abfd))
2152 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2153 else
2154 /* ??? Aborting here seems too drastic. We could default to big or little
2155 instead. */
2156 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2158 /* Allow the target to customize the info structure. */
2159 disassemble_init_for_target (& disasm_info);
2161 /* Pre-load the dynamic relocs if we are going
2162 to be dumping them along with the disassembly. */
2163 if (dump_dynamic_reloc_info)
2165 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2167 if (relsize < 0)
2168 bfd_fatal (bfd_get_filename (abfd));
2170 if (relsize > 0)
2172 aux.dynrelbuf = (arelent **) xmalloc (relsize);
2173 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2174 aux.dynrelbuf,
2175 dynsyms);
2176 if (aux.dynrelcount < 0)
2177 bfd_fatal (bfd_get_filename (abfd));
2179 /* Sort the relocs by address. */
2180 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2181 compare_relocs);
2184 disasm_info.symtab = sorted_syms;
2185 disasm_info.symtab_size = sorted_symcount;
2187 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2189 if (aux.dynrelbuf != NULL)
2190 free (aux.dynrelbuf);
2191 free (sorted_syms);
2194 static int
2195 load_specific_debug_section (enum dwarf_section_display_enum debug,
2196 asection *sec, void *file)
2198 struct dwarf_section *section = &debug_displays [debug].section;
2199 bfd *abfd = (bfd *) file;
2200 bfd_boolean ret;
2201 int section_is_compressed;
2203 /* If it is already loaded, do nothing. */
2204 if (section->start != NULL)
2205 return 1;
2207 section_is_compressed = section->name == section->compressed_name;
2209 section->address = 0;
2210 section->size = bfd_get_section_size (sec);
2211 section->start = (unsigned char *) xmalloc (section->size);
2213 ret = bfd_get_section_contents (abfd, sec, section->start, 0,
2214 section->size);
2216 if (! ret)
2218 free_debug_section (debug);
2219 printf (_("\nCan't get contents for section '%s'.\n"),
2220 section->name);
2221 return 0;
2224 if (section_is_compressed)
2226 bfd_size_type size = section->size;
2227 if (! bfd_uncompress_section_contents (&section->start, &size))
2229 free_debug_section (debug);
2230 printf (_("\nCan't uncompress section '%s'.\n"), section->name);
2231 return 0;
2233 section->size = size;
2236 if (is_relocatable && debug_displays [debug].relocate)
2238 /* We want to relocate the data we've already read (and
2239 decompressed), so we store a pointer to the data in
2240 the bfd_section, and tell it that the contents are
2241 already in memory. */
2242 sec->contents = section->start;
2243 sec->flags |= SEC_IN_MEMORY;
2244 sec->size = section->size;
2246 ret = bfd_simple_get_relocated_section_contents (abfd,
2247 sec,
2248 section->start,
2249 syms) != NULL;
2251 if (! ret)
2253 free_debug_section (debug);
2254 printf (_("\nCan't get contents for section '%s'.\n"),
2255 section->name);
2256 return 0;
2260 return 1;
2264 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2266 struct dwarf_section *section = &debug_displays [debug].section;
2267 bfd *abfd = (bfd *) file;
2268 asection *sec;
2270 /* If it is already loaded, do nothing. */
2271 if (section->start != NULL)
2272 return 1;
2274 /* Locate the debug section. */
2275 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2276 if (sec != NULL)
2277 section->name = section->uncompressed_name;
2278 else
2280 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2281 if (sec != NULL)
2282 section->name = section->compressed_name;
2284 if (sec == NULL)
2285 return 0;
2287 return load_specific_debug_section (debug, sec, file);
2290 void
2291 free_debug_section (enum dwarf_section_display_enum debug)
2293 struct dwarf_section *section = &debug_displays [debug].section;
2295 if (section->start == NULL)
2296 return;
2298 free ((char *) section->start);
2299 section->start = NULL;
2300 section->address = 0;
2301 section->size = 0;
2304 static void
2305 dump_dwarf_section (bfd *abfd, asection *section,
2306 void *arg ATTRIBUTE_UNUSED)
2308 const char *name = bfd_get_section_name (abfd, section);
2309 const char *match;
2310 int i;
2312 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2313 match = ".debug_info";
2314 else
2315 match = name;
2317 for (i = 0; i < max; i++)
2318 if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2319 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2320 && debug_displays [i].enabled != NULL
2321 && *debug_displays [i].enabled)
2323 struct dwarf_section *sec = &debug_displays [i].section;
2325 if (strcmp (sec->uncompressed_name, match) == 0)
2326 sec->name = sec->uncompressed_name;
2327 else
2328 sec->name = sec->compressed_name;
2329 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2330 section, abfd))
2332 debug_displays [i].display (sec, abfd);
2334 if (i != info && i != abbrev)
2335 free_debug_section ((enum dwarf_section_display_enum) i);
2337 break;
2341 /* Dump the dwarf debugging information. */
2343 static void
2344 dump_dwarf (bfd *abfd)
2346 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2348 eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
2350 if (bfd_big_endian (abfd))
2351 byte_get = byte_get_big_endian;
2352 else if (bfd_little_endian (abfd))
2353 byte_get = byte_get_little_endian;
2354 else
2355 abort ();
2357 switch (bfd_get_arch (abfd))
2359 case bfd_arch_i386:
2360 switch (bfd_get_mach (abfd))
2362 case bfd_mach_x86_64:
2363 case bfd_mach_x86_64_intel_syntax:
2364 init_dwarf_regnames_x86_64 ();
2365 break;
2367 default:
2368 init_dwarf_regnames_i386 ();
2369 break;
2371 break;
2373 default:
2374 break;
2377 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2379 free_debug_memory ();
2382 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2383 it. Return NULL on failure. */
2385 static char *
2386 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2388 asection *stabsect;
2389 bfd_size_type size;
2390 char *contents;
2392 stabsect = bfd_get_section_by_name (abfd, sect_name);
2393 if (stabsect == NULL)
2395 printf (_("No %s section present\n\n"), sect_name);
2396 return FALSE;
2399 size = bfd_section_size (abfd, stabsect);
2400 contents = (char *) xmalloc (size);
2402 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2404 non_fatal (_("reading %s section of %s failed: %s"),
2405 sect_name, bfd_get_filename (abfd),
2406 bfd_errmsg (bfd_get_error ()));
2407 exit_status = 1;
2408 free (contents);
2409 return NULL;
2412 *size_ptr = size;
2414 return contents;
2417 /* Stabs entries use a 12 byte format:
2418 4 byte string table index
2419 1 byte stab type
2420 1 byte stab other field
2421 2 byte stab desc field
2422 4 byte stab value
2423 FIXME: This will have to change for a 64 bit object format. */
2425 #define STRDXOFF (0)
2426 #define TYPEOFF (4)
2427 #define OTHEROFF (5)
2428 #define DESCOFF (6)
2429 #define VALOFF (8)
2430 #define STABSIZE (12)
2432 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2433 using string table section STRSECT_NAME (in `strtab'). */
2435 static void
2436 print_section_stabs (bfd *abfd,
2437 const char *stabsect_name,
2438 unsigned *string_offset_ptr)
2440 int i;
2441 unsigned file_string_table_offset = 0;
2442 unsigned next_file_string_table_offset = *string_offset_ptr;
2443 bfd_byte *stabp, *stabs_end;
2445 stabp = stabs;
2446 stabs_end = stabp + stab_size;
2448 printf (_("Contents of %s section:\n\n"), stabsect_name);
2449 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2451 /* Loop through all symbols and print them.
2453 We start the index at -1 because there is a dummy symbol on
2454 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2455 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2457 const char *name;
2458 unsigned long strx;
2459 unsigned char type, other;
2460 unsigned short desc;
2461 bfd_vma value;
2463 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2464 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2465 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2466 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2467 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2469 printf ("\n%-6d ", i);
2470 /* Either print the stab name, or, if unnamed, print its number
2471 again (makes consistent formatting for tools like awk). */
2472 name = bfd_get_stab_name (type);
2473 if (name != NULL)
2474 printf ("%-6s", name);
2475 else if (type == N_UNDF)
2476 printf ("HdrSym");
2477 else
2478 printf ("%-6d", type);
2479 printf (" %-6d %-6d ", other, desc);
2480 bfd_printf_vma (abfd, value);
2481 printf (" %-6lu", strx);
2483 /* Symbols with type == 0 (N_UNDF) specify the length of the
2484 string table associated with this file. We use that info
2485 to know how to relocate the *next* file's string table indices. */
2486 if (type == N_UNDF)
2488 file_string_table_offset = next_file_string_table_offset;
2489 next_file_string_table_offset += value;
2491 else
2493 /* Using the (possibly updated) string table offset, print the
2494 string (if any) associated with this symbol. */
2495 if ((strx + file_string_table_offset) < stabstr_size)
2496 printf (" %s", &strtab[strx + file_string_table_offset]);
2497 else
2498 printf (" *");
2501 printf ("\n\n");
2502 *string_offset_ptr = next_file_string_table_offset;
2505 typedef struct
2507 const char * section_name;
2508 const char * string_section_name;
2509 unsigned string_offset;
2511 stab_section_names;
2513 static void
2514 find_stabs_section (bfd *abfd, asection *section, void *names)
2516 int len;
2517 stab_section_names * sought = (stab_section_names *) names;
2519 /* Check for section names for which stabsect_name is a prefix, to
2520 handle .stab.N, etc. */
2521 len = strlen (sought->section_name);
2523 /* If the prefix matches, and the files section name ends with a
2524 nul or a digit, then we match. I.e., we want either an exact
2525 match or a section followed by a number. */
2526 if (strncmp (sought->section_name, section->name, len) == 0
2527 && (section->name[len] == 0
2528 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2530 if (strtab == NULL)
2531 strtab = read_section_stabs (abfd, sought->string_section_name,
2532 &stabstr_size);
2534 if (strtab)
2536 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2537 &stab_size);
2538 if (stabs)
2539 print_section_stabs (abfd, section->name, &sought->string_offset);
2544 static void
2545 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2547 stab_section_names s;
2549 s.section_name = stabsect_name;
2550 s.string_section_name = strsect_name;
2551 s.string_offset = 0;
2553 bfd_map_over_sections (abfd, find_stabs_section, & s);
2555 free (strtab);
2556 strtab = NULL;
2559 /* Dump the any sections containing stabs debugging information. */
2561 static void
2562 dump_stabs (bfd *abfd)
2564 dump_stabs_section (abfd, ".stab", ".stabstr");
2565 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2566 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2568 /* For Darwin. */
2569 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2571 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2574 static void
2575 dump_bfd_header (bfd *abfd)
2577 char *comma = "";
2579 printf (_("architecture: %s, "),
2580 bfd_printable_arch_mach (bfd_get_arch (abfd),
2581 bfd_get_mach (abfd)));
2582 printf (_("flags 0x%08x:\n"), abfd->flags);
2584 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2585 PF (HAS_RELOC, "HAS_RELOC");
2586 PF (EXEC_P, "EXEC_P");
2587 PF (HAS_LINENO, "HAS_LINENO");
2588 PF (HAS_DEBUG, "HAS_DEBUG");
2589 PF (HAS_SYMS, "HAS_SYMS");
2590 PF (HAS_LOCALS, "HAS_LOCALS");
2591 PF (DYNAMIC, "DYNAMIC");
2592 PF (WP_TEXT, "WP_TEXT");
2593 PF (D_PAGED, "D_PAGED");
2594 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2595 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2596 printf (_("\nstart address 0x"));
2597 bfd_printf_vma (abfd, abfd->start_address);
2598 printf ("\n");
2602 static void
2603 dump_bfd_private_header (bfd *abfd)
2605 bfd_print_private_bfd_data (abfd, stdout);
2609 /* Display a section in hexadecimal format with associated characters.
2610 Each line prefixed by the zero padded address. */
2612 static void
2613 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2615 bfd_byte *data = 0;
2616 bfd_size_type datasize;
2617 bfd_size_type addr_offset;
2618 bfd_size_type start_offset;
2619 bfd_size_type stop_offset;
2620 unsigned int opb = bfd_octets_per_byte (abfd);
2621 /* Bytes per line. */
2622 const int onaline = 16;
2623 char buf[64];
2624 int count;
2625 int width;
2627 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2628 return;
2630 if (! process_section_p (section))
2631 return;
2633 if ((datasize = bfd_section_size (abfd, section)) == 0)
2634 return;
2636 /* Compute the address range to display. */
2637 if (start_address == (bfd_vma) -1
2638 || start_address < section->vma)
2639 start_offset = 0;
2640 else
2641 start_offset = start_address - section->vma;
2643 if (stop_address == (bfd_vma) -1)
2644 stop_offset = datasize / opb;
2645 else
2647 if (stop_address < section->vma)
2648 stop_offset = 0;
2649 else
2650 stop_offset = stop_address - section->vma;
2652 if (stop_offset > datasize / opb)
2653 stop_offset = datasize / opb;
2656 if (start_offset >= stop_offset)
2657 return;
2659 printf (_("Contents of section %s:"), section->name);
2660 if (display_file_offsets)
2661 printf (_(" (Starting at file offset: 0x%lx)"),
2662 (unsigned long) (section->filepos + start_offset));
2663 printf ("\n");
2665 data = (bfd_byte *) xmalloc (datasize);
2667 bfd_get_section_contents (abfd, section, data, 0, datasize);
2669 width = 4;
2671 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2672 if (strlen (buf) >= sizeof (buf))
2673 abort ();
2675 count = 0;
2676 while (buf[count] == '0' && buf[count+1] != '\0')
2677 count++;
2678 count = strlen (buf) - count;
2679 if (count > width)
2680 width = count;
2682 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2683 if (strlen (buf) >= sizeof (buf))
2684 abort ();
2686 count = 0;
2687 while (buf[count] == '0' && buf[count+1] != '\0')
2688 count++;
2689 count = strlen (buf) - count;
2690 if (count > width)
2691 width = count;
2693 for (addr_offset = start_offset;
2694 addr_offset < stop_offset; addr_offset += onaline / opb)
2696 bfd_size_type j;
2698 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2699 count = strlen (buf);
2700 if ((size_t) count >= sizeof (buf))
2701 abort ();
2703 putchar (' ');
2704 while (count < width)
2706 putchar ('0');
2707 count++;
2709 fputs (buf + count - width, stdout);
2710 putchar (' ');
2712 for (j = addr_offset * opb;
2713 j < addr_offset * opb + onaline; j++)
2715 if (j < stop_offset * opb)
2716 printf ("%02x", (unsigned) (data[j]));
2717 else
2718 printf (" ");
2719 if ((j & 3) == 3)
2720 printf (" ");
2723 printf (" ");
2724 for (j = addr_offset * opb;
2725 j < addr_offset * opb + onaline; j++)
2727 if (j >= stop_offset * opb)
2728 printf (" ");
2729 else
2730 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2732 putchar ('\n');
2734 free (data);
2737 /* Actually display the various requested regions. */
2739 static void
2740 dump_data (bfd *abfd)
2742 bfd_map_over_sections (abfd, dump_section, NULL);
2745 /* Should perhaps share code and display with nm? */
2747 static void
2748 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2750 asymbol **current;
2751 long max_count;
2752 long count;
2754 if (dynamic)
2756 current = dynsyms;
2757 max_count = dynsymcount;
2758 printf ("DYNAMIC SYMBOL TABLE:\n");
2760 else
2762 current = syms;
2763 max_count = symcount;
2764 printf ("SYMBOL TABLE:\n");
2767 if (max_count == 0)
2768 printf (_("no symbols\n"));
2770 for (count = 0; count < max_count; count++)
2772 bfd *cur_bfd;
2774 if (*current == NULL)
2775 printf (_("no information for symbol number %ld\n"), count);
2777 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2778 printf (_("could not determine the type of symbol number %ld\n"),
2779 count);
2781 else if (process_section_p ((* current)->section)
2782 && (dump_special_syms
2783 || !bfd_is_target_special_symbol (cur_bfd, *current)))
2785 const char *name = (*current)->name;
2787 if (do_demangle && name != NULL && *name != '\0')
2789 char *alloc;
2791 /* If we want to demangle the name, we demangle it
2792 here, and temporarily clobber it while calling
2793 bfd_print_symbol. FIXME: This is a gross hack. */
2794 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2795 if (alloc != NULL)
2796 (*current)->name = alloc;
2797 bfd_print_symbol (cur_bfd, stdout, *current,
2798 bfd_print_symbol_all);
2799 if (alloc != NULL)
2801 (*current)->name = name;
2802 free (alloc);
2805 else
2806 bfd_print_symbol (cur_bfd, stdout, *current,
2807 bfd_print_symbol_all);
2808 printf ("\n");
2811 current++;
2813 printf ("\n\n");
2816 static void
2817 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2819 arelent **p;
2820 char *last_filename, *last_functionname;
2821 unsigned int last_line;
2823 /* Get column headers lined up reasonably. */
2825 static int width;
2827 if (width == 0)
2829 char buf[30];
2831 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2832 width = strlen (buf) - 7;
2834 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2837 last_filename = NULL;
2838 last_functionname = NULL;
2839 last_line = 0;
2841 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2843 arelent *q = *p;
2844 const char *filename, *functionname;
2845 unsigned int linenumber;
2846 const char *sym_name;
2847 const char *section_name;
2849 if (start_address != (bfd_vma) -1
2850 && q->address < start_address)
2851 continue;
2852 if (stop_address != (bfd_vma) -1
2853 && q->address > stop_address)
2854 continue;
2856 if (with_line_numbers
2857 && sec != NULL
2858 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2859 &filename, &functionname, &linenumber))
2861 if (functionname != NULL
2862 && (last_functionname == NULL
2863 || strcmp (functionname, last_functionname) != 0))
2865 printf ("%s():\n", functionname);
2866 if (last_functionname != NULL)
2867 free (last_functionname);
2868 last_functionname = xstrdup (functionname);
2871 if (linenumber > 0
2872 && (linenumber != last_line
2873 || (filename != NULL
2874 && last_filename != NULL
2875 && strcmp (filename, last_filename) != 0)))
2877 printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
2878 last_line = linenumber;
2879 if (last_filename != NULL)
2880 free (last_filename);
2881 if (filename == NULL)
2882 last_filename = NULL;
2883 else
2884 last_filename = xstrdup (filename);
2888 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2890 sym_name = (*(q->sym_ptr_ptr))->name;
2891 section_name = (*(q->sym_ptr_ptr))->section->name;
2893 else
2895 sym_name = NULL;
2896 section_name = NULL;
2899 bfd_printf_vma (abfd, q->address);
2900 if (q->howto == NULL)
2901 printf (" *unknown* ");
2902 else if (q->howto->name)
2903 printf (" %-16s ", q->howto->name);
2904 else
2905 printf (" %-16d ", q->howto->type);
2907 if (sym_name)
2909 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2911 else
2913 if (section_name == NULL)
2914 section_name = "*unknown*";
2915 printf ("[%s]", section_name);
2918 if (q->addend)
2920 printf ("+0x");
2921 bfd_printf_vma (abfd, q->addend);
2924 printf ("\n");
2928 static void
2929 dump_relocs_in_section (bfd *abfd,
2930 asection *section,
2931 void *dummy ATTRIBUTE_UNUSED)
2933 arelent **relpp;
2934 long relcount;
2935 long relsize;
2937 if ( bfd_is_abs_section (section)
2938 || bfd_is_und_section (section)
2939 || bfd_is_com_section (section)
2940 || (! process_section_p (section))
2941 || ((section->flags & SEC_RELOC) == 0))
2942 return;
2944 relsize = bfd_get_reloc_upper_bound (abfd, section);
2945 if (relsize < 0)
2946 bfd_fatal (bfd_get_filename (abfd));
2948 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2950 if (relsize == 0)
2952 printf (" (none)\n\n");
2953 return;
2956 relpp = (arelent **) xmalloc (relsize);
2957 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2959 if (relcount < 0)
2960 bfd_fatal (bfd_get_filename (abfd));
2961 else if (relcount == 0)
2962 printf (" (none)\n\n");
2963 else
2965 printf ("\n");
2966 dump_reloc_set (abfd, section, relpp, relcount);
2967 printf ("\n\n");
2969 free (relpp);
2972 static void
2973 dump_relocs (bfd *abfd)
2975 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2978 static void
2979 dump_dynamic_relocs (bfd *abfd)
2981 long relsize;
2982 arelent **relpp;
2983 long relcount;
2985 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2986 if (relsize < 0)
2987 bfd_fatal (bfd_get_filename (abfd));
2989 printf ("DYNAMIC RELOCATION RECORDS");
2991 if (relsize == 0)
2992 printf (" (none)\n\n");
2993 else
2995 relpp = (arelent **) xmalloc (relsize);
2996 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2998 if (relcount < 0)
2999 bfd_fatal (bfd_get_filename (abfd));
3000 else if (relcount == 0)
3001 printf (" (none)\n\n");
3002 else
3004 printf ("\n");
3005 dump_reloc_set (abfd, NULL, relpp, relcount);
3006 printf ("\n\n");
3008 free (relpp);
3012 /* Creates a table of paths, to search for source files. */
3014 static void
3015 add_include_path (const char *path)
3017 if (path[0] == 0)
3018 return;
3019 include_path_count++;
3020 include_paths = (const char **)
3021 xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3022 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3023 if (path[1] == ':' && path[2] == 0)
3024 path = concat (path, ".", (const char *) 0);
3025 #endif
3026 include_paths[include_path_count - 1] = path;
3029 static void
3030 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3031 asection *section,
3032 void *arg)
3034 if ((section->flags & SEC_DEBUGGING) == 0)
3036 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3037 section->vma += adjust_section_vma;
3038 if (*has_reloc_p)
3039 section->lma += adjust_section_vma;
3043 /* Dump selected contents of ABFD. */
3045 static void
3046 dump_bfd (bfd *abfd)
3048 /* If we are adjusting section VMA's, change them all now. Changing
3049 the BFD information is a hack. However, we must do it, or
3050 bfd_find_nearest_line will not do the right thing. */
3051 if (adjust_section_vma != 0)
3053 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3054 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3057 if (! dump_debugging_tags)
3058 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
3059 abfd->xvec->name);
3060 if (dump_ar_hdrs)
3061 print_arelt_descr (stdout, abfd, TRUE);
3062 if (dump_file_header)
3063 dump_bfd_header (abfd);
3064 if (dump_private_headers)
3065 dump_bfd_private_header (abfd);
3066 if (! dump_debugging_tags)
3067 putchar ('\n');
3068 if (dump_section_headers)
3069 dump_headers (abfd);
3071 if (dump_symtab
3072 || dump_reloc_info
3073 || disassemble
3074 || dump_debugging
3075 || dump_dwarf_section_info)
3076 syms = slurp_symtab (abfd);
3077 if (dump_dynamic_symtab || dump_dynamic_reloc_info
3078 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
3079 dynsyms = slurp_dynamic_symtab (abfd);
3080 if (disassemble)
3082 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
3083 dynsymcount, dynsyms, &synthsyms);
3084 if (synthcount < 0)
3085 synthcount = 0;
3088 if (dump_symtab)
3089 dump_symbols (abfd, FALSE);
3090 if (dump_dynamic_symtab)
3091 dump_symbols (abfd, TRUE);
3092 if (dump_dwarf_section_info)
3093 dump_dwarf (abfd);
3094 if (dump_stab_section_info)
3095 dump_stabs (abfd);
3096 if (dump_reloc_info && ! disassemble)
3097 dump_relocs (abfd);
3098 if (dump_dynamic_reloc_info && ! disassemble)
3099 dump_dynamic_relocs (abfd);
3100 if (dump_section_contents)
3101 dump_data (abfd);
3102 if (disassemble)
3103 disassemble_data (abfd);
3105 if (dump_debugging)
3107 void *dhandle;
3109 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3110 if (dhandle != NULL)
3112 if (!print_debugging_info (stdout, dhandle, abfd, syms,
3113 bfd_demangle,
3114 dump_debugging_tags ? TRUE : FALSE))
3116 non_fatal (_("%s: printing debugging information failed"),
3117 bfd_get_filename (abfd));
3118 exit_status = 1;
3121 /* PR 6483: If there was no STABS or IEEE debug
3122 info in the file, try DWARF instead. */
3123 else if (! dump_dwarf_section_info)
3125 dump_dwarf (abfd);
3129 if (syms)
3131 free (syms);
3132 syms = NULL;
3135 if (dynsyms)
3137 free (dynsyms);
3138 dynsyms = NULL;
3141 if (synthsyms)
3143 free (synthsyms);
3144 synthsyms = NULL;
3147 symcount = 0;
3148 dynsymcount = 0;
3149 synthcount = 0;
3152 static void
3153 display_bfd (bfd *abfd)
3155 char **matching;
3157 if (bfd_check_format_matches (abfd, bfd_object, &matching))
3159 dump_bfd (abfd);
3160 return;
3163 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3165 nonfatal (bfd_get_filename (abfd));
3166 list_matching_formats (matching);
3167 free (matching);
3168 return;
3171 if (bfd_get_error () != bfd_error_file_not_recognized)
3173 nonfatal (bfd_get_filename (abfd));
3174 return;
3177 if (bfd_check_format_matches (abfd, bfd_core, &matching))
3179 dump_bfd (abfd);
3180 return;
3183 nonfatal (bfd_get_filename (abfd));
3185 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3187 list_matching_formats (matching);
3188 free (matching);
3192 static void
3193 display_file (char *filename, char *target)
3195 bfd *file;
3196 bfd *arfile = NULL;
3198 if (get_file_size (filename) < 1)
3200 exit_status = 1;
3201 return;
3204 file = bfd_openr (filename, target);
3205 if (file == NULL)
3207 nonfatal (filename);
3208 return;
3211 /* If the file is an archive, process all of its elements. */
3212 if (bfd_check_format (file, bfd_archive))
3214 bfd *last_arfile = NULL;
3216 printf (_("In archive %s:\n"), bfd_get_filename (file));
3217 for (;;)
3219 bfd_set_error (bfd_error_no_error);
3221 arfile = bfd_openr_next_archived_file (file, arfile);
3222 if (arfile == NULL)
3224 if (bfd_get_error () != bfd_error_no_more_archived_files)
3225 nonfatal (bfd_get_filename (file));
3226 break;
3229 display_bfd (arfile);
3231 if (last_arfile != NULL)
3232 bfd_close (last_arfile);
3233 last_arfile = arfile;
3236 if (last_arfile != NULL)
3237 bfd_close (last_arfile);
3239 else
3240 display_bfd (file);
3242 bfd_close (file);
3246 main (int argc, char **argv)
3248 int c;
3249 char *target = default_target;
3250 bfd_boolean seenflag = FALSE;
3252 #if defined (HAVE_SETLOCALE)
3253 #if defined (HAVE_LC_MESSAGES)
3254 setlocale (LC_MESSAGES, "");
3255 #endif
3256 setlocale (LC_CTYPE, "");
3257 #endif
3259 bindtextdomain (PACKAGE, LOCALEDIR);
3260 textdomain (PACKAGE);
3262 program_name = *argv;
3263 xmalloc_set_program_name (program_name);
3265 START_PROGRESS (program_name, 0);
3267 expandargv (&argc, &argv);
3269 bfd_init ();
3270 set_default_bfd_target ();
3272 while ((c = getopt_long (argc, argv,
3273 "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3274 long_options, (int *) 0))
3275 != EOF)
3277 switch (c)
3279 case 0:
3280 break; /* We've been given a long option. */
3281 case 'm':
3282 machine = optarg;
3283 break;
3284 case 'M':
3285 if (disassembler_options)
3286 /* Ignore potential memory leak for now. */
3287 disassembler_options = concat (disassembler_options, ",",
3288 optarg, (const char *) NULL);
3289 else
3290 disassembler_options = optarg;
3291 break;
3292 case 'j':
3293 add_only (optarg);
3294 break;
3295 case 'F':
3296 display_file_offsets = TRUE;
3297 break;
3298 case 'l':
3299 with_line_numbers = TRUE;
3300 break;
3301 case 'b':
3302 target = optarg;
3303 break;
3304 case 'C':
3305 do_demangle = TRUE;
3306 if (optarg != NULL)
3308 enum demangling_styles style;
3310 style = cplus_demangle_name_to_style (optarg);
3311 if (style == unknown_demangling)
3312 fatal (_("unknown demangling style `%s'"),
3313 optarg);
3315 cplus_demangle_set_style (style);
3317 break;
3318 case 'w':
3319 wide_output = TRUE;
3320 break;
3321 case OPTION_ADJUST_VMA:
3322 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3323 break;
3324 case OPTION_START_ADDRESS:
3325 start_address = parse_vma (optarg, "--start-address");
3326 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3327 fatal (_("error: the start address should be before the end address"));
3328 break;
3329 case OPTION_STOP_ADDRESS:
3330 stop_address = parse_vma (optarg, "--stop-address");
3331 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3332 fatal (_("error: the stop address should be after the start address"));
3333 break;
3334 case OPTION_PREFIX:
3335 prefix = optarg;
3336 prefix_length = strlen (prefix);
3337 /* Remove an unnecessary trailing '/' */
3338 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3339 prefix_length--;
3340 break;
3341 case OPTION_PREFIX_STRIP:
3342 prefix_strip = atoi (optarg);
3343 if (prefix_strip < 0)
3344 fatal (_("error: prefix strip must be non-negative"));
3345 break;
3346 case OPTION_INSN_WIDTH:
3347 insn_width = strtoul (optarg, NULL, 0);
3348 if (insn_width <= 0)
3349 fatal (_("error: instruction width must be positive"));
3350 break;
3351 case 'E':
3352 if (strcmp (optarg, "B") == 0)
3353 endian = BFD_ENDIAN_BIG;
3354 else if (strcmp (optarg, "L") == 0)
3355 endian = BFD_ENDIAN_LITTLE;
3356 else
3358 nonfatal (_("unrecognized -E option"));
3359 usage (stderr, 1);
3361 break;
3362 case OPTION_ENDIAN:
3363 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3364 endian = BFD_ENDIAN_BIG;
3365 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3366 endian = BFD_ENDIAN_LITTLE;
3367 else
3369 non_fatal (_("unrecognized --endian type `%s'"), optarg);
3370 exit_status = 1;
3371 usage (stderr, 1);
3373 break;
3375 case 'f':
3376 dump_file_header = TRUE;
3377 seenflag = TRUE;
3378 break;
3379 case 'i':
3380 formats_info = TRUE;
3381 seenflag = TRUE;
3382 break;
3383 case 'I':
3384 add_include_path (optarg);
3385 break;
3386 case 'p':
3387 dump_private_headers = TRUE;
3388 seenflag = TRUE;
3389 break;
3390 case 'x':
3391 dump_private_headers = TRUE;
3392 dump_symtab = TRUE;
3393 dump_reloc_info = TRUE;
3394 dump_file_header = TRUE;
3395 dump_ar_hdrs = TRUE;
3396 dump_section_headers = TRUE;
3397 seenflag = TRUE;
3398 break;
3399 case 't':
3400 dump_symtab = TRUE;
3401 seenflag = TRUE;
3402 break;
3403 case 'T':
3404 dump_dynamic_symtab = TRUE;
3405 seenflag = TRUE;
3406 break;
3407 case 'd':
3408 disassemble = TRUE;
3409 seenflag = TRUE;
3410 break;
3411 case 'z':
3412 disassemble_zeroes = TRUE;
3413 break;
3414 case 'D':
3415 disassemble = TRUE;
3416 disassemble_all = TRUE;
3417 seenflag = TRUE;
3418 break;
3419 case 'S':
3420 disassemble = TRUE;
3421 with_source_code = TRUE;
3422 seenflag = TRUE;
3423 break;
3424 case 'g':
3425 dump_debugging = 1;
3426 seenflag = TRUE;
3427 break;
3428 case 'e':
3429 dump_debugging = 1;
3430 dump_debugging_tags = 1;
3431 do_demangle = TRUE;
3432 seenflag = TRUE;
3433 break;
3434 case 'W':
3435 dump_dwarf_section_info = TRUE;
3436 seenflag = TRUE;
3437 if (optarg)
3438 dwarf_select_sections_by_letters (optarg);
3439 else
3440 dwarf_select_sections_all ();
3441 break;
3442 case OPTION_DWARF:
3443 dump_dwarf_section_info = TRUE;
3444 seenflag = TRUE;
3445 if (optarg)
3446 dwarf_select_sections_by_names (optarg);
3447 else
3448 dwarf_select_sections_all ();
3449 break;
3450 case 'G':
3451 dump_stab_section_info = TRUE;
3452 seenflag = TRUE;
3453 break;
3454 case 's':
3455 dump_section_contents = TRUE;
3456 seenflag = TRUE;
3457 break;
3458 case 'r':
3459 dump_reloc_info = TRUE;
3460 seenflag = TRUE;
3461 break;
3462 case 'R':
3463 dump_dynamic_reloc_info = TRUE;
3464 seenflag = TRUE;
3465 break;
3466 case 'a':
3467 dump_ar_hdrs = TRUE;
3468 seenflag = TRUE;
3469 break;
3470 case 'h':
3471 dump_section_headers = TRUE;
3472 seenflag = TRUE;
3473 break;
3474 case 'H':
3475 usage (stdout, 0);
3476 seenflag = TRUE;
3477 case 'v':
3478 case 'V':
3479 show_version = TRUE;
3480 seenflag = TRUE;
3481 break;
3483 default:
3484 usage (stderr, 1);
3488 if (show_version)
3489 print_version ("objdump");
3491 if (!seenflag)
3492 usage (stderr, 2);
3494 if (formats_info)
3495 exit_status = display_info ();
3496 else
3498 if (optind == argc)
3499 display_file ("a.out", target);
3500 else
3501 for (; optind < argc;)
3502 display_file (argv[optind++], target);
3505 free_only_list ();
3507 END_PROGRESS (program_name);
3509 return exit_status;