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