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