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