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