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