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