projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
*** empty log message ***
[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{
5184c2ae 2169 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
365544c3
L		 2170
2171 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2172 targets will return 64. */
2173 eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2174
2175 if (bfd_big_endian (abfd))
2176 byte_get = byte_get_big_endian;
2177 else if (bfd_little_endian (abfd))
2178 byte_get = byte_get_little_endian;
2179 else
2180 abort ();
2181
bfe2612a
L		 2182 check_mach_o_dwarf (abfd);
2183
365544c3
L		 2184 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2185
2186 free_debug_memory ();
2187}
2188\f
29ca8dc5
NS		 2189/* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2190 it. Return NULL on failure. */
252b5132 2191
29ca8dc5
NS		 2192static char *
2193read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
252b5132 2194{
29ca8dc5
NS		 2195 asection *stabsect;
2196 bfd_size_type size;
2197 char *contents;
252b5132 2198
29ca8dc5 2199 stabsect = bfd_get_section_by_name (abfd, sect_name);
155e0d23 2200 if (stabsect == NULL)
252b5132 2201 {
29ca8dc5 2202 printf (_("No %s section present\n\n"), sect_name);
b34976b6 2203 return FALSE;
252b5132
RH		 2204 }
2205
29ca8dc5
NS		 2206 size = bfd_section_size (abfd, stabsect);
2207 contents = xmalloc (size);
0af11b59 2208
29ca8dc5 2209 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
252b5132 2210 {
37cc8ec1 2211 non_fatal (_("Reading %s section of %s failed: %s"),
29ca8dc5 2212 sect_name, bfd_get_filename (abfd),
37cc8ec1 2213 bfd_errmsg (bfd_get_error ()));
29ca8dc5 2214 free (contents);
75cd796a 2215 exit_status = 1;
29ca8dc5 2216 return NULL;
252b5132
RH		 2217 }
2218
29ca8dc5 2219 *size_ptr = size;
252b5132 2220
29ca8dc5 2221 return contents;
252b5132
RH		 2222}
2223
2224/* Stabs entries use a 12 byte format:
2225 4 byte string table index
2226 1 byte stab type
2227 1 byte stab other field
2228 2 byte stab desc field
2229 4 byte stab value
2230 FIXME: This will have to change for a 64 bit object format. */
2231
46dca2e0
NC		 2232#define STRDXOFF (0)
2233#define TYPEOFF (4)
2234#define OTHEROFF (5)
2235#define DESCOFF (6)
2236#define VALOFF (8)
252b5132
RH		 2237#define STABSIZE (12)
2238
2239/* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2240 using string table section STRSECT_NAME (in `strtab'). */
2241
2242static void
3b9ad1cc
AM		 2243print_section_stabs (bfd *abfd,
2244 const char *stabsect_name,
2245 unsigned *string_offset_ptr)
252b5132
RH		 2246{
2247 int i;
46dca2e0 2248 unsigned file_string_table_offset = 0;
29ca8dc5 2249 unsigned next_file_string_table_offset = *string_offset_ptr;
252b5132
RH		 2250 bfd_byte *stabp, *stabs_end;
2251
2252 stabp = stabs;
2253 stabs_end = stabp + stab_size;
2254
2255 printf (_("Contents of %s section:\n\n"), stabsect_name);
2256 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2257
2258 /* Loop through all symbols and print them.
2259
2260 We start the index at -1 because there is a dummy symbol on
2261 the front of stabs-in-{coff,elf} sections that supplies sizes. */
252b5132
RH		 2262 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2263 {
2264 const char *name;
2265 unsigned long strx;
2266 unsigned char type, other;
2267 unsigned short desc;
2268 bfd_vma value;
2269
2270 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2271 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2272 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2273 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2274 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2275
2276 printf ("\n%-6d ", i);
2277 /* Either print the stab name, or, if unnamed, print its number
0af11b59 2278 again (makes consistent formatting for tools like awk). */
252b5132
RH		 2279 name = bfd_get_stab_name (type);
2280 if (name != NULL)
2281 printf ("%-6s", name);
2282 else if (type == N_UNDF)
2283 printf ("HdrSym");
2284 else
2285 printf ("%-6d", type);
2286 printf (" %-6d %-6d ", other, desc);
d8180c76 2287 bfd_printf_vma (abfd, value);
252b5132
RH		 2288 printf (" %-6lu", strx);
2289
2290 /* Symbols with type == 0 (N_UNDF) specify the length of the
2291 string table associated with this file. We use that info
2292 to know how to relocate the *next* file's string table indices. */
252b5132
RH		 2293 if (type == N_UNDF)
2294 {
2295 file_string_table_offset = next_file_string_table_offset;
2296 next_file_string_table_offset += value;
2297 }
2298 else
2299 {
2300 /* Using the (possibly updated) string table offset, print the
2301 string (if any) associated with this symbol. */
252b5132
RH		 2302 if ((strx + file_string_table_offset) < stabstr_size)
2303 printf (" %s", &strtab[strx + file_string_table_offset]);
2304 else
2305 printf (" *");
2306 }
2307 }
2308 printf ("\n\n");
29ca8dc5 2309 *string_offset_ptr = next_file_string_table_offset;
252b5132
RH		 2310}
2311
155e0d23
NC		 2312typedef struct
2313{
2314 const char * section_name;
2315 const char * string_section_name;
29ca8dc5 2316 unsigned string_offset;
155e0d23
NC		 2317}
2318stab_section_names;
2319
252b5132 2320static void
155e0d23 2321find_stabs_section (bfd *abfd, asection *section, void *names)
252b5132 2322{
155e0d23
NC		 2323 int len;
2324 stab_section_names * sought = (stab_section_names *) names;
252b5132
RH		 2325
2326 /* Check for section names for which stabsect_name is a prefix, to
29ca8dc5 2327 handle .stab.N, etc. */
155e0d23
NC		 2328 len = strlen (sought->section_name);
2329
2330 /* If the prefix matches, and the files section name ends with a
2331 nul or a digit, then we match. I.e., we want either an exact
2332 match or a section followed by a number. */
2333 if (strncmp (sought->section_name, section->name, len) == 0
2334 && (section->name[len] == 0
29ca8dc5 2335 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
252b5132 2336 {
29ca8dc5
NS		 2337 if (strtab == NULL)
2338 strtab = read_section_stabs (abfd, sought->string_section_name,
2339 &stabstr_size);
2340
2341 if (strtab)
252b5132 2342 {
9210d879
AM		 2343 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2344 &stab_size);
29ca8dc5
NS		 2345 if (stabs)
2346 print_section_stabs (abfd, section->name, &sought->string_offset);
252b5132
RH		 2347 }
2348 }
2349}
98a91d6a 2350
155e0d23
NC		 2351static void
2352dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2353{
2354 stab_section_names s;
2355
2356 s.section_name = stabsect_name;
2357 s.string_section_name = strsect_name;
29ca8dc5
NS		 2358 s.string_offset = 0;
2359
155e0d23 2360 bfd_map_over_sections (abfd, find_stabs_section, & s);
29ca8dc5
NS		 2361
2362 free (strtab);
2363 strtab = NULL;
155e0d23
NC		 2364}
2365
2366/* Dump the any sections containing stabs debugging information. */
2367
2368static void
2369dump_stabs (bfd *abfd)
2370{
2371 dump_stabs_section (abfd, ".stab", ".stabstr");
2372 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2373 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2374 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2375}
252b5132
RH		 2376\f
2377static void
46dca2e0 2378dump_bfd_header (bfd *abfd)
252b5132
RH		 2379{
2380 char *comma = "";
2381
2382 printf (_("architecture: %s, "),
2383 bfd_printable_arch_mach (bfd_get_arch (abfd),
2384 bfd_get_mach (abfd)));
2385 printf (_("flags 0x%08x:\n"), abfd->flags);
2386
2387#define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2388 PF (HAS_RELOC, "HAS_RELOC");
2389 PF (EXEC_P, "EXEC_P");
2390 PF (HAS_LINENO, "HAS_LINENO");
2391 PF (HAS_DEBUG, "HAS_DEBUG");
2392 PF (HAS_SYMS, "HAS_SYMS");
2393 PF (HAS_LOCALS, "HAS_LOCALS");
2394 PF (DYNAMIC, "DYNAMIC");
2395 PF (WP_TEXT, "WP_TEXT");
2396 PF (D_PAGED, "D_PAGED");
2397 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
026df7c5 2398 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
252b5132 2399 printf (_("\nstart address 0x"));
d8180c76 2400 bfd_printf_vma (abfd, abfd->start_address);
252b5132
RH		 2401 printf ("\n");
2402}
98a91d6a 2403
252b5132
RH		 2404\f
2405static void
46dca2e0 2406dump_bfd_private_header (bfd *abfd)
252b5132
RH		 2407{
2408 bfd_print_private_bfd_data (abfd, stdout);
2409}
2410
155e0d23
NC		 2411\f
2412/* Display a section in hexadecimal format with associated characters.
2413 Each line prefixed by the zero padded address. */
d24de309 2414
252b5132 2415static void
155e0d23 2416dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
252b5132 2417{
155e0d23
NC		 2418 bfd_byte *data = 0;
2419 bfd_size_type datasize;
2420 bfd_size_type addr_offset;
2421 bfd_size_type start_offset;
2422 bfd_size_type stop_offset;
2423 unsigned int opb = bfd_octets_per_byte (abfd);
2424 /* Bytes per line. */
2425 const int onaline = 16;
2426 char buf[64];
2427 int count;
2428 int width;
2429
2430 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2431 return;
2432
2433 if (! process_section_p (section))
2434 return;
2435
2436 if ((datasize = bfd_section_size (abfd, section)) == 0)
2437 return;
2438
2439 printf (_("Contents of section %s:\n"), section->name);
2440
2441 data = xmalloc (datasize);
2442
2443 bfd_get_section_contents (abfd, section, data, 0, datasize);
2444
2445 /* Compute the address range to display. */
2446 if (start_address == (bfd_vma) -1
2447 || start_address < section->vma)
2448 start_offset = 0;
2449 else
2450 start_offset = start_address - section->vma;
2451
2452 if (stop_address == (bfd_vma) -1)
2453 stop_offset = datasize / opb;
2454 else
252b5132 2455 {
155e0d23
NC		 2456 if (stop_address < section->vma)
2457 stop_offset = 0;
2458 else
2459 stop_offset = stop_address - section->vma;
252b5132 2460
155e0d23
NC		 2461 if (stop_offset > datasize / opb)
2462 stop_offset = datasize / opb;
252b5132
RH		 2463 }
2464
155e0d23 2465 width = 4;
026df7c5 2466
155e0d23
NC		 2467 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2468 if (strlen (buf) >= sizeof (buf))
2469 abort ();
026df7c5 2470
155e0d23
NC		 2471 count = 0;
2472 while (buf[count] == '0' && buf[count+1] != '\0')
2473 count++;
2474 count = strlen (buf) - count;
2475 if (count > width)
2476 width = count;
252b5132 2477
155e0d23
NC		 2478 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2479 if (strlen (buf) >= sizeof (buf))
2480 abort ();
026df7c5 2481
155e0d23
NC		 2482 count = 0;
2483 while (buf[count] == '0' && buf[count+1] != '\0')
2484 count++;
2485 count = strlen (buf) - count;
2486 if (count > width)
2487 width = count;
026df7c5 2488
155e0d23
NC		 2489 for (addr_offset = start_offset;
2490 addr_offset < stop_offset; addr_offset += onaline / opb)
d24de309 2491 {
155e0d23 2492 bfd_size_type j;
d24de309 2493
155e0d23
NC		 2494 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2495 count = strlen (buf);
2496 if ((size_t) count >= sizeof (buf))
2497 abort ();
d24de309 2498
155e0d23
NC		 2499 putchar (' ');
2500 while (count < width)
252b5132 2501 {
155e0d23
NC		 2502 putchar ('0');
2503 count++;
2504 }
2505 fputs (buf + count - width, stdout);
2506 putchar (' ');
252b5132 2507
155e0d23
NC		 2508 for (j = addr_offset * opb;
2509 j < addr_offset * opb + onaline; j++)
2510 {
2511 if (j < stop_offset * opb)
2512 printf ("%02x", (unsigned) (data[j]));
2513 else
2514 printf (" ");
2515 if ((j & 3) == 3)
2516 printf (" ");
252b5132
RH		 2517 }
2518
155e0d23
NC		 2519 printf (" ");
2520 for (j = addr_offset * opb;
2521 j < addr_offset * opb + onaline; j++)
2522 {
2523 if (j >= stop_offset * opb)
2524 printf (" ");
2525 else
2526 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2527 }
2528 putchar ('\n');
252b5132 2529 }
155e0d23 2530 free (data);
252b5132 2531}
155e0d23 2532
98a91d6a 2533/* Actually display the various requested regions. */
252b5132
RH		 2534
2535static void
46dca2e0 2536dump_data (bfd *abfd)
252b5132 2537{
155e0d23 2538 bfd_map_over_sections (abfd, dump_section, NULL);
252b5132
RH		 2539}
2540
98a91d6a
NC		 2541/* Should perhaps share code and display with nm? */
2542
252b5132 2543static void
46dca2e0 2544dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
252b5132
RH		 2545{
2546 asymbol **current;
2547 long max;
2548 long count;
2549
2550 if (dynamic)
2551 {
2552 current = dynsyms;
2553 max = dynsymcount;
252b5132
RH		 2554 printf ("DYNAMIC SYMBOL TABLE:\n");
2555 }
2556 else
2557 {
2558 current = syms;
2559 max = symcount;
252b5132
RH		 2560 printf ("SYMBOL TABLE:\n");
2561 }
2562
a1df01d1
AM		 2563 if (max == 0)
2564 printf (_("no symbols\n"));
2565
252b5132
RH		 2566 for (count = 0; count < max; count++)
2567 {
155e0d23
NC		 2568 bfd *cur_bfd;
2569
2570 if (*current == NULL)
83ef0798 2571 printf (_("no information for symbol number %ld\n"), count);
155e0d23
NC		 2572
2573 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
83ef0798 2574 printf (_("could not determine the type of symbol number %ld\n"),
155e0d23
NC		 2575 count);
2576
661f7c35
NC		 2577 else if (process_section_p ((* current)->section)
2578 && (dump_special_syms
2579 || !bfd_is_target_special_symbol (cur_bfd, *current)))
252b5132 2580 {
155e0d23 2581 const char *name = (*current)->name;
252b5132 2582
155e0d23 2583 if (do_demangle && name != NULL && *name != '\0')
252b5132 2584 {
252b5132
RH		 2585 char *alloc;
2586
155e0d23
NC		 2587 /* If we want to demangle the name, we demangle it
2588 here, and temporarily clobber it while calling
2589 bfd_print_symbol. FIXME: This is a gross hack. */
ed180cc5
AM		 2590 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2591 if (alloc != NULL)
2592 (*current)->name = alloc;
252b5132
RH		 2593 bfd_print_symbol (cur_bfd, stdout, *current,
2594 bfd_print_symbol_all);
ed180cc5
AM		 2595 if (alloc != NULL)
2596 {
2597 (*current)->name = name;
2598 free (alloc);
2599 }
252b5132 2600 }
252b5132 2601 else
155e0d23
NC		 2602 bfd_print_symbol (cur_bfd, stdout, *current,
2603 bfd_print_symbol_all);
83ef0798 2604 printf ("\n");
252b5132 2605 }
661f7c35 2606
155e0d23 2607 current++;
252b5132 2608 }
155e0d23 2609 printf ("\n\n");
252b5132 2610}
155e0d23 2611\f
252b5132 2612static void
46dca2e0 2613dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
252b5132
RH		 2614{
2615 arelent **p;
2616 char *last_filename, *last_functionname;
2617 unsigned int last_line;
2618
2619 /* Get column headers lined up reasonably. */
2620 {
2621 static int width;
98a91d6a 2622
252b5132
RH		 2623 if (width == 0)
2624 {
2625 char buf[30];
155e0d23 2626
d8180c76 2627 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
252b5132
RH		 2628 width = strlen (buf) - 7;
2629 }
2630 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2631 }
2632
2633 last_filename = NULL;
2634 last_functionname = NULL;
2635 last_line = 0;
2636
d3ba0551 2637 for (p = relpp; relcount && *p != NULL; p++, relcount--)
252b5132
RH		 2638 {
2639 arelent *q = *p;
2640 const char *filename, *functionname;
2641 unsigned int line;
2642 const char *sym_name;
2643 const char *section_name;
2644
2645 if (start_address != (bfd_vma) -1
2646 && q->address < start_address)
2647 continue;
2648 if (stop_address != (bfd_vma) -1
2649 && q->address > stop_address)
2650 continue;
2651
2652 if (with_line_numbers
2653 && sec != NULL
2654 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2655 &filename, &functionname, &line))
2656 {
2657 if (functionname != NULL
2658 && (last_functionname == NULL
2659 || strcmp (functionname, last_functionname) != 0))
2660 {
2661 printf ("%s():\n", functionname);
2662 if (last_functionname != NULL)
2663 free (last_functionname);
2664 last_functionname = xstrdup (functionname);
2665 }
98a91d6a 2666
252b5132
RH		 2667 if (line > 0
2668 && (line != last_line
2669 || (filename != NULL
2670 && last_filename != NULL
2671 && strcmp (filename, last_filename) != 0)))
2672 {
2673 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2674 last_line = line;
2675 if (last_filename != NULL)
2676 free (last_filename);
2677 if (filename == NULL)
2678 last_filename = NULL;
2679 else
2680 last_filename = xstrdup (filename);
2681 }
2682 }
2683
2684 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2685 {
2686 sym_name = (*(q->sym_ptr_ptr))->name;
2687 section_name = (*(q->sym_ptr_ptr))->section->name;
2688 }
2689 else
2690 {
2691 sym_name = NULL;
2692 section_name = NULL;
2693 }
98a91d6a 2694
f9ecb0a4
JJ		 2695 bfd_printf_vma (abfd, q->address);
2696 if (q->howto == NULL)
2697 printf (" *unknown* ");
2698 else if (q->howto->name)
2699 printf (" %-16s ", q->howto->name);
2700 else
2701 printf (" %-16d ", q->howto->type);
252b5132 2702 if (sym_name)
f9ecb0a4 2703 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
252b5132
RH		 2704 else
2705 {
d3ba0551 2706 if (section_name == NULL)
252b5132 2707 section_name = "*unknown*";
f9ecb0a4 2708 printf ("[%s]", section_name);
252b5132 2709 }
98a91d6a 2710
252b5132
RH		 2711 if (q->addend)
2712 {
2713 printf ("+0x");
d8180c76 2714 bfd_printf_vma (abfd, q->addend);
252b5132 2715 }
98a91d6a 2716
252b5132
RH		 2717 printf ("\n");
2718 }
2719}
43ac9881 2720
155e0d23 2721static void
3b9ad1cc
AM		 2722dump_relocs_in_section (bfd *abfd,
2723 asection *section,
2724 void *dummy ATTRIBUTE_UNUSED)
155e0d23
NC		 2725{
2726 arelent **relpp;
2727 long relcount;
2728 long relsize;
2729
2730 if ( bfd_is_abs_section (section)
2731 || bfd_is_und_section (section)
2732 || bfd_is_com_section (section)
2733 || (! process_section_p (section))
2734 || ((section->flags & SEC_RELOC) == 0))
2735 return;
2736
2737 relsize = bfd_get_reloc_upper_bound (abfd, section);
2738 if (relsize < 0)
2739 bfd_fatal (bfd_get_filename (abfd));
2740
2741 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2742
2743 if (relsize == 0)
2744 {
2745 printf (" (none)\n\n");
2746 return;
2747 }
2748
2749 relpp = xmalloc (relsize);
2750 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2751
2752 if (relcount < 0)
2753 bfd_fatal (bfd_get_filename (abfd));
2754 else if (relcount == 0)
2755 printf (" (none)\n\n");
2756 else
2757 {
2758 printf ("\n");
2759 dump_reloc_set (abfd, section, relpp, relcount);
2760 printf ("\n\n");
2761 }
2762 free (relpp);
2763}
2764
2765static void
2766dump_relocs (bfd *abfd)
2767{
2768 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2769}
2770
2771static void
2772dump_dynamic_relocs (bfd *abfd)
2773{
2774 long relsize;
2775 arelent **relpp;
2776 long relcount;
2777
2778 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2779 if (relsize < 0)
2780 bfd_fatal (bfd_get_filename (abfd));
2781
2782 printf ("DYNAMIC RELOCATION RECORDS");
2783
2784 if (relsize == 0)
2785 printf (" (none)\n\n");
2786 else
2787 {
2788 relpp = xmalloc (relsize);
2789 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2790
2791 if (relcount < 0)
2792 bfd_fatal (bfd_get_filename (abfd));
2793 else if (relcount == 0)
2794 printf (" (none)\n\n");
2795 else
2796 {
2797 printf ("\n");
2798 dump_reloc_set (abfd, NULL, relpp, relcount);
2799 printf ("\n\n");
2800 }
2801 free (relpp);
2802 }
2803}
2804
43ac9881
AM		 2805/* Creates a table of paths, to search for source files. */
2806
2807static void
2808add_include_path (const char *path)
2809{
2810 if (path[0] == 0)
2811 return;
2812 include_path_count++;
2813 include_paths = xrealloc (include_paths,
2814 include_path_count * sizeof (*include_paths));
2815#ifdef HAVE_DOS_BASED_FILE_SYSTEM
2816 if (path[1] == ':' && path[2] == 0)
2817 path = concat (path, ".", (const char *) 0);
2818#endif
2819 include_paths[include_path_count - 1] = path;
2820}
155e0d23
NC		 2821
2822static void
3b9ad1cc
AM		 2823adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2824 asection *section,
bc79cded 2825 void *arg)
155e0d23 2826{
bc79cded
L		 2827 if ((section->flags & SEC_DEBUGGING) == 0)
2828 {
2829 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2830 section->vma += adjust_section_vma;
2831 if (*has_reloc_p)
2832 section->lma += adjust_section_vma;
2833 }
155e0d23
NC		 2834}
2835
2836/* Dump selected contents of ABFD. */
2837
2838static void
2839dump_bfd (bfd *abfd)
2840{
2841 /* If we are adjusting section VMA's, change them all now. Changing
2842 the BFD information is a hack. However, we must do it, or
2843 bfd_find_nearest_line will not do the right thing. */
2844 if (adjust_section_vma != 0)
bc79cded
L		 2845 {
2846 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2847 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2848 }
155e0d23
NC		 2849
2850 if (! dump_debugging_tags)
2851 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2852 abfd->xvec->name);
2853 if (dump_ar_hdrs)
2854 print_arelt_descr (stdout, abfd, TRUE);
2855 if (dump_file_header)
2856 dump_bfd_header (abfd);
2857 if (dump_private_headers)
2858 dump_bfd_private_header (abfd);
2859 if (! dump_debugging_tags)
2860 putchar ('\n');
2861 if (dump_section_headers)
2862 dump_headers (abfd);
2863
365544c3
L		 2864 if (dump_symtab
2865 || dump_reloc_info
2866 || disassemble
2867 || dump_debugging
2868 || dump_dwarf_section_info)
155e0d23 2869 syms = slurp_symtab (abfd);
4c45e5c9
JJ		 2870 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2871 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
155e0d23 2872 dynsyms = slurp_dynamic_symtab (abfd);
90e3cdf2 2873 if (disassemble)
4c45e5c9 2874 {
c9727e01
AM		 2875 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2876 dynsymcount, dynsyms, &synthsyms);
2877 if (synthcount < 0)
2878 synthcount = 0;
4c45e5c9 2879 }
155e0d23
NC		 2880
2881 if (dump_symtab)
2882 dump_symbols (abfd, FALSE);
2883 if (dump_dynamic_symtab)
2884 dump_symbols (abfd, TRUE);
365544c3
L		 2885 if (dump_dwarf_section_info)
2886 dump_dwarf (abfd);
155e0d23
NC		 2887 if (dump_stab_section_info)
2888 dump_stabs (abfd);
2889 if (dump_reloc_info && ! disassemble)
2890 dump_relocs (abfd);
2891 if (dump_dynamic_reloc_info && ! disassemble)
2892 dump_dynamic_relocs (abfd);
2893 if (dump_section_contents)
2894 dump_data (abfd);
2895 if (disassemble)
2896 disassemble_data (abfd);
2897
2898 if (dump_debugging)
2899 {
2900 void *dhandle;
2901
2902 dhandle = read_debugging_info (abfd, syms, symcount);
2903 if (dhandle != NULL)
2904 {
ed180cc5
AM		 2905 if (!print_debugging_info (stdout, dhandle, abfd, syms,
2906 bfd_demangle,
2907 dump_debugging_tags ? TRUE : FALSE))
155e0d23
NC		 2908 {
2909 non_fatal (_("%s: printing debugging information failed"),
2910 bfd_get_filename (abfd));
2911 exit_status = 1;
2912 }
2913 }
2914 }
2915
2916 if (syms)
2917 {
2918 free (syms);
2919 syms = NULL;
2920 }
2921
2922 if (dynsyms)
2923 {
2924 free (dynsyms);
2925 dynsyms = NULL;
2926 }
4c45e5c9
JJ		 2927
2928 if (synthsyms)
2929 {
2930 free (synthsyms);
2931 synthsyms = NULL;
2932 }
2933
2934 symcount = 0;
2935 dynsymcount = 0;
2936 synthcount = 0;
155e0d23
NC		 2937}
2938
2939static void
2940display_bfd (bfd *abfd)
2941{
2942 char **matching;
2943
2944 if (bfd_check_format_matches (abfd, bfd_object, &matching))
2945 {
2946 dump_bfd (abfd);
2947 return;
2948 }
2949
2950 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2951 {
2952 nonfatal (bfd_get_filename (abfd));
2953 list_matching_formats (matching);
2954 free (matching);
2955 return;
2956 }
2957
2958 if (bfd_get_error () != bfd_error_file_not_recognized)
2959 {
2960 nonfatal (bfd_get_filename (abfd));
2961 return;
2962 }
2963
2964 if (bfd_check_format_matches (abfd, bfd_core, &matching))
2965 {
2966 dump_bfd (abfd);
2967 return;
2968 }
2969
2970 nonfatal (bfd_get_filename (abfd));
2971
2972 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2973 {
2974 list_matching_formats (matching);
2975 free (matching);
2976 }
2977}
2978
2979static void
2980display_file (char *filename, char *target)
2981{
f24ddbdd
NC		 2982 bfd *file;
2983 bfd *arfile = NULL;
2984
2985 if (get_file_size (filename) < 1)
d68c385b
NC		 2986 {
2987 exit_status = 1;
2988 return;
2989 }
155e0d23
NC		 2990
2991 file = bfd_openr (filename, target);
2992 if (file == NULL)
2993 {
2994 nonfatal (filename);
2995 return;
2996 }
2997
2998 /* If the file is an archive, process all of its elements. */
2999 if (bfd_check_format (file, bfd_archive))
3000 {
3001 bfd *last_arfile = NULL;
3002
3003 printf (_("In archive %s:\n"), bfd_get_filename (file));
3004 for (;;)
3005 {
3006 bfd_set_error (bfd_error_no_error);
3007
3008 arfile = bfd_openr_next_archived_file (file, arfile);
3009 if (arfile == NULL)
3010 {
3011 if (bfd_get_error () != bfd_error_no_more_archived_files)
3012 nonfatal (bfd_get_filename (file));
3013 break;
3014 }
3015
3016 display_bfd (arfile);
3017
3018 if (last_arfile != NULL)
3019 bfd_close (last_arfile);
3020 last_arfile = arfile;
3021 }
3022
3023 if (last_arfile != NULL)
3024 bfd_close (last_arfile);
3025 }
3026 else
3027 display_bfd (file);
3028
3029 bfd_close (file);
3030}
252b5132 3031\f
252b5132 3032int
46dca2e0 3033main (int argc, char **argv)
252b5132
RH		 3034{
3035 int c;
3036 char *target = default_target;
b34976b6 3037 bfd_boolean seenflag = FALSE;
252b5132 3038
155e0d23
NC		 3039#if defined (HAVE_SETLOCALE)
3040#if defined (HAVE_LC_MESSAGES)
252b5132 3041 setlocale (LC_MESSAGES, "");
3882b010 3042#endif
3882b010 3043 setlocale (LC_CTYPE, "");
252b5132 3044#endif
155e0d23 3045
252b5132
RH		 3046 bindtextdomain (PACKAGE, LOCALEDIR);
3047 textdomain (PACKAGE);
3048
3049 program_name = *argv;
3050 xmalloc_set_program_name (program_name);
3051
3052 START_PROGRESS (program_name, 0);
3053
869b9d07
MM		 3054 expandargv (&argc, &argv);
3055
252b5132
RH		 3056 bfd_init ();
3057 set_default_bfd_target ();
3058
365544c3 3059 while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
252b5132
RH		 3060 long_options, (int *) 0))
3061 != EOF)
3062 {
252b5132
RH		 3063 switch (c)
3064 {
3065 case 0:
8b53311e 3066 break; /* We've been given a long option. */
252b5132
RH		 3067 case 'm':
3068 machine = optarg;
3069 break;
dd92f639 3070 case 'M':
073fbac6 3071 if (disassembler_options)
31e0f3cd 3072 /* Ignore potential memory leak for now. */
46dca2e0
NC		 3073 disassembler_options = concat (disassembler_options, ",",
3074 optarg, NULL);
31e0f3cd
NC		 3075 else
3076 disassembler_options = optarg;
dd92f639 3077 break;
252b5132 3078 case 'j':
43ac9881 3079 if (only_used == only_size)
6e50c90c
L		 3080 {
3081 only_size += 8;
43ac9881 3082 only = xrealloc (only, only_size * sizeof (char *));
6e50c90c
L		 3083 }
3084 only [only_used++] = optarg;
252b5132
RH		 3085 break;
3086 case 'l':
b34976b6 3087 with_line_numbers = TRUE;
252b5132
RH		 3088 break;
3089 case 'b':
3090 target = optarg;
3091 break;
1dada9c5 3092 case 'C':
b34976b6 3093 do_demangle = TRUE;
28c309a2
NC		 3094 if (optarg != NULL)
3095 {
3096 enum demangling_styles style;
8b53311e 3097
28c309a2 3098 style = cplus_demangle_name_to_style (optarg);
0af11b59 3099 if (style == unknown_demangling)
28c309a2
NC		 3100 fatal (_("unknown demangling style `%s'"),
3101 optarg);
8b53311e 3102
28c309a2 3103 cplus_demangle_set_style (style);
0af11b59 3104 }
1dada9c5
NC		 3105 break;
3106 case 'w':
b34976b6 3107 wide_output = TRUE;
1dada9c5
NC		 3108 break;
3109 case OPTION_ADJUST_VMA:
3110 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3111 break;
3112 case OPTION_START_ADDRESS:
3113 start_address = parse_vma (optarg, "--start-address");
3114 break;
3115 case OPTION_STOP_ADDRESS:
3116 stop_address = parse_vma (optarg, "--stop-address");
3117 break;
3118 case 'E':
3119 if (strcmp (optarg, "B") == 0)
3120 endian = BFD_ENDIAN_BIG;
3121 else if (strcmp (optarg, "L") == 0)
3122 endian = BFD_ENDIAN_LITTLE;
3123 else
3124 {
37cc8ec1 3125 non_fatal (_("unrecognized -E option"));
1dada9c5
NC		 3126 usage (stderr, 1);
3127 }
3128 break;
3129 case OPTION_ENDIAN:
3130 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3131 endian = BFD_ENDIAN_BIG;
3132 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3133 endian = BFD_ENDIAN_LITTLE;
3134 else
3135 {
37cc8ec1 3136 non_fatal (_("unrecognized --endian type `%s'"), optarg);
1dada9c5
NC		 3137 usage (stderr, 1);
3138 }
3139 break;
8b53311e 3140
252b5132 3141 case 'f':
b34976b6
AM		 3142 dump_file_header = TRUE;
3143 seenflag = TRUE;
252b5132
RH		 3144 break;
3145 case 'i':
b34976b6
AM		 3146 formats_info = TRUE;
3147 seenflag = TRUE;
252b5132 3148 break;
43ac9881
AM		 3149 case 'I':
3150 add_include_path (optarg);
3151 break;
252b5132 3152 case 'p':
b34976b6
AM		 3153 dump_private_headers = TRUE;
3154 seenflag = TRUE;
252b5132
RH		 3155 break;
3156 case 'x':
b34976b6
AM		 3157 dump_private_headers = TRUE;
3158 dump_symtab = TRUE;
3159 dump_reloc_info = TRUE;
3160 dump_file_header = TRUE;
3161 dump_ar_hdrs = TRUE;
3162 dump_section_headers = TRUE;
3163 seenflag = TRUE;
252b5132
RH		 3164 break;
3165 case 't':
b34976b6
AM		 3166 dump_symtab = TRUE;
3167 seenflag = TRUE;
252b5132
RH		 3168 break;
3169 case 'T':
b34976b6
AM		 3170 dump_dynamic_symtab = TRUE;
3171 seenflag = TRUE;
252b5132
RH		 3172 break;
3173 case 'd':
b34976b6
AM		 3174 disassemble = TRUE;
3175 seenflag = TRUE;
1dada9c5
NC		 3176 break;
3177 case 'z':
b34976b6 3178 disassemble_zeroes = TRUE;
252b5132
RH		 3179 break;
3180 case 'D':
b34976b6
AM		 3181 disassemble = TRUE;
3182 disassemble_all = TRUE;
3183 seenflag = TRUE;
252b5132
RH		 3184 break;
3185 case 'S':
b34976b6
AM		 3186 disassemble = TRUE;
3187 with_source_code = TRUE;
3188 seenflag = TRUE;
1dada9c5
NC		 3189 break;
3190 case 'g':
3191 dump_debugging = 1;
b34976b6 3192 seenflag = TRUE;
1dada9c5 3193 break;
51cdc6e0
NC		 3194 case 'e':
3195 dump_debugging = 1;
3196 dump_debugging_tags = 1;
3197 do_demangle = TRUE;
3198 seenflag = TRUE;
3199 break;
365544c3
L		 3200 case 'W':
3201 dump_dwarf_section_info = TRUE;
3202 seenflag = TRUE;
3203 do_debug_info = 1;
3204 do_debug_abbrevs = 1;
3205 do_debug_lines = 1;
3206 do_debug_pubnames = 1;
3207 do_debug_aranges = 1;
3208 do_debug_ranges = 1;
3209 do_debug_frames = 1;
3210 do_debug_macinfo = 1;
3211 do_debug_str = 1;
3212 do_debug_loc = 1;
3213 break;
1dada9c5 3214 case 'G':
b34976b6
AM		 3215 dump_stab_section_info = TRUE;
3216 seenflag = TRUE;
252b5132
RH		 3217 break;
3218 case 's':
b34976b6
AM		 3219 dump_section_contents = TRUE;
3220 seenflag = TRUE;
252b5132
RH		 3221 break;
3222 case 'r':
b34976b6
AM		 3223 dump_reloc_info = TRUE;
3224 seenflag = TRUE;
252b5132
RH		 3225 break;
3226 case 'R':
b34976b6
AM		 3227 dump_dynamic_reloc_info = TRUE;
3228 seenflag = TRUE;
252b5132
RH		 3229 break;
3230 case 'a':
b34976b6
AM		 3231 dump_ar_hdrs = TRUE;
3232 seenflag = TRUE;
252b5132
RH		 3233 break;
3234 case 'h':
b34976b6
AM		 3235 dump_section_headers = TRUE;
3236 seenflag = TRUE;
252b5132
RH		 3237 break;
3238 case 'H':
3239 usage (stdout, 0);
b34976b6 3240 seenflag = TRUE;
8b53311e 3241 case 'v':
252b5132 3242 case 'V':
b34976b6
AM		 3243 show_version = TRUE;
3244 seenflag = TRUE;
252b5132 3245 break;
0af11b59 3246
252b5132
RH		 3247 default:
3248 usage (stderr, 1);
3249 }
3250 }
3251
3252 if (show_version)
3253 print_version ("objdump");
3254
b34976b6 3255 if (!seenflag)
1dada9c5 3256 usage (stderr, 2);
252b5132
RH		 3257
3258 if (formats_info)
06d86cf7 3259 exit_status = display_info ();
252b5132
RH		 3260 else
3261 {
3262 if (optind == argc)
3263 display_file ("a.out", target);
3264 else
3265 for (; optind < argc;)
3266 display_file (argv[optind++], target);
3267 }
3268
3269 END_PROGRESS (program_name);
3270
75cd796a 3271 return exit_status;
252b5132 3272}
GDB Binutils - Deliverables
This page took 0.764673 seconds and 4 git commands to generate.