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