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.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
26 Objdump displays information about one or more object files, either on
27 their own, or inside libraries. It is commonly used as a disassembler,
28 but it can also display information about file headers, symbol tables,
29 relocations, debugging directives and more.
31 The flow of execution is as follows:
33 1. Command line arguments are checked for control switches and the
34 information to be displayed is selected.
36 2. Any remaining arguments are assumed to be object files, and they are
37 processed in order by display_bfd(). If the file is an archive each
38 of its elements is processed in turn.
40 3. The file's target architecture and binary file format are determined
41 by bfd_check_format(). If they are recognised, then dump_bfd() is
44 4. dump_bfd() in turn calls separate functions to display the requested
45 item(s) of information(s). For example disassemble_data() is called if
46 a disassembly has been requested.
48 When disassembling the code loops through blocks of instructions bounded
49 by symbols, calling disassemble_bytes() on each block. The actual
50 disassembling is done by the libopcodes library, via a function pointer
51 supplied by the disassembler() function. */
60 #include "safe-ctype.h"
62 #include "libiberty.h"
64 #include "filenames.h"
74 /* Internal headers for the ELF .stab-dump code - sorry. */
75 #define BYTES_IN_WORD 32
76 #include "aout/aout64.h"
79 static int exit_status
= 0;
81 static char *default_target
= NULL
; /* Default at runtime. */
83 /* The following variables are set based on arguments passed on the
85 static int show_version
= 0; /* Show the version number. */
86 static int dump_section_contents
; /* -s */
87 static int dump_section_headers
; /* -h */
88 static bfd_boolean dump_file_header
; /* -f */
89 static int dump_symtab
; /* -t */
90 static int dump_dynamic_symtab
; /* -T */
91 static int dump_reloc_info
; /* -r */
92 static int dump_dynamic_reloc_info
; /* -R */
93 static int dump_ar_hdrs
; /* -a */
94 static int dump_private_headers
; /* -p */
95 static int prefix_addresses
; /* --prefix-addresses */
96 static int with_line_numbers
; /* -l */
97 static bfd_boolean with_source_code
; /* -S */
98 static int show_raw_insn
; /* --show-raw-insn */
99 static int dump_dwarf_section_info
; /* --dwarf */
100 static int dump_stab_section_info
; /* --stabs */
101 static int do_demangle
; /* -C, --demangle */
102 static bfd_boolean disassemble
; /* -d */
103 static bfd_boolean disassemble_all
; /* -D */
104 static int disassemble_zeroes
; /* --disassemble-zeroes */
105 static bfd_boolean formats_info
; /* -i */
106 static int wide_output
; /* -w */
107 static int insn_width
; /* --insn-width */
108 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
109 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
110 static int dump_debugging
; /* --debugging */
111 static int dump_debugging_tags
; /* --debugging-tags */
112 static int dump_special_syms
= 0; /* --special-syms */
113 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
114 static int file_start_context
= 0; /* --file-start-context */
115 static bfd_boolean display_file_offsets
;/* -F */
116 static const char *prefix
; /* --prefix */
117 static int prefix_strip
; /* --prefix-strip */
118 static size_t prefix_length
;
120 /* Pointer to an array of section names provided by
121 one or more "-j secname" command line options. */
123 /* The total number of slots in the only[] array. */
124 static size_t only_size
= 0;
125 /* The number of occupied slots in the only[] array. */
126 static size_t only_used
= 0;
128 /* Variables for handling include file path table. */
129 static const char **include_paths
;
130 static int include_path_count
;
132 /* Extra info to pass to the section disassembler and address printing
134 struct objdump_disasm_info
138 bfd_boolean require_sec
;
139 arelent
** dynrelbuf
;
141 disassembler_ftype disassemble_fn
;
145 /* Architecture to disassemble for, or default if NULL. */
146 static char *machine
= NULL
;
148 /* Target specific options to the disassembler. */
149 static char *disassembler_options
= NULL
;
151 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
152 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
154 /* The symbol table. */
155 static asymbol
**syms
;
157 /* Number of symbols in `syms'. */
158 static long symcount
= 0;
160 /* The sorted symbol table. */
161 static asymbol
**sorted_syms
;
163 /* Number of symbols in `sorted_syms'. */
164 static long sorted_symcount
= 0;
166 /* The dynamic symbol table. */
167 static asymbol
**dynsyms
;
169 /* The synthetic symbol table. */
170 static asymbol
*synthsyms
;
171 static long synthcount
= 0;
173 /* Number of symbols in `dynsyms'. */
174 static long dynsymcount
= 0;
176 static bfd_byte
*stabs
;
177 static bfd_size_type stab_size
;
180 static bfd_size_type stabstr_size
;
182 static bfd_boolean is_relocatable
= FALSE
;
185 usage (FILE *stream
, int status
)
187 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
188 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
189 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
190 fprintf (stream
, _("\
191 -a, --archive-headers Display archive header information\n\
192 -f, --file-headers Display the contents of the overall file header\n\
193 -p, --private-headers Display object format specific file header contents\n\
194 -h, --[section-]headers Display the contents of the section headers\n\
195 -x, --all-headers Display the contents of all headers\n\
196 -d, --disassemble Display assembler contents of executable sections\n\
197 -D, --disassemble-all Display assembler contents of all sections\n\
198 -S, --source Intermix source code with disassembly\n\
199 -s, --full-contents Display the full contents of all sections requested\n\
200 -g, --debugging Display debug information in object file\n\
201 -e, --debugging-tags Display debug information using ctags style\n\
202 -G, --stabs Display (in raw form) any STABS info in the file\n\
203 -W[lLiaprmfFsoRt] or\n\
204 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
205 =frames-interp,=str,=loc,=Ranges,=pubtypes]\n\
206 Display DWARF info in the file\n\
207 -t, --syms Display the contents of the symbol table(s)\n\
208 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
209 -r, --reloc Display the relocation entries in the file\n\
210 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
211 @<file> Read options from <file>\n\
212 -v, --version Display this program's version number\n\
213 -i, --info List object formats and architectures supported\n\
214 -H, --help Display this information\n\
218 fprintf (stream
, _("\n The following switches are optional:\n"));
219 fprintf (stream
, _("\
220 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
221 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
222 -j, --section=NAME Only display information for section NAME\n\
223 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
224 -EB --endian=big Assume big endian format when disassembling\n\
225 -EL --endian=little Assume little endian format when disassembling\n\
226 --file-start-context Include context from start of file (with -S)\n\
227 -I, --include=DIR Add DIR to search list for source files\n\
228 -l, --line-numbers Include line numbers and filenames in output\n\
229 -F, --file-offsets Include file offsets when displaying information\n\
230 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
231 The STYLE, if specified, can be `auto', `gnu',\n\
232 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
234 -w, --wide Format output for more than 80 columns\n\
235 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
236 --start-address=ADDR Only process data whose address is >= ADDR\n\
237 --stop-address=ADDR Only process data whose address is <= ADDR\n\
238 --prefix-addresses Print complete address alongside disassembly\n\
239 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
240 --insn-width=WIDTH Display WIDTH bytes on a signle line for -d\n\
241 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
242 --special-syms Include special symbols in symbol dumps\n\
243 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
244 --prefix-strip=LEVEL Strip initial directory names for -S\n\
246 list_supported_targets (program_name
, stream
);
247 list_supported_architectures (program_name
, stream
);
249 disassembler_usage (stream
);
251 if (REPORT_BUGS_TO
[0] && status
== 0)
252 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
256 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
260 OPTION_START_ADDRESS
,
269 static struct option long_options
[]=
271 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
272 {"all-headers", no_argument
, NULL
, 'x'},
273 {"private-headers", no_argument
, NULL
, 'p'},
274 {"architecture", required_argument
, NULL
, 'm'},
275 {"archive-headers", no_argument
, NULL
, 'a'},
276 {"debugging", no_argument
, NULL
, 'g'},
277 {"debugging-tags", no_argument
, NULL
, 'e'},
278 {"demangle", optional_argument
, NULL
, 'C'},
279 {"disassemble", no_argument
, NULL
, 'd'},
280 {"disassemble-all", no_argument
, NULL
, 'D'},
281 {"disassembler-options", required_argument
, NULL
, 'M'},
282 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
283 {"dynamic-reloc", no_argument
, NULL
, 'R'},
284 {"dynamic-syms", no_argument
, NULL
, 'T'},
285 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
286 {"file-headers", no_argument
, NULL
, 'f'},
287 {"file-offsets", no_argument
, NULL
, 'F'},
288 {"file-start-context", no_argument
, &file_start_context
, 1},
289 {"full-contents", no_argument
, NULL
, 's'},
290 {"headers", no_argument
, NULL
, 'h'},
291 {"help", no_argument
, NULL
, 'H'},
292 {"info", no_argument
, NULL
, 'i'},
293 {"line-numbers", no_argument
, NULL
, 'l'},
294 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
295 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
296 {"reloc", no_argument
, NULL
, 'r'},
297 {"section", required_argument
, NULL
, 'j'},
298 {"section-headers", no_argument
, NULL
, 'h'},
299 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
300 {"source", no_argument
, NULL
, 'S'},
301 {"special-syms", no_argument
, &dump_special_syms
, 1},
302 {"include", required_argument
, NULL
, 'I'},
303 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
304 {"stabs", no_argument
, NULL
, 'G'},
305 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
306 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
307 {"syms", no_argument
, NULL
, 't'},
308 {"target", required_argument
, NULL
, 'b'},
309 {"version", no_argument
, NULL
, 'V'},
310 {"wide", no_argument
, NULL
, 'w'},
311 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
312 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
313 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
314 {0, no_argument
, 0, 0}
318 nonfatal (const char *msg
)
324 /* Returns TRUE if the specified section should be dumped. */
327 process_section_p (asection
* section
)
334 for (i
= 0; i
< only_used
; i
++)
335 if (strcmp (only
[i
], section
->name
) == 0)
342 dump_section_header (bfd
*abfd
, asection
*section
,
343 void *ignored ATTRIBUTE_UNUSED
)
346 unsigned int opb
= bfd_octets_per_byte (abfd
);
348 /* Ignore linker created section. See elfNN_ia64_object_p in
350 if (section
->flags
& SEC_LINKER_CREATED
)
353 /* PR 10413: Skip sections that we are ignoring. */
354 if (! process_section_p (section
))
357 printf ("%3d %-13s %08lx ", section
->index
,
358 bfd_get_section_name (abfd
, section
),
359 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
360 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
362 bfd_printf_vma (abfd
, section
->lma
);
363 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
364 bfd_get_section_alignment (abfd
, section
));
370 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
372 PF (SEC_HAS_CONTENTS
, "CONTENTS");
373 PF (SEC_ALLOC
, "ALLOC");
374 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
375 PF (SEC_LOAD
, "LOAD");
376 PF (SEC_RELOC
, "RELOC");
377 PF (SEC_READONLY
, "READONLY");
378 PF (SEC_CODE
, "CODE");
379 PF (SEC_DATA
, "DATA");
381 PF (SEC_DEBUGGING
, "DEBUGGING");
382 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
383 PF (SEC_EXCLUDE
, "EXCLUDE");
384 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
385 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
387 PF (SEC_TIC54X_BLOCK
, "BLOCK");
388 PF (SEC_TIC54X_CLINK
, "CLINK");
390 PF (SEC_SMALL_DATA
, "SMALL_DATA");
391 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
392 PF (SEC_COFF_SHARED
, "SHARED");
393 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
394 PF (SEC_GROUP
, "GROUP");
396 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
399 struct coff_comdat_info
*comdat
;
401 switch (section
->flags
& SEC_LINK_DUPLICATES
)
405 case SEC_LINK_DUPLICATES_DISCARD
:
406 ls
= "LINK_ONCE_DISCARD";
408 case SEC_LINK_DUPLICATES_ONE_ONLY
:
409 ls
= "LINK_ONCE_ONE_ONLY";
411 case SEC_LINK_DUPLICATES_SAME_SIZE
:
412 ls
= "LINK_ONCE_SAME_SIZE";
414 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
415 ls
= "LINK_ONCE_SAME_CONTENTS";
418 printf ("%s%s", comma
, ls
);
420 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
422 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
432 dump_headers (bfd
*abfd
)
434 printf (_("Sections:\n"));
437 printf (_("Idx Name Size VMA LMA File off Algn"));
439 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
440 if (bfd_get_arch_size (abfd
) == 32)
441 printf (_("Idx Name Size VMA LMA File off Algn"));
443 printf (_("Idx Name Size VMA LMA File off Algn"));
447 printf (_(" Flags"));
448 if (abfd
->flags
& HAS_LOAD_PAGE
)
452 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
456 slurp_symtab (bfd
*abfd
)
461 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
467 storage
= bfd_get_symtab_upper_bound (abfd
);
469 bfd_fatal (bfd_get_filename (abfd
));
471 sy
= (asymbol
**) xmalloc (storage
);
473 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
475 bfd_fatal (bfd_get_filename (abfd
));
479 /* Read in the dynamic symbols. */
482 slurp_dynamic_symtab (bfd
*abfd
)
487 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
490 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
492 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
497 bfd_fatal (bfd_get_filename (abfd
));
500 sy
= (asymbol
**) xmalloc (storage
);
502 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
504 bfd_fatal (bfd_get_filename (abfd
));
508 /* Filter out (in place) symbols that are useless for disassembly.
509 COUNT is the number of elements in SYMBOLS.
510 Return the number of useful symbols. */
513 remove_useless_symbols (asymbol
**symbols
, long count
)
515 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
519 asymbol
*sym
= *in_ptr
++;
521 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
523 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
525 if (bfd_is_und_section (sym
->section
)
526 || bfd_is_com_section (sym
->section
))
531 return out_ptr
- symbols
;
534 /* Sort symbols into value order. */
537 compare_symbols (const void *ap
, const void *bp
)
539 const asymbol
*a
= * (const asymbol
**) ap
;
540 const asymbol
*b
= * (const asymbol
**) bp
;
550 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
552 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
555 if (a
->section
> b
->section
)
557 else if (a
->section
< b
->section
)
560 an
= bfd_asymbol_name (a
);
561 bn
= bfd_asymbol_name (b
);
565 /* The symbols gnu_compiled and gcc2_compiled convey no real
566 information, so put them after other symbols with the same value. */
567 af
= (strstr (an
, "gnu_compiled") != NULL
568 || strstr (an
, "gcc2_compiled") != NULL
);
569 bf
= (strstr (bn
, "gnu_compiled") != NULL
570 || strstr (bn
, "gcc2_compiled") != NULL
);
577 /* We use a heuristic for the file name, to try to sort it after
578 more useful symbols. It may not work on non Unix systems, but it
579 doesn't really matter; the only difference is precisely which
580 symbol names get printed. */
582 #define file_symbol(s, sn, snl) \
583 (((s)->flags & BSF_FILE) != 0 \
584 || ((sn)[(snl) - 2] == '.' \
585 && ((sn)[(snl) - 1] == 'o' \
586 || (sn)[(snl) - 1] == 'a')))
588 af
= file_symbol (a
, an
, anl
);
589 bf
= file_symbol (b
, bn
, bnl
);
596 /* Try to sort global symbols before local symbols before function
597 symbols before debugging symbols. */
602 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
604 if ((aflags
& BSF_DEBUGGING
) != 0)
609 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
611 if ((aflags
& BSF_FUNCTION
) != 0)
616 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
618 if ((aflags
& BSF_LOCAL
) != 0)
623 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
625 if ((aflags
& BSF_GLOBAL
) != 0)
631 /* Symbols that start with '.' might be section names, so sort them
632 after symbols that don't start with '.'. */
633 if (an
[0] == '.' && bn
[0] != '.')
635 if (an
[0] != '.' && bn
[0] == '.')
638 /* Finally, if we can't distinguish them in any other way, try to
639 get consistent results by sorting the symbols by name. */
640 return strcmp (an
, bn
);
643 /* Sort relocs into address order. */
646 compare_relocs (const void *ap
, const void *bp
)
648 const arelent
*a
= * (const arelent
**) ap
;
649 const arelent
*b
= * (const arelent
**) bp
;
651 if (a
->address
> b
->address
)
653 else if (a
->address
< b
->address
)
656 /* So that associated relocations tied to the same address show up
657 in the correct order, we don't do any further sorting. */
666 /* Print an address (VMA) to the output stream in INFO.
667 If SKIP_ZEROES is TRUE, omit leading zeroes. */
670 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
671 bfd_boolean skip_zeroes
)
675 struct objdump_disasm_info
*aux
;
677 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
678 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
683 for (p
= buf
; *p
== '0'; ++p
)
688 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
691 /* Print the name of a symbol. */
694 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
701 name
= bfd_asymbol_name (sym
);
702 if (do_demangle
&& name
[0] != '\0')
704 /* Demangle the name. */
705 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
711 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
719 /* Locate a symbol given a bfd and a section (from INFO->application_data),
720 and a VMA. If INFO->application_data->require_sec is TRUE, then always
721 require the symbol to be in the section. Returns NULL if there is no
722 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
723 of the symbol in sorted_syms. */
726 find_symbol_for_address (bfd_vma vma
,
727 struct disassemble_info
*inf
,
730 /* @@ Would it speed things up to cache the last two symbols returned,
731 and maybe their address ranges? For many processors, only one memory
732 operand can be present at a time, so the 2-entry cache wouldn't be
733 constantly churned by code doing heavy memory accesses. */
735 /* Indices in `sorted_syms'. */
737 long max_count
= sorted_symcount
;
739 struct objdump_disasm_info
*aux
;
743 bfd_boolean want_section
;
745 if (sorted_symcount
< 1)
748 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
751 opb
= inf
->octets_per_byte
;
753 /* Perform a binary search looking for the closest symbol to the
754 required value. We are searching the range (min, max_count]. */
755 while (min
+ 1 < max_count
)
759 thisplace
= (max_count
+ min
) / 2;
760 sym
= sorted_syms
[thisplace
];
762 if (bfd_asymbol_value (sym
) > vma
)
763 max_count
= thisplace
;
764 else if (bfd_asymbol_value (sym
) < vma
)
773 /* The symbol we want is now in min, the low end of the range we
774 were searching. If there are several symbols with the same
775 value, we want the first one. */
778 && (bfd_asymbol_value (sorted_syms
[thisplace
])
779 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
782 /* Prefer a symbol in the current section if we have multple symbols
783 with the same value, as can occur with overlays or zero size
786 while (min
< max_count
787 && (bfd_asymbol_value (sorted_syms
[min
])
788 == bfd_asymbol_value (sorted_syms
[thisplace
])))
790 if (sorted_syms
[min
]->section
== sec
791 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
798 return sorted_syms
[thisplace
];
803 /* If the file is relocatable, and the symbol could be from this
804 section, prefer a symbol from this section over symbols from
805 others, even if the other symbol's value might be closer.
807 Note that this may be wrong for some symbol references if the
808 sections have overlapping memory ranges, but in that case there's
809 no way to tell what's desired without looking at the relocation
812 Also give the target a chance to reject symbols. */
813 want_section
= (aux
->require_sec
814 || ((abfd
->flags
& HAS_RELOC
) != 0
815 && vma
>= bfd_get_section_vma (abfd
, sec
)
816 && vma
< (bfd_get_section_vma (abfd
, sec
)
817 + bfd_section_size (abfd
, sec
) / opb
)));
818 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
819 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
822 long newplace
= sorted_symcount
;
824 for (i
= min
- 1; i
>= 0; i
--)
826 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
827 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
829 if (newplace
== sorted_symcount
)
832 if (bfd_asymbol_value (sorted_syms
[i
])
833 != bfd_asymbol_value (sorted_syms
[newplace
]))
836 /* Remember this symbol and keep searching until we reach
837 an earlier address. */
842 if (newplace
!= sorted_symcount
)
843 thisplace
= newplace
;
846 /* We didn't find a good symbol with a smaller value.
847 Look for one with a larger value. */
848 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
850 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
851 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
859 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
860 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
861 /* There is no suitable symbol. */
868 return sorted_syms
[thisplace
];
871 /* Print an address and the offset to the nearest symbol. */
874 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
875 bfd_vma vma
, struct disassemble_info
*inf
,
876 bfd_boolean skip_zeroes
)
878 objdump_print_value (vma
, inf
, skip_zeroes
);
884 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
885 bfd_get_section_name (abfd
, sec
));
886 secaddr
= bfd_get_section_vma (abfd
, sec
);
889 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
890 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
892 else if (vma
> secaddr
)
894 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
895 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
897 (*inf
->fprintf_func
) (inf
->stream
, ">");
901 (*inf
->fprintf_func
) (inf
->stream
, " <");
902 objdump_print_symname (abfd
, inf
, sym
);
903 if (bfd_asymbol_value (sym
) > vma
)
905 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
906 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
908 else if (vma
> bfd_asymbol_value (sym
))
910 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
911 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
913 (*inf
->fprintf_func
) (inf
->stream
, ">");
916 if (display_file_offsets
)
917 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
918 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
921 /* Print an address (VMA), symbolically if possible.
922 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
925 objdump_print_addr (bfd_vma vma
,
926 struct disassemble_info
*inf
,
927 bfd_boolean skip_zeroes
)
929 struct objdump_disasm_info
*aux
;
931 bfd_boolean skip_find
= FALSE
;
933 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
935 if (sorted_symcount
< 1)
937 (*inf
->fprintf_func
) (inf
->stream
, "0x");
938 objdump_print_value (vma
, inf
, skip_zeroes
);
940 if (display_file_offsets
)
941 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
942 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
946 if (aux
->reloc
!= NULL
947 && aux
->reloc
->sym_ptr_ptr
!= NULL
948 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
950 sym
= * aux
->reloc
->sym_ptr_ptr
;
952 /* Adjust the vma to the reloc. */
953 vma
+= bfd_asymbol_value (sym
);
955 if (bfd_is_und_section (bfd_get_section (sym
)))
960 sym
= find_symbol_for_address (vma
, inf
, NULL
);
962 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
966 /* Print VMA to INFO. This function is passed to the disassembler
970 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
972 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
975 /* Determine if the given address has a symbol associated with it. */
978 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
982 sym
= find_symbol_for_address (vma
, inf
, NULL
);
984 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
987 /* Hold the last function name and the last line number we displayed
990 static char *prev_functionname
;
991 static unsigned int prev_line
;
993 /* We keep a list of all files that we have seen when doing a
994 disassembly with source, so that we know how much of the file to
995 display. This can be important for inlined functions. */
997 struct print_file_list
999 struct print_file_list
*next
;
1000 const char *filename
;
1001 const char *modname
;
1004 const char **linemap
;
1010 static struct print_file_list
*print_files
;
1012 /* The number of preceding context lines to show when we start
1013 displaying a file for the first time. */
1015 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1017 /* Read a complete file into memory. */
1020 slurp_file (const char *fn
, size_t *size
)
1023 int ps
= getpagesize ();
1028 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1032 if (fstat (fd
, &st
) < 0)
1036 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1037 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1038 if (map
!= (char *)-1L)
1044 map
= (const char *) malloc (*size
);
1045 if (!map
|| (size_t) read (fd
, (char *)map
, *size
) != *size
)
1054 #define line_map_decrease 5
1056 /* Precompute array of lines for a mapped file. */
1058 static const char **
1059 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1061 const char *p
, *lstart
, *end
;
1062 int chars_per_line
= 45; /* First iteration will use 40. */
1063 unsigned int lineno
;
1064 const char **linemap
= NULL
;
1065 unsigned long line_map_size
= 0;
1071 for (p
= map
; p
< end
; p
++)
1075 if (p
+ 1 < end
&& p
[1] == '\r')
1078 else if (*p
== '\r')
1080 if (p
+ 1 < end
&& p
[1] == '\n')
1086 /* End of line found. */
1088 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1090 unsigned long newsize
;
1092 chars_per_line
-= line_map_decrease
;
1093 if (chars_per_line
<= 1)
1095 line_map_size
= size
/ chars_per_line
+ 1;
1096 if (line_map_size
< lineno
+ 1)
1097 line_map_size
= lineno
+ 1;
1098 newsize
= line_map_size
* sizeof (char *);
1099 linemap
= (const char **) xrealloc (linemap
, newsize
);
1102 linemap
[lineno
++] = lstart
;
1110 /* Tries to open MODNAME, and if successful adds a node to print_files
1111 linked list and returns that node. Returns NULL on failure. */
1113 static struct print_file_list
*
1114 try_print_file_open (const char *origname
, const char *modname
)
1116 struct print_file_list
*p
;
1118 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1120 p
->map
= slurp_file (modname
, &p
->mapsize
);
1127 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1129 p
->filename
= origname
;
1130 p
->modname
= modname
;
1131 p
->next
= print_files
;
1137 /* If the the source file, as described in the symtab, is not found
1138 try to locate it in one of the paths specified with -I
1139 If found, add location to print_files linked list. */
1141 static struct print_file_list
*
1142 update_source_path (const char *filename
)
1144 struct print_file_list
*p
;
1148 if (filename
== NULL
)
1151 p
= try_print_file_open (filename
, filename
);
1155 if (include_path_count
== 0)
1158 /* Get the name of the file. */
1159 fname
= lbasename (filename
);
1161 /* If file exists under a new path, we need to add it to the list
1162 so that show_line knows about it. */
1163 for (i
= 0; i
< include_path_count
; i
++)
1165 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1167 p
= try_print_file_open (filename
, modname
);
1177 /* Print a source file line. */
1180 print_line (struct print_file_list
*p
, unsigned int linenum
)
1186 if (linenum
>= p
->maxline
)
1188 l
= p
->linemap
[linenum
];
1189 /* Test fwrite return value to quiet glibc warning. */
1190 len
= strcspn (l
, "\n\r");
1191 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1195 /* Print a range of source code lines. */
1198 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1202 while (start
<= end
)
1204 print_line (p
, start
);
1209 /* Show the line number, or the source line, in a disassembly
1213 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1215 const char *filename
;
1216 const char *functionname
;
1217 unsigned int linenumber
;
1220 if (! with_line_numbers
&& ! with_source_code
)
1223 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1224 &functionname
, &linenumber
))
1227 if (filename
!= NULL
&& *filename
== '\0')
1229 if (functionname
!= NULL
&& *functionname
== '\0')
1230 functionname
= NULL
;
1233 && IS_ABSOLUTE_PATH (filename
)
1237 const char *fname
= filename
;
1238 char *path
= (char *) alloca (prefix_length
+ PATH_MAX
+ 1);
1241 memcpy (path
, prefix
, prefix_length
);
1242 path_up
= path
+ prefix_length
;
1244 /* Build relocated filename, stripping off leading directories
1245 from the initial filename if requested. */
1246 if (prefix_strip
> 0)
1251 /* Skip selected directory levels. */
1252 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1253 if (IS_DIR_SEPARATOR(*s
))
1260 /* Update complete filename. */
1261 strncpy (path_up
, fname
, PATH_MAX
);
1262 path_up
[PATH_MAX
] = '\0';
1270 if (with_line_numbers
)
1272 if (functionname
!= NULL
1273 && (prev_functionname
== NULL
1274 || strcmp (functionname
, prev_functionname
) != 0))
1275 printf ("%s():\n", functionname
);
1276 if (linenumber
> 0 && linenumber
!= prev_line
)
1277 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1280 if (with_source_code
1284 struct print_file_list
**pp
, *p
;
1287 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1288 if (strcmp ((*pp
)->filename
, filename
) == 0)
1295 filename
= xstrdup (filename
);
1296 p
= update_source_path (filename
);
1299 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1301 if (file_start_context
&& p
->first
)
1305 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1306 if (l
>= linenumber
)
1308 if (p
->last_line
>= l
&& p
->last_line
<= linenumber
)
1309 l
= p
->last_line
+ 1;
1311 dump_lines (p
, l
, linenumber
);
1312 p
->last_line
= linenumber
;
1317 if (functionname
!= NULL
1318 && (prev_functionname
== NULL
1319 || strcmp (functionname
, prev_functionname
) != 0))
1321 if (prev_functionname
!= NULL
)
1322 free (prev_functionname
);
1323 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1324 strcpy (prev_functionname
, functionname
);
1327 if (linenumber
> 0 && linenumber
!= prev_line
)
1328 prev_line
= linenumber
;
1331 /* Pseudo FILE object for strings. */
1339 /* sprintf to a "stream". */
1341 static int ATTRIBUTE_PRINTF_2
1342 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1349 size_t space
= f
->alloc
- f
->pos
;
1351 va_start (args
, format
);
1352 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1358 f
->alloc
= (f
->alloc
+ n
) * 2;
1359 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1366 /* The number of zeroes we want to see before we start skipping them.
1367 The number is arbitrarily chosen. */
1369 #define DEFAULT_SKIP_ZEROES 8
1371 /* The number of zeroes to skip at the end of a section. If the
1372 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1373 SKIP_ZEROES, they will be disassembled. If there are fewer than
1374 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1375 attempt to avoid disassembling zeroes inserted by section
1378 #define DEFAULT_SKIP_ZEROES_AT_END 3
1380 /* Disassemble some data in memory between given values. */
1383 disassemble_bytes (struct disassemble_info
* inf
,
1384 disassembler_ftype disassemble_fn
,
1387 bfd_vma start_offset
,
1388 bfd_vma stop_offset
,
1391 arelent
** relppend
)
1393 struct objdump_disasm_info
*aux
;
1395 int octets_per_line
;
1396 bfd_boolean done_dot
;
1397 int skip_addr_chars
;
1398 bfd_vma addr_offset
;
1399 unsigned int opb
= inf
->octets_per_byte
;
1400 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1401 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1405 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1409 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1413 octets_per_line
= insn_width
;
1415 octets_per_line
= 4;
1417 octets_per_line
= 16;
1419 /* Figure out how many characters to skip at the start of an
1420 address, to make the disassembly look nicer. We discard leading
1421 zeroes in chunks of 4, ensuring that there is always a leading
1423 skip_addr_chars
= 0;
1424 if (! prefix_addresses
)
1428 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1430 while (buf
[skip_addr_chars
] == '0')
1433 /* Don't discard zeros on overflow. */
1434 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1435 skip_addr_chars
= 0;
1437 if (skip_addr_chars
!= 0)
1438 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1441 inf
->insn_info_valid
= 0;
1444 addr_offset
= start_offset
;
1445 while (addr_offset
< stop_offset
)
1448 bfd_boolean need_nl
= FALSE
;
1449 int previous_octets
;
1451 /* Remember the length of the previous instruction. */
1452 previous_octets
= octets
;
1455 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1457 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1460 if (! disassemble_zeroes
1461 && (inf
->insn_info_valid
== 0
1462 || inf
->branch_delay_insns
== 0)
1463 && (z
- addr_offset
* opb
>= skip_zeroes
1464 || (z
== stop_offset
* opb
&&
1465 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1467 /* If there are more nonzero octets to follow, we only skip
1468 zeroes in multiples of 4, to try to avoid running over
1469 the start of an instruction which happens to start with
1471 if (z
!= stop_offset
* opb
)
1472 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1474 octets
= z
- addr_offset
* opb
;
1476 /* If we are going to display more data, and we are displaying
1477 file offsets, then tell the user how many zeroes we skip
1478 and the file offset from where we resume dumping. */
1479 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1480 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1482 (unsigned long) (section
->filepos
1483 + (addr_offset
+ (octets
/ opb
))));
1495 if (with_line_numbers
|| with_source_code
)
1496 show_line (aux
->abfd
, section
, addr_offset
);
1498 if (! prefix_addresses
)
1502 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1503 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1507 printf ("%s:\t", buf
+ skip_addr_chars
);
1511 aux
->require_sec
= TRUE
;
1512 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1513 aux
->require_sec
= FALSE
;
1520 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1521 inf
->stream
= &sfile
;
1522 inf
->bytes_per_line
= 0;
1523 inf
->bytes_per_chunk
= 0;
1524 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1526 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1528 if (inf
->disassembler_needs_relocs
1529 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1530 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1531 && *relppp
< relppend
)
1533 bfd_signed_vma distance_to_rel
;
1535 distance_to_rel
= (**relppp
)->address
1536 - (rel_offset
+ addr_offset
);
1538 /* Check to see if the current reloc is associated with
1539 the instruction that we are about to disassemble. */
1540 if (distance_to_rel
== 0
1541 /* FIXME: This is wrong. We are trying to catch
1542 relocs that are addressed part way through the
1543 current instruction, as might happen with a packed
1544 VLIW instruction. Unfortunately we do not know the
1545 length of the current instruction since we have not
1546 disassembled it yet. Instead we take a guess based
1547 upon the length of the previous instruction. The
1548 proper solution is to have a new target-specific
1549 disassembler function which just returns the length
1550 of an instruction at a given address without trying
1551 to display its disassembly. */
1552 || (distance_to_rel
> 0
1553 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1555 inf
->flags
|= INSN_HAS_RELOC
;
1556 aux
->reloc
= **relppp
;
1562 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1563 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1564 inf
->stream
= stdout
;
1565 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1566 octets_per_line
= inf
->bytes_per_line
;
1570 printf ("%s\n", sfile
.buffer
);
1578 octets
= octets_per_line
;
1579 if (addr_offset
+ octets
/ opb
> stop_offset
)
1580 octets
= (stop_offset
- addr_offset
) * opb
;
1582 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1584 if (ISPRINT (data
[j
]))
1585 buf
[j
- addr_offset
* opb
] = data
[j
];
1587 buf
[j
- addr_offset
* opb
] = '.';
1589 buf
[j
- addr_offset
* opb
] = '\0';
1592 if (prefix_addresses
1594 : show_raw_insn
>= 0)
1598 /* If ! prefix_addresses and ! wide_output, we print
1599 octets_per_line octets per line. */
1601 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1602 pb
= octets_per_line
;
1604 if (inf
->bytes_per_chunk
)
1605 bpc
= inf
->bytes_per_chunk
;
1609 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1613 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1615 for (k
= bpc
- 1; k
>= 0; k
--)
1616 printf ("%02x", (unsigned) data
[j
+ k
]);
1621 for (k
= 0; k
< bpc
; k
++)
1622 printf ("%02x", (unsigned) data
[j
+ k
]);
1627 for (; pb
< octets_per_line
; pb
+= bpc
)
1631 for (k
= 0; k
< bpc
; k
++)
1636 /* Separate raw data from instruction by extra space. */
1646 printf ("%s", sfile
.buffer
);
1648 if (prefix_addresses
1650 : show_raw_insn
>= 0)
1658 j
= addr_offset
* opb
+ pb
;
1660 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1661 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1665 printf ("%s:\t", buf
+ skip_addr_chars
);
1667 pb
+= octets_per_line
;
1670 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1674 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1676 for (k
= bpc
- 1; k
>= 0; k
--)
1677 printf ("%02x", (unsigned) data
[j
+ k
]);
1682 for (k
= 0; k
< bpc
; k
++)
1683 printf ("%02x", (unsigned) data
[j
+ k
]);
1696 while ((*relppp
) < relppend
1697 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1699 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1710 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1713 if (q
->howto
== NULL
)
1714 printf (": *unknown*\t");
1715 else if (q
->howto
->name
)
1716 printf (": %s\t", q
->howto
->name
);
1718 printf (": %d\t", q
->howto
->type
);
1720 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1721 printf ("*unknown*");
1724 const char *sym_name
;
1726 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1727 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1728 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
1733 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1734 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1735 if (sym_name
== NULL
|| *sym_name
== '\0')
1736 sym_name
= "*unknown*";
1737 printf ("%s", sym_name
);
1744 objdump_print_value (q
->addend
, inf
, TRUE
);
1756 addr_offset
+= octets
/ opb
;
1759 free (sfile
.buffer
);
1763 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
1765 const struct elf_backend_data
* bed
;
1766 bfd_vma sign_adjust
= 0;
1767 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
1768 struct objdump_disasm_info
* paux
;
1769 unsigned int opb
= pinfo
->octets_per_byte
;
1770 bfd_byte
* data
= NULL
;
1771 bfd_size_type datasize
= 0;
1772 arelent
** rel_pp
= NULL
;
1773 arelent
** rel_ppstart
= NULL
;
1774 arelent
** rel_ppend
;
1775 unsigned long stop_offset
;
1776 asymbol
* sym
= NULL
;
1780 unsigned long addr_offset
;
1782 /* Sections that do not contain machine
1783 code are not normally disassembled. */
1784 if (! disassemble_all
1786 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1787 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1790 if (! process_section_p (section
))
1793 datasize
= bfd_get_section_size (section
);
1797 /* Decide which set of relocs to use. Load them if necessary. */
1798 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1799 if (paux
->dynrelbuf
)
1801 rel_pp
= paux
->dynrelbuf
;
1802 rel_count
= paux
->dynrelcount
;
1803 /* Dynamic reloc addresses are absolute, non-dynamic are section
1804 relative. REL_OFFSET specifies the reloc address corresponding
1805 to the start of this section. */
1806 rel_offset
= section
->vma
;
1814 if ((section
->flags
& SEC_RELOC
) != 0
1815 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1819 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1821 bfd_fatal (bfd_get_filename (abfd
));
1825 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
1826 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1828 bfd_fatal (bfd_get_filename (abfd
));
1830 /* Sort the relocs by address. */
1831 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1835 rel_ppend
= rel_pp
+ rel_count
;
1837 data
= (bfd_byte
*) xmalloc (datasize
);
1839 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1841 paux
->sec
= section
;
1842 pinfo
->buffer
= data
;
1843 pinfo
->buffer_vma
= section
->vma
;
1844 pinfo
->buffer_length
= datasize
;
1845 pinfo
->section
= section
;
1847 if (start_address
== (bfd_vma
) -1
1848 || start_address
< pinfo
->buffer_vma
)
1851 addr_offset
= start_address
- pinfo
->buffer_vma
;
1853 if (stop_address
== (bfd_vma
) -1)
1854 stop_offset
= datasize
/ opb
;
1857 if (stop_address
< pinfo
->buffer_vma
)
1860 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1861 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1862 stop_offset
= pinfo
->buffer_length
/ opb
;
1865 /* Skip over the relocs belonging to addresses below the
1867 while (rel_pp
< rel_ppend
1868 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1871 if (addr_offset
< stop_offset
)
1872 printf (_("\nDisassembly of section %s:\n"), section
->name
);
1874 /* Find the nearest symbol forwards from our current position. */
1875 paux
->require_sec
= TRUE
;
1876 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
1877 (struct disassemble_info
*) inf
,
1879 paux
->require_sec
= FALSE
;
1881 /* PR 9774: If the target used signed addresses then we must make
1882 sure that we sign extend the value that we calculate for 'addr'
1883 in the loop below. */
1884 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1885 && (bed
= get_elf_backend_data (abfd
)) != NULL
1886 && bed
->sign_extend_vma
)
1887 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
1889 /* Disassemble a block of instructions up to the address associated with
1890 the symbol we have just found. Then print the symbol and find the
1891 next symbol on. Repeat until we have disassembled the entire section
1892 or we have reached the end of the address range we are interested in. */
1893 while (addr_offset
< stop_offset
)
1897 unsigned long nextstop_offset
;
1900 addr
= section
->vma
+ addr_offset
;
1901 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
1903 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1908 (x
< sorted_symcount
1909 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1913 pinfo
->symbols
= sorted_syms
+ place
;
1914 pinfo
->num_symbols
= x
- place
;
1915 pinfo
->symtab_pos
= place
;
1919 pinfo
->symbols
= NULL
;
1920 pinfo
->num_symbols
= 0;
1921 pinfo
->symtab_pos
= -1;
1924 if (! prefix_addresses
)
1926 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1927 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1929 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1932 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1934 else if (sym
== NULL
)
1938 #define is_valid_next_sym(SYM) \
1939 ((SYM)->section == section \
1940 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1941 && pinfo->symbol_is_valid (SYM, pinfo))
1943 /* Search forward for the next appropriate symbol in
1944 SECTION. Note that all the symbols are sorted
1945 together into one big array, and that some sections
1946 may have overlapping addresses. */
1947 while (place
< sorted_symcount
1948 && ! is_valid_next_sym (sorted_syms
[place
]))
1951 if (place
>= sorted_symcount
)
1954 nextsym
= sorted_syms
[place
];
1957 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1958 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1959 else if (nextsym
== NULL
)
1960 nextstop_offset
= stop_offset
;
1962 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1964 if (nextstop_offset
> stop_offset
1965 || nextstop_offset
<= addr_offset
)
1966 nextstop_offset
= stop_offset
;
1968 /* If a symbol is explicitly marked as being an object
1969 rather than a function, just dump the bytes without
1970 disassembling them. */
1973 || sym
->section
!= section
1974 || bfd_asymbol_value (sym
) > addr
1975 || ((sym
->flags
& BSF_OBJECT
) == 0
1976 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1978 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1980 || (sym
->flags
& BSF_FUNCTION
) != 0)
1985 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1986 addr_offset
, nextstop_offset
,
1987 rel_offset
, &rel_pp
, rel_ppend
);
1989 addr_offset
= nextstop_offset
;
1995 if (rel_ppstart
!= NULL
)
1999 /* Disassemble the contents of an object file. */
2002 disassemble_data (bfd
*abfd
)
2004 struct disassemble_info disasm_info
;
2005 struct objdump_disasm_info aux
;
2009 prev_functionname
= NULL
;
2012 /* We make a copy of syms to sort. We don't want to sort syms
2013 because that will screw up the relocs. */
2014 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2015 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2016 * sizeof (asymbol
*));
2017 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2018 sorted_symcount
* sizeof (asymbol
*));
2020 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2022 for (i
= 0; i
< synthcount
; ++i
)
2024 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2028 /* Sort the symbols into section and symbol order. */
2029 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2031 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2033 disasm_info
.application_data
= (void *) &aux
;
2035 aux
.require_sec
= FALSE
;
2036 aux
.dynrelbuf
= NULL
;
2037 aux
.dynrelcount
= 0;
2040 disasm_info
.print_address_func
= objdump_print_address
;
2041 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2043 if (machine
!= NULL
)
2045 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2048 fatal (_("Can't use supplied machine %s"), machine
);
2050 abfd
->arch_info
= inf
;
2053 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2055 struct bfd_target
*xvec
;
2057 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2058 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2059 xvec
->byteorder
= endian
;
2063 /* Use libopcodes to locate a suitable disassembler. */
2064 aux
.disassemble_fn
= disassembler (abfd
);
2065 if (!aux
.disassemble_fn
)
2067 non_fatal (_("Can't disassemble for architecture %s\n"),
2068 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2073 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2074 disasm_info
.arch
= bfd_get_arch (abfd
);
2075 disasm_info
.mach
= bfd_get_mach (abfd
);
2076 disasm_info
.disassembler_options
= disassembler_options
;
2077 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2078 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2079 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2080 disasm_info
.disassembler_needs_relocs
= FALSE
;
2082 if (bfd_big_endian (abfd
))
2083 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2084 else if (bfd_little_endian (abfd
))
2085 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2087 /* ??? Aborting here seems too drastic. We could default to big or little
2089 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2091 /* Allow the target to customize the info structure. */
2092 disassemble_init_for_target (& disasm_info
);
2094 /* Pre-load the dynamic relocs if we are going
2095 to be dumping them along with the disassembly. */
2096 if (dump_dynamic_reloc_info
)
2098 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2101 bfd_fatal (bfd_get_filename (abfd
));
2105 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2106 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2109 if (aux
.dynrelcount
< 0)
2110 bfd_fatal (bfd_get_filename (abfd
));
2112 /* Sort the relocs by address. */
2113 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2117 disasm_info
.symtab
= sorted_syms
;
2118 disasm_info
.symtab_size
= sorted_symcount
;
2120 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2122 if (aux
.dynrelbuf
!= NULL
)
2123 free (aux
.dynrelbuf
);
2128 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2129 asection
*sec
, void *file
)
2131 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2132 bfd
*abfd
= (bfd
*) file
;
2134 int section_is_compressed
;
2136 /* If it is already loaded, do nothing. */
2137 if (section
->start
!= NULL
)
2140 section_is_compressed
= section
->name
== section
->compressed_name
;
2142 section
->address
= 0;
2143 section
->size
= bfd_get_section_size (sec
);
2144 section
->start
= (unsigned char *) xmalloc (section
->size
);
2146 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2147 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2152 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
2157 free_debug_section (debug
);
2158 printf (_("\nCan't get contents for section '%s'.\n"),
2163 if (section_is_compressed
)
2165 bfd_size_type size
= section
->size
;
2166 if (! bfd_uncompress_section_contents (§ion
->start
, &size
))
2168 free_debug_section (debug
);
2169 printf (_("\nCan't uncompress section '%s'.\n"), section
->name
);
2172 section
->size
= size
;
2179 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2181 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2182 bfd
*abfd
= (bfd
*) file
;
2185 /* If it is already loaded, do nothing. */
2186 if (section
->start
!= NULL
)
2189 /* Locate the debug section. */
2190 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2192 section
->name
= section
->uncompressed_name
;
2195 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2197 section
->name
= section
->compressed_name
;
2202 return load_specific_debug_section (debug
, sec
, file
);
2206 free_debug_section (enum dwarf_section_display_enum debug
)
2208 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2210 if (section
->start
== NULL
)
2213 free ((char *) section
->start
);
2214 section
->start
= NULL
;
2215 section
->address
= 0;
2220 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2221 void *arg ATTRIBUTE_UNUSED
)
2223 const char *name
= bfd_get_section_name (abfd
, section
);
2227 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2228 match
= ".debug_info";
2232 for (i
= 0; i
< max
; i
++)
2233 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2234 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2235 && debug_displays
[i
].enabled
!= NULL
2236 && *debug_displays
[i
].enabled
)
2238 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2240 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2241 sec
->name
= sec
->uncompressed_name
;
2243 sec
->name
= sec
->compressed_name
;
2244 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2247 debug_displays
[i
].display (sec
, abfd
);
2249 if (i
!= info
&& i
!= abbrev
)
2250 free_debug_section ((enum dwarf_section_display_enum
) i
);
2256 /* Dump the dwarf debugging information. */
2259 dump_dwarf (bfd
*abfd
)
2261 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
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;
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
;
2274 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
2276 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2277 init_dwarf_regnames (bed
->elf_machine_code
);
2280 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2282 free_debug_memory ();
2285 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2286 it. Return NULL on failure. */
2289 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2295 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2296 if (stabsect
== NULL
)
2298 printf (_("No %s section present\n\n"), sect_name
);
2302 size
= bfd_section_size (abfd
, stabsect
);
2303 contents
= (char *) xmalloc (size
);
2305 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2307 non_fatal (_("Reading %s section of %s failed: %s"),
2308 sect_name
, bfd_get_filename (abfd
),
2309 bfd_errmsg (bfd_get_error ()));
2320 /* Stabs entries use a 12 byte format:
2321 4 byte string table index
2323 1 byte stab other field
2324 2 byte stab desc field
2326 FIXME: This will have to change for a 64 bit object format. */
2328 #define STRDXOFF (0)
2330 #define OTHEROFF (5)
2333 #define STABSIZE (12)
2335 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2336 using string table section STRSECT_NAME (in `strtab'). */
2339 print_section_stabs (bfd
*abfd
,
2340 const char *stabsect_name
,
2341 unsigned *string_offset_ptr
)
2344 unsigned file_string_table_offset
= 0;
2345 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2346 bfd_byte
*stabp
, *stabs_end
;
2349 stabs_end
= stabp
+ stab_size
;
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");
2354 /* Loop through all symbols and print them.
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
++)
2362 unsigned char type
, other
;
2363 unsigned short desc
;
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
);
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
);
2377 printf ("%-6s", name
);
2378 else if (type
== N_UNDF
)
2381 printf ("%-6d", type
);
2382 printf (" %-6d %-6d ", other
, desc
);
2383 bfd_printf_vma (abfd
, value
);
2384 printf (" %-6lu", strx
);
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. */
2391 file_string_table_offset
= next_file_string_table_offset
;
2392 next_file_string_table_offset
+= value
;
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
]);
2405 *string_offset_ptr
= next_file_string_table_offset
;
2410 const char * section_name
;
2411 const char * string_section_name
;
2412 unsigned string_offset
;
2417 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2420 stab_section_names
* sought
= (stab_section_names
*) names
;
2422 /* Check for section names for which stabsect_name is a prefix, to
2423 handle .stab.N, etc. */
2424 len
= strlen (sought
->section_name
);
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]))))
2434 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2439 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2442 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2448 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2450 stab_section_names s
;
2452 s
.section_name
= stabsect_name
;
2453 s
.string_section_name
= strsect_name
;
2454 s
.string_offset
= 0;
2456 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2462 /* Dump the any sections containing stabs debugging information. */
2465 dump_stabs (bfd
*abfd
)
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");
2472 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2474 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2478 dump_bfd_header (bfd
*abfd
)
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
);
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
);
2506 dump_bfd_private_header (bfd
*abfd
)
2508 bfd_print_private_bfd_data (abfd
, stdout
);
2512 /* Display a section in hexadecimal format with associated characters.
2513 Each line prefixed by the zero padded address. */
2516 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
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;
2530 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2533 if (! process_section_p (section
))
2536 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2539 /* Compute the address range to display. */
2540 if (start_address
== (bfd_vma
) -1
2541 || start_address
< section
->vma
)
2544 start_offset
= start_address
- section
->vma
;
2546 if (stop_address
== (bfd_vma
) -1)
2547 stop_offset
= datasize
/ opb
;
2550 if (stop_address
< section
->vma
)
2553 stop_offset
= stop_address
- section
->vma
;
2555 if (stop_offset
> datasize
/ opb
)
2556 stop_offset
= datasize
/ opb
;
2559 if (start_offset
>= stop_offset
)
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
));
2568 data
= (bfd_byte
*) xmalloc (datasize
);
2570 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2574 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2575 if (strlen (buf
) >= sizeof (buf
))
2579 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2581 count
= strlen (buf
) - count
;
2585 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2586 if (strlen (buf
) >= sizeof (buf
))
2590 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2592 count
= strlen (buf
) - count
;
2596 for (addr_offset
= start_offset
;
2597 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2601 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2602 count
= strlen (buf
);
2603 if ((size_t) count
>= sizeof (buf
))
2607 while (count
< width
)
2612 fputs (buf
+ count
- width
, stdout
);
2615 for (j
= addr_offset
* opb
;
2616 j
< addr_offset
* opb
+ onaline
; j
++)
2618 if (j
< stop_offset
* opb
)
2619 printf ("%02x", (unsigned) (data
[j
]));
2627 for (j
= addr_offset
* opb
;
2628 j
< addr_offset
* opb
+ onaline
; j
++)
2630 if (j
>= stop_offset
* opb
)
2633 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2640 /* Actually display the various requested regions. */
2643 dump_data (bfd
*abfd
)
2645 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2648 /* Should perhaps share code and display with nm? */
2651 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2660 max_count
= dynsymcount
;
2661 printf ("DYNAMIC SYMBOL TABLE:\n");
2666 max_count
= symcount
;
2667 printf ("SYMBOL TABLE:\n");
2671 printf (_("no symbols\n"));
2673 for (count
= 0; count
< max_count
; count
++)
2677 if (*current
== NULL
)
2678 printf (_("no information for symbol number %ld\n"), count
);
2680 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2681 printf (_("could not determine the type of symbol number %ld\n"),
2684 else if (process_section_p ((* current
)->section
)
2685 && (dump_special_syms
2686 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2688 const char *name
= (*current
)->name
;
2690 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
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
);
2699 (*current
)->name
= alloc
;
2700 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2701 bfd_print_symbol_all
);
2704 (*current
)->name
= name
;
2709 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2710 bfd_print_symbol_all
);
2720 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2723 char *last_filename
, *last_functionname
;
2724 unsigned int last_line
;
2726 /* Get column headers lined up reasonably. */
2734 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2735 width
= strlen (buf
) - 7;
2737 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2740 last_filename
= NULL
;
2741 last_functionname
= NULL
;
2744 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2747 const char *filename
, *functionname
;
2748 unsigned int linenumber
;
2749 const char *sym_name
;
2750 const char *section_name
;
2752 if (start_address
!= (bfd_vma
) -1
2753 && q
->address
< start_address
)
2755 if (stop_address
!= (bfd_vma
) -1
2756 && q
->address
> stop_address
)
2759 if (with_line_numbers
2761 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2762 &filename
, &functionname
, &linenumber
))
2764 if (functionname
!= NULL
2765 && (last_functionname
== NULL
2766 || strcmp (functionname
, last_functionname
) != 0))
2768 printf ("%s():\n", functionname
);
2769 if (last_functionname
!= NULL
)
2770 free (last_functionname
);
2771 last_functionname
= xstrdup (functionname
);
2775 && (linenumber
!= last_line
2776 || (filename
!= NULL
2777 && last_filename
!= NULL
2778 && strcmp (filename
, last_filename
) != 0)))
2780 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
2781 last_line
= linenumber
;
2782 if (last_filename
!= NULL
)
2783 free (last_filename
);
2784 if (filename
== NULL
)
2785 last_filename
= NULL
;
2787 last_filename
= xstrdup (filename
);
2791 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2793 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2794 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2799 section_name
= NULL
;
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
);
2808 printf (" %-16d ", q
->howto
->type
);
2812 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2816 if (section_name
== NULL
)
2817 section_name
= "*unknown*";
2818 printf ("[%s]", section_name
);
2824 bfd_printf_vma (abfd
, q
->addend
);
2832 dump_relocs_in_section (bfd
*abfd
,
2834 void *dummy ATTRIBUTE_UNUSED
)
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))
2847 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2849 bfd_fatal (bfd_get_filename (abfd
));
2851 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2855 printf (" (none)\n\n");
2859 relpp
= (arelent
**) xmalloc (relsize
);
2860 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2863 bfd_fatal (bfd_get_filename (abfd
));
2864 else if (relcount
== 0)
2865 printf (" (none)\n\n");
2869 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2876 dump_relocs (bfd
*abfd
)
2878 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2882 dump_dynamic_relocs (bfd
*abfd
)
2888 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2890 bfd_fatal (bfd_get_filename (abfd
));
2892 printf ("DYNAMIC RELOCATION RECORDS");
2895 printf (" (none)\n\n");
2898 relpp
= (arelent
**) xmalloc (relsize
);
2899 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2902 bfd_fatal (bfd_get_filename (abfd
));
2903 else if (relcount
== 0)
2904 printf (" (none)\n\n");
2908 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2915 /* Creates a table of paths, to search for source files. */
2918 add_include_path (const char *path
)
2922 include_path_count
++;
2923 include_paths
= (const char **)
2924 xrealloc (include_paths
, 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);
2929 include_paths
[include_path_count
- 1] = path
;
2933 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2937 if ((section
->flags
& SEC_DEBUGGING
) == 0)
2939 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
2940 section
->vma
+= adjust_section_vma
;
2942 section
->lma
+= adjust_section_vma
;
2946 /* Dump selected contents of ABFD. */
2949 dump_bfd (bfd
*abfd
)
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)
2956 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
2957 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
2960 if (! dump_debugging_tags
)
2961 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
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
)
2971 if (dump_section_headers
)
2972 dump_headers (abfd
);
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
);
2985 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2986 dynsymcount
, dynsyms
, &synthsyms
);
2992 dump_symbols (abfd
, FALSE
);
2993 if (dump_dynamic_symtab
)
2994 dump_symbols (abfd
, TRUE
);
2995 if (dump_dwarf_section_info
)
2997 if (dump_stab_section_info
)
2999 if (dump_reloc_info
&& ! disassemble
)
3001 if (dump_dynamic_reloc_info
&& ! disassemble
)
3002 dump_dynamic_relocs (abfd
);
3003 if (dump_section_contents
)
3006 disassemble_data (abfd
);
3012 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3013 if (dhandle
!= NULL
)
3015 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3017 dump_debugging_tags
? TRUE
: FALSE
))
3019 non_fatal (_("%s: printing debugging information failed"),
3020 bfd_get_filename (abfd
));
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
)
3056 display_bfd (bfd
*abfd
)
3060 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3066 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3068 nonfatal (bfd_get_filename (abfd
));
3069 list_matching_formats (matching
);
3074 if (bfd_get_error () != bfd_error_file_not_recognized
)
3076 nonfatal (bfd_get_filename (abfd
));
3080 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3086 nonfatal (bfd_get_filename (abfd
));
3088 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3090 list_matching_formats (matching
);
3096 display_file (char *filename
, char *target
)
3101 if (get_file_size (filename
) < 1)
3107 file
= bfd_openr (filename
, target
);
3110 nonfatal (filename
);
3114 /* If the file is an archive, process all of its elements. */
3115 if (bfd_check_format (file
, bfd_archive
))
3117 bfd
*last_arfile
= NULL
;
3119 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3122 bfd_set_error (bfd_error_no_error
);
3124 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3127 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3128 nonfatal (bfd_get_filename (file
));
3132 display_bfd (arfile
);
3134 if (last_arfile
!= NULL
)
3135 bfd_close (last_arfile
);
3136 last_arfile
= arfile
;
3139 if (last_arfile
!= NULL
)
3140 bfd_close (last_arfile
);
3149 main (int argc
, char **argv
)
3152 char *target
= default_target
;
3153 bfd_boolean seenflag
= FALSE
;
3155 #if defined (HAVE_SETLOCALE)
3156 #if defined (HAVE_LC_MESSAGES)
3157 setlocale (LC_MESSAGES
, "");
3159 setlocale (LC_CTYPE
, "");
3162 bindtextdomain (PACKAGE
, LOCALEDIR
);
3163 textdomain (PACKAGE
);
3165 program_name
= *argv
;
3166 xmalloc_set_program_name (program_name
);
3168 START_PROGRESS (program_name
, 0);
3170 expandargv (&argc
, &argv
);
3173 set_default_bfd_target ();
3175 while ((c
= getopt_long (argc
, argv
,
3176 "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3177 long_options
, (int *) 0))
3183 break; /* We've been given a long option. */
3188 if (disassembler_options
)
3189 /* Ignore potential memory leak for now. */
3190 disassembler_options
= concat (disassembler_options
, ",",
3191 optarg
, (const char *) NULL
);
3193 disassembler_options
= optarg
;
3196 if (only_used
== only_size
)
3199 only
= (char **) xrealloc (only
, only_size
* sizeof (char *));
3201 only
[only_used
++] = optarg
;
3204 display_file_offsets
= TRUE
;
3207 with_line_numbers
= TRUE
;
3216 enum demangling_styles style
;
3218 style
= cplus_demangle_name_to_style (optarg
);
3219 if (style
== unknown_demangling
)
3220 fatal (_("unknown demangling style `%s'"),
3223 cplus_demangle_set_style (style
);
3229 case OPTION_ADJUST_VMA
:
3230 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
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"));
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"));
3244 prefix_length
= strlen (prefix
);
3245 /* Remove an unnecessary trailing '/' */
3246 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3249 case OPTION_PREFIX_STRIP
:
3250 prefix_strip
= atoi (optarg
);
3251 if (prefix_strip
< 0)
3252 fatal (_("error: prefix strip must be non-negative"));
3254 case OPTION_INSN_WIDTH
:
3255 insn_width
= strtoul (optarg
, NULL
, 0);
3256 if (insn_width
<= 0)
3257 fatal (_("error: instruction width must be positive"));
3260 if (strcmp (optarg
, "B") == 0)
3261 endian
= BFD_ENDIAN_BIG
;
3262 else if (strcmp (optarg
, "L") == 0)
3263 endian
= BFD_ENDIAN_LITTLE
;
3266 non_fatal (_("unrecognized -E option"));
3271 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3272 endian
= BFD_ENDIAN_BIG
;
3273 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3274 endian
= BFD_ENDIAN_LITTLE
;
3277 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3283 dump_file_header
= TRUE
;
3287 formats_info
= TRUE
;
3291 add_include_path (optarg
);
3294 dump_private_headers
= TRUE
;
3298 dump_private_headers
= TRUE
;
3300 dump_reloc_info
= TRUE
;
3301 dump_file_header
= TRUE
;
3302 dump_ar_hdrs
= TRUE
;
3303 dump_section_headers
= TRUE
;
3311 dump_dynamic_symtab
= TRUE
;
3319 disassemble_zeroes
= TRUE
;
3323 disassemble_all
= TRUE
;
3328 with_source_code
= TRUE
;
3337 dump_debugging_tags
= 1;
3342 dump_dwarf_section_info
= TRUE
;
3345 dwarf_select_sections_by_letters (optarg
);
3347 dwarf_select_sections_all ();
3350 dump_dwarf_section_info
= TRUE
;
3353 dwarf_select_sections_by_names (optarg
);
3355 dwarf_select_sections_all ();
3358 dump_stab_section_info
= TRUE
;
3362 dump_section_contents
= TRUE
;
3366 dump_reloc_info
= TRUE
;
3370 dump_dynamic_reloc_info
= TRUE
;
3374 dump_ar_hdrs
= TRUE
;
3378 dump_section_headers
= TRUE
;
3386 show_version
= TRUE
;
3396 print_version ("objdump");
3402 exit_status
= display_info ();
3406 display_file ("a.out", target
);
3408 for (; optind
< argc
;)
3409 display_file (argv
[optind
++], target
);
3412 END_PROGRESS (program_name
);