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. */
164 static int with_symbol_versions
= 0; /* Include symbol version information in the output. */
166 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
168 /* When to print the names of files. Not mutually exclusive in SYSV format. */
169 static int filename_per_file
= 0; /* Once per file, on its own line. */
170 static int filename_per_symbol
= 0; /* Once per symbol, at start of line. */
172 static int print_width
= 0;
173 static int print_radix
= 16;
174 /* Print formats for printing stab info. */
175 static char other_format
[] = "%02x";
176 static char desc_format
[] = "%04x";
178 static char *target
= NULL
;
179 #if BFD_SUPPORTS_PLUGINS
180 static const char *plugin_target
= "plugin";
182 static const char *plugin_target
= NULL
;
185 /* Used to cache the line numbers for a BFD. */
186 static bfd
*lineno_cache_bfd
;
187 static bfd
*lineno_cache_rel_bfd
;
189 enum long_option_values
194 OPTION_RECURSE_LIMIT
,
195 OPTION_NO_RECURSE_LIMIT
198 static struct option long_options
[] =
200 {"debug-syms", no_argument
, &print_debug_syms
, 1},
201 {"demangle", optional_argument
, 0, 'C'},
202 {"dynamic", no_argument
, &dynamic
, 1},
203 {"extern-only", no_argument
, &external_only
, 1},
204 {"format", required_argument
, 0, 'f'},
205 {"help", no_argument
, 0, 'h'},
206 {"line-numbers", no_argument
, 0, 'l'},
207 {"no-cplus", no_argument
, &do_demangle
, 0}, /* Linux compatibility. */
208 {"no-demangle", no_argument
, &do_demangle
, 0},
209 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
210 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
211 {"no-sort", no_argument
, 0, 'p'},
212 {"numeric-sort", no_argument
, 0, 'n'},
213 {"plugin", required_argument
, 0, OPTION_PLUGIN
},
214 {"portability", no_argument
, 0, 'P'},
215 {"print-armap", no_argument
, &print_armap
, 1},
216 {"print-file-name", no_argument
, 0, 'o'},
217 {"print-size", no_argument
, 0, 'S'},
218 {"radix", required_argument
, 0, 't'},
219 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
220 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
221 {"reverse-sort", no_argument
, &reverse_sort
, 1},
222 {"size-sort", no_argument
, 0, OPTION_SIZE_SORT
},
223 {"special-syms", no_argument
, &allow_special_symbols
, 1},
224 {"synthetic", no_argument
, &show_synthetic
, 1},
225 {"target", required_argument
, 0, OPTION_TARGET
},
226 {"defined-only", no_argument
, &defined_only
, 1},
227 {"undefined-only", no_argument
, &undefined_only
, 1},
228 {"version", no_argument
, &show_version
, 1},
229 {"with-symbol-versions", no_argument
, &with_symbol_versions
, 1},
230 {0, no_argument
, 0, 0}
233 /* Some error-reporting functions. */
235 ATTRIBUTE_NORETURN
static void
236 usage (FILE *stream
, int status
)
238 fprintf (stream
, _("Usage: %s [option(s)] [file(s)]\n"), program_name
);
239 fprintf (stream
, _(" List symbols in [file(s)] (a.out by default).\n"));
240 fprintf (stream
, _(" The options are:\n\
241 -a, --debug-syms Display debugger-only symbols\n\
242 -A, --print-file-name Print name of the input file before every symbol\n\
243 -B Same as --format=bsd\n\
244 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
245 The STYLE, if specified, can be `auto' (the default),\n\
246 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
248 --no-demangle Do not demangle low-level symbol names\n\
249 --recurse-limit Enable a demangling recursion limit. This is the default.\n\
250 --no-recurse-limit Disable a demangling recursion limit.\n\
251 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
252 --defined-only Display only defined symbols\n\
254 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
255 `sysv' or `posix'. The default is `bsd'\n\
256 -g, --extern-only Display only external symbols\n\
257 -l, --line-numbers Use debugging information to find a filename and\n\
258 line number for each symbol\n\
259 -n, --numeric-sort Sort symbols numerically by address\n\
261 -p, --no-sort Do not sort the symbols\n\
262 -P, --portability Same as --format=posix\n\
263 -r, --reverse-sort Reverse the sense of the sort\n"));
264 #if BFD_SUPPORTS_PLUGINS
265 fprintf (stream
, _("\
266 --plugin NAME Load the specified plugin\n"));
268 fprintf (stream
, _("\
269 -S, --print-size Print size of defined symbols\n\
270 -s, --print-armap Include index for symbols from archive members\n\
271 --size-sort Sort symbols by size\n\
272 --special-syms Include special symbols in the output\n\
273 --synthetic Display synthetic symbols as well\n\
274 -t, --radix=RADIX Use RADIX for printing symbol values\n\
275 --target=BFDNAME Specify the target object format as BFDNAME\n\
276 -u, --undefined-only Display only undefined symbols\n\
277 --with-symbol-versions Display version strings after symbol names\n\
278 -X 32_64 (ignored)\n\
279 @FILE Read options from FILE\n\
280 -h, --help Display this information\n\
281 -V, --version Display this program's version number\n\
283 list_supported_targets (program_name
, stream
);
284 if (REPORT_BUGS_TO
[0] && status
== 0)
285 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
289 /* Set the radix for the symbol value and size according to RADIX. */
292 set_print_radix (char *radix
)
296 case 'x': print_radix
= 16; break;
297 case 'd': print_radix
= 10; break;
298 case 'o': print_radix
= 8; break;
301 fatal (_("%s: invalid radix"), radix
);
304 other_format
[3] = desc_format
[3] = *radix
;
308 set_output_format (char *f
)
327 fatal (_("%s: invalid output format"), f
);
329 format
= &formats
[i
];
334 get_elf_symbol_type (unsigned int type
)
341 case STT_NOTYPE
: return "NOTYPE";
342 case STT_OBJECT
: return "OBJECT";
343 case STT_FUNC
: return "FUNC";
344 case STT_SECTION
: return "SECTION";
345 case STT_FILE
: return "FILE";
346 case STT_COMMON
: return "COMMON";
347 case STT_TLS
: return "TLS";
351 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
352 n
= asprintf (&bufp
, _("<processor specific>: %d"), type
);
353 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
354 n
= asprintf (&bufp
, _("<OS specific>: %d"), type
);
356 n
= asprintf (&bufp
, _("<unknown>: %d"), type
);
358 fatal ("%s", xstrerror (errno
));
363 get_coff_symbol_type (const struct internal_syment
*sym
)
368 switch (sym
->n_sclass
)
370 case C_BLOCK
: return "Block";
371 case C_FILE
: return "File";
372 case C_LINE
: return "Line";
378 switch (DTYPE(sym
->n_type
))
380 case DT_FCN
: return "Function";
381 case DT_PTR
: return "Pointer";
382 case DT_ARY
: return "Array";
386 n
= asprintf (&bufp
, _("<unknown>: %d/%d"), sym
->n_sclass
, sym
->n_type
);
388 fatal ("%s", xstrerror (errno
));
392 /* Print symbol name NAME, read from ABFD, with printf format FORM,
393 demangling it if requested. */
396 print_symname (const char *form
, struct extended_symbol_info
*info
,
397 const char *name
, bfd
*abfd
)
400 name
= info
->sinfo
->name
;
401 if (do_demangle
&& *name
)
403 char *res
= bfd_demangle (abfd
, name
, demangle_flags
);
414 if (info
!= NULL
&& info
->elfinfo
)
416 const char *version_string
;
420 = bfd_get_symbol_version_string (abfd
, &info
->elfinfo
->symbol
,
422 if (version_string
&& version_string
[0])
423 printf ("%s%s", hidden
? "@" : "@@", version_string
);
428 print_symdef_entry (bfd
*abfd
)
430 symindex idx
= BFD_NO_MORE_SYMBOLS
;
432 bfd_boolean everprinted
= FALSE
;
434 for (idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
);
435 idx
!= BFD_NO_MORE_SYMBOLS
;
436 idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
))
441 printf (_("\nArchive index:\n"));
444 elt
= bfd_get_elt_at_index (abfd
, idx
);
446 bfd_fatal ("bfd_get_elt_at_index");
447 if (thesym
->name
!= (char *) NULL
)
449 print_symname ("%s", NULL
, thesym
->name
, abfd
);
450 printf (" in %s\n", bfd_get_filename (elt
));
456 /* True when we can report missing plugin error. */
457 bfd_boolean report_plugin_err
= TRUE
;
459 /* Choose which symbol entries to print;
460 compact them downward to get rid of the rest.
461 Return the number of symbols to be printed. */
464 filter_symbols (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
465 long symcount
, unsigned int size
)
467 bfd_byte
*from
, *fromend
, *to
;
470 store
= bfd_make_empty_symbol (abfd
);
472 bfd_fatal (bfd_get_filename (abfd
));
474 from
= (bfd_byte
*) minisyms
;
475 fromend
= from
+ symcount
* size
;
476 to
= (bfd_byte
*) minisyms
;
478 for (; from
< fromend
; from
+= size
)
485 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
, store
);
487 bfd_fatal (bfd_get_filename (abfd
));
489 if (sym
->name
[0] == '_'
490 && sym
->name
[1] == '_'
491 && strcmp (sym
->name
+ (sym
->name
[2] == '_'), "__gnu_lto_slim") == 0
492 && report_plugin_err
)
494 report_plugin_err
= FALSE
;
495 non_fatal (_("%s: plugin needed to handle lto object"),
496 bfd_get_filename (abfd
));
500 keep
= bfd_is_und_section (sym
->section
);
501 else if (external_only
)
502 /* PR binutls/12753: Unique symbols are global too. */
503 keep
= ((sym
->flags
& (BSF_GLOBAL
505 | BSF_GNU_UNIQUE
)) != 0
506 || bfd_is_und_section (sym
->section
)
507 || bfd_is_com_section (sym
->section
));
512 && ! print_debug_syms
513 && (sym
->flags
& BSF_DEBUGGING
) != 0)
518 && (bfd_is_abs_section (sym
->section
)
519 || bfd_is_und_section (sym
->section
)))
525 if (bfd_is_und_section (sym
->section
))
530 && bfd_is_target_special_symbol (abfd
, sym
)
531 && ! allow_special_symbols
)
537 memcpy (to
, from
, size
);
542 return (to
- (bfd_byte
*) minisyms
) / size
;
545 /* These globals are used to pass information into the sorting
547 static bfd
*sort_bfd
;
548 static bfd_boolean sort_dynamic
;
549 static asymbol
*sort_x
;
550 static asymbol
*sort_y
;
552 /* Symbol-sorting predicates */
553 #define valueof(x) ((x)->section->vma + (x)->value)
555 /* Numeric sorts. Undefined symbols are always considered "less than"
556 defined symbols with zero values. Common symbols are not treated
557 specially -- i.e., their sizes are used as their "values". */
560 non_numeric_forward (const void *P_x
, const void *P_y
)
565 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
566 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
567 if (x
== NULL
|| y
== NULL
)
568 bfd_fatal (bfd_get_filename (sort_bfd
));
570 xn
= bfd_asymbol_name (x
);
571 yn
= bfd_asymbol_name (y
);
579 /* Solaris 2.5 has a bug in strcoll.
580 strcoll returns invalid values when confronted with empty strings. */
586 return strcoll (xn
, yn
);
588 return strcmp (xn
, yn
);
593 non_numeric_reverse (const void *x
, const void *y
)
595 return - non_numeric_forward (x
, y
);
599 numeric_forward (const void *P_x
, const void *P_y
)
604 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
605 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
606 if (x
== NULL
|| y
== NULL
)
607 bfd_fatal (bfd_get_filename (sort_bfd
));
609 xs
= bfd_asymbol_section (x
);
610 ys
= bfd_asymbol_section (y
);
612 if (bfd_is_und_section (xs
))
614 if (! bfd_is_und_section (ys
))
617 else if (bfd_is_und_section (ys
))
619 else if (valueof (x
) != valueof (y
))
620 return valueof (x
) < valueof (y
) ? -1 : 1;
622 return non_numeric_forward (P_x
, P_y
);
626 numeric_reverse (const void *x
, const void *y
)
628 return - numeric_forward (x
, y
);
631 static int (*(sorters
[2][2])) (const void *, const void *) =
633 { non_numeric_forward
, non_numeric_reverse
},
634 { numeric_forward
, numeric_reverse
}
637 /* This sort routine is used by sort_symbols_by_size. It is similar
638 to numeric_forward, but when symbols have the same value it sorts
639 by section VMA. This simplifies the sort_symbols_by_size code
640 which handles symbols at the end of sections. Also, this routine
641 tries to sort file names before other symbols with the same value.
642 That will make the file name have a zero size, which will make
643 sort_symbols_by_size choose the non file name symbol, leading to
644 more meaningful output. For similar reasons, this code sorts
645 gnu_compiled_* and gcc2_compiled before other symbols with the same
649 size_forward1 (const void *P_x
, const void *P_y
)
657 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
658 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
659 if (x
== NULL
|| y
== NULL
)
660 bfd_fatal (bfd_get_filename (sort_bfd
));
662 xs
= bfd_asymbol_section (x
);
663 ys
= bfd_asymbol_section (y
);
665 if (bfd_is_und_section (xs
))
667 if (bfd_is_und_section (ys
))
670 if (valueof (x
) != valueof (y
))
671 return valueof (x
) < valueof (y
) ? -1 : 1;
673 if (xs
->vma
!= ys
->vma
)
674 return xs
->vma
< ys
->vma
? -1 : 1;
676 xn
= bfd_asymbol_name (x
);
677 yn
= bfd_asymbol_name (y
);
681 /* The symbols gnu_compiled and gcc2_compiled convey even less
682 information than the file name, so sort them out first. */
684 xf
= (strstr (xn
, "gnu_compiled") != NULL
685 || strstr (xn
, "gcc2_compiled") != NULL
);
686 yf
= (strstr (yn
, "gnu_compiled") != NULL
687 || strstr (yn
, "gcc2_compiled") != NULL
);
694 /* We use a heuristic for the file name. It may not work on non
695 Unix systems, but it doesn't really matter; the only difference
696 is precisely which symbol names get printed. */
698 #define file_symbol(s, sn, snl) \
699 (((s)->flags & BSF_FILE) != 0 \
701 && (sn)[(snl) - 2] == '.' \
702 && ((sn)[(snl) - 1] == 'o' \
703 || (sn)[(snl) - 1] == 'a')))
705 xf
= file_symbol (x
, xn
, xnl
);
706 yf
= file_symbol (y
, yn
, ynl
);
713 return non_numeric_forward (P_x
, P_y
);
716 /* This sort routine is used by sort_symbols_by_size. It is sorting
717 an array of size_sym structures into size order. */
720 size_forward2 (const void *P_x
, const void *P_y
)
722 const struct size_sym
*x
= (const struct size_sym
*) P_x
;
723 const struct size_sym
*y
= (const struct size_sym
*) P_y
;
725 if (x
->size
< y
->size
)
726 return reverse_sort
? 1 : -1;
727 else if (x
->size
> y
->size
)
728 return reverse_sort
? -1 : 1;
730 return sorters
[0][reverse_sort
] (x
->minisym
, y
->minisym
);
733 /* Sort the symbols by size. ELF provides a size but for other formats
734 we have to make a guess by assuming that the difference between the
735 address of a symbol and the address of the next higher symbol is the
739 sort_symbols_by_size (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
740 long symcount
, unsigned int size
,
741 struct size_sym
**symsizesp
)
743 struct size_sym
*symsizes
;
744 bfd_byte
*from
, *fromend
;
746 asymbol
*store_sym
, *store_next
;
748 qsort (minisyms
, symcount
, size
, size_forward1
);
750 /* We are going to return a special set of symbols and sizes to
752 symsizes
= (struct size_sym
*) xmalloc (symcount
* sizeof (struct size_sym
));
753 *symsizesp
= symsizes
;
755 /* Note that filter_symbols has already removed all absolute and
756 undefined symbols. Here we remove all symbols whose size winds
758 from
= (bfd_byte
*) minisyms
;
759 fromend
= from
+ symcount
* size
;
766 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
,
769 bfd_fatal (bfd_get_filename (abfd
));
772 for (; from
< fromend
; from
+= size
)
779 if (from
+ size
< fromend
)
781 next
= bfd_minisymbol_to_symbol (abfd
,
783 (const void *) (from
+ size
),
786 bfd_fatal (bfd_get_filename (abfd
));
791 sec
= bfd_asymbol_section (sym
);
793 /* Synthetic symbols don't have a full type set of data available, thus
794 we can't rely on that information for the symbol size. Ditto for
795 bfd/section.c:global_syms like *ABS*. */
796 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
797 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
798 sz
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
799 else if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
800 && bfd_is_com_section (sec
))
804 if (from
+ size
< fromend
805 && sec
== bfd_asymbol_section (next
))
806 sz
= valueof (next
) - valueof (sym
);
808 sz
= (bfd_section_vma (sec
)
809 + bfd_section_size (sec
)
815 symsizes
->minisym
= (const void *) from
;
823 store_sym
= store_next
;
827 symcount
= symsizes
- *symsizesp
;
829 /* We must now sort again by size. */
830 qsort ((void *) *symsizesp
, symcount
, sizeof (struct size_sym
), size_forward2
);
835 /* This function is used to get the relocs for a particular section.
836 It is called via bfd_map_over_sections. */
839 get_relocs (bfd
*abfd
, asection
*sec
, void *dataarg
)
841 struct get_relocs_info
*data
= (struct get_relocs_info
*) dataarg
;
845 if ((sec
->flags
& SEC_RELOC
) == 0)
847 *data
->relocs
= NULL
;
854 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
856 bfd_fatal (bfd_get_filename (abfd
));
858 *data
->relocs
= (arelent
**) xmalloc (relsize
);
859 *data
->relcount
= bfd_canonicalize_reloc (abfd
, sec
, *data
->relocs
,
861 if (*data
->relcount
< 0)
862 bfd_fatal (bfd_get_filename (abfd
));
870 /* Print a single symbol. */
873 print_symbol (bfd
* abfd
,
879 struct extended_symbol_info info
;
883 format
->print_symbol_filename (archive_bfd
, abfd
);
885 bfd_get_symbol_info (abfd
, sym
, &syminfo
);
887 info
.sinfo
= &syminfo
;
889 /* Synthetic symbols do not have a full symbol type set of data available.
890 Nor do bfd/section.c:global_syms like *ABS*. */
891 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) != 0)
894 info
.coffinfo
= NULL
;
898 info
.elfinfo
= elf_symbol_from (abfd
, sym
);
899 info
.coffinfo
= coff_symbol_from (sym
);
902 format
->print_symbol_info (&info
, abfd
);
904 if (with_symbol_versions
)
906 const char * version_string
= NULL
;
907 bfd_boolean hidden
= FALSE
;
909 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
910 version_string
= bfd_get_symbol_version_string (abfd
, sym
,
913 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
916 if (version_string
&& *version_string
!= '\0')
917 printf (hidden
? "@%s" : "@@%s", version_string
);
922 static asymbol
**syms
;
923 static long symcount
;
924 const char *filename
, *functionname
;
927 /* We need to get the canonical symbols in order to call
928 bfd_find_nearest_line. This is inefficient, but, then, you
929 don't have to use --line-numbers. */
930 if (abfd
!= lineno_cache_bfd
&& syms
!= NULL
)
939 symsize
= bfd_get_symtab_upper_bound (abfd
);
941 bfd_fatal (bfd_get_filename (abfd
));
942 syms
= (asymbol
**) xmalloc (symsize
);
943 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
945 bfd_fatal (bfd_get_filename (abfd
));
946 lineno_cache_bfd
= abfd
;
949 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
951 static asection
**secs
;
952 static arelent
***relocs
;
953 static long *relcount
;
954 static unsigned int seccount
;
958 /* For an undefined symbol, we try to find a reloc for the
959 symbol, and print the line number of the reloc. */
960 if (abfd
!= lineno_cache_rel_bfd
&& relocs
!= NULL
)
962 for (i
= 0; i
< seccount
; i
++)
963 if (relocs
[i
] != NULL
)
975 struct get_relocs_info rinfo
;
977 seccount
= bfd_count_sections (abfd
);
979 secs
= (asection
**) xmalloc (seccount
* sizeof *secs
);
980 relocs
= (arelent
***) xmalloc (seccount
* sizeof *relocs
);
981 relcount
= (long *) xmalloc (seccount
* sizeof *relcount
);
984 rinfo
.relocs
= relocs
;
985 rinfo
.relcount
= relcount
;
987 bfd_map_over_sections (abfd
, get_relocs
, (void *) &rinfo
);
988 lineno_cache_rel_bfd
= abfd
;
991 symname
= bfd_asymbol_name (sym
);
992 for (i
= 0; i
< seccount
; i
++)
996 for (j
= 0; j
< relcount
[i
]; j
++)
1001 if (r
->sym_ptr_ptr
!= NULL
1002 && (*r
->sym_ptr_ptr
)->section
== sym
->section
1003 && (*r
->sym_ptr_ptr
)->value
== sym
->value
1005 bfd_asymbol_name (*r
->sym_ptr_ptr
)) == 0
1006 && bfd_find_nearest_line (abfd
, secs
[i
], syms
,
1007 r
->address
, &filename
,
1008 &functionname
, &lineno
)
1009 && filename
!= NULL
)
1011 /* We only print the first one we find. */
1012 printf ("\t%s:%u", filename
, lineno
);
1019 else if (bfd_asymbol_section (sym
)->owner
== abfd
)
1021 if ((bfd_find_line (abfd
, syms
, sym
, &filename
, &lineno
)
1022 || bfd_find_nearest_line (abfd
, bfd_asymbol_section (sym
),
1023 syms
, sym
->value
, &filename
,
1024 &functionname
, &lineno
))
1027 printf ("\t%s:%u", filename
, lineno
);
1034 /* Print the symbols when sorting by size. */
1037 print_size_symbols (bfd
* abfd
,
1038 bfd_boolean is_dynamic
,
1039 struct size_sym
* symsizes
,
1044 struct size_sym
*from
;
1045 struct size_sym
*fromend
;
1047 store
= bfd_make_empty_symbol (abfd
);
1049 bfd_fatal (bfd_get_filename (abfd
));
1052 fromend
= from
+ symcount
;
1054 for (; from
< fromend
; from
++)
1058 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
->minisym
, store
);
1060 bfd_fatal (bfd_get_filename (abfd
));
1062 print_symbol (abfd
, sym
, from
->size
, archive_bfd
);
1067 /* Print the symbols of ABFD that are held in MINISYMS.
1069 If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1071 SYMCOUNT is the number of symbols in MINISYMS.
1073 SIZE is the size of a symbol in MINISYMS. */
1076 print_symbols (bfd
* abfd
,
1077 bfd_boolean is_dynamic
,
1087 store
= bfd_make_empty_symbol (abfd
);
1089 bfd_fatal (bfd_get_filename (abfd
));
1091 from
= (bfd_byte
*) minisyms
;
1092 fromend
= from
+ symcount
* size
;
1094 for (; from
< fromend
; from
+= size
)
1098 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
, store
);
1100 bfd_fatal (bfd_get_filename (abfd
));
1102 print_symbol (abfd
, sym
, (bfd_vma
) 0, archive_bfd
);
1106 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1109 display_rel_file (bfd
*abfd
, bfd
*archive_bfd
)
1114 struct size_sym
*symsizes
;
1115 asymbol
*synthsyms
= NULL
;
1119 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1121 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1126 symcount
= bfd_read_minisymbols (abfd
, dynamic
, &minisyms
, &size
);
1129 if (dynamic
&& bfd_get_error () == bfd_error_no_symbols
)
1131 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1135 bfd_fatal (bfd_get_filename (abfd
));
1140 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1144 if (show_synthetic
&& size
== sizeof (asymbol
*))
1146 asymbol
**static_syms
= NULL
;
1147 asymbol
**dyn_syms
= NULL
;
1148 long static_count
= 0;
1154 dyn_count
= symcount
;
1155 dyn_syms
= (asymbol
**) minisyms
;
1159 long storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1161 static_count
= symcount
;
1162 static_syms
= (asymbol
**) minisyms
;
1166 dyn_syms
= (asymbol
**) xmalloc (storage
);
1167 dyn_count
= bfd_canonicalize_dynamic_symtab (abfd
, dyn_syms
);
1169 bfd_fatal (bfd_get_filename (abfd
));
1173 synth_count
= bfd_get_synthetic_symtab (abfd
, static_count
, static_syms
,
1174 dyn_count
, dyn_syms
, &synthsyms
);
1175 if (synth_count
> 0)
1180 minisyms
= xrealloc (minisyms
,
1181 (symcount
+ synth_count
+ 1) * sizeof (*symp
));
1182 symp
= (asymbol
**) minisyms
+ symcount
;
1183 for (i
= 0; i
< synth_count
; i
++)
1184 *symp
++ = synthsyms
+ i
;
1186 symcount
+= synth_count
;
1188 if (!dynamic
&& dyn_syms
!= NULL
)
1192 /* lto_slim_object is set to false when a bfd is loaded with a compiler
1194 if (abfd
->lto_slim_object
)
1196 report_plugin_err
= FALSE
;
1197 non_fatal (_("%s: plugin needed to handle lto object"),
1198 bfd_get_filename (abfd
));
1201 /* Discard the symbols we don't want to print.
1202 It's OK to do this in place; we'll free the storage anyway
1203 (after printing). */
1205 symcount
= filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
);
1211 sort_dynamic
= dynamic
;
1212 sort_x
= bfd_make_empty_symbol (abfd
);
1213 sort_y
= bfd_make_empty_symbol (abfd
);
1214 if (sort_x
== NULL
|| sort_y
== NULL
)
1215 bfd_fatal (bfd_get_filename (abfd
));
1218 qsort (minisyms
, symcount
, size
,
1219 sorters
[sort_numerically
][reverse_sort
]);
1221 symcount
= sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
,
1226 print_symbols (abfd
, dynamic
, minisyms
, symcount
, size
, archive_bfd
);
1228 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, archive_bfd
);
1236 /* Construct a formatting string for printing symbol values. */
1239 get_print_format (void)
1241 const char * padding
;
1242 if (print_format
== FORMAT_POSIX
)
1244 /* POSIX compatible output does not have any padding. */
1247 else if (print_width
== 32)
1251 else /* print_width == 64 */
1256 const char * length
= "l";
1257 if (print_width
== 64)
1259 #if BFD_HOST_64BIT_LONG
1261 #elif BFD_HOST_64BIT_LONG_LONG
1270 const char * radix
= NULL
;
1271 switch (print_radix
)
1273 case 8: radix
= "o"; break;
1274 case 10: radix
= "d"; break;
1275 case 16: radix
= "x"; break;
1278 return concat ("%", padding
, length
, radix
, NULL
);
1282 set_print_width (bfd
*file
)
1284 print_width
= bfd_get_arch_size (file
);
1286 if (print_width
== -1)
1289 Guess the target's bitsize based on its name.
1290 We assume here than any 64-bit format will include
1291 "64" somewhere in its name. The only known exception
1292 is the MMO object file format. */
1293 if (strstr (bfd_get_target (file
), "64") != NULL
1294 || strcmp (bfd_get_target (file
), "mmo") == 0)
1299 free ((char *) print_format_string
);
1300 print_format_string
= get_print_format ();
1304 display_archive (bfd
*file
)
1307 bfd
*last_arfile
= NULL
;
1310 format
->print_archive_filename (bfd_get_filename (file
));
1313 print_symdef_entry (file
);
1319 arfile
= bfd_openr_next_archived_file (file
, arfile
);
1323 if (bfd_get_error () != bfd_error_no_more_archived_files
)
1324 bfd_fatal (bfd_get_filename (file
));
1328 if (bfd_check_format_matches (arfile
, bfd_object
, &matching
))
1330 set_print_width (arfile
);
1331 format
->print_archive_member (bfd_get_filename (file
),
1332 bfd_get_filename (arfile
));
1333 display_rel_file (arfile
, file
);
1337 bfd_nonfatal (bfd_get_filename (arfile
));
1338 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1340 list_matching_formats (matching
);
1345 if (last_arfile
!= NULL
)
1347 bfd_close (last_arfile
);
1348 lineno_cache_bfd
= NULL
;
1349 lineno_cache_rel_bfd
= NULL
;
1350 if (arfile
== last_arfile
)
1353 last_arfile
= arfile
;
1356 if (last_arfile
!= NULL
)
1358 bfd_close (last_arfile
);
1359 lineno_cache_bfd
= NULL
;
1360 lineno_cache_rel_bfd
= NULL
;
1365 display_file (char *filename
)
1367 bfd_boolean retval
= TRUE
;
1371 if (get_file_size (filename
) < 1)
1374 file
= bfd_openr (filename
, target
? target
: plugin_target
);
1377 bfd_nonfatal (filename
);
1381 /* If printing line numbers, decompress the debug sections. */
1383 file
->flags
|= BFD_DECOMPRESS
;
1385 if (bfd_check_format (file
, bfd_archive
))
1387 display_archive (file
);
1389 else if (bfd_check_format_matches (file
, bfd_object
, &matching
))
1391 set_print_width (file
);
1392 format
->print_object_filename (filename
);
1393 display_rel_file (file
, NULL
);
1397 bfd_nonfatal (filename
);
1398 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1400 list_matching_formats (matching
);
1406 if (!bfd_close (file
))
1407 bfd_fatal (filename
);
1409 lineno_cache_bfd
= NULL
;
1410 lineno_cache_rel_bfd
= NULL
;
1415 /* The following 3 groups of functions are called unconditionally,
1416 once at the start of processing each file of the appropriate type.
1417 They should check `filename_per_file' and `filename_per_symbol',
1418 as appropriate for their output format, to determine whether to
1421 /* Print the name of an object file given on the command line. */
1424 print_object_filename_bsd (const char *filename
)
1426 if (filename_per_file
&& !filename_per_symbol
)
1427 printf ("\n%s:\n", filename
);
1431 print_object_filename_sysv (const char *filename
)
1434 printf (_("\n\nUndefined symbols from %s:\n\n"), filename
);
1436 printf (_("\n\nSymbols from %s:\n\n"), filename
);
1437 if (print_width
== 32)
1439 Name Value Class Type Size Line Section\n\n"));
1442 Name Value Class Type Size Line Section\n\n"));
1446 print_object_filename_posix (const char *filename
)
1448 if (filename_per_file
&& !filename_per_symbol
)
1449 printf ("%s:\n", filename
);
1452 /* Print the name of an archive file given on the command line. */
1455 print_archive_filename_bsd (const char *filename
)
1457 if (filename_per_file
)
1458 printf ("\n%s:\n", filename
);
1462 print_archive_filename_sysv (const char *filename ATTRIBUTE_UNUSED
)
1467 print_archive_filename_posix (const char *filename ATTRIBUTE_UNUSED
)
1471 /* Print the name of an archive member file. */
1474 print_archive_member_bsd (const char *archive ATTRIBUTE_UNUSED
,
1475 const char *filename
)
1477 if (!filename_per_symbol
)
1478 printf ("\n%s:\n", filename
);
1482 print_archive_member_sysv (const char *archive
, const char *filename
)
1485 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive
, filename
);
1487 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive
, filename
);
1488 if (print_width
== 32)
1490 Name Value Class Type Size Line Section\n\n"));
1493 Name Value Class Type Size Line Section\n\n"));
1497 print_archive_member_posix (const char *archive
, const char *filename
)
1499 if (!filename_per_symbol
)
1500 printf ("%s[%s]:\n", archive
, filename
);
1503 /* Print the name of the file (and archive, if there is one)
1504 containing a symbol. */
1507 print_symbol_filename_bsd (bfd
*archive_bfd
, bfd
*abfd
)
1509 if (filename_per_symbol
)
1512 printf ("%s:", bfd_get_filename (archive_bfd
));
1513 printf ("%s:", bfd_get_filename (abfd
));
1518 print_symbol_filename_sysv (bfd
*archive_bfd
, bfd
*abfd
)
1520 if (filename_per_symbol
)
1523 printf ("%s:", bfd_get_filename (archive_bfd
));
1524 printf ("%s:", bfd_get_filename (abfd
));
1529 print_symbol_filename_posix (bfd
*archive_bfd
, bfd
*abfd
)
1531 if (filename_per_symbol
)
1534 printf ("%s[%s]: ", bfd_get_filename (archive_bfd
),
1535 bfd_get_filename (abfd
));
1537 printf ("%s: ", bfd_get_filename (abfd
));
1541 /* Print a symbol value. */
1544 print_value (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_vma val
)
1546 switch (print_width
)
1549 printf (print_format_string
, (unsigned long) val
);
1553 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1554 printf (print_format_string
, val
);
1556 /* We have a 64 bit value to print, but the host is only 32 bit. */
1557 if (print_radix
== 16)
1558 bfd_fprintf_vma (abfd
, stdout
, val
);
1564 s
= buf
+ sizeof buf
;
1568 *--s
= (val
% print_radix
) + '0';
1571 while ((buf
+ sizeof buf
- 1) - s
< 16)
1579 fatal (_("Print width has not been initialized (%d)"), print_width
);
1584 /* Print a line of information about a symbol. */
1587 print_symbol_info_bsd (struct extended_symbol_info
*info
, bfd
*abfd
)
1589 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1591 if (print_width
== 64)
1597 /* Normally we print the value of the symbol. If we are printing the
1598 size or sorting by size then we print its size, except for the
1599 (weird) special case where both flags are defined, in which case we
1600 print both values. This conforms to documented behaviour. */
1601 if (sort_by_size
&& !print_size
)
1602 print_value (abfd
, SYM_SIZE (info
));
1604 print_value (abfd
, SYM_VALUE (info
));
1605 if (print_size
&& SYM_SIZE (info
))
1608 print_value (abfd
, SYM_SIZE (info
));
1612 printf (" %c", SYM_TYPE (info
));
1614 if (SYM_TYPE (info
) == '-')
1618 printf (other_format
, SYM_STAB_OTHER (info
));
1620 printf (desc_format
, SYM_STAB_DESC (info
));
1621 printf (" %5s", SYM_STAB_NAME (info
));
1623 print_symname (" %s", info
, NULL
, abfd
);
1627 print_symbol_info_sysv (struct extended_symbol_info
*info
, bfd
*abfd
)
1629 print_symname ("%-20s|", info
, NULL
, abfd
);
1631 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1633 if (print_width
== 32)
1639 print_value (abfd
, SYM_VALUE (info
));
1641 printf ("| %c |", SYM_TYPE (info
));
1643 if (SYM_TYPE (info
) == '-')
1646 printf ("%18s| ", SYM_STAB_NAME (info
)); /* (C) Type. */
1647 printf (desc_format
, SYM_STAB_DESC (info
)); /* Size. */
1648 printf ("| |"); /* Line, Section. */
1652 /* Type, Size, Line, Section */
1655 get_elf_symbol_type (ELF_ST_TYPE (info
->elfinfo
->internal_elf_sym
.st_info
)));
1656 else if (info
->coffinfo
)
1658 get_coff_symbol_type (&info
->coffinfo
->native
->u
.syment
));
1662 if (SYM_SIZE (info
))
1663 print_value (abfd
, SYM_SIZE (info
));
1666 if (print_width
== 32)
1673 printf("| |%s", info
->elfinfo
->symbol
.section
->name
);
1674 else if (info
->coffinfo
)
1675 printf("| |%s", info
->coffinfo
->symbol
.section
->name
);
1682 print_symbol_info_posix (struct extended_symbol_info
*info
, bfd
*abfd
)
1684 print_symname ("%s ", info
, NULL
, abfd
);
1685 printf ("%c ", SYM_TYPE (info
));
1687 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1691 print_value (abfd
, SYM_VALUE (info
));
1693 if (SYM_SIZE (info
))
1694 print_value (abfd
, SYM_SIZE (info
));
1699 main (int argc
, char **argv
)
1704 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1705 setlocale (LC_MESSAGES
, "");
1707 #if defined (HAVE_SETLOCALE)
1708 setlocale (LC_CTYPE
, "");
1709 setlocale (LC_COLLATE
, "");
1711 bindtextdomain (PACKAGE
, LOCALEDIR
);
1712 textdomain (PACKAGE
);
1714 program_name
= *argv
;
1715 xmalloc_set_program_name (program_name
);
1716 bfd_set_error_program_name (program_name
);
1717 #if BFD_SUPPORTS_PLUGINS
1718 bfd_plugin_set_program_name (program_name
);
1721 START_PROGRESS (program_name
, 0);
1723 expandargv (&argc
, &argv
);
1725 if (bfd_init () != BFD_INIT_MAGIC
)
1726 fatal (_("fatal error: libbfd ABI mismatch"));
1727 set_default_bfd_target ();
1729 while ((c
= getopt_long (argc
, argv
, "aABCDef:gHhlnopPrSst:uvVvX:",
1730 long_options
, (int *) 0)) != EOF
)
1735 print_debug_syms
= 1;
1739 filename_per_symbol
= 1;
1741 case 'B': /* For MIPS compatibility. */
1742 set_output_format ("bsd");
1748 enum demangling_styles style
;
1750 style
= cplus_demangle_name_to_style (optarg
);
1751 if (style
== unknown_demangling
)
1752 fatal (_("unknown demangling style `%s'"),
1755 cplus_demangle_set_style (style
);
1758 case OPTION_RECURSE_LIMIT
:
1759 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
1761 case OPTION_NO_RECURSE_LIMIT
:
1762 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
1768 /* Ignored for HP/UX compatibility. */
1771 set_output_format (optarg
);
1785 sort_numerically
= 1;
1790 sort_numerically
= 0;
1793 case OPTION_SIZE_SORT
:
1795 sort_numerically
= 0;
1799 set_output_format ("posix");
1811 set_print_radix (optarg
);
1820 /* Ignored for (partial) AIX compatibility. On AIX, the
1821 argument has values 32, 64, or 32_64, and specifies that
1822 only 32-bit, only 64-bit, or both kinds of objects should
1823 be examined. The default is 32. So plain AIX nm on a
1824 library archive with both kinds of objects will ignore
1825 the 64-bit ones. For GNU nm, the default is and always
1826 has been -X 32_64, and other options are not supported. */
1827 if (strcmp (optarg
, "32_64") != 0)
1828 fatal (_("Only -X 32_64 is supported"));
1831 case OPTION_TARGET
: /* --target */
1835 case OPTION_PLUGIN
: /* --plugin */
1836 #if BFD_SUPPORTS_PLUGINS
1837 bfd_plugin_set_plugin (optarg
);
1839 fatal (_("sorry - this program has been built without plugin support\n"));
1843 case 0: /* A long option that just sets a flag. */
1852 print_version ("nm");
1854 if (sort_by_size
&& undefined_only
)
1856 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1857 non_fatal (_("will produce no output, since undefined symbols have no size."));
1861 /* OK, all options now parsed. If no filename specified, do a.out. */
1863 return !display_file ("a.out");
1867 if (argc
- optind
> 1)
1868 filename_per_file
= 1;
1870 /* We were given several filenames to do. */
1871 while (optind
< argc
)
1874 if (!display_file (argv
[optind
++]))
1878 END_PROGRESS (program_name
);