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