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