1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
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 2, 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, MA 02110-1301, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
57 #include "safe-ctype.h"
59 #include "libiberty.h"
68 /* Internal headers for the ELF .stab-dump code - sorry. */
69 #define BYTES_IN_WORD 32
70 #include "aout/aout64.h"
73 static int exit_status
= 0;
75 static char *default_target
= NULL
; /* Default at runtime. */
77 /* The following variables are set based on arguments passed on the
79 static int show_version
= 0; /* Show the version number. */
80 static int dump_section_contents
; /* -s */
81 static int dump_section_headers
; /* -h */
82 static bfd_boolean dump_file_header
; /* -f */
83 static int dump_symtab
; /* -t */
84 static int dump_dynamic_symtab
; /* -T */
85 static int dump_reloc_info
; /* -r */
86 static int dump_dynamic_reloc_info
; /* -R */
87 static int dump_ar_hdrs
; /* -a */
88 static int dump_private_headers
; /* -p */
89 static int prefix_addresses
; /* --prefix-addresses */
90 static int with_line_numbers
; /* -l */
91 static bfd_boolean with_source_code
; /* -S */
92 static int show_raw_insn
; /* --show-raw-insn */
93 static int dump_dwarf_section_info
; /* --dwarf */
94 static int dump_stab_section_info
; /* --stabs */
95 static int do_demangle
; /* -C, --demangle */
96 static bfd_boolean disassemble
; /* -d */
97 static bfd_boolean disassemble_all
; /* -D */
98 static int disassemble_zeroes
; /* --disassemble-zeroes */
99 static bfd_boolean formats_info
; /* -i */
100 static int wide_output
; /* -w */
101 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
102 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
103 static int dump_debugging
; /* --debugging */
104 static int dump_debugging_tags
; /* --debugging-tags */
105 static int dump_special_syms
= 0; /* --special-syms */
106 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
107 static int file_start_context
= 0; /* --file-start-context */
109 /* Pointer to an array of section names provided by
110 one or more "-j secname" command line options. */
112 /* The total number of slots in the only[] array. */
113 static size_t only_size
= 0;
114 /* The number of occupied slots in the only[] array. */
115 static size_t only_used
= 0;
117 /* Variables for handling include file path table. */
118 static const char **include_paths
;
119 static int include_path_count
;
121 /* Extra info to pass to the section disassembler and address printing
123 struct objdump_disasm_info
127 bfd_boolean require_sec
;
128 arelent
** dynrelbuf
;
130 disassembler_ftype disassemble_fn
;
134 /* Architecture to disassemble for, or default if NULL. */
135 static char *machine
= NULL
;
137 /* Target specific options to the disassembler. */
138 static char *disassembler_options
= NULL
;
140 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
141 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
143 /* The symbol table. */
144 static asymbol
**syms
;
146 /* Number of symbols in `syms'. */
147 static long symcount
= 0;
149 /* The sorted symbol table. */
150 static asymbol
**sorted_syms
;
152 /* Number of symbols in `sorted_syms'. */
153 static long sorted_symcount
= 0;
155 /* The dynamic symbol table. */
156 static asymbol
**dynsyms
;
158 /* The synthetic symbol table. */
159 static asymbol
*synthsyms
;
160 static long synthcount
= 0;
162 /* Number of symbols in `dynsyms'. */
163 static long dynsymcount
= 0;
165 static bfd_byte
*stabs
;
166 static bfd_size_type stab_size
;
169 static bfd_size_type stabstr_size
;
172 usage (FILE *stream
, int status
)
174 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
175 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
176 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
177 fprintf (stream
, _("\
178 -a, --archive-headers Display archive header information\n\
179 -f, --file-headers Display the contents of the overall file header\n\
180 -p, --private-headers Display object format specific file header contents\n\
181 -h, --[section-]headers Display the contents of the section headers\n\
182 -x, --all-headers Display the contents of all headers\n\
183 -d, --disassemble Display assembler contents of executable sections\n\
184 -D, --disassemble-all Display assembler contents of all sections\n\
185 -S, --source Intermix source code with disassembly\n\
186 -s, --full-contents Display the full contents of all sections requested\n\
187 -g, --debugging Display debug information in object file\n\
188 -e, --debugging-tags Display debug information using ctags style\n\
189 -G, --stabs Display (in raw form) any STABS info in the file\n\
190 -W, --dwarf Display DWARF info in the file\n\
191 -t, --syms Display the contents of the symbol table(s)\n\
192 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
193 -r, --reloc Display the relocation entries in the file\n\
194 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
195 @<file> Read options from <file>\n\
196 -v, --version Display this program's version number\n\
197 -i, --info List object formats and architectures supported\n\
198 -H, --help Display this information\n\
202 fprintf (stream
, _("\n The following switches are optional:\n"));
203 fprintf (stream
, _("\
204 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
205 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
206 -j, --section=NAME Only display information for section NAME\n\
207 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
208 -EB --endian=big Assume big endian format when disassembling\n\
209 -EL --endian=little Assume little endian format when disassembling\n\
210 --file-start-context Include context from start of file (with -S)\n\
211 -I, --include=DIR Add DIR to search list for source files\n\
212 -l, --line-numbers Include line numbers and filenames in output\n\
213 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
214 The STYLE, if specified, can be `auto', `gnu',\n\
215 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
217 -w, --wide Format output for more than 80 columns\n\
218 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
219 --start-address=ADDR Only process data whose address is >= ADDR\n\
220 --stop-address=ADDR Only process data whose address is <= ADDR\n\
221 --prefix-addresses Print complete address alongside disassembly\n\
222 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
223 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
224 --special-syms Include special symbols in symbol dumps\n\
226 list_supported_targets (program_name
, stream
);
227 list_supported_architectures (program_name
, stream
);
229 disassembler_usage (stream
);
231 if (REPORT_BUGS_TO
[0] && status
== 0)
232 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
236 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
240 OPTION_START_ADDRESS
,
245 static struct option long_options
[]=
247 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
248 {"all-headers", no_argument
, NULL
, 'x'},
249 {"private-headers", no_argument
, NULL
, 'p'},
250 {"architecture", required_argument
, NULL
, 'm'},
251 {"archive-headers", no_argument
, NULL
, 'a'},
252 {"debugging", no_argument
, NULL
, 'g'},
253 {"debugging-tags", no_argument
, NULL
, 'e'},
254 {"demangle", optional_argument
, NULL
, 'C'},
255 {"disassemble", no_argument
, NULL
, 'd'},
256 {"disassemble-all", no_argument
, NULL
, 'D'},
257 {"disassembler-options", required_argument
, NULL
, 'M'},
258 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
259 {"dynamic-reloc", no_argument
, NULL
, 'R'},
260 {"dynamic-syms", no_argument
, NULL
, 'T'},
261 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
262 {"file-headers", no_argument
, NULL
, 'f'},
263 {"file-start-context", no_argument
, &file_start_context
, 1},
264 {"full-contents", no_argument
, NULL
, 's'},
265 {"headers", no_argument
, NULL
, 'h'},
266 {"help", no_argument
, NULL
, 'H'},
267 {"info", no_argument
, NULL
, 'i'},
268 {"line-numbers", no_argument
, NULL
, 'l'},
269 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
270 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
271 {"reloc", no_argument
, NULL
, 'r'},
272 {"section", required_argument
, NULL
, 'j'},
273 {"section-headers", no_argument
, NULL
, 'h'},
274 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
275 {"source", no_argument
, NULL
, 'S'},
276 {"special-syms", no_argument
, &dump_special_syms
, 1},
277 {"include", required_argument
, NULL
, 'I'},
278 {"dwarf", no_argument
, NULL
, 'W'},
279 {"stabs", no_argument
, NULL
, 'G'},
280 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
281 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
282 {"syms", no_argument
, NULL
, 't'},
283 {"target", required_argument
, NULL
, 'b'},
284 {"version", no_argument
, NULL
, 'V'},
285 {"wide", no_argument
, NULL
, 'w'},
286 {0, no_argument
, 0, 0}
290 nonfatal (const char *msg
)
297 dump_section_header (bfd
*abfd
, asection
*section
,
298 void *ignored ATTRIBUTE_UNUSED
)
301 unsigned int opb
= bfd_octets_per_byte (abfd
);
303 /* Ignore linker created section. See elfNN_ia64_object_p in
305 if (section
->flags
& SEC_LINKER_CREATED
)
308 printf ("%3d %-13s %08lx ", section
->index
,
309 bfd_get_section_name (abfd
, section
),
310 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
311 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
313 bfd_printf_vma (abfd
, section
->lma
);
314 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
315 bfd_get_section_alignment (abfd
, section
));
321 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
323 PF (SEC_HAS_CONTENTS
, "CONTENTS");
324 PF (SEC_ALLOC
, "ALLOC");
325 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
326 PF (SEC_LOAD
, "LOAD");
327 PF (SEC_RELOC
, "RELOC");
328 PF (SEC_READONLY
, "READONLY");
329 PF (SEC_CODE
, "CODE");
330 PF (SEC_DATA
, "DATA");
332 PF (SEC_DEBUGGING
, "DEBUGGING");
333 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
334 PF (SEC_EXCLUDE
, "EXCLUDE");
335 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
336 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
338 PF (SEC_TIC54X_BLOCK
, "BLOCK");
339 PF (SEC_TIC54X_CLINK
, "CLINK");
341 PF (SEC_SMALL_DATA
, "SMALL_DATA");
342 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
343 PF (SEC_COFF_SHARED
, "SHARED");
344 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
345 PF (SEC_GROUP
, "GROUP");
347 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
350 struct coff_comdat_info
*comdat
;
352 switch (section
->flags
& SEC_LINK_DUPLICATES
)
356 case SEC_LINK_DUPLICATES_DISCARD
:
357 ls
= "LINK_ONCE_DISCARD";
359 case SEC_LINK_DUPLICATES_ONE_ONLY
:
360 ls
= "LINK_ONCE_ONE_ONLY";
362 case SEC_LINK_DUPLICATES_SAME_SIZE
:
363 ls
= "LINK_ONCE_SAME_SIZE";
365 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
366 ls
= "LINK_ONCE_SAME_CONTENTS";
369 printf ("%s%s", comma
, ls
);
371 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
373 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
383 dump_headers (bfd
*abfd
)
385 printf (_("Sections:\n"));
388 printf (_("Idx Name Size VMA LMA File off Algn"));
390 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
391 if (bfd_get_arch_size (abfd
) == 32)
392 printf (_("Idx Name Size VMA LMA File off Algn"));
394 printf (_("Idx Name Size VMA LMA File off Algn"));
398 printf (_(" Flags"));
399 if (abfd
->flags
& HAS_LOAD_PAGE
)
403 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
407 slurp_symtab (bfd
*abfd
)
412 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
418 storage
= bfd_get_symtab_upper_bound (abfd
);
420 bfd_fatal (bfd_get_filename (abfd
));
422 sy
= xmalloc (storage
);
424 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
426 bfd_fatal (bfd_get_filename (abfd
));
430 /* Read in the dynamic symbols. */
433 slurp_dynamic_symtab (bfd
*abfd
)
438 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
441 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
443 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
448 bfd_fatal (bfd_get_filename (abfd
));
451 sy
= xmalloc (storage
);
453 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
455 bfd_fatal (bfd_get_filename (abfd
));
459 /* Filter out (in place) symbols that are useless for disassembly.
460 COUNT is the number of elements in SYMBOLS.
461 Return the number of useful symbols. */
464 remove_useless_symbols (asymbol
**symbols
, long count
)
466 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
470 asymbol
*sym
= *in_ptr
++;
472 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
474 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
476 if (bfd_is_und_section (sym
->section
)
477 || bfd_is_com_section (sym
->section
))
482 return out_ptr
- symbols
;
485 /* Sort symbols into value order. */
488 compare_symbols (const void *ap
, const void *bp
)
490 const asymbol
*a
= * (const asymbol
**) ap
;
491 const asymbol
*b
= * (const asymbol
**) bp
;
501 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
503 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
506 if (a
->section
> b
->section
)
508 else if (a
->section
< b
->section
)
511 an
= bfd_asymbol_name (a
);
512 bn
= bfd_asymbol_name (b
);
516 /* The symbols gnu_compiled and gcc2_compiled convey no real
517 information, so put them after other symbols with the same value. */
518 af
= (strstr (an
, "gnu_compiled") != NULL
519 || strstr (an
, "gcc2_compiled") != NULL
);
520 bf
= (strstr (bn
, "gnu_compiled") != NULL
521 || strstr (bn
, "gcc2_compiled") != NULL
);
528 /* We use a heuristic for the file name, to try to sort it after
529 more useful symbols. It may not work on non Unix systems, but it
530 doesn't really matter; the only difference is precisely which
531 symbol names get printed. */
533 #define file_symbol(s, sn, snl) \
534 (((s)->flags & BSF_FILE) != 0 \
535 || ((sn)[(snl) - 2] == '.' \
536 && ((sn)[(snl) - 1] == 'o' \
537 || (sn)[(snl) - 1] == 'a')))
539 af
= file_symbol (a
, an
, anl
);
540 bf
= file_symbol (b
, bn
, bnl
);
547 /* Try to sort global symbols before local symbols before function
548 symbols before debugging symbols. */
553 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
555 if ((aflags
& BSF_DEBUGGING
) != 0)
560 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
562 if ((aflags
& BSF_FUNCTION
) != 0)
567 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
569 if ((aflags
& BSF_LOCAL
) != 0)
574 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
576 if ((aflags
& BSF_GLOBAL
) != 0)
582 /* Symbols that start with '.' might be section names, so sort them
583 after symbols that don't start with '.'. */
584 if (an
[0] == '.' && bn
[0] != '.')
586 if (an
[0] != '.' && bn
[0] == '.')
589 /* Finally, if we can't distinguish them in any other way, try to
590 get consistent results by sorting the symbols by name. */
591 return strcmp (an
, bn
);
594 /* Sort relocs into address order. */
597 compare_relocs (const void *ap
, const void *bp
)
599 const arelent
*a
= * (const arelent
**) ap
;
600 const arelent
*b
= * (const arelent
**) bp
;
602 if (a
->address
> b
->address
)
604 else if (a
->address
< b
->address
)
607 /* So that associated relocations tied to the same address show up
608 in the correct order, we don't do any further sorting. */
617 /* Print an address (VMA) to the output stream in INFO.
618 If SKIP_ZEROES is TRUE, omit leading zeroes. */
621 objdump_print_value (bfd_vma vma
, struct disassemble_info
*info
,
622 bfd_boolean skip_zeroes
)
626 struct objdump_disasm_info
*aux
;
628 aux
= (struct objdump_disasm_info
*) info
->application_data
;
629 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
634 for (p
= buf
; *p
== '0'; ++p
)
639 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
642 /* Print the name of a symbol. */
645 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*info
,
652 name
= bfd_asymbol_name (sym
);
653 if (do_demangle
&& name
[0] != '\0')
655 /* Demangle the name. */
656 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
662 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
670 /* Locate a symbol given a bfd and a section (from INFO->application_data),
671 and a VMA. If INFO->application_data->require_sec is TRUE, then always
672 require the symbol to be in the section. Returns NULL if there is no
673 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
674 of the symbol in sorted_syms. */
677 find_symbol_for_address (bfd_vma vma
,
678 struct disassemble_info
*info
,
681 /* @@ Would it speed things up to cache the last two symbols returned,
682 and maybe their address ranges? For many processors, only one memory
683 operand can be present at a time, so the 2-entry cache wouldn't be
684 constantly churned by code doing heavy memory accesses. */
686 /* Indices in `sorted_syms'. */
688 long max
= sorted_symcount
;
690 struct objdump_disasm_info
*aux
;
694 bfd_boolean want_section
;
696 if (sorted_symcount
< 1)
699 aux
= (struct objdump_disasm_info
*) info
->application_data
;
702 opb
= bfd_octets_per_byte (abfd
);
704 /* Perform a binary search looking for the closest symbol to the
705 required value. We are searching the range (min, max]. */
706 while (min
+ 1 < max
)
710 thisplace
= (max
+ min
) / 2;
711 sym
= sorted_syms
[thisplace
];
713 if (bfd_asymbol_value (sym
) > vma
)
715 else if (bfd_asymbol_value (sym
) < vma
)
724 /* The symbol we want is now in min, the low end of the range we
725 were searching. If there are several symbols with the same
726 value, we want the first one. */
729 && (bfd_asymbol_value (sorted_syms
[thisplace
])
730 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
733 /* If the file is relocatable, and the symbol could be from this
734 section, prefer a symbol from this section over symbols from
735 others, even if the other symbol's value might be closer.
737 Note that this may be wrong for some symbol references if the
738 sections have overlapping memory ranges, but in that case there's
739 no way to tell what's desired without looking at the relocation
742 Also give the target a chance to reject symbols. */
743 want_section
= (aux
->require_sec
744 || ((abfd
->flags
& HAS_RELOC
) != 0
745 && vma
>= bfd_get_section_vma (abfd
, sec
)
746 && vma
< (bfd_get_section_vma (abfd
, sec
)
747 + bfd_section_size (abfd
, sec
) / opb
)));
748 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
749 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
754 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
756 if (bfd_asymbol_value (sorted_syms
[i
])
757 != bfd_asymbol_value (sorted_syms
[thisplace
]))
762 newplace
= sorted_symcount
;
766 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
767 && info
->symbol_is_valid (sorted_syms
[i
], info
))
769 if (newplace
== sorted_symcount
)
772 if (bfd_asymbol_value (sorted_syms
[i
])
773 != bfd_asymbol_value (sorted_syms
[newplace
]))
776 /* Remember this symbol and keep searching until we reach
777 an earlier address. */
782 if (newplace
!= sorted_symcount
)
783 thisplace
= newplace
;
786 /* We didn't find a good symbol with a smaller value.
787 Look for one with a larger value. */
788 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
790 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
791 && info
->symbol_is_valid (sorted_syms
[i
], info
))
799 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
800 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
801 /* There is no suitable symbol. */
808 return sorted_syms
[thisplace
];
811 /* Print an address and the offset to the nearest symbol. */
814 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
815 bfd_vma vma
, struct disassemble_info
*info
,
816 bfd_boolean skip_zeroes
)
818 objdump_print_value (vma
, info
, skip_zeroes
);
824 (*info
->fprintf_func
) (info
->stream
, " <%s",
825 bfd_get_section_name (abfd
, sec
));
826 secaddr
= bfd_get_section_vma (abfd
, sec
);
829 (*info
->fprintf_func
) (info
->stream
, "-0x");
830 objdump_print_value (secaddr
- vma
, info
, TRUE
);
832 else if (vma
> secaddr
)
834 (*info
->fprintf_func
) (info
->stream
, "+0x");
835 objdump_print_value (vma
- secaddr
, info
, TRUE
);
837 (*info
->fprintf_func
) (info
->stream
, ">");
841 (*info
->fprintf_func
) (info
->stream
, " <");
842 objdump_print_symname (abfd
, info
, sym
);
843 if (bfd_asymbol_value (sym
) > vma
)
845 (*info
->fprintf_func
) (info
->stream
, "-0x");
846 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
848 else if (vma
> bfd_asymbol_value (sym
))
850 (*info
->fprintf_func
) (info
->stream
, "+0x");
851 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
853 (*info
->fprintf_func
) (info
->stream
, ">");
857 /* Print an address (VMA), symbolically if possible.
858 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
861 objdump_print_addr (bfd_vma vma
,
862 struct disassemble_info
*info
,
863 bfd_boolean skip_zeroes
)
865 struct objdump_disasm_info
*aux
;
866 asymbol
*sym
= NULL
; /* Initialize to avoid compiler warning. */
867 bfd_boolean skip_find
= FALSE
;
869 if (sorted_symcount
< 1)
871 (*info
->fprintf_func
) (info
->stream
, "0x");
872 objdump_print_value (vma
, info
, skip_zeroes
);
876 aux
= (struct objdump_disasm_info
*) info
->application_data
;
878 if (aux
->reloc
!= NULL
879 && aux
->reloc
->sym_ptr_ptr
!= NULL
880 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
882 sym
= * aux
->reloc
->sym_ptr_ptr
;
884 /* Adjust the vma to the reloc. */
885 vma
+= bfd_asymbol_value (sym
);
887 if (bfd_is_und_section (bfd_get_section (sym
)))
892 sym
= find_symbol_for_address (vma
, info
, NULL
);
894 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
898 /* Print VMA to INFO. This function is passed to the disassembler
902 objdump_print_address (bfd_vma vma
, struct disassemble_info
*info
)
904 objdump_print_addr (vma
, info
, ! prefix_addresses
);
907 /* Determine if the given address has a symbol associated with it. */
910 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* info
)
914 sym
= find_symbol_for_address (vma
, info
, NULL
);
916 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
919 /* Hold the last function name and the last line number we displayed
922 static char *prev_functionname
;
923 static unsigned int prev_line
;
925 /* We keep a list of all files that we have seen when doing a
926 disassembly with source, so that we know how much of the file to
927 display. This can be important for inlined functions. */
929 struct print_file_list
931 struct print_file_list
*next
;
932 const char *filename
;
936 const char **linemap
;
942 static struct print_file_list
*print_files
;
944 /* The number of preceding context lines to show when we start
945 displaying a file for the first time. */
947 #define SHOW_PRECEDING_CONTEXT_LINES (5)
949 /* Read a complete file into memory. */
952 slurp_file (const char *fn
, size_t *size
)
955 int ps
= getpagesize ();
960 int fd
= open (fn
, O_RDONLY
);
964 if (fstat (fd
, &st
) < 0)
968 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
969 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
970 if (map
!= (char *)-1L)
976 map
= malloc (*size
);
977 if (!map
|| (size_t) read (fd
, (char *)map
, *size
) != *size
)
986 #define line_map_decrease 5
988 /* Precompute array of lines for a mapped file. */
991 index_file (const char *map
, size_t size
, unsigned int *maxline
)
993 const char *p
, *lstart
, *end
;
994 int chars_per_line
= 45; /* First iteration will use 40. */
996 const char **linemap
= NULL
;
997 unsigned long line_map_size
= 0;
1003 for (p
= map
; p
< end
; p
++)
1007 if (p
+ 1 < end
&& p
[1] == '\r')
1010 else if (*p
== '\r')
1012 if (p
+ 1 < end
&& p
[1] == '\n')
1018 /* End of line found. */
1020 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1022 unsigned long newsize
;
1024 chars_per_line
-= line_map_decrease
;
1025 if (chars_per_line
<= 1)
1027 line_map_size
= size
/ chars_per_line
+ 1;
1028 if (line_map_size
< lineno
+ 1)
1029 line_map_size
= lineno
+ 1;
1030 newsize
= line_map_size
* sizeof (char *);
1031 linemap
= xrealloc (linemap
, newsize
);
1034 linemap
[lineno
++] = lstart
;
1042 /* Tries to open MODNAME, and if successful adds a node to print_files
1043 linked list and returns that node. Returns NULL on failure. */
1045 static struct print_file_list
*
1046 try_print_file_open (const char *origname
, const char *modname
)
1048 struct print_file_list
*p
;
1050 p
= xmalloc (sizeof (struct print_file_list
));
1052 p
->map
= slurp_file (modname
, &p
->mapsize
);
1059 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1061 p
->filename
= origname
;
1062 p
->modname
= modname
;
1063 p
->next
= print_files
;
1069 /* If the the source file, as described in the symtab, is not found
1070 try to locate it in one of the paths specified with -I
1071 If found, add location to print_files linked list. */
1073 static struct print_file_list
*
1074 update_source_path (const char *filename
)
1076 struct print_file_list
*p
;
1080 if (filename
== NULL
)
1083 p
= try_print_file_open (filename
, filename
);
1087 if (include_path_count
== 0)
1090 /* Get the name of the file. */
1091 fname
= strrchr (filename
, '/');
1092 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1094 /* We could have a mixed forward/back slash case. */
1095 char *backslash
= strrchr (filename
, '\\');
1096 if (fname
== NULL
|| (backslash
!= NULL
&& backslash
> fname
))
1098 if (fname
== NULL
&& filename
[0] != '\0' && filename
[1] == ':')
1099 fname
= filename
+ 1;
1107 /* If file exists under a new path, we need to add it to the list
1108 so that show_line knows about it. */
1109 for (i
= 0; i
< include_path_count
; i
++)
1111 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1113 p
= try_print_file_open (filename
, modname
);
1123 /* Print a source file line. */
1126 print_line (struct print_file_list
*p
, unsigned int line
)
1131 if (line
>= p
->maxline
)
1133 l
= p
->linemap
[line
];
1134 fwrite (l
, 1, strcspn (l
, "\n\r"), stdout
);
1138 /* Print a range of source code lines. */
1141 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1145 while (start
<= end
)
1147 print_line (p
, start
);
1152 /* Show the line number, or the source line, in a disassembly
1156 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1158 const char *filename
;
1159 const char *functionname
;
1162 if (! with_line_numbers
&& ! with_source_code
)
1165 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1166 &functionname
, &line
))
1169 if (filename
!= NULL
&& *filename
== '\0')
1171 if (functionname
!= NULL
&& *functionname
== '\0')
1172 functionname
= NULL
;
1174 if (with_line_numbers
)
1176 if (functionname
!= NULL
1177 && (prev_functionname
== NULL
1178 || strcmp (functionname
, prev_functionname
) != 0))
1179 printf ("%s():\n", functionname
);
1180 if (line
> 0 && line
!= prev_line
)
1181 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1184 if (with_source_code
1188 struct print_file_list
**pp
, *p
;
1191 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1192 if (strcmp ((*pp
)->filename
, filename
) == 0)
1197 p
= update_source_path (filename
);
1199 if (p
!= NULL
&& line
!= p
->last_line
)
1201 if (file_start_context
&& p
->first
)
1205 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1208 if (p
->last_line
>= l
&& p
->last_line
<= line
)
1209 l
= p
->last_line
+ 1;
1211 dump_lines (p
, l
, line
);
1212 p
->last_line
= line
;
1217 if (functionname
!= NULL
1218 && (prev_functionname
== NULL
1219 || strcmp (functionname
, prev_functionname
) != 0))
1221 if (prev_functionname
!= NULL
)
1222 free (prev_functionname
);
1223 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1224 strcpy (prev_functionname
, functionname
);
1227 if (line
> 0 && line
!= prev_line
)
1231 /* Pseudo FILE object for strings. */
1239 /* sprintf to a "stream". */
1241 static int ATTRIBUTE_PRINTF_2
1242 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1249 size_t space
= f
->alloc
- f
->pos
;
1251 va_start (args
, format
);
1252 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1258 f
->alloc
= (f
->alloc
+ n
) * 2;
1259 f
->buffer
= xrealloc (f
->buffer
, f
->alloc
);
1266 /* Returns TRUE if the specified section should be dumped. */
1269 process_section_p (asection
* section
)
1276 for (i
= 0; i
< only_used
; i
++)
1277 if (strcmp (only
[i
], section
->name
) == 0)
1284 /* The number of zeroes we want to see before we start skipping them.
1285 The number is arbitrarily chosen. */
1287 #define DEFAULT_SKIP_ZEROES 8
1289 /* The number of zeroes to skip at the end of a section. If the
1290 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1291 SKIP_ZEROES, they will be disassembled. If there are fewer than
1292 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1293 attempt to avoid disassembling zeroes inserted by section
1296 #define DEFAULT_SKIP_ZEROES_AT_END 3
1298 /* Disassemble some data in memory between given values. */
1301 disassemble_bytes (struct disassemble_info
* info
,
1302 disassembler_ftype disassemble_fn
,
1305 bfd_vma start_offset
,
1306 bfd_vma stop_offset
,
1309 arelent
** relppend
)
1311 struct objdump_disasm_info
*aux
;
1313 int octets_per_line
;
1314 bfd_boolean done_dot
;
1315 int skip_addr_chars
;
1316 bfd_vma addr_offset
;
1317 unsigned int opb
= info
->octets_per_byte
;
1318 unsigned int skip_zeroes
= info
->skip_zeroes
;
1319 unsigned int skip_zeroes_at_end
= info
->skip_zeroes_at_end
;
1323 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1327 sfile
.buffer
= xmalloc (sfile
.alloc
);
1331 octets_per_line
= 4;
1333 octets_per_line
= 16;
1335 /* Figure out how many characters to skip at the start of an
1336 address, to make the disassembly look nicer. We discard leading
1337 zeroes in chunks of 4, ensuring that there is always a leading
1339 skip_addr_chars
= 0;
1340 if (! prefix_addresses
)
1348 + bfd_section_size (section
->owner
, section
) / opb
));
1350 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1353 skip_addr_chars
+= 4;
1358 info
->insn_info_valid
= 0;
1361 addr_offset
= start_offset
;
1362 while (addr_offset
< stop_offset
)
1365 bfd_boolean need_nl
= FALSE
;
1366 int previous_octets
;
1368 /* Remember the length of the previous instruction. */
1369 previous_octets
= octets
;
1372 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1374 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1377 if (! disassemble_zeroes
1378 && (info
->insn_info_valid
== 0
1379 || info
->branch_delay_insns
== 0)
1380 && (z
- addr_offset
* opb
>= skip_zeroes
1381 || (z
== stop_offset
* opb
&&
1382 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1386 /* If there are more nonzero octets to follow, we only skip
1387 zeroes in multiples of 4, to try to avoid running over
1388 the start of an instruction which happens to start with
1390 if (z
!= stop_offset
* opb
)
1391 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1393 octets
= z
- addr_offset
* opb
;
1403 if (with_line_numbers
|| with_source_code
)
1404 show_line (aux
->abfd
, section
, addr_offset
);
1406 if (! prefix_addresses
)
1410 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1411 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1415 printf ("%s:\t", buf
+ skip_addr_chars
);
1419 aux
->require_sec
= TRUE
;
1420 objdump_print_address (section
->vma
+ addr_offset
, info
);
1421 aux
->require_sec
= FALSE
;
1428 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1429 info
->stream
= &sfile
;
1430 info
->bytes_per_line
= 0;
1431 info
->bytes_per_chunk
= 0;
1434 if (info
->disassembler_needs_relocs
1435 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1436 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1437 && *relppp
< relppend
)
1439 bfd_signed_vma distance_to_rel
;
1441 distance_to_rel
= (**relppp
)->address
1442 - (rel_offset
+ addr_offset
);
1444 /* Check to see if the current reloc is associated with
1445 the instruction that we are about to disassemble. */
1446 if (distance_to_rel
== 0
1447 /* FIXME: This is wrong. We are trying to catch
1448 relocs that are addressed part way through the
1449 current instruction, as might happen with a packed
1450 VLIW instruction. Unfortunately we do not know the
1451 length of the current instruction since we have not
1452 disassembled it yet. Instead we take a guess based
1453 upon the length of the previous instruction. The
1454 proper solution is to have a new target-specific
1455 disassembler function which just returns the length
1456 of an instruction at a given address without trying
1457 to display its disassembly. */
1458 || (distance_to_rel
> 0
1459 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1461 info
->flags
= INSN_HAS_RELOC
;
1462 aux
->reloc
= **relppp
;
1468 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1469 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1470 info
->stream
= stdout
;
1471 if (info
->bytes_per_line
!= 0)
1472 octets_per_line
= info
->bytes_per_line
;
1476 printf ("%s\n", sfile
.buffer
);
1484 octets
= octets_per_line
;
1485 if (addr_offset
+ octets
/ opb
> stop_offset
)
1486 octets
= (stop_offset
- addr_offset
) * opb
;
1488 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1490 if (ISPRINT (data
[j
]))
1491 buf
[j
- addr_offset
* opb
] = data
[j
];
1493 buf
[j
- addr_offset
* opb
] = '.';
1495 buf
[j
- addr_offset
* opb
] = '\0';
1498 if (prefix_addresses
1500 : show_raw_insn
>= 0)
1504 /* If ! prefix_addresses and ! wide_output, we print
1505 octets_per_line octets per line. */
1507 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1508 pb
= octets_per_line
;
1510 if (info
->bytes_per_chunk
)
1511 bpc
= info
->bytes_per_chunk
;
1515 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1519 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1521 for (k
= bpc
- 1; k
>= 0; k
--)
1522 printf ("%02x", (unsigned) data
[j
+ k
]);
1527 for (k
= 0; k
< bpc
; k
++)
1528 printf ("%02x", (unsigned) data
[j
+ k
]);
1533 for (; pb
< octets_per_line
; pb
+= bpc
)
1537 for (k
= 0; k
< bpc
; k
++)
1542 /* Separate raw data from instruction by extra space. */
1552 printf ("%s", sfile
.buffer
);
1554 if (prefix_addresses
1556 : show_raw_insn
>= 0)
1564 j
= addr_offset
* opb
+ pb
;
1566 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1567 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1571 printf ("%s:\t", buf
+ skip_addr_chars
);
1573 pb
+= octets_per_line
;
1576 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1580 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1582 for (k
= bpc
- 1; k
>= 0; k
--)
1583 printf ("%02x", (unsigned) data
[j
+ k
]);
1588 for (k
= 0; k
< bpc
; k
++)
1589 printf ("%02x", (unsigned) data
[j
+ k
]);
1602 while ((*relppp
) < relppend
1603 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1605 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1616 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1619 if (q
->howto
== NULL
)
1620 printf (": *unknown*\t");
1621 else if (q
->howto
->name
)
1622 printf (": %s\t", q
->howto
->name
);
1624 printf (": %d\t", q
->howto
->type
);
1626 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1627 printf ("*unknown*");
1630 const char *sym_name
;
1632 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1633 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1634 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1639 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1640 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1641 if (sym_name
== NULL
|| *sym_name
== '\0')
1642 sym_name
= "*unknown*";
1643 printf ("%s", sym_name
);
1650 objdump_print_value (q
->addend
, info
, TRUE
);
1662 addr_offset
+= octets
/ opb
;
1665 free (sfile
.buffer
);
1669 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1671 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1672 struct objdump_disasm_info
* paux
;
1673 unsigned int opb
= pinfo
->octets_per_byte
;
1674 bfd_byte
* data
= NULL
;
1675 bfd_size_type datasize
= 0;
1676 arelent
** rel_pp
= NULL
;
1677 arelent
** rel_ppstart
= NULL
;
1678 arelent
** rel_ppend
;
1679 unsigned long stop_offset
;
1680 asymbol
* sym
= NULL
;
1684 unsigned long addr_offset
;
1686 /* Sections that do not contain machine
1687 code are not normally disassembled. */
1688 if (! disassemble_all
1690 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1691 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1694 if (! process_section_p (section
))
1697 datasize
= bfd_get_section_size (section
);
1701 /* Decide which set of relocs to use. Load them if necessary. */
1702 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1703 if (paux
->dynrelbuf
)
1705 rel_pp
= paux
->dynrelbuf
;
1706 rel_count
= paux
->dynrelcount
;
1707 /* Dynamic reloc addresses are absolute, non-dynamic are section
1708 relative. REL_OFFSET specifies the reloc address corresponding
1709 to the start of this section. */
1710 rel_offset
= section
->vma
;
1718 if ((section
->flags
& SEC_RELOC
) != 0
1719 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1723 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1725 bfd_fatal (bfd_get_filename (abfd
));
1729 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1730 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1732 bfd_fatal (bfd_get_filename (abfd
));
1734 /* Sort the relocs by address. */
1735 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1740 rel_ppend
= rel_pp
+ rel_count
;
1742 data
= xmalloc (datasize
);
1744 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1746 paux
->sec
= section
;
1747 pinfo
->buffer
= data
;
1748 pinfo
->buffer_vma
= section
->vma
;
1749 pinfo
->buffer_length
= datasize
;
1750 pinfo
->section
= section
;
1752 if (start_address
== (bfd_vma
) -1
1753 || start_address
< pinfo
->buffer_vma
)
1756 addr_offset
= start_address
- pinfo
->buffer_vma
;
1758 if (stop_address
== (bfd_vma
) -1)
1759 stop_offset
= datasize
/ opb
;
1762 if (stop_address
< pinfo
->buffer_vma
)
1765 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1766 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1767 stop_offset
= pinfo
->buffer_length
/ opb
;
1770 /* Skip over the relocs belonging to addresses below the
1772 while (rel_pp
< rel_ppend
1773 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1776 printf (_("Disassembly of section %s:\n"), section
->name
);
1778 /* Find the nearest symbol forwards from our current position. */
1779 paux
->require_sec
= TRUE
;
1780 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1781 paux
->require_sec
= FALSE
;
1783 /* Disassemble a block of instructions up to the address associated with
1784 the symbol we have just found. Then print the symbol and find the
1785 next symbol on. Repeat until we have disassembled the entire section
1786 or we have reached the end of the address range we are interested in. */
1787 while (addr_offset
< stop_offset
)
1791 unsigned long nextstop_offset
;
1794 addr
= section
->vma
+ addr_offset
;
1796 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1801 (x
< sorted_symcount
1802 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1806 pinfo
->symbols
= sorted_syms
+ place
;
1807 pinfo
->num_symbols
= x
- place
;
1808 pinfo
->symtab_pos
= place
;
1812 pinfo
->symbols
= NULL
;
1813 pinfo
->num_symbols
= 0;
1814 pinfo
->symtab_pos
= -1;
1817 if (! prefix_addresses
)
1819 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1820 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1822 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1825 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1827 else if (sym
== NULL
)
1831 #define is_valid_next_sym(SYM) \
1832 ((SYM)->section == section \
1833 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1834 && pinfo->symbol_is_valid (SYM, pinfo))
1836 /* Search forward for the next appropriate symbol in
1837 SECTION. Note that all the symbols are sorted
1838 together into one big array, and that some sections
1839 may have overlapping addresses. */
1840 while (place
< sorted_symcount
1841 && ! is_valid_next_sym (sorted_syms
[place
]))
1844 if (place
>= sorted_symcount
)
1847 nextsym
= sorted_syms
[place
];
1850 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1851 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1852 else if (nextsym
== NULL
)
1853 nextstop_offset
= stop_offset
;
1855 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1857 if (nextstop_offset
> stop_offset
)
1858 nextstop_offset
= stop_offset
;
1860 /* If a symbol is explicitly marked as being an object
1861 rather than a function, just dump the bytes without
1862 disassembling them. */
1865 || bfd_asymbol_value (sym
) > addr
1866 || ((sym
->flags
& BSF_OBJECT
) == 0
1867 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1869 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1871 || (sym
->flags
& BSF_FUNCTION
) != 0)
1876 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1877 addr_offset
, nextstop_offset
,
1878 rel_offset
, &rel_pp
, rel_ppend
);
1880 addr_offset
= nextstop_offset
;
1886 if (rel_ppstart
!= NULL
)
1890 /* Disassemble the contents of an object file. */
1893 disassemble_data (bfd
*abfd
)
1895 struct disassemble_info disasm_info
;
1896 struct objdump_disasm_info aux
;
1900 prev_functionname
= NULL
;
1903 /* We make a copy of syms to sort. We don't want to sort syms
1904 because that will screw up the relocs. */
1905 sorted_symcount
= symcount
? symcount
: dynsymcount
;
1906 sorted_syms
= xmalloc ((sorted_symcount
+ synthcount
) * sizeof (asymbol
*));
1907 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
1908 sorted_symcount
* sizeof (asymbol
*));
1910 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
1912 for (i
= 0; i
< synthcount
; ++i
)
1914 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
1918 /* Sort the symbols into section and symbol order. */
1919 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1921 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
1923 disasm_info
.application_data
= (void *) &aux
;
1925 aux
.require_sec
= FALSE
;
1926 aux
.dynrelbuf
= NULL
;
1927 aux
.dynrelcount
= 0;
1930 disasm_info
.print_address_func
= objdump_print_address
;
1931 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1933 if (machine
!= NULL
)
1935 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1938 fatal (_("Can't use supplied machine %s"), machine
);
1940 abfd
->arch_info
= info
;
1943 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1945 struct bfd_target
*xvec
;
1947 xvec
= xmalloc (sizeof (struct bfd_target
));
1948 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1949 xvec
->byteorder
= endian
;
1953 /* Use libopcodes to locate a suitable disassembler. */
1954 aux
.disassemble_fn
= disassembler (abfd
);
1955 if (!aux
.disassemble_fn
)
1957 non_fatal (_("Can't disassemble for architecture %s\n"),
1958 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1963 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1964 disasm_info
.arch
= bfd_get_arch (abfd
);
1965 disasm_info
.mach
= bfd_get_mach (abfd
);
1966 disasm_info
.disassembler_options
= disassembler_options
;
1967 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
1968 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
1969 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
1970 disasm_info
.disassembler_needs_relocs
= FALSE
;
1972 if (bfd_big_endian (abfd
))
1973 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1974 else if (bfd_little_endian (abfd
))
1975 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1977 /* ??? Aborting here seems too drastic. We could default to big or little
1979 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1981 /* Allow the target to customize the info structure. */
1982 disassemble_init_for_target (& disasm_info
);
1984 /* Pre-load the dynamic relocs if we are going
1985 to be dumping them along with the disassembly. */
1986 if (dump_dynamic_reloc_info
)
1988 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1991 bfd_fatal (bfd_get_filename (abfd
));
1995 aux
.dynrelbuf
= xmalloc (relsize
);
1996 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
1999 if (aux
.dynrelcount
< 0)
2000 bfd_fatal (bfd_get_filename (abfd
));
2002 /* Sort the relocs by address. */
2003 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2007 disasm_info
.symtab
= sorted_syms
;
2008 disasm_info
.symtab_size
= sorted_symcount
;
2010 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2012 if (aux
.dynrelbuf
!= NULL
)
2013 free (aux
.dynrelbuf
);
2018 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2020 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2025 /* If it is already loaded, do nothing. */
2026 if (section
->start
!= NULL
)
2029 /* Locate the debug section. */
2030 sec
= bfd_get_section_by_name (abfd
, section
->name
);
2034 /* Compute a bias to be added to offsets found within the DWARF debug
2035 information. These offsets are meant to be relative to the start of
2036 the dwarf section, and hence the bias should be 0. For MACH-O however
2037 a dwarf section is really just a region of a much larger section and so
2038 the bias is the address of the start of that area within the larger
2039 section. This test is important for PE and COFF based targets which
2040 use DWARF debug information, since unlike ELF, they do not allow the
2041 dwarf sections to be placed at address 0. */
2042 if (bfd_get_flavour (abfd
) == bfd_target_mach_o_flavour
)
2043 section
->address
= bfd_get_section_vma (abfd
, sec
);
2045 section
->address
= 0;
2047 section
->size
= bfd_get_section_size (sec
);
2048 section
->start
= xmalloc (section
->size
);
2050 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2051 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2056 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
2061 free_debug_section (debug
);
2062 printf (_("\nCan't get contents for section '%s'.\n"),
2070 free_debug_section (enum dwarf_section_display_enum debug
)
2072 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2074 if (section
->start
== NULL
)
2077 free ((char *) section
->start
);
2078 section
->start
= NULL
;
2079 section
->address
= 0;
2084 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2085 void *arg ATTRIBUTE_UNUSED
)
2087 const char *name
= bfd_get_section_name (abfd
, section
);
2089 enum dwarf_section_display_enum i
;
2091 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2092 match
= ".debug_info";
2096 for (i
= 0; i
< max
; i
++)
2097 if (strcmp (debug_displays
[i
].section
.name
, match
) == 0)
2099 if (!debug_displays
[i
].eh_frame
)
2101 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2103 if (load_debug_section (i
, abfd
))
2105 debug_displays
[i
].display (sec
, abfd
);
2107 if (i
!= info
&& i
!= abbrev
)
2108 free_debug_section (i
);
2115 static const char *mach_o_dwarf_sections
[] = {
2116 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2117 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2118 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2119 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2120 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2121 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2122 ".eh_frame", /* .eh_frame */
2123 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2124 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2125 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2126 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2127 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2128 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2129 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2130 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2131 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2134 static const char *generic_dwarf_sections
[max
];
2137 check_mach_o_dwarf (bfd
*abfd
)
2139 static enum bfd_flavour old_flavour
= bfd_target_unknown_flavour
;
2140 enum bfd_flavour current_flavour
= bfd_get_flavour (abfd
);
2141 enum dwarf_section_display_enum i
;
2143 if (generic_dwarf_sections
[0] == NULL
)
2144 for (i
= 0; i
< max
; i
++)
2145 generic_dwarf_sections
[i
] = debug_displays
[i
].section
.name
;
2147 if (old_flavour
!= current_flavour
)
2149 if (current_flavour
== bfd_target_mach_o_flavour
)
2150 for (i
= 0; i
< max
; i
++)
2151 debug_displays
[i
].section
.name
= mach_o_dwarf_sections
[i
];
2152 else if (old_flavour
== bfd_target_mach_o_flavour
)
2153 for (i
= 0; i
< max
; i
++)
2154 debug_displays
[i
].section
.name
= generic_dwarf_sections
[i
];
2156 old_flavour
= current_flavour
;
2160 /* Dump the dwarf debugging information. */
2163 dump_dwarf (bfd
*abfd
)
2165 is_relocatable
= ((abfd
->flags
& (HAS_RELOC
| EXEC_P
| DYNAMIC
))
2168 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2169 targets will return 64. */
2170 eh_addr_size
= bfd_get_arch_size (abfd
) == 64 ? 8 : 4;
2172 if (bfd_big_endian (abfd
))
2173 byte_get
= byte_get_big_endian
;
2174 else if (bfd_little_endian (abfd
))
2175 byte_get
= byte_get_little_endian
;
2179 check_mach_o_dwarf (abfd
);
2181 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2183 free_debug_memory ();
2186 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2187 it. Return NULL on failure. */
2190 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2196 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2197 if (stabsect
== NULL
)
2199 printf (_("No %s section present\n\n"), sect_name
);
2203 size
= bfd_section_size (abfd
, stabsect
);
2204 contents
= xmalloc (size
);
2206 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2208 non_fatal (_("Reading %s section of %s failed: %s"),
2209 sect_name
, bfd_get_filename (abfd
),
2210 bfd_errmsg (bfd_get_error ()));
2221 /* Stabs entries use a 12 byte format:
2222 4 byte string table index
2224 1 byte stab other field
2225 2 byte stab desc field
2227 FIXME: This will have to change for a 64 bit object format. */
2229 #define STRDXOFF (0)
2231 #define OTHEROFF (5)
2234 #define STABSIZE (12)
2236 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2237 using string table section STRSECT_NAME (in `strtab'). */
2240 print_section_stabs (bfd
*abfd
,
2241 const char *stabsect_name
,
2242 unsigned *string_offset_ptr
)
2245 unsigned file_string_table_offset
= 0;
2246 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2247 bfd_byte
*stabp
, *stabs_end
;
2250 stabs_end
= stabp
+ stab_size
;
2252 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2253 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2255 /* Loop through all symbols and print them.
2257 We start the index at -1 because there is a dummy symbol on
2258 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2259 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2263 unsigned char type
, other
;
2264 unsigned short desc
;
2267 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2268 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2269 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2270 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2271 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2273 printf ("\n%-6d ", i
);
2274 /* Either print the stab name, or, if unnamed, print its number
2275 again (makes consistent formatting for tools like awk). */
2276 name
= bfd_get_stab_name (type
);
2278 printf ("%-6s", name
);
2279 else if (type
== N_UNDF
)
2282 printf ("%-6d", type
);
2283 printf (" %-6d %-6d ", other
, desc
);
2284 bfd_printf_vma (abfd
, value
);
2285 printf (" %-6lu", strx
);
2287 /* Symbols with type == 0 (N_UNDF) specify the length of the
2288 string table associated with this file. We use that info
2289 to know how to relocate the *next* file's string table indices. */
2292 file_string_table_offset
= next_file_string_table_offset
;
2293 next_file_string_table_offset
+= value
;
2297 /* Using the (possibly updated) string table offset, print the
2298 string (if any) associated with this symbol. */
2299 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2300 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2306 *string_offset_ptr
= next_file_string_table_offset
;
2311 const char * section_name
;
2312 const char * string_section_name
;
2313 unsigned string_offset
;
2318 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2321 stab_section_names
* sought
= (stab_section_names
*) names
;
2323 /* Check for section names for which stabsect_name is a prefix, to
2324 handle .stab.N, etc. */
2325 len
= strlen (sought
->section_name
);
2327 /* If the prefix matches, and the files section name ends with a
2328 nul or a digit, then we match. I.e., we want either an exact
2329 match or a section followed by a number. */
2330 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2331 && (section
->name
[len
] == 0
2332 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2335 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2340 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2343 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2349 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2351 stab_section_names s
;
2353 s
.section_name
= stabsect_name
;
2354 s
.string_section_name
= strsect_name
;
2355 s
.string_offset
= 0;
2357 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2363 /* Dump the any sections containing stabs debugging information. */
2366 dump_stabs (bfd
*abfd
)
2368 dump_stabs_section (abfd
, ".stab", ".stabstr");
2369 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2370 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2371 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2375 dump_bfd_header (bfd
*abfd
)
2379 printf (_("architecture: %s, "),
2380 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2381 bfd_get_mach (abfd
)));
2382 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2384 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2385 PF (HAS_RELOC
, "HAS_RELOC");
2386 PF (EXEC_P
, "EXEC_P");
2387 PF (HAS_LINENO
, "HAS_LINENO");
2388 PF (HAS_DEBUG
, "HAS_DEBUG");
2389 PF (HAS_SYMS
, "HAS_SYMS");
2390 PF (HAS_LOCALS
, "HAS_LOCALS");
2391 PF (DYNAMIC
, "DYNAMIC");
2392 PF (WP_TEXT
, "WP_TEXT");
2393 PF (D_PAGED
, "D_PAGED");
2394 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2395 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2396 printf (_("\nstart address 0x"));
2397 bfd_printf_vma (abfd
, abfd
->start_address
);
2403 dump_bfd_private_header (bfd
*abfd
)
2405 bfd_print_private_bfd_data (abfd
, stdout
);
2409 /* Display a section in hexadecimal format with associated characters.
2410 Each line prefixed by the zero padded address. */
2413 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2416 bfd_size_type datasize
;
2417 bfd_size_type addr_offset
;
2418 bfd_size_type start_offset
;
2419 bfd_size_type stop_offset
;
2420 unsigned int opb
= bfd_octets_per_byte (abfd
);
2421 /* Bytes per line. */
2422 const int onaline
= 16;
2427 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2430 if (! process_section_p (section
))
2433 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2436 printf (_("Contents of section %s:\n"), section
->name
);
2438 data
= xmalloc (datasize
);
2440 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2442 /* Compute the address range to display. */
2443 if (start_address
== (bfd_vma
) -1
2444 || start_address
< section
->vma
)
2447 start_offset
= start_address
- section
->vma
;
2449 if (stop_address
== (bfd_vma
) -1)
2450 stop_offset
= datasize
/ opb
;
2453 if (stop_address
< section
->vma
)
2456 stop_offset
= stop_address
- section
->vma
;
2458 if (stop_offset
> datasize
/ opb
)
2459 stop_offset
= datasize
/ opb
;
2464 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2465 if (strlen (buf
) >= sizeof (buf
))
2469 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2471 count
= strlen (buf
) - count
;
2475 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2476 if (strlen (buf
) >= sizeof (buf
))
2480 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2482 count
= strlen (buf
) - count
;
2486 for (addr_offset
= start_offset
;
2487 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2491 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2492 count
= strlen (buf
);
2493 if ((size_t) count
>= sizeof (buf
))
2497 while (count
< width
)
2502 fputs (buf
+ count
- width
, stdout
);
2505 for (j
= addr_offset
* opb
;
2506 j
< addr_offset
* opb
+ onaline
; j
++)
2508 if (j
< stop_offset
* opb
)
2509 printf ("%02x", (unsigned) (data
[j
]));
2517 for (j
= addr_offset
* opb
;
2518 j
< addr_offset
* opb
+ onaline
; j
++)
2520 if (j
>= stop_offset
* opb
)
2523 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2530 /* Actually display the various requested regions. */
2533 dump_data (bfd
*abfd
)
2535 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2538 /* Should perhaps share code and display with nm? */
2541 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2551 printf ("DYNAMIC SYMBOL TABLE:\n");
2557 printf ("SYMBOL TABLE:\n");
2561 printf (_("no symbols\n"));
2563 for (count
= 0; count
< max
; count
++)
2567 if (*current
== NULL
)
2568 printf (_("no information for symbol number %ld\n"), count
);
2570 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2571 printf (_("could not determine the type of symbol number %ld\n"),
2574 else if (process_section_p ((* current
)->section
)
2575 && (dump_special_syms
2576 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2578 const char *name
= (*current
)->name
;
2580 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2584 /* If we want to demangle the name, we demangle it
2585 here, and temporarily clobber it while calling
2586 bfd_print_symbol. FIXME: This is a gross hack. */
2587 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2589 (*current
)->name
= alloc
;
2590 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2591 bfd_print_symbol_all
);
2594 (*current
)->name
= name
;
2599 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2600 bfd_print_symbol_all
);
2610 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2613 char *last_filename
, *last_functionname
;
2614 unsigned int last_line
;
2616 /* Get column headers lined up reasonably. */
2624 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2625 width
= strlen (buf
) - 7;
2627 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2630 last_filename
= NULL
;
2631 last_functionname
= NULL
;
2634 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2637 const char *filename
, *functionname
;
2639 const char *sym_name
;
2640 const char *section_name
;
2642 if (start_address
!= (bfd_vma
) -1
2643 && q
->address
< start_address
)
2645 if (stop_address
!= (bfd_vma
) -1
2646 && q
->address
> stop_address
)
2649 if (with_line_numbers
2651 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2652 &filename
, &functionname
, &line
))
2654 if (functionname
!= NULL
2655 && (last_functionname
== NULL
2656 || strcmp (functionname
, last_functionname
) != 0))
2658 printf ("%s():\n", functionname
);
2659 if (last_functionname
!= NULL
)
2660 free (last_functionname
);
2661 last_functionname
= xstrdup (functionname
);
2665 && (line
!= last_line
2666 || (filename
!= NULL
2667 && last_filename
!= NULL
2668 && strcmp (filename
, last_filename
) != 0)))
2670 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2672 if (last_filename
!= NULL
)
2673 free (last_filename
);
2674 if (filename
== NULL
)
2675 last_filename
= NULL
;
2677 last_filename
= xstrdup (filename
);
2681 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2683 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2684 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2689 section_name
= NULL
;
2692 bfd_printf_vma (abfd
, q
->address
);
2693 if (q
->howto
== NULL
)
2694 printf (" *unknown* ");
2695 else if (q
->howto
->name
)
2696 printf (" %-16s ", q
->howto
->name
);
2698 printf (" %-16d ", q
->howto
->type
);
2700 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2703 if (section_name
== NULL
)
2704 section_name
= "*unknown*";
2705 printf ("[%s]", section_name
);
2711 bfd_printf_vma (abfd
, q
->addend
);
2719 dump_relocs_in_section (bfd
*abfd
,
2721 void *dummy ATTRIBUTE_UNUSED
)
2727 if ( bfd_is_abs_section (section
)
2728 || bfd_is_und_section (section
)
2729 || bfd_is_com_section (section
)
2730 || (! process_section_p (section
))
2731 || ((section
->flags
& SEC_RELOC
) == 0))
2734 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2736 bfd_fatal (bfd_get_filename (abfd
));
2738 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2742 printf (" (none)\n\n");
2746 relpp
= xmalloc (relsize
);
2747 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2750 bfd_fatal (bfd_get_filename (abfd
));
2751 else if (relcount
== 0)
2752 printf (" (none)\n\n");
2756 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2763 dump_relocs (bfd
*abfd
)
2765 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2769 dump_dynamic_relocs (bfd
*abfd
)
2775 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2777 bfd_fatal (bfd_get_filename (abfd
));
2779 printf ("DYNAMIC RELOCATION RECORDS");
2782 printf (" (none)\n\n");
2785 relpp
= xmalloc (relsize
);
2786 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2789 bfd_fatal (bfd_get_filename (abfd
));
2790 else if (relcount
== 0)
2791 printf (" (none)\n\n");
2795 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2802 /* Creates a table of paths, to search for source files. */
2805 add_include_path (const char *path
)
2809 include_path_count
++;
2810 include_paths
= xrealloc (include_paths
,
2811 include_path_count
* sizeof (*include_paths
));
2812 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2813 if (path
[1] == ':' && path
[2] == 0)
2814 path
= concat (path
, ".", (const char *) 0);
2816 include_paths
[include_path_count
- 1] = path
;
2820 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2824 if ((section
->flags
& SEC_DEBUGGING
) == 0)
2826 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
2827 section
->vma
+= adjust_section_vma
;
2829 section
->lma
+= adjust_section_vma
;
2833 /* Dump selected contents of ABFD. */
2836 dump_bfd (bfd
*abfd
)
2838 /* If we are adjusting section VMA's, change them all now. Changing
2839 the BFD information is a hack. However, we must do it, or
2840 bfd_find_nearest_line will not do the right thing. */
2841 if (adjust_section_vma
!= 0)
2843 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
2844 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
2847 if (! dump_debugging_tags
)
2848 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2851 print_arelt_descr (stdout
, abfd
, TRUE
);
2852 if (dump_file_header
)
2853 dump_bfd_header (abfd
);
2854 if (dump_private_headers
)
2855 dump_bfd_private_header (abfd
);
2856 if (! dump_debugging_tags
)
2858 if (dump_section_headers
)
2859 dump_headers (abfd
);
2865 || dump_dwarf_section_info
)
2866 syms
= slurp_symtab (abfd
);
2867 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
2868 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
2869 dynsyms
= slurp_dynamic_symtab (abfd
);
2872 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2873 dynsymcount
, dynsyms
, &synthsyms
);
2879 dump_symbols (abfd
, FALSE
);
2880 if (dump_dynamic_symtab
)
2881 dump_symbols (abfd
, TRUE
);
2882 if (dump_dwarf_section_info
)
2884 if (dump_stab_section_info
)
2886 if (dump_reloc_info
&& ! disassemble
)
2888 if (dump_dynamic_reloc_info
&& ! disassemble
)
2889 dump_dynamic_relocs (abfd
);
2890 if (dump_section_contents
)
2893 disassemble_data (abfd
);
2899 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2900 if (dhandle
!= NULL
)
2902 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
2904 dump_debugging_tags
? TRUE
: FALSE
))
2906 non_fatal (_("%s: printing debugging information failed"),
2907 bfd_get_filename (abfd
));
2937 display_bfd (bfd
*abfd
)
2941 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2947 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2949 nonfatal (bfd_get_filename (abfd
));
2950 list_matching_formats (matching
);
2955 if (bfd_get_error () != bfd_error_file_not_recognized
)
2957 nonfatal (bfd_get_filename (abfd
));
2961 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2967 nonfatal (bfd_get_filename (abfd
));
2969 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2971 list_matching_formats (matching
);
2977 display_file (char *filename
, char *target
)
2982 if (get_file_size (filename
) < 1)
2988 file
= bfd_openr (filename
, target
);
2991 nonfatal (filename
);
2995 /* If the file is an archive, process all of its elements. */
2996 if (bfd_check_format (file
, bfd_archive
))
2998 bfd
*last_arfile
= NULL
;
3000 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3003 bfd_set_error (bfd_error_no_error
);
3005 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3008 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3009 nonfatal (bfd_get_filename (file
));
3013 display_bfd (arfile
);
3015 if (last_arfile
!= NULL
)
3016 bfd_close (last_arfile
);
3017 last_arfile
= arfile
;
3020 if (last_arfile
!= NULL
)
3021 bfd_close (last_arfile
);
3030 main (int argc
, char **argv
)
3033 char *target
= default_target
;
3034 bfd_boolean seenflag
= FALSE
;
3036 #if defined (HAVE_SETLOCALE)
3037 #if defined (HAVE_LC_MESSAGES)
3038 setlocale (LC_MESSAGES
, "");
3040 setlocale (LC_CTYPE
, "");
3043 bindtextdomain (PACKAGE
, LOCALEDIR
);
3044 textdomain (PACKAGE
);
3046 program_name
= *argv
;
3047 xmalloc_set_program_name (program_name
);
3049 START_PROGRESS (program_name
, 0);
3051 expandargv (&argc
, &argv
);
3054 set_default_bfd_target ();
3056 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
3057 long_options
, (int *) 0))
3063 break; /* We've been given a long option. */
3068 if (disassembler_options
)
3069 /* Ignore potential memory leak for now. */
3070 disassembler_options
= concat (disassembler_options
, ",",
3073 disassembler_options
= optarg
;
3076 if (only_used
== only_size
)
3079 only
= xrealloc (only
, only_size
* sizeof (char *));
3081 only
[only_used
++] = optarg
;
3084 with_line_numbers
= TRUE
;
3093 enum demangling_styles style
;
3095 style
= cplus_demangle_name_to_style (optarg
);
3096 if (style
== unknown_demangling
)
3097 fatal (_("unknown demangling style `%s'"),
3100 cplus_demangle_set_style (style
);
3106 case OPTION_ADJUST_VMA
:
3107 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3109 case OPTION_START_ADDRESS
:
3110 start_address
= parse_vma (optarg
, "--start-address");
3112 case OPTION_STOP_ADDRESS
:
3113 stop_address
= parse_vma (optarg
, "--stop-address");
3116 if (strcmp (optarg
, "B") == 0)
3117 endian
= BFD_ENDIAN_BIG
;
3118 else if (strcmp (optarg
, "L") == 0)
3119 endian
= BFD_ENDIAN_LITTLE
;
3122 non_fatal (_("unrecognized -E option"));
3127 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3128 endian
= BFD_ENDIAN_BIG
;
3129 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3130 endian
= BFD_ENDIAN_LITTLE
;
3133 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3139 dump_file_header
= TRUE
;
3143 formats_info
= TRUE
;
3147 add_include_path (optarg
);
3150 dump_private_headers
= TRUE
;
3154 dump_private_headers
= TRUE
;
3156 dump_reloc_info
= TRUE
;
3157 dump_file_header
= TRUE
;
3158 dump_ar_hdrs
= TRUE
;
3159 dump_section_headers
= TRUE
;
3167 dump_dynamic_symtab
= TRUE
;
3175 disassemble_zeroes
= TRUE
;
3179 disassemble_all
= TRUE
;
3184 with_source_code
= TRUE
;
3193 dump_debugging_tags
= 1;
3198 dump_dwarf_section_info
= TRUE
;
3201 do_debug_abbrevs
= 1;
3203 do_debug_pubnames
= 1;
3204 do_debug_aranges
= 1;
3205 do_debug_ranges
= 1;
3206 do_debug_frames
= 1;
3207 do_debug_macinfo
= 1;
3212 dump_stab_section_info
= TRUE
;
3216 dump_section_contents
= TRUE
;
3220 dump_reloc_info
= TRUE
;
3224 dump_dynamic_reloc_info
= TRUE
;
3228 dump_ar_hdrs
= TRUE
;
3232 dump_section_headers
= TRUE
;
3240 show_version
= TRUE
;
3250 print_version ("objdump");
3256 exit_status
= display_info ();
3260 display_file ("a.out", target
);
3262 for (; optind
< argc
;)
3263 display_file (argv
[optind
++], target
);
3266 END_PROGRESS (program_name
);