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