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