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