1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
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 of the License, or
10 (at your option) any later version.
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.
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, Inc., 59 Temple Place - Suite 330, Boston, MA
26 #include "aout/stab_gnu.h"
27 #include "aout/ranlib.h"
29 #include "libiberty.h"
31 /* When sorting by size, we use this structure to hold the size and a
32 pointer to the minisymbol. */
40 /* When fetching relocs, we use this structure to pass information to
43 struct get_relocs_info
52 usage
PARAMS ((FILE *, int));
55 set_print_radix
PARAMS ((char *));
58 set_output_format
PARAMS ((char *));
61 display_archive
PARAMS ((bfd
*));
64 display_file
PARAMS ((char *filename
));
67 display_rel_file
PARAMS ((bfd
* file
, bfd
* archive
));
70 filter_symbols
PARAMS ((bfd
*, boolean
, PTR
, long, unsigned int));
73 sort_symbols_by_size
PARAMS ((bfd
*, boolean
, PTR
, long, unsigned int,
77 print_symbols
PARAMS ((bfd
*, boolean
, PTR
, long, unsigned int, bfd
*));
80 print_size_symbols
PARAMS ((bfd
*, boolean
, struct size_sym
*, long, bfd
*));
83 print_symname
PARAMS ((const char *, const char *, bfd
*));
86 print_symbol
PARAMS ((bfd
*, asymbol
*, bfd
*));
89 print_symdef_entry
PARAMS ((bfd
* abfd
));
91 /* The sorting functions. */
94 numeric_forward
PARAMS ((const PTR
, const PTR
));
97 numeric_reverse
PARAMS ((const PTR
, const PTR
));
100 non_numeric_forward
PARAMS ((const PTR
, const PTR
));
103 non_numeric_reverse
PARAMS ((const PTR
, const PTR
));
106 size_forward1
PARAMS ((const PTR
, const PTR
));
109 size_forward2
PARAMS ((const PTR
, const PTR
));
111 /* The output formatting functions. */
114 print_object_filename_bsd
PARAMS ((char *filename
));
117 print_object_filename_sysv
PARAMS ((char *filename
));
120 print_object_filename_posix
PARAMS ((char *filename
));
124 print_archive_filename_bsd
PARAMS ((char *filename
));
127 print_archive_filename_sysv
PARAMS ((char *filename
));
130 print_archive_filename_posix
PARAMS ((char *filename
));
134 print_archive_member_bsd
PARAMS ((char *archive
, CONST
char *filename
));
137 print_archive_member_sysv
PARAMS ((char *archive
, CONST
char *filename
));
140 print_archive_member_posix
PARAMS ((char *archive
, CONST
char *filename
));
144 print_symbol_filename_bsd
PARAMS ((bfd
* archive_bfd
, bfd
* abfd
));
147 print_symbol_filename_sysv
PARAMS ((bfd
* archive_bfd
, bfd
* abfd
));
150 print_symbol_filename_posix
PARAMS ((bfd
* archive_bfd
, bfd
* abfd
));
154 print_value
PARAMS ((bfd_vma
));
157 print_symbol_info_bsd
PARAMS ((symbol_info
* info
, bfd
* abfd
));
160 print_symbol_info_sysv
PARAMS ((symbol_info
* info
, bfd
* abfd
));
163 print_symbol_info_posix
PARAMS ((symbol_info
* info
, bfd
* abfd
));
166 get_relocs
PARAMS ((bfd
*, asection
*, PTR
));
168 /* Support for different output formats. */
171 /* Print the name of an object file given on the command line. */
172 void (*print_object_filename
) PARAMS ((char *filename
));
174 /* Print the name of an archive file given on the command line. */
175 void (*print_archive_filename
) PARAMS ((char *filename
));
177 /* Print the name of an archive member file. */
178 void (*print_archive_member
) PARAMS ((char *archive
, CONST
char *filename
));
180 /* Print the name of the file (and archive, if there is one)
181 containing a symbol. */
182 void (*print_symbol_filename
) PARAMS ((bfd
* archive_bfd
, bfd
* abfd
));
184 /* Print a line of information about a symbol. */
185 void (*print_symbol_info
) PARAMS ((symbol_info
* info
, bfd
* abfd
));
187 static struct output_fns formats
[] =
189 {print_object_filename_bsd
,
190 print_archive_filename_bsd
,
191 print_archive_member_bsd
,
192 print_symbol_filename_bsd
,
193 print_symbol_info_bsd
},
194 {print_object_filename_sysv
,
195 print_archive_filename_sysv
,
196 print_archive_member_sysv
,
197 print_symbol_filename_sysv
,
198 print_symbol_info_sysv
},
199 {print_object_filename_posix
,
200 print_archive_filename_posix
,
201 print_archive_member_posix
,
202 print_symbol_filename_posix
,
203 print_symbol_info_posix
}
206 /* Indices in `formats'. */
208 #define FORMAT_SYSV 1
209 #define FORMAT_POSIX 2
210 #define FORMAT_DEFAULT FORMAT_BSD
212 /* The output format to use. */
213 static struct output_fns
*format
= &formats
[FORMAT_DEFAULT
];
216 /* Command options. */
218 static int do_demangle
= 0; /* Pretty print C++ symbol names. */
219 static int external_only
= 0; /* print external symbols only */
220 static int defined_only
= 0; /* Print defined symbols only */
221 static int no_sort
= 0; /* don't sort; print syms in order found */
222 static int print_debug_syms
= 0; /* print debugger-only symbols too */
223 static int print_armap
= 0; /* describe __.SYMDEF data in archive files. */
224 static int reverse_sort
= 0; /* sort in downward(alpha or numeric) order */
225 static int sort_numerically
= 0; /* sort in numeric rather than alpha order */
226 static int sort_by_size
= 0; /* sort by size of symbol */
227 static int undefined_only
= 0; /* print undefined symbols only */
228 static int dynamic
= 0; /* print dynamic symbols. */
229 static int show_version
= 0; /* show the version number */
230 static int show_stats
= 0; /* show statistics */
231 static int line_numbers
= 0; /* print line numbers for symbols */
233 /* When to print the names of files. Not mutually exclusive in SYSV format. */
234 static int filename_per_file
= 0; /* Once per file, on its own line. */
235 static int filename_per_symbol
= 0; /* Once per symbol, at start of line. */
237 /* Print formats for printing a symbol value. */
239 static char value_format
[] = "%08lx";
241 #if BFD_HOST_64BIT_LONG
242 static char value_format
[] = "%016lx";
244 /* We don't use value_format for this case. */
247 static int print_radix
= 16;
248 /* Print formats for printing stab info. */
249 static char other_format
[] = "%02x";
250 static char desc_format
[] = "%04x";
252 static char *target
= NULL
;
254 /* Used to cache the line numbers for a BFD. */
255 static bfd
*lineno_cache_bfd
;
256 static bfd
*lineno_cache_rel_bfd
;
258 #define OPTION_TARGET 200
260 static struct option long_options
[] =
262 {"debug-syms", no_argument
, &print_debug_syms
, 1},
263 {"demangle", no_argument
, &do_demangle
, 1},
264 {"dynamic", no_argument
, &dynamic
, 1},
265 {"extern-only", no_argument
, &external_only
, 1},
266 {"format", required_argument
, 0, 'f'},
267 {"help", no_argument
, 0, 'h'},
268 {"line-numbers", no_argument
, 0, 'l'},
269 {"no-cplus", no_argument
, &do_demangle
, 0}, /* Linux compatibility. */
270 {"no-demangle", no_argument
, &do_demangle
, 0},
271 {"no-sort", no_argument
, &no_sort
, 1},
272 {"numeric-sort", no_argument
, &sort_numerically
, 1},
273 {"portability", no_argument
, 0, 'P'},
274 {"print-armap", no_argument
, &print_armap
, 1},
275 {"print-file-name", no_argument
, 0, 'o'},
276 {"radix", required_argument
, 0, 't'},
277 {"reverse-sort", no_argument
, &reverse_sort
, 1},
278 {"size-sort", no_argument
, &sort_by_size
, 1},
279 {"stats", no_argument
, &show_stats
, 1},
280 {"target", required_argument
, 0, OPTION_TARGET
},
281 {"defined-only", no_argument
, &defined_only
, 1},
282 {"undefined-only", no_argument
, &undefined_only
, 1},
283 {"version", no_argument
, &show_version
, 1},
284 {0, no_argument
, 0, 0}
287 /* Some error-reporting functions */
290 usage (stream
, status
)
294 fprintf (stream
, _("Usage: %s [OPTION]... [FILE]...\n"), program_name
);
295 fprintf (stream
, _("List symbols from FILEs (a.out by default).\n"));
296 fprintf (stream
, _("\n\
297 -a, --debug-syms Display debugger-only symbols\n\
298 -A, --print-file-name Print name of the input file before every symbol\n\
299 -B Same as --format=bsd\n\
300 -C, --demangle Decode low-level symbol names into user-level names\n\
301 --no-demangle Do not demangle low-level symbol names\n\
302 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
303 --defined-only Display only defined symbols\n\
305 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
306 `sysv' or `posix'. The default is `bsd'\n\
307 -g, --extern-only Display only external symbols\n\
308 -h, --help Display this information\n\
309 -l, --line-numbers Use debugging information to find a filename and\n\
310 line number for each symbol\n\
311 -n, --numeric-sort Sort symbols numerically by address\n\
313 -p, --no-sort Do not sort the symbols\n\
314 -P, --portability Same as --format=posix\n\
315 -r, --reverse-sort Reverse the sense of the sort\n\
316 -s, --print-armap Include index for symbols from archive members\n\
317 --size-sort Sort symbols by size\n\
318 -t, --radix=RADIX Use RADIX for printing symbol values\n\
319 --target=BFDNAME Specify the target object format as BFDNAME\n\
320 -u, --undefined-only Display only undefined symbols\n\
321 -V, --version Display this program's version number\n\
323 list_supported_targets (program_name
, stream
);
325 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
329 /* Set the radix for the symbol value and size according to RADIX. */
332 set_print_radix (radix
)
346 value_format
[4] = *radix
;
348 #if BFD_HOST_64BIT_LONG
349 value_format
[5] = *radix
;
351 /* This case requires special handling for octal and decimal
355 other_format
[3] = desc_format
[3] = *radix
;
358 fatal (_("%s: invalid radix"), radix
);
363 set_output_format (f
)
383 fatal (_("%s: invalid output format"), f
);
385 format
= &formats
[i
];
396 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
397 setlocale (LC_MESSAGES
, "");
399 bindtextdomain (PACKAGE
, LOCALEDIR
);
400 textdomain (PACKAGE
);
402 program_name
= *argv
;
403 xmalloc_set_program_name (program_name
);
405 START_PROGRESS (program_name
, 0);
408 set_default_bfd_target ();
410 while ((c
= getopt_long (argc
, argv
, "aABCDef:glnopPrst:uvV", long_options
, (int *) 0)) != EOF
)
415 print_debug_syms
= 1;
419 filename_per_symbol
= 1;
421 case 'B': /* For MIPS compatibility. */
422 set_output_format ("bsd");
431 /* Ignored for HP/UX compatibility. */
434 set_output_format (optarg
);
446 sort_numerically
= 1;
452 set_output_format ("posix");
461 set_print_radix (optarg
);
470 case OPTION_TARGET
: /* --target */
474 case 0: /* A long option that just sets a flag. */
483 print_version ("nm");
485 /* OK, all options now parsed. If no filename specified, do a.out. */
487 return !display_file ("a.out");
491 if (argc
- optind
> 1)
492 filename_per_file
= 1;
494 /* We were given several filenames to do. */
495 while (optind
< argc
)
498 if (!display_file (argv
[optind
++]))
502 END_PROGRESS (program_name
);
507 char *lim
= (char *) sbrk (0);
509 non_fatal (_("data size %ld"), (long) (lim
- (char *) &environ
));
518 display_archive (file
)
522 bfd
*last_arfile
= NULL
;
525 (*format
->print_archive_filename
) (bfd_get_filename (file
));
528 print_symdef_entry (file
);
534 arfile
= bfd_openr_next_archived_file (file
, arfile
);
538 if (bfd_get_error () != bfd_error_no_more_archived_files
)
539 bfd_fatal (bfd_get_filename (file
));
543 if (bfd_check_format_matches (arfile
, bfd_object
, &matching
))
545 (*format
->print_archive_member
) (bfd_get_filename (file
),
546 bfd_get_filename (arfile
));
547 display_rel_file (arfile
, file
);
551 bfd_nonfatal (bfd_get_filename (arfile
));
552 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
554 list_matching_formats (matching
);
559 if (last_arfile
!= NULL
)
561 bfd_close (last_arfile
);
562 lineno_cache_bfd
= NULL
;
563 lineno_cache_rel_bfd
= NULL
;
565 last_arfile
= arfile
;
568 if (last_arfile
!= NULL
)
570 bfd_close (last_arfile
);
571 lineno_cache_bfd
= NULL
;
572 lineno_cache_rel_bfd
= NULL
;
577 display_file (filename
)
580 boolean retval
= true;
584 file
= bfd_openr (filename
, target
);
587 bfd_nonfatal (filename
);
591 if (bfd_check_format (file
, bfd_archive
))
593 display_archive (file
);
595 else if (bfd_check_format_matches (file
, bfd_object
, &matching
))
597 (*format
->print_object_filename
) (filename
);
598 display_rel_file (file
, NULL
);
602 bfd_nonfatal (filename
);
603 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
605 list_matching_formats (matching
);
611 if (bfd_close (file
) == false)
612 bfd_fatal (filename
);
614 lineno_cache_bfd
= NULL
;
615 lineno_cache_rel_bfd
= NULL
;
620 /* These globals are used to pass information into the sorting
622 static bfd
*sort_bfd
;
623 static boolean sort_dynamic
;
624 static asymbol
*sort_x
;
625 static asymbol
*sort_y
;
627 /* Symbol-sorting predicates */
628 #define valueof(x) ((x)->section->vma + (x)->value)
630 /* Numeric sorts. Undefined symbols are always considered "less than"
631 defined symbols with zero values. Common symbols are not treated
632 specially -- i.e., their sizes are used as their "values". */
635 numeric_forward (P_x
, P_y
)
642 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
643 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
644 if (x
== NULL
|| y
== NULL
)
645 bfd_fatal (bfd_get_filename (sort_bfd
));
647 xs
= bfd_get_section (x
);
648 ys
= bfd_get_section (y
);
650 if (bfd_is_und_section (xs
))
652 if (! bfd_is_und_section (ys
))
655 else if (bfd_is_und_section (ys
))
657 else if (valueof (x
) != valueof (y
))
658 return valueof (x
) < valueof (y
) ? -1 : 1;
660 return non_numeric_forward (P_x
, P_y
);
664 numeric_reverse (x
, y
)
668 return - numeric_forward (x
, y
);
672 non_numeric_forward (P_x
, P_y
)
679 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
680 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
681 if (x
== NULL
|| y
== NULL
)
682 bfd_fatal (bfd_get_filename (sort_bfd
));
684 xn
= bfd_asymbol_name (x
);
685 yn
= bfd_asymbol_name (y
);
687 return ((xn
== NULL
) ? ((yn
== NULL
) ? 0 : -1) :
688 ((yn
== NULL
) ? 1 : strcmp (xn
, yn
)));
692 non_numeric_reverse (x
, y
)
696 return - non_numeric_forward (x
, y
);
699 static int (*(sorters
[2][2])) PARAMS ((const PTR
, const PTR
)) =
701 { non_numeric_forward
, non_numeric_reverse
},
702 { numeric_forward
, numeric_reverse
}
705 /* This sort routine is used by sort_symbols_by_size. It is similar
706 to numeric_forward, but when symbols have the same value it sorts
707 by section VMA. This simplifies the sort_symbols_by_size code
708 which handles symbols at the end of sections. Also, this routine
709 tries to sort file names before other symbols with the same value.
710 That will make the file name have a zero size, which will make
711 sort_symbols_by_size choose the non file name symbol, leading to
712 more meaningful output. For similar reasons, this code sorts
713 gnu_compiled_* and gcc2_compiled before other symbols with the same
717 size_forward1 (P_x
, P_y
)
727 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
728 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
729 if (x
== NULL
|| y
== NULL
)
730 bfd_fatal (bfd_get_filename (sort_bfd
));
732 xs
= bfd_get_section (x
);
733 ys
= bfd_get_section (y
);
735 if (bfd_is_und_section (xs
))
737 if (bfd_is_und_section (ys
))
740 if (valueof (x
) != valueof (y
))
741 return valueof (x
) < valueof (y
) ? -1 : 1;
743 if (xs
->vma
!= ys
->vma
)
744 return xs
->vma
< ys
->vma
? -1 : 1;
746 xn
= bfd_asymbol_name (x
);
747 yn
= bfd_asymbol_name (y
);
751 /* The symbols gnu_compiled and gcc2_compiled convey even less
752 information than the file name, so sort them out first. */
754 xf
= (strstr (xn
, "gnu_compiled") != NULL
755 || strstr (xn
, "gcc2_compiled") != NULL
);
756 yf
= (strstr (yn
, "gnu_compiled") != NULL
757 || strstr (yn
, "gcc2_compiled") != NULL
);
764 /* We use a heuristic for the file name. It may not work on non
765 Unix systems, but it doesn't really matter; the only difference
766 is precisely which symbol names get printed. */
768 #define file_symbol(s, sn, snl) \
769 (((s)->flags & BSF_FILE) != 0 \
770 || ((sn)[(snl) - 2] == '.' \
771 && ((sn)[(snl) - 1] == 'o' \
772 || (sn)[(snl) - 1] == 'a')))
774 xf
= file_symbol (x
, xn
, xnl
);
775 yf
= file_symbol (y
, yn
, ynl
);
782 return non_numeric_forward (P_x
, P_y
);
785 /* This sort routine is used by sort_symbols_by_size. It is sorting
786 an array of size_sym structures into size order. */
789 size_forward2 (P_x
, P_y
)
793 const struct size_sym
*x
= (const struct size_sym
*) P_x
;
794 const struct size_sym
*y
= (const struct size_sym
*) P_y
;
796 if (x
->size
< y
->size
)
797 return reverse_sort
? 1 : -1;
798 else if (x
->size
> y
->size
)
799 return reverse_sort
? -1 : 1;
801 return sorters
[0][reverse_sort
] (x
->minisym
, y
->minisym
);
804 /* Sort the symbols by size. We guess the size by assuming that the
805 difference between the address of a symbol and the address of the
806 next higher symbol is the size. FIXME: ELF actually stores a size
807 with each symbol. We should use it. */
810 sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
, size
, symsizesp
)
816 struct size_sym
**symsizesp
;
818 struct size_sym
*symsizes
;
819 bfd_byte
*from
, *fromend
;
821 asymbol
*store_sym
, *store_next
;
823 qsort (minisyms
, symcount
, size
, size_forward1
);
825 /* We are going to return a special set of symbols and sizes to
827 symsizes
= (struct size_sym
*) xmalloc (symcount
* sizeof (struct size_sym
));
828 *symsizesp
= symsizes
;
830 /* Note that filter_symbols has already removed all absolute and
831 undefined symbols. Here we remove all symbols whose size winds
834 from
= (bfd_byte
*) minisyms
;
835 fromend
= from
+ symcount
* size
;
842 sym
= bfd_minisymbol_to_symbol (abfd
, dynamic
, (const PTR
) from
,
845 bfd_fatal (bfd_get_filename (abfd
));
848 for (; from
< fromend
; from
+= size
)
855 if (from
+ size
< fromend
)
857 next
= bfd_minisymbol_to_symbol (abfd
,
859 (const PTR
) (from
+ size
),
862 bfd_fatal (bfd_get_filename (abfd
));
867 sec
= bfd_get_section (sym
);
869 if (bfd_is_com_section (sec
))
873 if (from
+ size
< fromend
874 && sec
== bfd_get_section (next
))
875 sz
= valueof (next
) - valueof (sym
);
877 sz
= (bfd_get_section_vma (abfd
, sec
)
878 + bfd_section_size (abfd
, sec
)
884 symsizes
->minisym
= (const PTR
) from
;
892 store_sym
= store_next
;
896 symcount
= symsizes
- *symsizesp
;
898 /* We must now sort again by size. */
899 qsort ((PTR
) *symsizesp
, symcount
, sizeof (struct size_sym
), size_forward2
);
904 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
907 display_rel_file (abfd
, archive_bfd
)
914 struct size_sym
*symsizes
;
918 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
920 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
925 symcount
= bfd_read_minisymbols (abfd
, dynamic
, &minisyms
, &size
);
927 bfd_fatal (bfd_get_filename (abfd
));
931 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
935 /* Discard the symbols we don't want to print.
936 It's OK to do this in place; we'll free the storage anyway
939 symcount
= filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
);
945 sort_dynamic
= dynamic
;
946 sort_x
= bfd_make_empty_symbol (abfd
);
947 sort_y
= bfd_make_empty_symbol (abfd
);
948 if (sort_x
== NULL
|| sort_y
== NULL
)
949 bfd_fatal (bfd_get_filename (abfd
));
952 qsort (minisyms
, symcount
, size
,
953 sorters
[sort_numerically
][reverse_sort
]);
955 symcount
= sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
,
960 print_symbols (abfd
, dynamic
, minisyms
, symcount
, size
, archive_bfd
);
962 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, archive_bfd
);
967 /* Choose which symbol entries to print;
968 compact them downward to get rid of the rest.
969 Return the number of symbols to be printed. */
972 filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
)
979 bfd_byte
*from
, *fromend
, *to
;
982 store
= bfd_make_empty_symbol (abfd
);
984 bfd_fatal (bfd_get_filename (abfd
));
986 from
= (bfd_byte
*) minisyms
;
987 fromend
= from
+ symcount
* size
;
988 to
= (bfd_byte
*) minisyms
;
990 for (; from
< fromend
; from
+= size
)
997 sym
= bfd_minisymbol_to_symbol (abfd
, dynamic
, (const PTR
) from
, store
);
999 bfd_fatal (bfd_get_filename (abfd
));
1002 keep
= bfd_is_und_section (sym
->section
);
1003 else if (external_only
)
1004 keep
= ((sym
->flags
& BSF_GLOBAL
) != 0
1005 || (sym
->flags
& BSF_WEAK
) != 0
1006 || bfd_is_und_section (sym
->section
)
1007 || bfd_is_com_section (sym
->section
));
1012 && ! print_debug_syms
1013 && (sym
->flags
& BSF_DEBUGGING
) != 0)
1018 && (bfd_is_abs_section (sym
->section
)
1019 || bfd_is_und_section (sym
->section
)))
1025 if (bfd_is_und_section (sym
->section
))
1031 memcpy (to
, from
, size
);
1036 return (to
- (bfd_byte
*) minisyms
) / size
;
1039 /* Print symbol name NAME, read from ABFD, with printf format FORMAT,
1040 demangling it if requested. */
1043 print_symname (format
, name
, abfd
)
1048 if (do_demangle
&& *name
)
1052 /* In this mode, give a user-level view of the symbol name
1053 even if it's not mangled; strip off any leading
1055 if (bfd_get_symbol_leading_char (abfd
) == name
[0])
1058 res
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1061 printf (format
, res
);
1067 printf (format
, name
);
1070 /* Print the symbols. If ARCHIVE_BFD is non-NULL, it is the archive
1074 print_symbols (abfd
, dynamic
, minisyms
, symcount
, size
, archive_bfd
)
1083 bfd_byte
*from
, *fromend
;
1085 store
= bfd_make_empty_symbol (abfd
);
1087 bfd_fatal (bfd_get_filename (abfd
));
1089 from
= (bfd_byte
*) minisyms
;
1090 fromend
= from
+ symcount
* size
;
1091 for (; from
< fromend
; from
+= size
)
1095 sym
= bfd_minisymbol_to_symbol (abfd
, dynamic
, from
, store
);
1097 bfd_fatal (bfd_get_filename (abfd
));
1099 print_symbol (abfd
, sym
, archive_bfd
);
1103 /* Print the symbols when sorting by size. */
1106 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, archive_bfd
)
1109 struct size_sym
*symsizes
;
1114 struct size_sym
*from
, *fromend
;
1116 store
= bfd_make_empty_symbol (abfd
);
1118 bfd_fatal (bfd_get_filename (abfd
));
1121 fromend
= from
+ symcount
;
1122 for (; from
< fromend
; from
++)
1126 sym
= bfd_minisymbol_to_symbol (abfd
, dynamic
, from
->minisym
, store
);
1128 bfd_fatal (bfd_get_filename (abfd
));
1130 /* Set the symbol value so that we actually display the symbol
1132 sym
->value
= from
->size
- bfd_section_vma (abfd
, bfd_get_section (sym
));
1134 print_symbol (abfd
, sym
, archive_bfd
);
1138 /* Print a single symbol. */
1141 print_symbol (abfd
, sym
, archive_bfd
)
1148 (*format
->print_symbol_filename
) (archive_bfd
, abfd
);
1152 if (bfd_is_und_section (bfd_get_section (sym
)))
1153 print_symname ("%s", bfd_asymbol_name (sym
), abfd
);
1157 symbol_info syminfo
;
1159 bfd_get_symbol_info (abfd
, sym
, &syminfo
);
1160 (*format
->print_symbol_info
) (&syminfo
, abfd
);
1165 static asymbol
**syms
;
1166 static long symcount
;
1167 const char *filename
, *functionname
;
1168 unsigned int lineno
;
1170 /* We need to get the canonical symbols in order to call
1171 bfd_find_nearest_line. This is inefficient, but, then, you
1172 don't have to use --line-numbers. */
1173 if (abfd
!= lineno_cache_bfd
&& syms
!= NULL
)
1182 symsize
= bfd_get_symtab_upper_bound (abfd
);
1184 bfd_fatal (bfd_get_filename (abfd
));
1185 syms
= (asymbol
**) xmalloc (symsize
);
1186 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
1188 bfd_fatal (bfd_get_filename (abfd
));
1189 lineno_cache_bfd
= abfd
;
1192 if (bfd_is_und_section (bfd_get_section (sym
)))
1194 static asection
**secs
;
1195 static arelent
***relocs
;
1196 static long *relcount
;
1197 static unsigned int seccount
;
1199 const char *symname
;
1201 /* For an undefined symbol, we try to find a reloc for the
1202 symbol, and print the line number of the reloc. */
1204 if (abfd
!= lineno_cache_rel_bfd
&& relocs
!= NULL
)
1206 for (i
= 0; i
< seccount
; i
++)
1207 if (relocs
[i
] != NULL
)
1219 struct get_relocs_info info
;
1221 seccount
= bfd_count_sections (abfd
);
1223 secs
= (asection
**) xmalloc (seccount
* sizeof *secs
);
1224 relocs
= (arelent
***) xmalloc (seccount
* sizeof *relocs
);
1225 relcount
= (long *) xmalloc (seccount
* sizeof *relcount
);
1228 info
.relocs
= relocs
;
1229 info
.relcount
= relcount
;
1231 bfd_map_over_sections (abfd
, get_relocs
, (PTR
) &info
);
1232 lineno_cache_rel_bfd
= abfd
;
1235 symname
= bfd_asymbol_name (sym
);
1236 for (i
= 0; i
< seccount
; i
++)
1240 for (j
= 0; j
< relcount
[i
]; j
++)
1245 if (r
->sym_ptr_ptr
!= NULL
1246 && (*r
->sym_ptr_ptr
)->section
== sym
->section
1247 && (*r
->sym_ptr_ptr
)->value
== sym
->value
1249 bfd_asymbol_name (*r
->sym_ptr_ptr
)) == 0
1250 && bfd_find_nearest_line (abfd
, secs
[i
], syms
,
1251 r
->address
, &filename
,
1252 &functionname
, &lineno
))
1254 /* We only print the first one we find. */
1255 printf ("\t%s:%u", filename
, lineno
);
1262 else if (bfd_get_section (sym
)->owner
== abfd
)
1264 if (bfd_find_nearest_line (abfd
, bfd_get_section (sym
), syms
,
1265 sym
->value
, &filename
, &functionname
,
1270 printf ("\t%s:%u", filename
, lineno
);
1278 /* The following 3 groups of functions are called unconditionally,
1279 once at the start of processing each file of the appropriate type.
1280 They should check `filename_per_file' and `filename_per_symbol',
1281 as appropriate for their output format, to determine whether to
1284 /* Print the name of an object file given on the command line. */
1287 print_object_filename_bsd (filename
)
1290 if (filename_per_file
&& !filename_per_symbol
)
1291 printf ("\n%s:\n", filename
);
1295 print_object_filename_sysv (filename
)
1299 printf (_("\n\nUndefined symbols from %s:\n\n"), filename
);
1301 printf (_("\n\nSymbols from %s:\n\n"), filename
);
1303 Name Value Class Type Size Line Section\n\n"));
1307 print_object_filename_posix (filename
)
1310 if (filename_per_file
&& !filename_per_symbol
)
1311 printf ("%s:\n", filename
);
1314 /* Print the name of an archive file given on the command line. */
1317 print_archive_filename_bsd (filename
)
1320 if (filename_per_file
)
1321 printf ("\n%s:\n", filename
);
1325 print_archive_filename_sysv (filename
)
1326 char *filename ATTRIBUTE_UNUSED
;
1331 print_archive_filename_posix (filename
)
1332 char *filename ATTRIBUTE_UNUSED
;
1336 /* Print the name of an archive member file. */
1339 print_archive_member_bsd (archive
, filename
)
1340 char *archive ATTRIBUTE_UNUSED
;
1341 CONST
char *filename
;
1343 if (!filename_per_symbol
)
1344 printf ("\n%s:\n", filename
);
1348 print_archive_member_sysv (archive
, filename
)
1350 CONST
char *filename
;
1353 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive
, filename
);
1355 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive
, filename
);
1357 Name Value Class Type Size Line Section\n\n"));
1361 print_archive_member_posix (archive
, filename
)
1363 CONST
char *filename
;
1365 if (!filename_per_symbol
)
1366 printf ("%s[%s]:\n", archive
, filename
);
1369 /* Print the name of the file (and archive, if there is one)
1370 containing a symbol. */
1373 print_symbol_filename_bsd (archive_bfd
, abfd
)
1374 bfd
*archive_bfd
, *abfd
;
1376 if (filename_per_symbol
)
1379 printf ("%s:", bfd_get_filename (archive_bfd
));
1380 printf ("%s:", bfd_get_filename (abfd
));
1385 print_symbol_filename_sysv (archive_bfd
, abfd
)
1386 bfd
*archive_bfd
, *abfd
;
1388 if (filename_per_symbol
)
1391 printf ("%s:", bfd_get_filename (archive_bfd
));
1392 printf ("%s:", bfd_get_filename (abfd
));
1397 print_symbol_filename_posix (archive_bfd
, abfd
)
1398 bfd
*archive_bfd
, *abfd
;
1400 if (filename_per_symbol
)
1403 printf ("%s[%s]: ", bfd_get_filename (archive_bfd
),
1404 bfd_get_filename (abfd
));
1406 printf ("%s: ", bfd_get_filename (abfd
));
1410 /* Print a symbol value. */
1416 #if ! defined (BFD64) || BFD_HOST_64BIT_LONG
1417 printf (value_format
, val
);
1419 /* We have a 64 bit value to print, but the host is only 32 bit. */
1420 if (print_radix
== 16)
1421 fprintf_vma (stdout
, val
);
1427 s
= buf
+ sizeof buf
;
1431 *--s
= (val
% print_radix
) + '0';
1434 while ((buf
+ sizeof buf
- 1) - s
< 16)
1441 /* Print a line of information about a symbol. */
1444 print_symbol_info_bsd (info
, abfd
)
1448 if (bfd_is_undefined_symclass (info
->type
))
1459 print_value (info
->value
);
1460 printf (" %c", info
->type
);
1461 if (info
->type
== '-')
1465 printf (other_format
, info
->stab_other
);
1467 printf (desc_format
, info
->stab_desc
);
1468 printf (" %5s", info
->stab_name
);
1470 print_symname (" %s", info
->name
, abfd
);
1474 print_symbol_info_sysv (info
, abfd
)
1478 print_symname ("%-20s|", info
->name
, abfd
); /* Name */
1479 if (bfd_is_undefined_symclass (info
->type
))
1480 printf (" "); /* Value */
1482 print_value (info
->value
);
1483 printf ("| %c |", info
->type
); /* Class */
1484 if (info
->type
== '-')
1487 printf ("%18s| ", info
->stab_name
); /* (C) Type */
1488 printf (desc_format
, info
->stab_desc
); /* Size */
1489 printf ("| |"); /* Line, Section */
1492 printf (" | | |"); /* Type, Size, Line, Section */
1496 print_symbol_info_posix (info
, abfd
)
1500 print_symname ("%s ", info
->name
, abfd
);
1501 printf ("%c ", info
->type
);
1502 if (bfd_is_undefined_symclass (info
->type
))
1505 print_value (info
->value
);
1506 /* POSIX.2 wants the symbol size printed here, when applicable;
1507 BFD currently doesn't provide it, so we take the easy way out by
1508 considering it to never be applicable. */
1512 print_symdef_entry (abfd
)
1515 symindex idx
= BFD_NO_MORE_SYMBOLS
;
1517 boolean everprinted
= false;
1519 for (idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
);
1520 idx
!= BFD_NO_MORE_SYMBOLS
;
1521 idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
))
1526 printf (_("\nArchive index:\n"));
1529 elt
= bfd_get_elt_at_index (abfd
, idx
);
1531 bfd_fatal ("bfd_get_elt_at_index");
1532 if (thesym
->name
!= (char *) NULL
)
1534 print_symname ("%s", thesym
->name
, abfd
);
1535 printf (" in %s\n", bfd_get_filename (elt
));
1540 /* This function is used to get the relocs for a particular section.
1541 It is called via bfd_map_over_sections. */
1544 get_relocs (abfd
, sec
, dataarg
)
1549 struct get_relocs_info
*data
= (struct get_relocs_info
*) dataarg
;
1553 if ((sec
->flags
& SEC_RELOC
) == 0)
1555 *data
->relocs
= NULL
;
1556 *data
->relcount
= 0;
1562 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1564 bfd_fatal (bfd_get_filename (abfd
));
1566 *data
->relocs
= (arelent
**) xmalloc (relsize
);
1567 *data
->relcount
= bfd_canonicalize_reloc (abfd
, sec
, *data
->relocs
,
1569 if (*data
->relcount
< 0)
1570 bfd_fatal (bfd_get_filename (abfd
));