1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright (C) 1991-2021 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
25 #include "aout/stab_gnu.h"
26 #include "aout/ranlib.h"
28 #include "libiberty.h"
30 #include "elf/common.h"
31 #define DO_NOT_DEFINE_AOUTHDR
32 #define DO_NOT_DEFINE_FILHDR
33 #define DO_NOT_DEFINE_LINENO
34 #define DO_NOT_DEFINE_SCNHDR
35 #include "coff/external.h"
36 #include "coff/internal.h"
39 #include "plugin-api.h"
42 /* When sorting by size, we use this structure to hold the size and a
43 pointer to the minisymbol. */
51 /* When fetching relocs, we use this structure to pass information to
54 struct get_relocs_info
62 struct extended_symbol_info
66 elf_symbol_type
*elfinfo
;
67 coff_symbol_type
*coffinfo
;
68 /* FIXME: We should add more fields for Type, Line, Section. */
70 #define SYM_VALUE(sym) (sym->sinfo->value)
71 #define SYM_TYPE(sym) (sym->sinfo->type)
72 #define SYM_STAB_NAME(sym) (sym->sinfo->stab_name)
73 #define SYM_STAB_DESC(sym) (sym->sinfo->stab_desc)
74 #define SYM_STAB_OTHER(sym) (sym->sinfo->stab_other)
75 #define SYM_SIZE(sym) \
76 (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
78 /* The output formatting functions. */
79 static void print_object_filename_bsd (const char *);
80 static void print_object_filename_sysv (const char *);
81 static void print_object_filename_posix (const char *);
82 static void print_archive_filename_bsd (const char *);
83 static void print_archive_filename_sysv (const char *);
84 static void print_archive_filename_posix (const char *);
85 static void print_archive_member_bsd (const char *, const char *);
86 static void print_archive_member_sysv (const char *, const char *);
87 static void print_archive_member_posix (const char *, const char *);
88 static void print_symbol_filename_bsd (bfd
*, bfd
*);
89 static void print_symbol_filename_sysv (bfd
*, bfd
*);
90 static void print_symbol_filename_posix (bfd
*, bfd
*);
91 static void print_value (bfd
*, bfd_vma
);
92 static void print_symbol_info_bsd (struct extended_symbol_info
*, bfd
*);
93 static void print_symbol_info_sysv (struct extended_symbol_info
*, bfd
*);
94 static void print_symbol_info_posix (struct extended_symbol_info
*, bfd
*);
96 /* Support for different output formats. */
99 /* Print the name of an object file given on the command line. */
100 void (*print_object_filename
) (const char *);
102 /* Print the name of an archive file given on the command line. */
103 void (*print_archive_filename
) (const char *);
105 /* Print the name of an archive member file. */
106 void (*print_archive_member
) (const char *, const char *);
108 /* Print the name of the file (and archive, if there is one)
109 containing a symbol. */
110 void (*print_symbol_filename
) (bfd
*, bfd
*);
112 /* Print a line of information about a symbol. */
113 void (*print_symbol_info
) (struct extended_symbol_info
*, bfd
*);
116 static struct output_fns formats
[] =
118 {print_object_filename_bsd
,
119 print_archive_filename_bsd
,
120 print_archive_member_bsd
,
121 print_symbol_filename_bsd
,
122 print_symbol_info_bsd
},
123 {print_object_filename_sysv
,
124 print_archive_filename_sysv
,
125 print_archive_member_sysv
,
126 print_symbol_filename_sysv
,
127 print_symbol_info_sysv
},
128 {print_object_filename_posix
,
129 print_archive_filename_posix
,
130 print_archive_member_posix
,
131 print_symbol_filename_posix
,
132 print_symbol_info_posix
}
135 /* Indices in `formats'. */
137 #define FORMAT_SYSV 1
138 #define FORMAT_POSIX 2
139 #define FORMAT_DEFAULT FORMAT_BSD
141 /* The output format to use. */
142 static struct output_fns
*format
= &formats
[FORMAT_DEFAULT
];
143 static unsigned int print_format
= FORMAT_DEFAULT
;
144 static const char *print_format_string
= NULL
;
146 /* Command options. */
148 static int do_demangle
= 0; /* Pretty print C++ symbol names. */
149 static int external_only
= 0; /* Print external symbols only. */
150 static int defined_only
= 0; /* Print defined symbols only. */
151 static int no_sort
= 0; /* Don't sort; print syms in order found. */
152 static int print_debug_syms
= 0;/* Print debugger-only symbols too. */
153 static int print_armap
= 0; /* Describe __.SYMDEF data in archive files. */
154 static int print_size
= 0; /* Print size of defined symbols. */
155 static int reverse_sort
= 0; /* Sort in downward(alpha or numeric) order. */
156 static int sort_numerically
= 0;/* Sort in numeric rather than alpha order. */
157 static int sort_by_size
= 0; /* Sort by size of symbol. */
158 static int undefined_only
= 0; /* Print undefined symbols only. */
159 static int dynamic
= 0; /* Print dynamic symbols. */
160 static int show_version
= 0; /* Show the version number. */
161 static int show_synthetic
= 0; /* Display synthesized symbols too. */
162 static int line_numbers
= 0; /* Print line numbers for symbols. */
163 static int allow_special_symbols
= 0; /* Allow special symbols. */
165 /* The characters to use for global and local ifunc symbols. */
166 #if DEFAULT_F_FOR_IFUNC_SYMBOLS
167 static const char * ifunc_type_chars
= "Ff";
169 static const char * ifunc_type_chars
= NULL
;
172 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
174 /* When to print the names of files. Not mutually exclusive in SYSV format. */
175 static int filename_per_file
= 0; /* Once per file, on its own line. */
176 static int filename_per_symbol
= 0; /* Once per symbol, at start of line. */
178 static int print_width
= 0;
179 static int print_radix
= 16;
180 /* Print formats for printing stab info. */
181 static char other_format
[] = "%02x";
182 static char desc_format
[] = "%04x";
184 static char *target
= NULL
;
185 #if BFD_SUPPORTS_PLUGINS
186 static const char *plugin_target
= "plugin";
188 static const char *plugin_target
= NULL
;
191 /* Used to cache the line numbers for a BFD. */
192 static bfd
*lineno_cache_bfd
;
193 static bfd
*lineno_cache_rel_bfd
;
195 enum long_option_values
200 OPTION_RECURSE_LIMIT
,
201 OPTION_NO_RECURSE_LIMIT
,
203 OPTION_WITH_SYMBOL_VERSIONS
206 static struct option long_options
[] =
208 {"debug-syms", no_argument
, &print_debug_syms
, 1},
209 {"demangle", optional_argument
, 0, 'C'},
210 {"dynamic", no_argument
, &dynamic
, 1},
211 {"extern-only", no_argument
, &external_only
, 1},
212 {"format", required_argument
, 0, 'f'},
213 {"help", no_argument
, 0, 'h'},
214 {"ifunc-chars", required_argument
, 0, OPTION_IFUNC_CHARS
},
215 {"line-numbers", no_argument
, 0, 'l'},
216 {"no-cplus", no_argument
, &do_demangle
, 0}, /* Linux compatibility. */
217 {"no-demangle", no_argument
, &do_demangle
, 0},
218 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
219 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
220 {"no-sort", no_argument
, 0, 'p'},
221 {"numeric-sort", no_argument
, 0, 'n'},
222 {"plugin", required_argument
, 0, OPTION_PLUGIN
},
223 {"portability", no_argument
, 0, 'P'},
224 {"print-armap", no_argument
, &print_armap
, 1},
225 {"print-file-name", no_argument
, 0, 'o'},
226 {"print-size", no_argument
, 0, 'S'},
227 {"radix", required_argument
, 0, 't'},
228 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
229 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
230 {"reverse-sort", no_argument
, &reverse_sort
, 1},
231 {"size-sort", no_argument
, 0, OPTION_SIZE_SORT
},
232 {"special-syms", no_argument
, &allow_special_symbols
, 1},
233 {"synthetic", no_argument
, &show_synthetic
, 1},
234 {"target", required_argument
, 0, OPTION_TARGET
},
235 {"defined-only", no_argument
, &defined_only
, 1},
236 {"undefined-only", no_argument
, &undefined_only
, 1},
237 {"version", no_argument
, &show_version
, 1},
238 {"with-symbol-versions", no_argument
, NULL
,
239 OPTION_WITH_SYMBOL_VERSIONS
},
240 {0, no_argument
, 0, 0}
243 /* Some error-reporting functions. */
245 ATTRIBUTE_NORETURN
static void
246 usage (FILE *stream
, int status
)
248 fprintf (stream
, _("Usage: %s [option(s)] [file(s)]\n"), program_name
);
249 fprintf (stream
, _(" List symbols in [file(s)] (a.out by default).\n"));
250 fprintf (stream
, _(" The options are:\n\
251 -a, --debug-syms Display debugger-only symbols\n\
252 -A, --print-file-name Print name of the input file before every symbol\n\
253 -B Same as --format=bsd\n\
254 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
255 The STYLE, if specified, can be `auto' (the default),\n\
256 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
258 --no-demangle Do not demangle low-level symbol names\n\
259 --recurse-limit Enable a demangling recursion limit. This is the default.\n\
260 --no-recurse-limit Disable a demangling recursion limit.\n\
261 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
262 --defined-only Display only defined symbols\n\
264 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
265 `sysv' or `posix'. The default is `bsd'\n\
266 -g, --extern-only Display only external symbols\n\
267 --ifunc-chars=CHARS Characters to use when displaying ifunc symbols\n\
268 -l, --line-numbers Use debugging information to find a filename and\n\
269 line number for each symbol\n\
270 -n, --numeric-sort Sort symbols numerically by address\n\
272 -p, --no-sort Do not sort the symbols\n\
273 -P, --portability Same as --format=posix\n\
274 -r, --reverse-sort Reverse the sense of the sort\n"));
275 #if BFD_SUPPORTS_PLUGINS
276 fprintf (stream
, _("\
277 --plugin NAME Load the specified plugin\n"));
279 fprintf (stream
, _("\
280 -S, --print-size Print size of defined symbols\n\
281 -s, --print-armap Include index for symbols from archive members\n\
282 --size-sort Sort symbols by size\n\
283 --special-syms Include special symbols in the output\n\
284 --synthetic Display synthetic symbols as well\n\
285 -t, --radix=RADIX Use RADIX for printing symbol values\n\
286 --target=BFDNAME Specify the target object format as BFDNAME\n\
287 -u, --undefined-only Display only undefined symbols\n\
288 --with-symbol-versions Display version strings after symbol names\n\
289 -X 32_64 (ignored)\n\
290 @FILE Read options from FILE\n\
291 -h, --help Display this information\n\
292 -V, --version Display this program's version number\n\
294 list_supported_targets (program_name
, stream
);
295 if (REPORT_BUGS_TO
[0] && status
== 0)
296 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
300 /* Set the radix for the symbol value and size according to RADIX. */
303 set_print_radix (char *radix
)
307 case 'x': print_radix
= 16; break;
308 case 'd': print_radix
= 10; break;
309 case 'o': print_radix
= 8; break;
312 fatal (_("%s: invalid radix"), radix
);
315 other_format
[3] = desc_format
[3] = *radix
;
319 set_output_format (char *f
)
338 fatal (_("%s: invalid output format"), f
);
340 format
= &formats
[i
];
345 get_elf_symbol_type (unsigned int type
)
352 case STT_NOTYPE
: return "NOTYPE";
353 case STT_OBJECT
: return "OBJECT";
354 case STT_FUNC
: return "FUNC";
355 case STT_SECTION
: return "SECTION";
356 case STT_FILE
: return "FILE";
357 case STT_COMMON
: return "COMMON";
358 case STT_TLS
: return "TLS";
362 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
363 n
= asprintf (&bufp
, _("<processor specific>: %d"), type
);
364 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
365 n
= asprintf (&bufp
, _("<OS specific>: %d"), type
);
367 n
= asprintf (&bufp
, _("<unknown>: %d"), type
);
369 fatal ("%s", xstrerror (errno
));
374 get_coff_symbol_type (const struct internal_syment
*sym
)
379 switch (sym
->n_sclass
)
381 case C_BLOCK
: return "Block";
382 case C_FILE
: return "File";
383 case C_LINE
: return "Line";
389 switch (DTYPE(sym
->n_type
))
391 case DT_FCN
: return "Function";
392 case DT_PTR
: return "Pointer";
393 case DT_ARY
: return "Array";
397 n
= asprintf (&bufp
, _("<unknown>: %d/%d"), sym
->n_sclass
, sym
->n_type
);
399 fatal ("%s", xstrerror (errno
));
403 /* Print symbol name NAME, read from ABFD, with printf format FORM,
404 demangling it if requested. */
407 print_symname (const char *form
, struct extended_symbol_info
*info
,
408 const char *name
, bfd
*abfd
)
413 name
= info
->sinfo
->name
;
414 if (do_demangle
&& *name
)
416 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
421 if (info
!= NULL
&& info
->elfinfo
)
423 const char *version_string
;
427 = bfd_get_symbol_version_string (abfd
, &info
->elfinfo
->symbol
,
429 if (version_string
&& version_string
[0])
431 const char *at
= "@@";
432 if (hidden
|| bfd_is_und_section (info
->elfinfo
->symbol
.section
))
434 alloc
= reconcat (alloc
, name
, at
, version_string
, NULL
);
444 print_symdef_entry (bfd
*abfd
)
446 symindex idx
= BFD_NO_MORE_SYMBOLS
;
448 bfd_boolean everprinted
= FALSE
;
450 for (idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
);
451 idx
!= BFD_NO_MORE_SYMBOLS
;
452 idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
))
457 printf (_("\nArchive index:\n"));
460 elt
= bfd_get_elt_at_index (abfd
, idx
);
462 bfd_fatal ("bfd_get_elt_at_index");
463 if (thesym
->name
!= (char *) NULL
)
465 print_symname ("%s", NULL
, thesym
->name
, abfd
);
466 printf (" in %s\n", bfd_get_filename (elt
));
472 /* True when we can report missing plugin error. */
473 bfd_boolean report_plugin_err
= TRUE
;
475 /* Choose which symbol entries to print;
476 compact them downward to get rid of the rest.
477 Return the number of symbols to be printed. */
480 filter_symbols (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
481 long symcount
, unsigned int size
)
483 bfd_byte
*from
, *fromend
, *to
;
486 store
= bfd_make_empty_symbol (abfd
);
488 bfd_fatal (bfd_get_filename (abfd
));
490 from
= (bfd_byte
*) minisyms
;
491 fromend
= from
+ symcount
* size
;
492 to
= (bfd_byte
*) minisyms
;
494 for (; from
< fromend
; from
+= size
)
501 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
, store
);
503 bfd_fatal (bfd_get_filename (abfd
));
505 if (sym
->name
[0] == '_'
506 && sym
->name
[1] == '_'
507 && strcmp (sym
->name
+ (sym
->name
[2] == '_'), "__gnu_lto_slim") == 0
508 && report_plugin_err
)
510 report_plugin_err
= FALSE
;
511 non_fatal (_("%s: plugin needed to handle lto object"),
512 bfd_get_filename (abfd
));
516 keep
= bfd_is_und_section (sym
->section
);
517 else if (external_only
)
518 /* PR binutls/12753: Unique symbols are global too. */
519 keep
= ((sym
->flags
& (BSF_GLOBAL
521 | BSF_GNU_UNIQUE
)) != 0
522 || bfd_is_und_section (sym
->section
)
523 || bfd_is_com_section (sym
->section
));
528 && ! print_debug_syms
529 && (sym
->flags
& BSF_DEBUGGING
) != 0)
534 && (bfd_is_abs_section (sym
->section
)
535 || bfd_is_und_section (sym
->section
)))
541 if (bfd_is_und_section (sym
->section
))
546 && bfd_is_target_special_symbol (abfd
, sym
)
547 && ! allow_special_symbols
)
553 memcpy (to
, from
, size
);
558 return (to
- (bfd_byte
*) minisyms
) / size
;
561 /* These globals are used to pass information into the sorting
563 static bfd
*sort_bfd
;
564 static bfd_boolean sort_dynamic
;
565 static asymbol
*sort_x
;
566 static asymbol
*sort_y
;
568 /* Symbol-sorting predicates */
569 #define valueof(x) ((x)->section->vma + (x)->value)
571 /* Numeric sorts. Undefined symbols are always considered "less than"
572 defined symbols with zero values. Common symbols are not treated
573 specially -- i.e., their sizes are used as their "values". */
576 non_numeric_forward (const void *P_x
, const void *P_y
)
581 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
582 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
583 if (x
== NULL
|| y
== NULL
)
584 bfd_fatal (bfd_get_filename (sort_bfd
));
586 xn
= bfd_asymbol_name (x
);
587 yn
= bfd_asymbol_name (y
);
595 /* Solaris 2.5 has a bug in strcoll.
596 strcoll returns invalid values when confronted with empty strings. */
602 return strcoll (xn
, yn
);
604 return strcmp (xn
, yn
);
609 non_numeric_reverse (const void *x
, const void *y
)
611 return - non_numeric_forward (x
, y
);
615 numeric_forward (const void *P_x
, const void *P_y
)
620 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
621 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
622 if (x
== NULL
|| y
== NULL
)
623 bfd_fatal (bfd_get_filename (sort_bfd
));
625 xs
= bfd_asymbol_section (x
);
626 ys
= bfd_asymbol_section (y
);
628 if (bfd_is_und_section (xs
))
630 if (! bfd_is_und_section (ys
))
633 else if (bfd_is_und_section (ys
))
635 else if (valueof (x
) != valueof (y
))
636 return valueof (x
) < valueof (y
) ? -1 : 1;
638 return non_numeric_forward (P_x
, P_y
);
642 numeric_reverse (const void *x
, const void *y
)
644 return - numeric_forward (x
, y
);
647 static int (*(sorters
[2][2])) (const void *, const void *) =
649 { non_numeric_forward
, non_numeric_reverse
},
650 { numeric_forward
, numeric_reverse
}
653 /* This sort routine is used by sort_symbols_by_size. It is similar
654 to numeric_forward, but when symbols have the same value it sorts
655 by section VMA. This simplifies the sort_symbols_by_size code
656 which handles symbols at the end of sections. Also, this routine
657 tries to sort file names before other symbols with the same value.
658 That will make the file name have a zero size, which will make
659 sort_symbols_by_size choose the non file name symbol, leading to
660 more meaningful output. For similar reasons, this code sorts
661 gnu_compiled_* and gcc2_compiled before other symbols with the same
665 size_forward1 (const void *P_x
, const void *P_y
)
673 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
674 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
675 if (x
== NULL
|| y
== NULL
)
676 bfd_fatal (bfd_get_filename (sort_bfd
));
678 xs
= bfd_asymbol_section (x
);
679 ys
= bfd_asymbol_section (y
);
681 if (bfd_is_und_section (xs
))
683 if (bfd_is_und_section (ys
))
686 if (valueof (x
) != valueof (y
))
687 return valueof (x
) < valueof (y
) ? -1 : 1;
689 if (xs
->vma
!= ys
->vma
)
690 return xs
->vma
< ys
->vma
? -1 : 1;
692 xn
= bfd_asymbol_name (x
);
693 yn
= bfd_asymbol_name (y
);
697 /* The symbols gnu_compiled and gcc2_compiled convey even less
698 information than the file name, so sort them out first. */
700 xf
= (strstr (xn
, "gnu_compiled") != NULL
701 || strstr (xn
, "gcc2_compiled") != NULL
);
702 yf
= (strstr (yn
, "gnu_compiled") != NULL
703 || strstr (yn
, "gcc2_compiled") != NULL
);
710 /* We use a heuristic for the file name. It may not work on non
711 Unix systems, but it doesn't really matter; the only difference
712 is precisely which symbol names get printed. */
714 #define file_symbol(s, sn, snl) \
715 (((s)->flags & BSF_FILE) != 0 \
717 && (sn)[(snl) - 2] == '.' \
718 && ((sn)[(snl) - 1] == 'o' \
719 || (sn)[(snl) - 1] == 'a')))
721 xf
= file_symbol (x
, xn
, xnl
);
722 yf
= file_symbol (y
, yn
, ynl
);
729 return non_numeric_forward (P_x
, P_y
);
732 /* This sort routine is used by sort_symbols_by_size. It is sorting
733 an array of size_sym structures into size order. */
736 size_forward2 (const void *P_x
, const void *P_y
)
738 const struct size_sym
*x
= (const struct size_sym
*) P_x
;
739 const struct size_sym
*y
= (const struct size_sym
*) P_y
;
741 if (x
->size
< y
->size
)
742 return reverse_sort
? 1 : -1;
743 else if (x
->size
> y
->size
)
744 return reverse_sort
? -1 : 1;
746 return sorters
[0][reverse_sort
] (x
->minisym
, y
->minisym
);
749 /* Sort the symbols by size. ELF provides a size but for other formats
750 we have to make a guess by assuming that the difference between the
751 address of a symbol and the address of the next higher symbol is the
755 sort_symbols_by_size (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
756 long symcount
, unsigned int size
,
757 struct size_sym
**symsizesp
)
759 struct size_sym
*symsizes
;
760 bfd_byte
*from
, *fromend
;
762 asymbol
*store_sym
, *store_next
;
764 qsort (minisyms
, symcount
, size
, size_forward1
);
766 /* We are going to return a special set of symbols and sizes to
768 symsizes
= (struct size_sym
*) xmalloc (symcount
* sizeof (struct size_sym
));
769 *symsizesp
= symsizes
;
771 /* Note that filter_symbols has already removed all absolute and
772 undefined symbols. Here we remove all symbols whose size winds
774 from
= (bfd_byte
*) minisyms
;
775 fromend
= from
+ symcount
* size
;
782 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
,
785 bfd_fatal (bfd_get_filename (abfd
));
788 for (; from
< fromend
; from
+= size
)
795 if (from
+ size
< fromend
)
797 next
= bfd_minisymbol_to_symbol (abfd
,
799 (const void *) (from
+ size
),
802 bfd_fatal (bfd_get_filename (abfd
));
807 sec
= bfd_asymbol_section (sym
);
809 /* Synthetic symbols don't have a full type set of data available, thus
810 we can't rely on that information for the symbol size. Ditto for
811 bfd/section.c:global_syms like *ABS*. */
812 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
813 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
814 sz
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
815 else if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
816 && bfd_is_com_section (sec
))
820 if (from
+ size
< fromend
821 && sec
== bfd_asymbol_section (next
))
822 sz
= valueof (next
) - valueof (sym
);
824 sz
= (bfd_section_vma (sec
)
825 + bfd_section_size (sec
)
831 symsizes
->minisym
= (const void *) from
;
839 store_sym
= store_next
;
843 symcount
= symsizes
- *symsizesp
;
845 /* We must now sort again by size. */
846 qsort ((void *) *symsizesp
, symcount
, sizeof (struct size_sym
), size_forward2
);
851 /* This function is used to get the relocs for a particular section.
852 It is called via bfd_map_over_sections. */
855 get_relocs (bfd
*abfd
, asection
*sec
, void *dataarg
)
857 struct get_relocs_info
*data
= (struct get_relocs_info
*) dataarg
;
861 if ((sec
->flags
& SEC_RELOC
) == 0)
863 *data
->relocs
= NULL
;
870 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
872 bfd_fatal (bfd_get_filename (abfd
));
874 *data
->relocs
= (arelent
**) xmalloc (relsize
);
875 *data
->relcount
= bfd_canonicalize_reloc (abfd
, sec
, *data
->relocs
,
877 if (*data
->relcount
< 0)
878 bfd_fatal (bfd_get_filename (abfd
));
886 /* Print a single symbol. */
889 print_symbol (bfd
* abfd
,
895 struct extended_symbol_info info
;
899 format
->print_symbol_filename (archive_bfd
, abfd
);
901 bfd_get_symbol_info (abfd
, sym
, &syminfo
);
903 /* PR 22967 - Distinguish between local and global ifunc symbols. */
904 if (syminfo
.type
== 'i'
905 && sym
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
907 if (ifunc_type_chars
== NULL
|| ifunc_type_chars
[0] == 0)
908 ; /* Change nothing. */
909 else if (sym
->flags
& BSF_GLOBAL
)
910 syminfo
.type
= ifunc_type_chars
[0];
911 else if (ifunc_type_chars
[1] != 0)
912 syminfo
.type
= ifunc_type_chars
[1];
915 info
.sinfo
= &syminfo
;
917 /* Synthetic symbols do not have a full symbol type set of data available.
918 Nor do bfd/section.c:global_syms like *ABS*. */
919 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) != 0)
922 info
.coffinfo
= NULL
;
926 info
.elfinfo
= elf_symbol_from (sym
);
927 info
.coffinfo
= coff_symbol_from (sym
);
930 format
->print_symbol_info (&info
, abfd
);
934 static asymbol
**syms
;
935 static long symcount
;
936 const char *filename
, *functionname
;
939 /* We need to get the canonical symbols in order to call
940 bfd_find_nearest_line. This is inefficient, but, then, you
941 don't have to use --line-numbers. */
942 if (abfd
!= lineno_cache_bfd
&& syms
!= NULL
)
951 symsize
= bfd_get_symtab_upper_bound (abfd
);
953 bfd_fatal (bfd_get_filename (abfd
));
954 syms
= (asymbol
**) xmalloc (symsize
);
955 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
957 bfd_fatal (bfd_get_filename (abfd
));
958 lineno_cache_bfd
= abfd
;
961 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
963 static asection
**secs
;
964 static arelent
***relocs
;
965 static long *relcount
;
966 static unsigned int seccount
;
970 /* For an undefined symbol, we try to find a reloc for the
971 symbol, and print the line number of the reloc. */
972 if (abfd
!= lineno_cache_rel_bfd
&& relocs
!= NULL
)
974 for (i
= 0; i
< seccount
; i
++)
975 if (relocs
[i
] != NULL
)
987 struct get_relocs_info rinfo
;
989 seccount
= bfd_count_sections (abfd
);
991 secs
= (asection
**) xmalloc (seccount
* sizeof *secs
);
992 relocs
= (arelent
***) xmalloc (seccount
* sizeof *relocs
);
993 relcount
= (long *) xmalloc (seccount
* sizeof *relcount
);
996 rinfo
.relocs
= relocs
;
997 rinfo
.relcount
= relcount
;
999 bfd_map_over_sections (abfd
, get_relocs
, (void *) &rinfo
);
1000 lineno_cache_rel_bfd
= abfd
;
1003 symname
= bfd_asymbol_name (sym
);
1004 for (i
= 0; i
< seccount
; i
++)
1008 for (j
= 0; j
< relcount
[i
]; j
++)
1013 if (r
->sym_ptr_ptr
!= NULL
1014 && (*r
->sym_ptr_ptr
)->section
== sym
->section
1015 && (*r
->sym_ptr_ptr
)->value
== sym
->value
1017 bfd_asymbol_name (*r
->sym_ptr_ptr
)) == 0
1018 && bfd_find_nearest_line (abfd
, secs
[i
], syms
,
1019 r
->address
, &filename
,
1020 &functionname
, &lineno
)
1021 && filename
!= NULL
)
1023 /* We only print the first one we find. */
1024 printf ("\t%s:%u", filename
, lineno
);
1031 else if (bfd_asymbol_section (sym
)->owner
== abfd
)
1033 if ((bfd_find_line (abfd
, syms
, sym
, &filename
, &lineno
)
1034 || bfd_find_nearest_line (abfd
, bfd_asymbol_section (sym
),
1035 syms
, sym
->value
, &filename
,
1036 &functionname
, &lineno
))
1039 printf ("\t%s:%u", filename
, lineno
);
1046 /* Print the symbols when sorting by size. */
1049 print_size_symbols (bfd
* abfd
,
1050 bfd_boolean is_dynamic
,
1051 struct size_sym
* symsizes
,
1056 struct size_sym
*from
;
1057 struct size_sym
*fromend
;
1059 store
= bfd_make_empty_symbol (abfd
);
1061 bfd_fatal (bfd_get_filename (abfd
));
1064 fromend
= from
+ symcount
;
1066 for (; from
< fromend
; from
++)
1070 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
->minisym
, store
);
1072 bfd_fatal (bfd_get_filename (abfd
));
1074 print_symbol (abfd
, sym
, from
->size
, archive_bfd
);
1079 /* Print the symbols of ABFD that are held in MINISYMS.
1081 If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1083 SYMCOUNT is the number of symbols in MINISYMS.
1085 SIZE is the size of a symbol in MINISYMS. */
1088 print_symbols (bfd
* abfd
,
1089 bfd_boolean is_dynamic
,
1099 store
= bfd_make_empty_symbol (abfd
);
1101 bfd_fatal (bfd_get_filename (abfd
));
1103 from
= (bfd_byte
*) minisyms
;
1104 fromend
= from
+ symcount
* size
;
1106 for (; from
< fromend
; from
+= size
)
1110 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
, store
);
1112 bfd_fatal (bfd_get_filename (abfd
));
1114 print_symbol (abfd
, sym
, (bfd_vma
) 0, archive_bfd
);
1118 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1121 display_rel_file (bfd
*abfd
, bfd
*archive_bfd
)
1126 struct size_sym
*symsizes
;
1127 asymbol
*synthsyms
= NULL
;
1131 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1133 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1138 symcount
= bfd_read_minisymbols (abfd
, dynamic
, &minisyms
, &size
);
1141 if (dynamic
&& bfd_get_error () == bfd_error_no_symbols
)
1143 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1147 bfd_fatal (bfd_get_filename (abfd
));
1152 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1156 if (show_synthetic
&& size
== sizeof (asymbol
*))
1158 asymbol
**static_syms
= NULL
;
1159 asymbol
**dyn_syms
= NULL
;
1160 long static_count
= 0;
1166 dyn_count
= symcount
;
1167 dyn_syms
= (asymbol
**) minisyms
;
1171 long storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1173 static_count
= symcount
;
1174 static_syms
= (asymbol
**) minisyms
;
1178 dyn_syms
= (asymbol
**) xmalloc (storage
);
1179 dyn_count
= bfd_canonicalize_dynamic_symtab (abfd
, dyn_syms
);
1181 bfd_fatal (bfd_get_filename (abfd
));
1185 synth_count
= bfd_get_synthetic_symtab (abfd
, static_count
, static_syms
,
1186 dyn_count
, dyn_syms
, &synthsyms
);
1187 if (synth_count
> 0)
1192 minisyms
= xrealloc (minisyms
,
1193 (symcount
+ synth_count
+ 1) * sizeof (*symp
));
1194 symp
= (asymbol
**) minisyms
+ symcount
;
1195 for (i
= 0; i
< synth_count
; i
++)
1196 *symp
++ = synthsyms
+ i
;
1198 symcount
+= synth_count
;
1200 if (!dynamic
&& dyn_syms
!= NULL
)
1204 /* lto_slim_object is set to false when a bfd is loaded with a compiler
1206 if (abfd
->lto_slim_object
)
1208 report_plugin_err
= FALSE
;
1209 non_fatal (_("%s: plugin needed to handle lto object"),
1210 bfd_get_filename (abfd
));
1213 /* Discard the symbols we don't want to print.
1214 It's OK to do this in place; we'll free the storage anyway
1215 (after printing). */
1217 symcount
= filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
);
1223 sort_dynamic
= dynamic
;
1224 sort_x
= bfd_make_empty_symbol (abfd
);
1225 sort_y
= bfd_make_empty_symbol (abfd
);
1226 if (sort_x
== NULL
|| sort_y
== NULL
)
1227 bfd_fatal (bfd_get_filename (abfd
));
1230 qsort (minisyms
, symcount
, size
,
1231 sorters
[sort_numerically
][reverse_sort
]);
1233 symcount
= sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
,
1238 print_symbols (abfd
, dynamic
, minisyms
, symcount
, size
, archive_bfd
);
1240 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, archive_bfd
);
1248 /* Construct a formatting string for printing symbol values. */
1251 get_print_format (void)
1253 const char * padding
;
1254 if (print_format
== FORMAT_POSIX
)
1256 /* POSIX compatible output does not have any padding. */
1259 else if (print_width
== 32)
1263 else /* print_width == 64 */
1268 const char * length
= "l";
1269 if (print_width
== 64)
1271 #if BFD_HOST_64BIT_LONG
1273 #elif BFD_HOST_64BIT_LONG_LONG
1282 const char * radix
= NULL
;
1283 switch (print_radix
)
1285 case 8: radix
= "o"; break;
1286 case 10: radix
= "d"; break;
1287 case 16: radix
= "x"; break;
1290 return concat ("%", padding
, length
, radix
, NULL
);
1294 set_print_width (bfd
*file
)
1296 print_width
= bfd_get_arch_size (file
);
1298 if (print_width
== -1)
1301 Guess the target's bitsize based on its name.
1302 We assume here than any 64-bit format will include
1303 "64" somewhere in its name. The only known exception
1304 is the MMO object file format. */
1305 if (strstr (bfd_get_target (file
), "64") != NULL
1306 || strcmp (bfd_get_target (file
), "mmo") == 0)
1311 free ((char *) print_format_string
);
1312 print_format_string
= get_print_format ();
1316 display_archive (bfd
*file
)
1319 bfd
*last_arfile
= NULL
;
1322 format
->print_archive_filename (bfd_get_filename (file
));
1325 print_symdef_entry (file
);
1331 arfile
= bfd_openr_next_archived_file (file
, arfile
);
1335 if (bfd_get_error () != bfd_error_no_more_archived_files
)
1336 bfd_fatal (bfd_get_filename (file
));
1340 if (bfd_check_format_matches (arfile
, bfd_object
, &matching
))
1342 set_print_width (arfile
);
1343 format
->print_archive_member (bfd_get_filename (file
),
1344 bfd_get_filename (arfile
));
1345 display_rel_file (arfile
, file
);
1349 bfd_nonfatal (bfd_get_filename (arfile
));
1350 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1352 list_matching_formats (matching
);
1357 if (last_arfile
!= NULL
)
1359 bfd_close (last_arfile
);
1360 lineno_cache_bfd
= NULL
;
1361 lineno_cache_rel_bfd
= NULL
;
1362 if (arfile
== last_arfile
)
1365 last_arfile
= arfile
;
1368 if (last_arfile
!= NULL
)
1370 bfd_close (last_arfile
);
1371 lineno_cache_bfd
= NULL
;
1372 lineno_cache_rel_bfd
= NULL
;
1377 display_file (char *filename
)
1379 bfd_boolean retval
= TRUE
;
1383 if (get_file_size (filename
) < 1)
1386 file
= bfd_openr (filename
, target
? target
: plugin_target
);
1389 bfd_nonfatal (filename
);
1393 /* If printing line numbers, decompress the debug sections. */
1395 file
->flags
|= BFD_DECOMPRESS
;
1397 if (bfd_check_format (file
, bfd_archive
))
1399 display_archive (file
);
1401 else if (bfd_check_format_matches (file
, bfd_object
, &matching
))
1403 set_print_width (file
);
1404 format
->print_object_filename (filename
);
1405 display_rel_file (file
, NULL
);
1409 bfd_nonfatal (filename
);
1410 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1412 list_matching_formats (matching
);
1418 if (!bfd_close (file
))
1419 bfd_fatal (filename
);
1421 lineno_cache_bfd
= NULL
;
1422 lineno_cache_rel_bfd
= NULL
;
1427 /* The following 3 groups of functions are called unconditionally,
1428 once at the start of processing each file of the appropriate type.
1429 They should check `filename_per_file' and `filename_per_symbol',
1430 as appropriate for their output format, to determine whether to
1433 /* Print the name of an object file given on the command line. */
1436 print_object_filename_bsd (const char *filename
)
1438 if (filename_per_file
&& !filename_per_symbol
)
1439 printf ("\n%s:\n", filename
);
1443 print_object_filename_sysv (const char *filename
)
1446 printf (_("\n\nUndefined symbols from %s:\n\n"), filename
);
1448 printf (_("\n\nSymbols from %s:\n\n"), filename
);
1449 if (print_width
== 32)
1451 Name Value Class Type Size Line Section\n\n"));
1454 Name Value Class Type Size Line Section\n\n"));
1458 print_object_filename_posix (const char *filename
)
1460 if (filename_per_file
&& !filename_per_symbol
)
1461 printf ("%s:\n", filename
);
1464 /* Print the name of an archive file given on the command line. */
1467 print_archive_filename_bsd (const char *filename
)
1469 if (filename_per_file
)
1470 printf ("\n%s:\n", filename
);
1474 print_archive_filename_sysv (const char *filename ATTRIBUTE_UNUSED
)
1479 print_archive_filename_posix (const char *filename ATTRIBUTE_UNUSED
)
1483 /* Print the name of an archive member file. */
1486 print_archive_member_bsd (const char *archive ATTRIBUTE_UNUSED
,
1487 const char *filename
)
1489 if (!filename_per_symbol
)
1490 printf ("\n%s:\n", filename
);
1494 print_archive_member_sysv (const char *archive
, const char *filename
)
1497 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive
, filename
);
1499 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive
, filename
);
1500 if (print_width
== 32)
1502 Name Value Class Type Size Line Section\n\n"));
1505 Name Value Class Type Size Line Section\n\n"));
1509 print_archive_member_posix (const char *archive
, const char *filename
)
1511 if (!filename_per_symbol
)
1512 printf ("%s[%s]:\n", archive
, filename
);
1515 /* Print the name of the file (and archive, if there is one)
1516 containing a symbol. */
1519 print_symbol_filename_bsd (bfd
*archive_bfd
, bfd
*abfd
)
1521 if (filename_per_symbol
)
1524 printf ("%s:", bfd_get_filename (archive_bfd
));
1525 printf ("%s:", bfd_get_filename (abfd
));
1530 print_symbol_filename_sysv (bfd
*archive_bfd
, bfd
*abfd
)
1532 if (filename_per_symbol
)
1535 printf ("%s:", bfd_get_filename (archive_bfd
));
1536 printf ("%s:", bfd_get_filename (abfd
));
1541 print_symbol_filename_posix (bfd
*archive_bfd
, bfd
*abfd
)
1543 if (filename_per_symbol
)
1546 printf ("%s[%s]: ", bfd_get_filename (archive_bfd
),
1547 bfd_get_filename (abfd
));
1549 printf ("%s: ", bfd_get_filename (abfd
));
1553 /* Print a symbol value. */
1556 print_value (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_vma val
)
1558 switch (print_width
)
1561 printf (print_format_string
, (unsigned long) val
);
1565 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1566 printf (print_format_string
, val
);
1568 /* We have a 64 bit value to print, but the host is only 32 bit. */
1569 if (print_radix
== 16)
1570 bfd_fprintf_vma (abfd
, stdout
, val
);
1576 s
= buf
+ sizeof buf
;
1580 *--s
= (val
% print_radix
) + '0';
1583 while ((buf
+ sizeof buf
- 1) - s
< 16)
1591 fatal (_("Print width has not been initialized (%d)"), print_width
);
1596 /* Print a line of information about a symbol. */
1599 print_symbol_info_bsd (struct extended_symbol_info
*info
, bfd
*abfd
)
1601 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1603 if (print_width
== 64)
1609 /* Normally we print the value of the symbol. If we are printing the
1610 size or sorting by size then we print its size, except for the
1611 (weird) special case where both flags are defined, in which case we
1612 print both values. This conforms to documented behaviour. */
1613 if (sort_by_size
&& !print_size
)
1614 print_value (abfd
, SYM_SIZE (info
));
1616 print_value (abfd
, SYM_VALUE (info
));
1617 if (print_size
&& SYM_SIZE (info
))
1620 print_value (abfd
, SYM_SIZE (info
));
1624 printf (" %c", SYM_TYPE (info
));
1626 if (SYM_TYPE (info
) == '-')
1630 printf (other_format
, SYM_STAB_OTHER (info
));
1632 printf (desc_format
, SYM_STAB_DESC (info
));
1633 printf (" %5s", SYM_STAB_NAME (info
));
1635 print_symname (" %s", info
, NULL
, abfd
);
1639 print_symbol_info_sysv (struct extended_symbol_info
*info
, bfd
*abfd
)
1641 print_symname ("%-20s|", info
, NULL
, abfd
);
1643 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1645 if (print_width
== 32)
1651 print_value (abfd
, SYM_VALUE (info
));
1653 printf ("| %c |", SYM_TYPE (info
));
1655 if (SYM_TYPE (info
) == '-')
1658 printf ("%18s| ", SYM_STAB_NAME (info
)); /* (C) Type. */
1659 printf (desc_format
, SYM_STAB_DESC (info
)); /* Size. */
1660 printf ("| |"); /* Line, Section. */
1664 /* Type, Size, Line, Section */
1667 get_elf_symbol_type (ELF_ST_TYPE (info
->elfinfo
->internal_elf_sym
.st_info
)));
1668 else if (info
->coffinfo
)
1670 get_coff_symbol_type (&info
->coffinfo
->native
->u
.syment
));
1674 if (SYM_SIZE (info
))
1675 print_value (abfd
, SYM_SIZE (info
));
1678 if (print_width
== 32)
1685 printf("| |%s", info
->elfinfo
->symbol
.section
->name
);
1686 else if (info
->coffinfo
)
1687 printf("| |%s", info
->coffinfo
->symbol
.section
->name
);
1694 print_symbol_info_posix (struct extended_symbol_info
*info
, bfd
*abfd
)
1696 print_symname ("%s ", info
, NULL
, abfd
);
1697 printf ("%c ", SYM_TYPE (info
));
1699 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1703 print_value (abfd
, SYM_VALUE (info
));
1705 if (SYM_SIZE (info
))
1706 print_value (abfd
, SYM_SIZE (info
));
1711 main (int argc
, char **argv
)
1716 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1717 setlocale (LC_MESSAGES
, "");
1719 #if defined (HAVE_SETLOCALE)
1720 setlocale (LC_CTYPE
, "");
1721 setlocale (LC_COLLATE
, "");
1723 bindtextdomain (PACKAGE
, LOCALEDIR
);
1724 textdomain (PACKAGE
);
1726 program_name
= *argv
;
1727 xmalloc_set_program_name (program_name
);
1728 bfd_set_error_program_name (program_name
);
1729 #if BFD_SUPPORTS_PLUGINS
1730 bfd_plugin_set_program_name (program_name
);
1733 START_PROGRESS (program_name
, 0);
1735 expandargv (&argc
, &argv
);
1737 if (bfd_init () != BFD_INIT_MAGIC
)
1738 fatal (_("fatal error: libbfd ABI mismatch"));
1739 set_default_bfd_target ();
1741 while ((c
= getopt_long (argc
, argv
, "aABCDef:gHhlnopPrSst:uvVvX:",
1742 long_options
, (int *) 0)) != EOF
)
1747 print_debug_syms
= 1;
1751 filename_per_symbol
= 1;
1753 case 'B': /* For MIPS compatibility. */
1754 set_output_format ("bsd");
1760 enum demangling_styles style
;
1762 style
= cplus_demangle_name_to_style (optarg
);
1763 if (style
== unknown_demangling
)
1764 fatal (_("unknown demangling style `%s'"),
1767 cplus_demangle_set_style (style
);
1770 case OPTION_RECURSE_LIMIT
:
1771 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
1773 case OPTION_NO_RECURSE_LIMIT
:
1774 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
1776 case OPTION_WITH_SYMBOL_VERSIONS
:
1777 /* Ignored for backward compatibility. */
1783 /* Ignored for HP/UX compatibility. */
1786 set_output_format (optarg
);
1800 sort_numerically
= 1;
1805 sort_numerically
= 0;
1808 case OPTION_SIZE_SORT
:
1810 sort_numerically
= 0;
1814 set_output_format ("posix");
1826 set_print_radix (optarg
);
1835 /* Ignored for (partial) AIX compatibility. On AIX, the
1836 argument has values 32, 64, or 32_64, and specifies that
1837 only 32-bit, only 64-bit, or both kinds of objects should
1838 be examined. The default is 32. So plain AIX nm on a
1839 library archive with both kinds of objects will ignore
1840 the 64-bit ones. For GNU nm, the default is and always
1841 has been -X 32_64, and other options are not supported. */
1842 if (strcmp (optarg
, "32_64") != 0)
1843 fatal (_("Only -X 32_64 is supported"));
1846 case OPTION_TARGET
: /* --target */
1850 case OPTION_PLUGIN
: /* --plugin */
1851 #if BFD_SUPPORTS_PLUGINS
1852 bfd_plugin_set_plugin (optarg
);
1854 fatal (_("sorry - this program has been built without plugin support\n"));
1858 case OPTION_IFUNC_CHARS
:
1859 ifunc_type_chars
= optarg
;
1862 case 0: /* A long option that just sets a flag. */
1871 print_version ("nm");
1873 if (sort_by_size
&& undefined_only
)
1875 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1876 non_fatal (_("will produce no output, since undefined symbols have no size."));
1880 /* OK, all options now parsed. If no filename specified, do a.out. */
1882 return !display_file ("a.out");
1886 if (argc
- optind
> 1)
1887 filename_per_file
= 1;
1889 /* We were given several filenames to do. */
1890 while (optind
< argc
)
1893 if (!display_file (argv
[optind
++]))
1897 END_PROGRESS (program_name
);