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