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