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