OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* nm.c (print_symdef_entry): Check return value of 

bfd_get_elt_at_index.
This commit is contained in:
Ian Lance Taylor 1995-12-26 23:20:35 +00:00
parent 54fe92c5a1
commit 5d0bc3b9df
2 changed files with 399 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
binutils/ChangeLog
View File

@ -1,3 +1,8 @@
Tue Dec 26 18:23:18 1995 Ian Lance Taylor <ian@cygnus.com>
* nm.c (print_symdef_entry): Check return value of
bfd_get_elt_at_index.
Sat Dec 23 11:03:16 1995 Michael Meissner <meissner@tiktok.cgynsu.com>
* configure.in (DLLTOOL_DEFS): Build dlltool for PowerPC if target

586
binutils/nm.c
View File

@ -15,10 +15,9 @@
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "bfd.h"
#include "sysdep.h"
#include "progress.h"
#include "bucomm.h"
#include "getopt.h"
@ -27,21 +26,36 @@
#include "demangle.h"
#include "libiberty.h"
/* When sorting by size, we use this structure to hold the size and a
pointer to the minisymbol. */
struct size_sym
{
const PTR minisym;
bfd_vma size;
};
static boolean
display_file PARAMS ((char *filename));
static void
display_rel_file PARAMS ((bfd * file, bfd * archive));
static unsigned int
filter_symbols PARAMS ((bfd * file, asymbol ** syms, unsigned long symcount));
static long
filter_symbols PARAMS ((bfd *, boolean, PTR, long, unsigned int));
static unsigned int
sort_symbols_by_size PARAMS ((bfd *, asymbol **, unsigned long));
static long
sort_symbols_by_size PARAMS ((bfd *, boolean, PTR, long, unsigned int,
struct size_sym **));
static void
print_symbols PARAMS ((bfd * file, asymbol ** syms, unsigned long symcount,
bfd * archive));
print_symbols PARAMS ((bfd *, boolean, PTR, long, unsigned int, bfd *));
static void
print_size_symbols PARAMS ((bfd *, boolean, struct size_sym *, long, bfd *));
static void
print_symbol PARAMS ((bfd *, asymbol *, bfd *));
static void
print_symdef_entry PARAMS ((bfd * abfd));
@ -61,7 +75,10 @@ static int
non_numeric_reverse PARAMS ((const PTR, const PTR));
static int
size_forward PARAMS ((const PTR, const PTR));
size_forward1 PARAMS ((const PTR, const PTR));
static int
size_forward2 PARAMS ((const PTR, const PTR));
/* The output formatting functions. */
@ -105,6 +122,9 @@ static void
print_symbol_filename_posix PARAMS ((bfd * archive_bfd, bfd * abfd));
static void
print_value PARAMS ((bfd_vma));
static void
print_symbol_info_bsd PARAMS ((symbol_info * info, bfd * abfd));
@ -176,17 +196,23 @@ static int sort_by_size = 0; /* sort by size of symbol */
static int undefined_only = 0; /* print undefined symbols only */
static int dynamic = 0; /* print dynamic symbols. */
static int show_version = 0; /* show the version number */
static int show_stats = 0; /* show statistics */
/* When to print the names of files. Not mutually exclusive in SYSV format. */
static int filename_per_file = 0; /* Once per file, on its own line. */
static int filename_per_symbol = 0; /* Once per symbol, at start of line. */
/* Print formats for printing a symbol value. */
#ifdef BFD_HOST_64_BIT
static char value_format[] = "%08x%08x";
#else
#ifndef BFD64
static char value_format[] = "%08lx";
#else
#if BFD_HOST_64BIT_LONG
static char value_format[] = "%016lx";
#else
/* We don't use value_format for this case. */
#endif
#endif
static int print_radix = 16;
/* Print formats for printing stab info. */
static char other_format[] = "%02x";
static char desc_format[] = "%04x";
@ -215,6 +241,7 @@ static struct option long_options[] =
{"radix", required_argument, 0, 't'},
{"reverse-sort", no_argument, &reverse_sort, 1},
{"size-sort", no_argument, &sort_by_size, 1},
{"stats", no_argument, &show_stats, 1},
{"target", required_argument, 0, 200},
{"undefined-only", no_argument, &undefined_only, 1},
{"version", no_argument, &show_version, 1},
@ -249,13 +276,23 @@ set_print_radix (radix)
{
switch (*radix)
{
case 'x':
break;
case 'd':
case 'o':
case 'x':
#ifdef BFD_HOST_64_BIT
value_format[3] = value_format[7] = *radix;
#else
if (*radix == 'd')
print_radix = 10;
else
print_radix = 8;
#ifndef BFD64
value_format[4] = *radix;
#else
#if BFD_HOST_64BIT_LONG
value_format[5] = *radix;
#else
/* This case requires special handling for octal and decimal
printing. */
#endif
#endif
other_format[3] = desc_format[3] = *radix;
break;
@ -307,7 +344,7 @@ main (argc, argv)
bfd_init ();
while ((c = getopt_long (argc, argv, "aABCDf:gnopPrst:uvV", long_options, (int *) 0)) != EOF)
while ((c = getopt_long (argc, argv, "aABCDef:gnopPrst:uvV", long_options, (int *) 0)) != EOF)
{
switch (c)
{
@ -327,6 +364,9 @@ main (argc, argv)
case 'D':
dynamic = 1;
break;
case 'e':
/* Ignored for HP/UX compatibility. */
break;
case 'f':
set_output_format (optarg);
break;
@ -398,6 +438,17 @@ main (argc, argv)
END_PROGRESS (program_name);
#ifdef HAVE_SBRK
if (show_stats)
{
extern char **environ;
char *lim = (char *) sbrk (0);
fprintf (stderr, "%s: data size %ld\n", program_name,
(long) (lim - (char *) &environ));
}
#endif
exit (retval);
return retval;
}
@ -494,34 +545,46 @@ display_file (filename)
return retval;
}
/* These globals are used to pass information into the sorting
routines. */
static bfd *sort_bfd;
static boolean sort_dynamic;
static asymbol *sort_x;
static asymbol *sort_y;
/* Symbol-sorting predicates */
#define valueof(x) ((x)->section->vma + (x)->value)
/* Numeric sorts. Undefined symbols are always considered "less than"
defined symbols with zero values. Common symbols are not treated
specially -- i.e., their sizes are used as their "values". */
static int
numeric_forward (P_x, P_y)
const PTR P_x;
const PTR P_y;
{
asymbol *x = *(asymbol **) P_x;
asymbol *y = *(asymbol **) P_y;
asection *xs = bfd_get_section (x);
asection *ys = bfd_get_section (y);
asymbol *x, *y;
asection *xs, *ys;
x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
if (x == NULL || y == NULL)
bfd_fatal (bfd_get_filename (sort_bfd));
xs = bfd_get_section (x);
ys = bfd_get_section (y);
if (bfd_is_und_section (xs))
{
if (bfd_is_und_section (ys))
goto equal;
return -1;
if (! bfd_is_und_section (ys))
return -1;
}
else if (bfd_is_und_section (ys))
return 1;
/* Don't just return the difference -- in cross configurations,
after truncation to `int' it might not have the sign we want. */
if (valueof (x) != valueof (y))
else if (valueof (x) != valueof (y))
return valueof (x) < valueof (y) ? -1 : 1;
equal:
return non_numeric_forward (P_x, P_y);
}
@ -530,16 +593,24 @@ numeric_reverse (x, y)
const PTR x;
const PTR y;
{
return -numeric_forward (x, y);
return - numeric_forward (x, y);
}
static int
non_numeric_forward (x, y)
const PTR x;
const PTR y;
non_numeric_forward (P_x, P_y)
const PTR P_x;
const PTR P_y;
{
CONST char *xn = (*(asymbol **) x)->name;
CONST char *yn = (*(asymbol **) y)->name;
asymbol *x, *y;
const char *xn, *yn;
x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
if (x == NULL || y == NULL)
bfd_fatal (bfd_get_filename (sort_bfd));
xn = bfd_asymbol_name (x);
yn = bfd_asymbol_name (y);
return ((xn == NULL) ? ((yn == NULL) ? 0 : -1) :
((yn == NULL) ? 1 : strcmp (xn, yn)));
@ -550,7 +621,7 @@ non_numeric_reverse (x, y)
const PTR x;
const PTR y;
{
return -non_numeric_forward (x, y);
return - non_numeric_forward (x, y);
}
static int (*(sorters[2][2])) PARAMS ((const PTR, const PTR)) =
@ -571,20 +642,23 @@ static int (*(sorters[2][2])) PARAMS ((const PTR, const PTR)) =
value. */
static int
size_forward (P_x, P_y)
size_forward1 (P_x, P_y)
const PTR P_x;
const PTR P_y;
{
asymbol *x = *(asymbol **) P_x;
asymbol *y = *(asymbol **) P_y;
asection *xs = bfd_get_section (x);
asection *ys = bfd_get_section (y);
const char *xn;
const char *yn;
size_t xnl;
size_t ynl;
int xf;
int yf;
asymbol *x, *y;
asection *xs, *ys;
const char *xn, *yn;
size_t xnl, ynl;
int xf, yf;
x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
if (x == NULL || y == NULL)
bfd_fatal (bfd_get_filename (sort_bfd));
xs = bfd_get_section (x);
ys = bfd_get_section (y);
if (bfd_is_und_section (xs))
abort ();
@ -620,10 +694,10 @@ size_forward (P_x, P_y)
is precisely which symbol names get printed. */
#define file_symbol(s, sn, snl) \
((s->flags & BSF_FILE) != 0 \
|| (sn[snl - 2] == '.' \
&& (sn[snl - 1] == 'o' \
|| sn[snl - 1] == 'a')))
(((s)->flags & BSF_FILE) != 0 \
|| ((sn)[(snl) - 2] == '.' \
&& ((sn)[(snl) - 1] == 'o' \
|| (sn)[(snl) - 1] == 'a')))
xf = file_symbol (x, xn, xnl);
yf = file_symbol (y, yn, ynl);
@ -636,63 +710,121 @@ size_forward (P_x, P_y)
return non_numeric_forward (P_x, P_y);
}
/* This sort routine is used by sort_symbols_by_size. It is sorting
an array of size_sym structures into size order. */
static int
size_forward2 (P_x, P_y)
const PTR P_x;
const PTR P_y;
{
const struct size_sym *x = (const struct size_sym *) P_x;
const struct size_sym *y = (const struct size_sym *) P_y;
if (x->size < y->size)
return reverse_sort ? 1 : -1;
else if (x->size > y->size)
return reverse_sort ? -1 : 1;
else
return sorters[0][reverse_sort] (x->minisym, y->minisym);
}
/* Sort the symbols by size. We guess the size by assuming that the
difference between the address of a symbol and the address of the
next higher symbol is the size. FIXME: ELF actually stores a size
with each symbol. We should use it. */
static unsigned int
sort_symbols_by_size (abfd, syms, symcount)
static long
sort_symbols_by_size (abfd, dynamic, minisyms, symcount, size, symsizesp)
bfd *abfd;
asymbol **syms;
unsigned long symcount;
boolean dynamic;
PTR minisyms;
long symcount;
unsigned int size;
struct size_sym **symsizesp;
{
asymbol **from, **to;
unsigned int src_count;
unsigned int dst_count = 0;
struct size_sym *symsizes;
bfd_byte *from, *fromend;
asymbol *sym;
asection *sec;
asymbol *store_sym, *store_next;
qsort ((PTR) syms, symcount, sizeof (asymbol *), size_forward);
qsort (minisyms, symcount, size, size_forward1);
/* We are going to return a special set of symbols and sizes to
print. */
symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
*symsizesp = symsizes;
/* Note that filter_symbols has already removed all absolute and
undefined symbols. Here we remove all symbols whose size winds
up as zero. */
for (from = to = syms, src_count = 0; src_count < symcount; src_count++)
{
bfd_vma size;
from = (bfd_byte *) minisyms;
fromend = from + symcount * size;
store_sym = sort_x;
store_next = sort_y;
if (from < fromend)
{
sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const PTR) from,
store_sym);
if (sym == NULL)
bfd_fatal (bfd_get_filename (abfd));
}
for (; from < fromend; from += size)
{
asymbol *next;
asection *sec;
bfd_vma sz;
asymbol *temp;
if (from + size < fromend)
{
next = bfd_minisymbol_to_symbol (abfd,
dynamic,
(const PTR) (from + size),
store_next);
if (next == NULL)
bfd_fatal (bfd_get_filename (abfd));
}
sym = from[src_count];
sec = bfd_get_section (sym);
if (bfd_is_com_section (sec))
size = sym->value;
sz = sym->value;
else
{
if (src_count + 1 < symcount
&& sec == bfd_get_section (from[src_count + 1]))
size = valueof (from[src_count + 1]) - valueof (sym);
if (from + size < fromend
&& sec == bfd_get_section (next))
sz = valueof (next) - valueof (sym);
else
size = (bfd_get_section_vma (abfd, sec)
+ bfd_section_size (abfd, sec)
- valueof (sym));
sz = (bfd_get_section_vma (abfd, sec)
+ bfd_section_size (abfd, sec)
- valueof (sym));
}
if (size != 0)
if (sz != 0)
{
/* We adjust the value of the symbol so that when it is
printed out, it will actually be the size. */
sym->value = size - bfd_get_section_vma (abfd, sec);
to[dst_count++] = sym;
symsizes->minisym = (const PTR) from;
symsizes->size = sz;
++symsizes;
}
sym = next;
temp = store_sym;
store_sym = store_next;
store_next = temp;
}
/* We must now sort again by size. */
qsort ((PTR) syms, dst_count, sizeof (asymbol *), sorters[1][reverse_sort]);
symcount = symsizes - *symsizesp;
return dst_count;
/* We must now sort again by size. */
qsort ((PTR) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
return symcount;
}
/* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
@ -702,20 +834,12 @@ display_rel_file (abfd, archive_bfd)
bfd *abfd;
bfd *archive_bfd;
{
long storage;
asymbol **syms;
long symcount = 0;
long symcount;
PTR minisyms;
unsigned int size;
struct size_sym *symsizes;
if (dynamic)
{
if (!(bfd_get_file_flags (abfd) & DYNAMIC))
{
printf ("\"%s\" is not a dynamic object.\n",
bfd_get_filename (abfd));
return;
}
}
else
if (! dynamic)
{
if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
{
@ -724,101 +848,110 @@ display_rel_file (abfd, archive_bfd)
}
}
if (dynamic)
storage = bfd_get_dynamic_symtab_upper_bound (abfd);
else
storage = bfd_get_symtab_upper_bound (abfd);
if (storage < 0)
bfd_fatal (bfd_get_filename (abfd));
if (storage == 0)
{
nosymz:
if (dynamic)
fprintf (stderr, "%s: no symbols\n", bfd_get_filename (abfd));
else
fprintf (stderr, "%s: Symflags set but there are none?\n",
bfd_get_filename (abfd));
return;
}
syms = (asymbol **) xmalloc (storage);
if (dynamic)
symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
else
symcount = bfd_canonicalize_symtab (abfd, syms);
symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
if (symcount < 0)
bfd_fatal (bfd_get_filename (abfd));
if (symcount == 0)
{
free (syms);
goto nosymz;
fprintf (stderr, "%s: no symbols\n", bfd_get_filename (abfd));
return;
}
/* Discard the symbols we don't want to print.
It's OK to do this in place; we'll free the storage anyway
(after printing). */
symcount = filter_symbols (abfd, syms, symcount);
symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
if (!no_sort)
symsizes = NULL;
if (! no_sort)
{
sort_bfd = abfd;
sort_dynamic = dynamic;
sort_x = bfd_make_empty_symbol (abfd);
sort_y = bfd_make_empty_symbol (abfd);
if (sort_x == NULL || sort_y == NULL)
bfd_fatal (bfd_get_filename (abfd));
if (! sort_by_size)
qsort ((char *) syms, symcount, sizeof (asymbol *),
qsort (minisyms, symcount, size,
sorters[sort_numerically][reverse_sort]);
else
symcount = sort_symbols_by_size (abfd, syms, symcount);
symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
size, &symsizes);
}
print_symbols (abfd, syms, symcount, archive_bfd);
free (syms);
if (! sort_by_size)
print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
else
print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
free (minisyms);
}
/* Choose which symbol entries to print;
compact them downward to get rid of the rest.
Return the number of symbols to be printed. */
static unsigned int
filter_symbols (abfd, syms, symcount)
bfd *abfd; /* Unused. */
asymbol **syms;
unsigned long symcount;
static long
filter_symbols (abfd, dynamic, minisyms, symcount, size)
bfd *abfd;
boolean dynamic;
PTR minisyms;
long symcount;
unsigned int size;
{
asymbol **from, **to;
unsigned int src_count;
unsigned int dst_count = 0;
asymbol *sym;
bfd_byte *from, *fromend, *to;
asymbol *store;
for (from = to = syms, src_count = 0; src_count < symcount; src_count++)
store = bfd_make_empty_symbol (abfd);
if (store == NULL)
bfd_fatal (bfd_get_filename (abfd));
from = (bfd_byte *) minisyms;
fromend = from + symcount * size;
to = (bfd_byte *) minisyms;
for (; from < fromend; from += size)
{
int keep = 0;
flagword flags = (from[src_count])->flags;
asymbol *sym;
PROGRESS (1);
sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const PTR) from, store);
if (sym == NULL)
bfd_fatal (bfd_get_filename (abfd));
sym = from[src_count];
if (undefined_only)
keep = bfd_is_und_section (sym->section);
else if (external_only)
keep = ((flags & BSF_GLOBAL)
keep = ((sym->flags & BSF_GLOBAL) != 0
|| bfd_is_und_section (sym->section)
|| bfd_is_com_section (sym->section));
else
keep = 1;
if (!print_debug_syms && ((flags & BSF_DEBUGGING) != 0))
if (keep
&& ! print_debug_syms
&& (sym->flags & BSF_DEBUGGING) != 0)
keep = 0;
if (sort_by_size
if (keep
&& sort_by_size
&& (bfd_is_abs_section (sym->section)
|| bfd_is_und_section (sym->section)))
keep = 0;
if (keep)
to[dst_count++] = from[src_count];
{
memcpy (to, from, size);
to += size;
}
}
return dst_count;
return (to - (bfd_byte *) minisyms) / size;
}
/* Print symbol name NAME, read from ABFD, with printf format FORMAT,
@ -829,7 +962,7 @@ print_symname (format, name, abfd)
char *format, *name;
bfd *abfd;
{
if (do_demangle)
if (do_demangle && *name)
{
char *res;
@ -851,41 +984,98 @@ print_symname (format, name, abfd)
printf (format, name);
}
/* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
/* Print the symbols. If ARCHIVE_BFD is non-NULL, it is the archive
containing ABFD. */
static void
print_symbols (abfd, syms, symcount, archive_bfd)
print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd)
bfd *abfd;
asymbol **syms;
unsigned long symcount;
boolean dynamic;
PTR minisyms;
long symcount;
unsigned int size;
bfd *archive_bfd;
{
asymbol **sym = syms, **end = syms + symcount;
symbol_info syminfo;
asymbol *store;
bfd_byte *from, *fromend;
for (; sym < end; ++sym)
store = bfd_make_empty_symbol (abfd);
if (store == NULL)
bfd_fatal (bfd_get_filename (abfd));
from = (bfd_byte *) minisyms;
fromend = from + symcount * size;
for (; from < fromend; from += size)
{
PROGRESS (1);
asymbol *sym;
(*format->print_symbol_filename) (archive_bfd, abfd);
sym = bfd_minisymbol_to_symbol (abfd, dynamic, from, store);
if (sym == NULL)
bfd_fatal (bfd_get_filename (abfd));
if (undefined_only)
{
if (bfd_is_und_section ((*sym)->section))
{
print_symname ("%s\n", (*sym)->name, abfd);
}
}
else
{
asymbol *p = *sym;
if (p)
{
bfd_get_symbol_info (abfd, p, &syminfo);
(*format->print_symbol_info) (&syminfo, abfd);
putchar ('\n');
}
}
print_symbol (abfd, sym, archive_bfd);
}
}
/* Print the symbols when sorting by size. */
static void
print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd)
bfd *abfd;
boolean dynamic;
struct size_sym *symsizes;
long symcount;
bfd *archive_bfd;
{
asymbol *store;
struct size_sym *from, *fromend;
store = bfd_make_empty_symbol (abfd);
if (store == NULL)
bfd_fatal (bfd_get_filename (abfd));
from = symsizes;
fromend = from + symcount;
for (; from < fromend; from++)
{
asymbol *sym;
sym = bfd_minisymbol_to_symbol (abfd, dynamic, from->minisym, store);
if (sym == NULL)
bfd_fatal (bfd_get_filename (abfd));
/* Set the symbol value so that we actually display the symbol
size. */
sym->value = from->size - bfd_section_vma (abfd, bfd_get_section (sym));
print_symbol (abfd, sym, archive_bfd);
}
}
/* Print a single symbol. */
static void
print_symbol (abfd, sym, archive_bfd)
bfd *abfd;
asymbol *sym;
bfd *archive_bfd;
{
PROGRESS (1);
(*format->print_symbol_filename) (archive_bfd, abfd);
if (undefined_only)
{
if (bfd_is_und_section (bfd_get_section (sym)))
print_symname ("%s\n", bfd_asymbol_name (sym), abfd);
}
else
{
symbol_info syminfo;
bfd_get_symbol_info (abfd, sym, &syminfo);
(*format->print_symbol_info) (&syminfo, abfd);
putchar ('\n');
}
}
@ -1021,6 +1211,37 @@ print_symbol_filename_posix (archive_bfd, abfd)
}
}
/* Print a symbol value. */
static void
print_value (val)
bfd_vma val;
{
#if ! defined (BFD64) || BFD_HOST_64BIT_LONG
printf (value_format, val);
#else
/* We have a 64 bit value to print, but the host is only 32 bit. */
if (print_radix == 16)
fprintf_vma (stdout, val);
else
{
char buf[30];
char *s;
s = buf + sizeof buf;
*--s = '\0';
while (val > 0)
{
*--s = (val % print_radix) + '0';
val /= print_radix;
}
while ((buf + sizeof buf - 1) - s < 16)
*--s = '0';
printf ("%s", s);
}
#endif
}
/* Print a line of information about a symbol. */
static void
@ -1031,7 +1252,7 @@ print_symbol_info_bsd (info, abfd)
if (info->type == 'U')
{
printf ("%*s",
#ifdef BFD_HOST_64_BIT
#ifdef BFD64
16,
#else
8,
@ -1039,14 +1260,7 @@ print_symbol_info_bsd (info, abfd)
"");
}
else
{
#ifdef BFD_HOST_64_BIT
printf (value_format, uint64_typeHIGH (info->value),
uint64_typeLOW (info->value));
#else
printf (value_format, info->value);
#endif
}
print_value (info->value);
printf (" %c", info->type);
if (info->type == '-')
{
@ -1069,14 +1283,7 @@ print_symbol_info_sysv (info, abfd)
if (info->type == 'U')
printf (" "); /* Value */
else
{
#ifdef BFD_HOST_64_BIT
printf (value_format, uint64_typeHIGH (info->value),
uint64_typeLOW (info->value));
#else
printf (value_format, info->value);
#endif
}
print_value (info->value);
printf ("| %c |", info->type); /* Class */
if (info->type == '-')
{
@ -1099,14 +1306,7 @@ print_symbol_info_posix (info, abfd)
if (info->type == 'U')
printf (" ");
else
{
#ifdef BFD_HOST_64_BIT
printf (value_format, uint64_typeHIGH (info->value),
uint64_typeLOW (info->value));
#else
printf (value_format, info->value);
#endif
}
print_value (info->value);
/* POSIX.2 wants the symbol size printed here, when applicable;
BFD currently doesn't provide it, so we take the easy way out by
considering it to never be applicable. */
@ -1131,6 +1331,8 @@ print_symdef_entry (abfd)
everprinted = true;
}
elt = bfd_get_elt_at_index (abfd, idx);
if (elt == NULL)
bfd_fatal ("bfd_get_elt_at_index");
if (thesym->name != (char *) NULL)
{
print_symname ("%s", thesym->name, abfd);