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