/* nm.c -- Describe symbol table of a rel file.
- Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
- 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012
- Free Software Foundation, Inc.
+ Copyright (C) 1991-2016 Free Software Foundation, Inc.
This file is part of GNU Binutils.
#include "libiberty.h"
#include "elf-bfd.h"
#include "elf/common.h"
+#define DO_NOT_DEFINE_AOUTHDR
+#define DO_NOT_DEFINE_FILHDR
+#define DO_NOT_DEFINE_LINENO
+#define DO_NOT_DEFINE_SCNHDR
+#include "coff/external.h"
+#include "coff/internal.h"
+#include "libcoff.h"
#include "bucomm.h"
+#include "plugin-api.h"
#include "plugin.h"
/* When sorting by size, we use this structure to hold the size and a
symbol_info *sinfo;
bfd_vma ssize;
elf_symbol_type *elfinfo;
+ coff_symbol_type *coffinfo;
/* FIXME: We should add more fields for Type, Line, Section. */
};
#define SYM_NAME(sym) (sym->sinfo->name)
static char desc_format[] = "%04x";
static char *target = NULL;
-static char *plugin_target = NULL;
+#if BFD_SUPPORTS_PLUGINS
+static const char *plugin_target = "plugin";
+#else
+static const char *plugin_target = NULL;
+#endif
/* Used to cache the line numbers for a BFD. */
static bfd *lineno_cache_bfd;
}
\f
static const char *
-get_symbol_type (unsigned int type)
+get_elf_symbol_type (unsigned int type)
{
- static char buff [32];
+ static char *bufp;
+ int n;
switch (type)
{
case STT_FILE: return "FILE";
case STT_COMMON: return "COMMON";
case STT_TLS: return "TLS";
- default:
- if (type >= STT_LOPROC && type <= STT_HIPROC)
- sprintf (buff, _("<processor specific>: %d"), type);
- else if (type >= STT_LOOS && type <= STT_HIOS)
- sprintf (buff, _("<OS specific>: %d"), type);
- else
- sprintf (buff, _("<unknown>: %d"), type);
- return buff;
}
+
+ free (bufp);
+ if (type >= STT_LOPROC && type <= STT_HIPROC)
+ n = asprintf (&bufp, _("<processor specific>: %d"), type);
+ else if (type >= STT_LOOS && type <= STT_HIOS)
+ n = asprintf (&bufp, _("<OS specific>: %d"), type);
+ else
+ n = asprintf (&bufp, _("<unknown>: %d"), type);
+ if (n < 0)
+ fatal ("%s", xstrerror (errno));
+ return bufp;
+}
+
+static const char *
+get_coff_symbol_type (const struct internal_syment *sym)
+{
+ static char *bufp;
+ int n;
+
+ switch (sym->n_sclass)
+ {
+ case C_BLOCK: return "Block";
+ case C_FILE: return "File";
+ case C_LINE: return "Line";
+ }
+
+ if (!sym->n_type)
+ return "None";
+
+ switch (DTYPE(sym->n_type))
+ {
+ case DT_FCN: return "Function";
+ case DT_PTR: return "Pointer";
+ case DT_ARY: return "Array";
+ }
+
+ free (bufp);
+ n = asprintf (&bufp, _("<unknown>: %d/%d"), sym->n_sclass, sym->n_type);
+ if (n < 0)
+ fatal ("%s", xstrerror (errno));
+ return bufp;
}
\f
/* Print symbol name NAME, read from ABFD, with printf format FORM,
if (sym == NULL)
bfd_fatal (bfd_get_filename (abfd));
+ if (strcmp (sym->name, "__gnu_lto_slim") == 0)
+ non_fatal (_("%s: plugin needed to handle lto object"),
+ bfd_get_filename (abfd));
+
if (undefined_only)
keep = bfd_is_und_section (sym->section);
else if (external_only)
/* Print a single symbol. */
static void
-print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
+print_symbol (bfd * abfd,
+ asymbol * sym,
+ bfd_vma ssize,
+ bfd * archive_bfd)
{
symbol_info syminfo;
struct extended_symbol_info info;
format->print_symbol_filename (archive_bfd, abfd);
bfd_get_symbol_info (abfd, sym, &syminfo);
+
info.sinfo = &syminfo;
info.ssize = ssize;
- if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
- info.elfinfo = (elf_symbol_type *) sym;
+ /* Synthetic symbols do not have a full symbol type set of data available. */
+ if ((sym->flags & BSF_SYNTHETIC) != 0)
+ {
+ info.elfinfo = NULL;
+ info.coffinfo = NULL;
+ }
else
- info.elfinfo = NULL;
+ {
+ info.elfinfo = elf_symbol_from (abfd, sym);
+ info.coffinfo = coff_symbol_from (sym);
+ }
+
format->print_symbol_info (&info, abfd);
if (line_numbers)
/* Print the symbols when sorting by size. */
static void
-print_size_symbols (bfd *abfd, bfd_boolean is_dynamic,
- struct size_sym *symsizes, long symcount,
- bfd *archive_bfd)
+print_size_symbols (bfd * abfd,
+ bfd_boolean is_dynamic,
+ struct size_sym * symsizes,
+ long symcount,
+ bfd * archive_bfd)
{
asymbol *store;
- struct size_sym *from, *fromend;
+ struct size_sym *from;
+ struct size_sym *fromend;
store = bfd_make_empty_symbol (abfd);
if (store == NULL)
from = symsizes;
fromend = from + symcount;
+
for (; from < fromend; from++)
{
asymbol *sym;
}
\f
-/* Print the symbols. If ARCHIVE_BFD is non-NULL, it is the archive
- containing ABFD. */
+/* Print the symbols of ABFD that are held in MINISYMS.
+
+ If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
+
+ SYMCOUNT is the number of symbols in MINISYMS.
+
+ SIZE is the size of a symbol in MINISYMS. */
static void
-print_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms, long symcount,
- unsigned int size, bfd *archive_bfd)
+print_symbols (bfd * abfd,
+ bfd_boolean is_dynamic,
+ void * minisyms,
+ long symcount,
+ unsigned int size,
+ bfd * archive_bfd)
{
asymbol *store;
- bfd_byte *from, *fromend;
+ bfd_byte *from;
+ bfd_byte *fromend;
store = bfd_make_empty_symbol (abfd);
if (store == NULL)
from = (bfd_byte *) minisyms;
fromend = from + symcount * size;
+
for (; from < fromend; from += size)
{
asymbol *sym;
if (show_synthetic && size == sizeof (asymbol *))
{
asymbol *synthsyms;
- long synth_count;
asymbol **static_syms = NULL;
asymbol **dyn_syms = NULL;
long static_count = 0;
long dyn_count = 0;
+ long synth_count;
if (dynamic)
{
bfd_fatal (bfd_get_filename (abfd));
}
}
+
synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
dyn_count, dyn_syms, &synthsyms);
if (synth_count > 0)
bfd_close (last_arfile);
lineno_cache_bfd = NULL;
lineno_cache_rel_bfd = NULL;
+ if (arfile == last_arfile)
+ return;
}
last_arfile = arfile;
}
print_value (abfd, SYM_SIZE (info));
else
print_value (abfd, SYM_VALUE (info));
-
if (print_size && SYM_SIZE (info))
{
printf (" ");
/* Type, Size, Line, Section */
if (info->elfinfo)
printf ("%18s|",
- get_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
+ get_elf_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
+ else if (info->coffinfo)
+ printf ("%18s|",
+ get_coff_symbol_type (&info->coffinfo->native->u.syment));
else
printf (" |");
if (info->elfinfo)
printf("| |%s", info->elfinfo->symbol.section->name);
+ else if (info->coffinfo)
+ printf("| |%s", info->coffinfo->symbol.section->name);
else
printf("| |");
}
program_name = *argv;
xmalloc_set_program_name (program_name);
+ bfd_set_error_program_name (program_name);
#if BFD_SUPPORTS_PLUGINS
bfd_plugin_set_program_name (program_name);
#endif
case OPTION_PLUGIN: /* --plugin */
#if BFD_SUPPORTS_PLUGINS
- plugin_target = "plugin";
bfd_plugin_set_plugin (optarg);
#else
fatal (_("sorry - this program has been built without plugin support\n"));
projects / deliverable / binutils-gdb.git / blobdiff