1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright (C) 1991-2020 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
)
411 name
= info
->sinfo
->name
;
412 if (do_demangle
&& *name
)
414 char *res
= bfd_demangle (abfd
, name
, demangle_flags
);
425 if (info
!= NULL
&& info
->elfinfo
)
427 const char *version_string
;
431 = bfd_get_symbol_version_string (abfd
, &info
->elfinfo
->symbol
,
433 if (version_string
&& version_string
[0])
435 (hidden
|| bfd_is_und_section (info
->elfinfo
->symbol
.section
)
442 print_symdef_entry (bfd
*abfd
)
444 symindex idx
= BFD_NO_MORE_SYMBOLS
;
446 bfd_boolean everprinted
= FALSE
;
448 for (idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
);
449 idx
!= BFD_NO_MORE_SYMBOLS
;
450 idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
))
455 printf (_("\nArchive index:\n"));
458 elt
= bfd_get_elt_at_index (abfd
, idx
);
460 bfd_fatal ("bfd_get_elt_at_index");
461 if (thesym
->name
!= (char *) NULL
)
463 print_symname ("%s", NULL
, thesym
->name
, abfd
);
464 printf (" in %s\n", bfd_get_filename (elt
));
470 /* True when we can report missing plugin error. */
471 bfd_boolean report_plugin_err
= TRUE
;
473 /* Choose which symbol entries to print;
474 compact them downward to get rid of the rest.
475 Return the number of symbols to be printed. */
478 filter_symbols (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
479 long symcount
, unsigned int size
)
481 bfd_byte
*from
, *fromend
, *to
;
484 store
= bfd_make_empty_symbol (abfd
);
486 bfd_fatal (bfd_get_filename (abfd
));
488 from
= (bfd_byte
*) minisyms
;
489 fromend
= from
+ symcount
* size
;
490 to
= (bfd_byte
*) minisyms
;
492 for (; from
< fromend
; from
+= size
)
499 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
, store
);
501 bfd_fatal (bfd_get_filename (abfd
));
503 if (sym
->name
[0] == '_'
504 && sym
->name
[1] == '_'
505 && strcmp (sym
->name
+ (sym
->name
[2] == '_'), "__gnu_lto_slim") == 0
506 && report_plugin_err
)
508 report_plugin_err
= FALSE
;
509 non_fatal (_("%s: plugin needed to handle lto object"),
510 bfd_get_filename (abfd
));
514 keep
= bfd_is_und_section (sym
->section
);
515 else if (external_only
)
516 /* PR binutls/12753: Unique symbols are global too. */
517 keep
= ((sym
->flags
& (BSF_GLOBAL
519 | BSF_GNU_UNIQUE
)) != 0
520 || bfd_is_und_section (sym
->section
)
521 || bfd_is_com_section (sym
->section
));
526 && ! print_debug_syms
527 && (sym
->flags
& BSF_DEBUGGING
) != 0)
532 && (bfd_is_abs_section (sym
->section
)
533 || bfd_is_und_section (sym
->section
)))
539 if (bfd_is_und_section (sym
->section
))
544 && bfd_is_target_special_symbol (abfd
, sym
)
545 && ! allow_special_symbols
)
551 memcpy (to
, from
, size
);
556 return (to
- (bfd_byte
*) minisyms
) / size
;
559 /* These globals are used to pass information into the sorting
561 static bfd
*sort_bfd
;
562 static bfd_boolean sort_dynamic
;
563 static asymbol
*sort_x
;
564 static asymbol
*sort_y
;
566 /* Symbol-sorting predicates */
567 #define valueof(x) ((x)->section->vma + (x)->value)
569 /* Numeric sorts. Undefined symbols are always considered "less than"
570 defined symbols with zero values. Common symbols are not treated
571 specially -- i.e., their sizes are used as their "values". */
574 non_numeric_forward (const void *P_x
, const void *P_y
)
579 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
580 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
581 if (x
== NULL
|| y
== NULL
)
582 bfd_fatal (bfd_get_filename (sort_bfd
));
584 xn
= bfd_asymbol_name (x
);
585 yn
= bfd_asymbol_name (y
);
593 /* Solaris 2.5 has a bug in strcoll.
594 strcoll returns invalid values when confronted with empty strings. */
600 return strcoll (xn
, yn
);
602 return strcmp (xn
, yn
);
607 non_numeric_reverse (const void *x
, const void *y
)
609 return - non_numeric_forward (x
, y
);
613 numeric_forward (const void *P_x
, const void *P_y
)
618 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
619 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
620 if (x
== NULL
|| y
== NULL
)
621 bfd_fatal (bfd_get_filename (sort_bfd
));
623 xs
= bfd_asymbol_section (x
);
624 ys
= bfd_asymbol_section (y
);
626 if (bfd_is_und_section (xs
))
628 if (! bfd_is_und_section (ys
))
631 else if (bfd_is_und_section (ys
))
633 else if (valueof (x
) != valueof (y
))
634 return valueof (x
) < valueof (y
) ? -1 : 1;
636 return non_numeric_forward (P_x
, P_y
);
640 numeric_reverse (const void *x
, const void *y
)
642 return - numeric_forward (x
, y
);
645 static int (*(sorters
[2][2])) (const void *, const void *) =
647 { non_numeric_forward
, non_numeric_reverse
},
648 { numeric_forward
, numeric_reverse
}
651 /* This sort routine is used by sort_symbols_by_size. It is similar
652 to numeric_forward, but when symbols have the same value it sorts
653 by section VMA. This simplifies the sort_symbols_by_size code
654 which handles symbols at the end of sections. Also, this routine
655 tries to sort file names before other symbols with the same value.
656 That will make the file name have a zero size, which will make
657 sort_symbols_by_size choose the non file name symbol, leading to
658 more meaningful output. For similar reasons, this code sorts
659 gnu_compiled_* and gcc2_compiled before other symbols with the same
663 size_forward1 (const void *P_x
, const void *P_y
)
671 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
672 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
673 if (x
== NULL
|| y
== NULL
)
674 bfd_fatal (bfd_get_filename (sort_bfd
));
676 xs
= bfd_asymbol_section (x
);
677 ys
= bfd_asymbol_section (y
);
679 if (bfd_is_und_section (xs
))
681 if (bfd_is_und_section (ys
))
684 if (valueof (x
) != valueof (y
))
685 return valueof (x
) < valueof (y
) ? -1 : 1;
687 if (xs
->vma
!= ys
->vma
)
688 return xs
->vma
< ys
->vma
? -1 : 1;
690 xn
= bfd_asymbol_name (x
);
691 yn
= bfd_asymbol_name (y
);
695 /* The symbols gnu_compiled and gcc2_compiled convey even less
696 information than the file name, so sort them out first. */
698 xf
= (strstr (xn
, "gnu_compiled") != NULL
699 || strstr (xn
, "gcc2_compiled") != NULL
);
700 yf
= (strstr (yn
, "gnu_compiled") != NULL
701 || strstr (yn
, "gcc2_compiled") != NULL
);
708 /* We use a heuristic for the file name. It may not work on non
709 Unix systems, but it doesn't really matter; the only difference
710 is precisely which symbol names get printed. */
712 #define file_symbol(s, sn, snl) \
713 (((s)->flags & BSF_FILE) != 0 \
715 && (sn)[(snl) - 2] == '.' \
716 && ((sn)[(snl) - 1] == 'o' \
717 || (sn)[(snl) - 1] == 'a')))
719 xf
= file_symbol (x
, xn
, xnl
);
720 yf
= file_symbol (y
, yn
, ynl
);
727 return non_numeric_forward (P_x
, P_y
);
730 /* This sort routine is used by sort_symbols_by_size. It is sorting
731 an array of size_sym structures into size order. */
734 size_forward2 (const void *P_x
, const void *P_y
)
736 const struct size_sym
*x
= (const struct size_sym
*) P_x
;
737 const struct size_sym
*y
= (const struct size_sym
*) P_y
;
739 if (x
->size
< y
->size
)
740 return reverse_sort
? 1 : -1;
741 else if (x
->size
> y
->size
)
742 return reverse_sort
? -1 : 1;
744 return sorters
[0][reverse_sort
] (x
->minisym
, y
->minisym
);
747 /* Sort the symbols by size. ELF provides a size but for other formats
748 we have to make a guess by assuming that the difference between the
749 address of a symbol and the address of the next higher symbol is the
753 sort_symbols_by_size (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
754 long symcount
, unsigned int size
,
755 struct size_sym
**symsizesp
)
757 struct size_sym
*symsizes
;
758 bfd_byte
*from
, *fromend
;
760 asymbol
*store_sym
, *store_next
;
762 qsort (minisyms
, symcount
, size
, size_forward1
);
764 /* We are going to return a special set of symbols and sizes to
766 symsizes
= (struct size_sym
*) xmalloc (symcount
* sizeof (struct size_sym
));
767 *symsizesp
= symsizes
;
769 /* Note that filter_symbols has already removed all absolute and
770 undefined symbols. Here we remove all symbols whose size winds
772 from
= (bfd_byte
*) minisyms
;
773 fromend
= from
+ symcount
* size
;
780 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
,
783 bfd_fatal (bfd_get_filename (abfd
));
786 for (; from
< fromend
; from
+= size
)
793 if (from
+ size
< fromend
)
795 next
= bfd_minisymbol_to_symbol (abfd
,
797 (const void *) (from
+ size
),
800 bfd_fatal (bfd_get_filename (abfd
));
805 sec
= bfd_asymbol_section (sym
);
807 /* Synthetic symbols don't have a full type set of data available, thus
808 we can't rely on that information for the symbol size. Ditto for
809 bfd/section.c:global_syms like *ABS*. */
810 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
811 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
812 sz
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
813 else if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
814 && bfd_is_com_section (sec
))
818 if (from
+ size
< fromend
819 && sec
== bfd_asymbol_section (next
))
820 sz
= valueof (next
) - valueof (sym
);
822 sz
= (bfd_section_vma (sec
)
823 + bfd_section_size (sec
)
829 symsizes
->minisym
= (const void *) from
;
837 store_sym
= store_next
;
841 symcount
= symsizes
- *symsizesp
;
843 /* We must now sort again by size. */
844 qsort ((void *) *symsizesp
, symcount
, sizeof (struct size_sym
), size_forward2
);
849 /* This function is used to get the relocs for a particular section.
850 It is called via bfd_map_over_sections. */
853 get_relocs (bfd
*abfd
, asection
*sec
, void *dataarg
)
855 struct get_relocs_info
*data
= (struct get_relocs_info
*) dataarg
;
859 if ((sec
->flags
& SEC_RELOC
) == 0)
861 *data
->relocs
= NULL
;
868 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
870 bfd_fatal (bfd_get_filename (abfd
));
872 *data
->relocs
= (arelent
**) xmalloc (relsize
);
873 *data
->relcount
= bfd_canonicalize_reloc (abfd
, sec
, *data
->relocs
,
875 if (*data
->relcount
< 0)
876 bfd_fatal (bfd_get_filename (abfd
));
884 /* Print a single symbol. */
887 print_symbol (bfd
* abfd
,
893 struct extended_symbol_info info
;
897 format
->print_symbol_filename (archive_bfd
, abfd
);
899 bfd_get_symbol_info (abfd
, sym
, &syminfo
);
901 /* PR 22967 - Distinguish between local and global ifunc symbols. */
902 if (syminfo
.type
== 'i'
903 && sym
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
905 if (ifunc_type_chars
== NULL
|| ifunc_type_chars
[0] == 0)
906 ; /* Change nothing. */
907 else if (sym
->flags
& BSF_GLOBAL
)
908 syminfo
.type
= ifunc_type_chars
[0];
909 else if (ifunc_type_chars
[1] != 0)
910 syminfo
.type
= ifunc_type_chars
[1];
913 info
.sinfo
= &syminfo
;
915 /* Synthetic symbols do not have a full symbol type set of data available.
916 Nor do bfd/section.c:global_syms like *ABS*. */
917 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) != 0)
920 info
.coffinfo
= NULL
;
924 info
.elfinfo
= elf_symbol_from (sym
);
925 info
.coffinfo
= coff_symbol_from (sym
);
928 format
->print_symbol_info (&info
, abfd
);
932 static asymbol
**syms
;
933 static long symcount
;
934 const char *filename
, *functionname
;
937 /* We need to get the canonical symbols in order to call
938 bfd_find_nearest_line. This is inefficient, but, then, you
939 don't have to use --line-numbers. */
940 if (abfd
!= lineno_cache_bfd
&& syms
!= NULL
)
949 symsize
= bfd_get_symtab_upper_bound (abfd
);
951 bfd_fatal (bfd_get_filename (abfd
));
952 syms
= (asymbol
**) xmalloc (symsize
);
953 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
955 bfd_fatal (bfd_get_filename (abfd
));
956 lineno_cache_bfd
= abfd
;
959 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
961 static asection
**secs
;
962 static arelent
***relocs
;
963 static long *relcount
;
964 static unsigned int seccount
;
968 /* For an undefined symbol, we try to find a reloc for the
969 symbol, and print the line number of the reloc. */
970 if (abfd
!= lineno_cache_rel_bfd
&& relocs
!= NULL
)
972 for (i
= 0; i
< seccount
; i
++)
973 if (relocs
[i
] != NULL
)
985 struct get_relocs_info rinfo
;
987 seccount
= bfd_count_sections (abfd
);
989 secs
= (asection
**) xmalloc (seccount
* sizeof *secs
);
990 relocs
= (arelent
***) xmalloc (seccount
* sizeof *relocs
);
991 relcount
= (long *) xmalloc (seccount
* sizeof *relcount
);
994 rinfo
.relocs
= relocs
;
995 rinfo
.relcount
= relcount
;
997 bfd_map_over_sections (abfd
, get_relocs
, (void *) &rinfo
);
998 lineno_cache_rel_bfd
= abfd
;
1001 symname
= bfd_asymbol_name (sym
);
1002 for (i
= 0; i
< seccount
; i
++)
1006 for (j
= 0; j
< relcount
[i
]; j
++)
1011 if (r
->sym_ptr_ptr
!= NULL
1012 && (*r
->sym_ptr_ptr
)->section
== sym
->section
1013 && (*r
->sym_ptr_ptr
)->value
== sym
->value
1015 bfd_asymbol_name (*r
->sym_ptr_ptr
)) == 0
1016 && bfd_find_nearest_line (abfd
, secs
[i
], syms
,
1017 r
->address
, &filename
,
1018 &functionname
, &lineno
)
1019 && filename
!= NULL
)
1021 /* We only print the first one we find. */
1022 printf ("\t%s:%u", filename
, lineno
);
1029 else if (bfd_asymbol_section (sym
)->owner
== abfd
)
1031 if ((bfd_find_line (abfd
, syms
, sym
, &filename
, &lineno
)
1032 || bfd_find_nearest_line (abfd
, bfd_asymbol_section (sym
),
1033 syms
, sym
->value
, &filename
,
1034 &functionname
, &lineno
))
1037 printf ("\t%s:%u", filename
, lineno
);
1044 /* Print the symbols when sorting by size. */
1047 print_size_symbols (bfd
* abfd
,
1048 bfd_boolean is_dynamic
,
1049 struct size_sym
* symsizes
,
1054 struct size_sym
*from
;
1055 struct size_sym
*fromend
;
1057 store
= bfd_make_empty_symbol (abfd
);
1059 bfd_fatal (bfd_get_filename (abfd
));
1062 fromend
= from
+ symcount
;
1064 for (; from
< fromend
; from
++)
1068 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
->minisym
, store
);
1070 bfd_fatal (bfd_get_filename (abfd
));
1072 print_symbol (abfd
, sym
, from
->size
, archive_bfd
);
1077 /* Print the symbols of ABFD that are held in MINISYMS.
1079 If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1081 SYMCOUNT is the number of symbols in MINISYMS.
1083 SIZE is the size of a symbol in MINISYMS. */
1086 print_symbols (bfd
* abfd
,
1087 bfd_boolean is_dynamic
,
1097 store
= bfd_make_empty_symbol (abfd
);
1099 bfd_fatal (bfd_get_filename (abfd
));
1101 from
= (bfd_byte
*) minisyms
;
1102 fromend
= from
+ symcount
* size
;
1104 for (; from
< fromend
; from
+= size
)
1108 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
, store
);
1110 bfd_fatal (bfd_get_filename (abfd
));
1112 print_symbol (abfd
, sym
, (bfd_vma
) 0, archive_bfd
);
1116 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1119 display_rel_file (bfd
*abfd
, bfd
*archive_bfd
)
1124 struct size_sym
*symsizes
;
1125 asymbol
*synthsyms
= NULL
;
1129 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1131 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1136 symcount
= bfd_read_minisymbols (abfd
, dynamic
, &minisyms
, &size
);
1139 if (dynamic
&& bfd_get_error () == bfd_error_no_symbols
)
1141 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1145 bfd_fatal (bfd_get_filename (abfd
));
1150 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1154 if (show_synthetic
&& size
== sizeof (asymbol
*))
1156 asymbol
**static_syms
= NULL
;
1157 asymbol
**dyn_syms
= NULL
;
1158 long static_count
= 0;
1164 dyn_count
= symcount
;
1165 dyn_syms
= (asymbol
**) minisyms
;
1169 long storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1171 static_count
= symcount
;
1172 static_syms
= (asymbol
**) minisyms
;
1176 dyn_syms
= (asymbol
**) xmalloc (storage
);
1177 dyn_count
= bfd_canonicalize_dynamic_symtab (abfd
, dyn_syms
);
1179 bfd_fatal (bfd_get_filename (abfd
));
1183 synth_count
= bfd_get_synthetic_symtab (abfd
, static_count
, static_syms
,
1184 dyn_count
, dyn_syms
, &synthsyms
);
1185 if (synth_count
> 0)
1190 minisyms
= xrealloc (minisyms
,
1191 (symcount
+ synth_count
+ 1) * sizeof (*symp
));
1192 symp
= (asymbol
**) minisyms
+ symcount
;
1193 for (i
= 0; i
< synth_count
; i
++)
1194 *symp
++ = synthsyms
+ i
;
1196 symcount
+= synth_count
;
1198 if (!dynamic
&& dyn_syms
!= NULL
)
1202 /* lto_slim_object is set to false when a bfd is loaded with a compiler
1204 if (abfd
->lto_slim_object
)
1206 report_plugin_err
= FALSE
;
1207 non_fatal (_("%s: plugin needed to handle lto object"),
1208 bfd_get_filename (abfd
));
1211 /* Discard the symbols we don't want to print.
1212 It's OK to do this in place; we'll free the storage anyway
1213 (after printing). */
1215 symcount
= filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
);
1221 sort_dynamic
= dynamic
;
1222 sort_x
= bfd_make_empty_symbol (abfd
);
1223 sort_y
= bfd_make_empty_symbol (abfd
);
1224 if (sort_x
== NULL
|| sort_y
== NULL
)
1225 bfd_fatal (bfd_get_filename (abfd
));
1228 qsort (minisyms
, symcount
, size
,
1229 sorters
[sort_numerically
][reverse_sort
]);
1231 symcount
= sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
,
1236 print_symbols (abfd
, dynamic
, minisyms
, symcount
, size
, archive_bfd
);
1238 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, archive_bfd
);
1246 /* Construct a formatting string for printing symbol values. */
1249 get_print_format (void)
1251 const char * padding
;
1252 if (print_format
== FORMAT_POSIX
)
1254 /* POSIX compatible output does not have any padding. */
1257 else if (print_width
== 32)
1261 else /* print_width == 64 */
1266 const char * length
= "l";
1267 if (print_width
== 64)
1269 #if BFD_HOST_64BIT_LONG
1271 #elif BFD_HOST_64BIT_LONG_LONG
1280 const char * radix
= NULL
;
1281 switch (print_radix
)
1283 case 8: radix
= "o"; break;
1284 case 10: radix
= "d"; break;
1285 case 16: radix
= "x"; break;
1288 return concat ("%", padding
, length
, radix
, NULL
);
1292 set_print_width (bfd
*file
)
1294 print_width
= bfd_get_arch_size (file
);
1296 if (print_width
== -1)
1299 Guess the target's bitsize based on its name.
1300 We assume here than any 64-bit format will include
1301 "64" somewhere in its name. The only known exception
1302 is the MMO object file format. */
1303 if (strstr (bfd_get_target (file
), "64") != NULL
1304 || strcmp (bfd_get_target (file
), "mmo") == 0)
1309 free ((char *) print_format_string
);
1310 print_format_string
= get_print_format ();
1314 display_archive (bfd
*file
)
1317 bfd
*last_arfile
= NULL
;
1320 format
->print_archive_filename (bfd_get_filename (file
));
1323 print_symdef_entry (file
);
1329 arfile
= bfd_openr_next_archived_file (file
, arfile
);
1333 if (bfd_get_error () != bfd_error_no_more_archived_files
)
1334 bfd_fatal (bfd_get_filename (file
));
1338 if (bfd_check_format_matches (arfile
, bfd_object
, &matching
))
1340 set_print_width (arfile
);
1341 format
->print_archive_member (bfd_get_filename (file
),
1342 bfd_get_filename (arfile
));
1343 display_rel_file (arfile
, file
);
1347 bfd_nonfatal (bfd_get_filename (arfile
));
1348 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1350 list_matching_formats (matching
);
1355 if (last_arfile
!= NULL
)
1357 bfd_close (last_arfile
);
1358 lineno_cache_bfd
= NULL
;
1359 lineno_cache_rel_bfd
= NULL
;
1360 if (arfile
== last_arfile
)
1363 last_arfile
= arfile
;
1366 if (last_arfile
!= NULL
)
1368 bfd_close (last_arfile
);
1369 lineno_cache_bfd
= NULL
;
1370 lineno_cache_rel_bfd
= NULL
;
1375 display_file (char *filename
)
1377 bfd_boolean retval
= TRUE
;
1381 if (get_file_size (filename
) < 1)
1384 file
= bfd_openr (filename
, target
? target
: plugin_target
);
1387 bfd_nonfatal (filename
);
1391 /* If printing line numbers, decompress the debug sections. */
1393 file
->flags
|= BFD_DECOMPRESS
;
1395 if (bfd_check_format (file
, bfd_archive
))
1397 display_archive (file
);
1399 else if (bfd_check_format_matches (file
, bfd_object
, &matching
))
1401 set_print_width (file
);
1402 format
->print_object_filename (filename
);
1403 display_rel_file (file
, NULL
);
1407 bfd_nonfatal (filename
);
1408 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1410 list_matching_formats (matching
);
1416 if (!bfd_close (file
))
1417 bfd_fatal (filename
);
1419 lineno_cache_bfd
= NULL
;
1420 lineno_cache_rel_bfd
= NULL
;
1425 /* The following 3 groups of functions are called unconditionally,
1426 once at the start of processing each file of the appropriate type.
1427 They should check `filename_per_file' and `filename_per_symbol',
1428 as appropriate for their output format, to determine whether to
1431 /* Print the name of an object file given on the command line. */
1434 print_object_filename_bsd (const char *filename
)
1436 if (filename_per_file
&& !filename_per_symbol
)
1437 printf ("\n%s:\n", filename
);
1441 print_object_filename_sysv (const char *filename
)
1444 printf (_("\n\nUndefined symbols from %s:\n\n"), filename
);
1446 printf (_("\n\nSymbols from %s:\n\n"), filename
);
1447 if (print_width
== 32)
1449 Name Value Class Type Size Line Section\n\n"));
1452 Name Value Class Type Size Line Section\n\n"));
1456 print_object_filename_posix (const char *filename
)
1458 if (filename_per_file
&& !filename_per_symbol
)
1459 printf ("%s:\n", filename
);
1462 /* Print the name of an archive file given on the command line. */
1465 print_archive_filename_bsd (const char *filename
)
1467 if (filename_per_file
)
1468 printf ("\n%s:\n", filename
);
1472 print_archive_filename_sysv (const char *filename ATTRIBUTE_UNUSED
)
1477 print_archive_filename_posix (const char *filename ATTRIBUTE_UNUSED
)
1481 /* Print the name of an archive member file. */
1484 print_archive_member_bsd (const char *archive ATTRIBUTE_UNUSED
,
1485 const char *filename
)
1487 if (!filename_per_symbol
)
1488 printf ("\n%s:\n", filename
);
1492 print_archive_member_sysv (const char *archive
, const char *filename
)
1495 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive
, filename
);
1497 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive
, filename
);
1498 if (print_width
== 32)
1500 Name Value Class Type Size Line Section\n\n"));
1503 Name Value Class Type Size Line Section\n\n"));
1507 print_archive_member_posix (const char *archive
, const char *filename
)
1509 if (!filename_per_symbol
)
1510 printf ("%s[%s]:\n", archive
, filename
);
1513 /* Print the name of the file (and archive, if there is one)
1514 containing a symbol. */
1517 print_symbol_filename_bsd (bfd
*archive_bfd
, bfd
*abfd
)
1519 if (filename_per_symbol
)
1522 printf ("%s:", bfd_get_filename (archive_bfd
));
1523 printf ("%s:", bfd_get_filename (abfd
));
1528 print_symbol_filename_sysv (bfd
*archive_bfd
, bfd
*abfd
)
1530 if (filename_per_symbol
)
1533 printf ("%s:", bfd_get_filename (archive_bfd
));
1534 printf ("%s:", bfd_get_filename (abfd
));
1539 print_symbol_filename_posix (bfd
*archive_bfd
, bfd
*abfd
)
1541 if (filename_per_symbol
)
1544 printf ("%s[%s]: ", bfd_get_filename (archive_bfd
),
1545 bfd_get_filename (abfd
));
1547 printf ("%s: ", bfd_get_filename (abfd
));
1551 /* Print a symbol value. */
1554 print_value (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_vma val
)
1556 switch (print_width
)
1559 printf (print_format_string
, (unsigned long) val
);
1563 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1564 printf (print_format_string
, val
);
1566 /* We have a 64 bit value to print, but the host is only 32 bit. */
1567 if (print_radix
== 16)
1568 bfd_fprintf_vma (abfd
, stdout
, val
);
1574 s
= buf
+ sizeof buf
;
1578 *--s
= (val
% print_radix
) + '0';
1581 while ((buf
+ sizeof buf
- 1) - s
< 16)
1589 fatal (_("Print width has not been initialized (%d)"), print_width
);
1594 /* Print a line of information about a symbol. */
1597 print_symbol_info_bsd (struct extended_symbol_info
*info
, bfd
*abfd
)
1599 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1601 if (print_width
== 64)
1607 /* Normally we print the value of the symbol. If we are printing the
1608 size or sorting by size then we print its size, except for the
1609 (weird) special case where both flags are defined, in which case we
1610 print both values. This conforms to documented behaviour. */
1611 if (sort_by_size
&& !print_size
)
1612 print_value (abfd
, SYM_SIZE (info
));
1614 print_value (abfd
, SYM_VALUE (info
));
1615 if (print_size
&& SYM_SIZE (info
))
1618 print_value (abfd
, SYM_SIZE (info
));
1622 printf (" %c", SYM_TYPE (info
));
1624 if (SYM_TYPE (info
) == '-')
1628 printf (other_format
, SYM_STAB_OTHER (info
));
1630 printf (desc_format
, SYM_STAB_DESC (info
));
1631 printf (" %5s", SYM_STAB_NAME (info
));
1633 print_symname (" %s", info
, NULL
, abfd
);
1637 print_symbol_info_sysv (struct extended_symbol_info
*info
, bfd
*abfd
)
1639 print_symname ("%-20s|", info
, NULL
, abfd
);
1641 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1643 if (print_width
== 32)
1649 print_value (abfd
, SYM_VALUE (info
));
1651 printf ("| %c |", SYM_TYPE (info
));
1653 if (SYM_TYPE (info
) == '-')
1656 printf ("%18s| ", SYM_STAB_NAME (info
)); /* (C) Type. */
1657 printf (desc_format
, SYM_STAB_DESC (info
)); /* Size. */
1658 printf ("| |"); /* Line, Section. */
1662 /* Type, Size, Line, Section */
1665 get_elf_symbol_type (ELF_ST_TYPE (info
->elfinfo
->internal_elf_sym
.st_info
)));
1666 else if (info
->coffinfo
)
1668 get_coff_symbol_type (&info
->coffinfo
->native
->u
.syment
));
1672 if (SYM_SIZE (info
))
1673 print_value (abfd
, SYM_SIZE (info
));
1676 if (print_width
== 32)
1683 printf("| |%s", info
->elfinfo
->symbol
.section
->name
);
1684 else if (info
->coffinfo
)
1685 printf("| |%s", info
->coffinfo
->symbol
.section
->name
);
1692 print_symbol_info_posix (struct extended_symbol_info
*info
, bfd
*abfd
)
1694 print_symname ("%s ", info
, NULL
, abfd
);
1695 printf ("%c ", SYM_TYPE (info
));
1697 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1701 print_value (abfd
, SYM_VALUE (info
));
1703 if (SYM_SIZE (info
))
1704 print_value (abfd
, SYM_SIZE (info
));
1709 main (int argc
, char **argv
)
1714 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1715 setlocale (LC_MESSAGES
, "");
1717 #if defined (HAVE_SETLOCALE)
1718 setlocale (LC_CTYPE
, "");
1719 setlocale (LC_COLLATE
, "");
1721 bindtextdomain (PACKAGE
, LOCALEDIR
);
1722 textdomain (PACKAGE
);
1724 program_name
= *argv
;
1725 xmalloc_set_program_name (program_name
);
1726 bfd_set_error_program_name (program_name
);
1727 #if BFD_SUPPORTS_PLUGINS
1728 bfd_plugin_set_program_name (program_name
);
1731 START_PROGRESS (program_name
, 0);
1733 expandargv (&argc
, &argv
);
1735 if (bfd_init () != BFD_INIT_MAGIC
)
1736 fatal (_("fatal error: libbfd ABI mismatch"));
1737 set_default_bfd_target ();
1739 while ((c
= getopt_long (argc
, argv
, "aABCDef:gHhlnopPrSst:uvVvX:",
1740 long_options
, (int *) 0)) != EOF
)
1745 print_debug_syms
= 1;
1749 filename_per_symbol
= 1;
1751 case 'B': /* For MIPS compatibility. */
1752 set_output_format ("bsd");
1758 enum demangling_styles style
;
1760 style
= cplus_demangle_name_to_style (optarg
);
1761 if (style
== unknown_demangling
)
1762 fatal (_("unknown demangling style `%s'"),
1765 cplus_demangle_set_style (style
);
1768 case OPTION_RECURSE_LIMIT
:
1769 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
1771 case OPTION_NO_RECURSE_LIMIT
:
1772 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
1774 case OPTION_WITH_SYMBOL_VERSIONS
:
1775 /* Ignored for backward compatibility. */
1781 /* Ignored for HP/UX compatibility. */
1784 set_output_format (optarg
);
1798 sort_numerically
= 1;
1803 sort_numerically
= 0;
1806 case OPTION_SIZE_SORT
:
1808 sort_numerically
= 0;
1812 set_output_format ("posix");
1824 set_print_radix (optarg
);
1833 /* Ignored for (partial) AIX compatibility. On AIX, the
1834 argument has values 32, 64, or 32_64, and specifies that
1835 only 32-bit, only 64-bit, or both kinds of objects should
1836 be examined. The default is 32. So plain AIX nm on a
1837 library archive with both kinds of objects will ignore
1838 the 64-bit ones. For GNU nm, the default is and always
1839 has been -X 32_64, and other options are not supported. */
1840 if (strcmp (optarg
, "32_64") != 0)
1841 fatal (_("Only -X 32_64 is supported"));
1844 case OPTION_TARGET
: /* --target */
1848 case OPTION_PLUGIN
: /* --plugin */
1849 #if BFD_SUPPORTS_PLUGINS
1850 bfd_plugin_set_plugin (optarg
);
1852 fatal (_("sorry - this program has been built without plugin support\n"));
1856 case OPTION_IFUNC_CHARS
:
1857 ifunc_type_chars
= optarg
;
1860 case 0: /* A long option that just sets a flag. */
1869 print_version ("nm");
1871 if (sort_by_size
&& undefined_only
)
1873 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1874 non_fatal (_("will produce no output, since undefined symbols have no size."));
1878 /* OK, all options now parsed. If no filename specified, do a.out. */
1880 return !display_file ("a.out");
1884 if (argc
- optind
> 1)
1885 filename_per_file
= 1;
1887 /* We were given several filenames to do. */
1888 while (optind
< argc
)
1891 if (!display_file (argv
[optind
++]))
1895 END_PROGRESS (program_name
);