/* od-xcoff.c -- dump information about an xcoff object file.

   Copyright (C) 2011-2023 Free Software Foundation, Inc.

   Written by Tristan Gingold, Adacore.

   This file is part of GNU Binutils.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3, or (at your option)

   any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

#include "sysdep.h"

#include <stddef.h>

#include <time.h>

#include "safe-ctype.h"

#include "bfd.h"

#include "objdump.h"

#include "bucomm.h"

#include "bfdlink.h"

/* Force the support of weak symbols.  */

#ifndef AIX_WEAK_SUPPORT

#define AIX_WEAK_SUPPORT 1

#endif

#include "coff/internal.h"

#include "coff/rs6000.h"

#include "coff/xcoff.h"

#include "libcoff.h"

#include "libxcoff.h"

/* Index of the options in the options[] array.  */

#define OPT_FILE_HEADER 0

#define OPT_AOUT 1

#define OPT_SECTIONS 2

#define OPT_SYMS 3

#define OPT_RELOCS 4

#define OPT_LINENO 5

#define OPT_LOADER 6

#define OPT_EXCEPT 7

#define OPT_TYPCHK 8

#define OPT_TRACEBACK 9

#define OPT_TOC 10

#define OPT_LDINFO 11

/* List of actions.  */

static struct objdump_private_option options[] =

  {

    { "header", 0 },

    { "aout", 0 },

    { "sections", 0 },

    { "syms", 0 },

    { "relocs", 0 },

    { "lineno", 0 },

    { "loader", 0 },

    { "except", 0 },

    { "typchk", 0 },

    { "traceback", 0 },

    { "toc", 0 },

    { "ldinfo", 0 },

    { NULL, 0 }

  };

/* Display help.  */

static void

xcoff_help (FILE *stream)

{

  fprintf (stream, _("\

For XCOFF files:\n\

  header      Display the file header\n\

  aout        Display the auxiliary header\n\

  sections    Display the section headers\n\

  syms        Display the symbols table\n\

  relocs      Display the relocation entries\n\

  lineno      Display the line number entries\n\

  loader      Display loader section\n\

  except      Display exception table\n\

  typchk      Display type-check section\n\

  traceback   Display traceback tags\n\

  toc         Display toc symbols\n\

  ldinfo      Display loader info in core files\n\

"));

}

/* Return TRUE if ABFD is handled.  */

static int

xcoff_filter (bfd *abfd)

{

  return bfd_get_flavour (abfd) == bfd_target_xcoff_flavour;

}

/* Translation entry type.  The last entry must be {0, NULL}.  */

struct xlat_table {

  unsigned int val;

  const char *name;

};

/* Display the list of name (from TABLE) for FLAGS, using comma to separate

   them.  A name is displayed if FLAGS & VAL is not 0.  */

static void

dump_flags (const struct xlat_table *table, unsigned int flags)

{

  unsigned int r = flags;

  int first = 1;

  const struct xlat_table *t;

  for (t = table; t->name; t++)

    if ((flags & t->val) != 0)

      {

        r &= ~t->val;

        if (first)

          first = 0;

        else

          putchar (',');

        fputs (t->name, stdout);

      }

  /* Not decoded flags.  */

  if (r != 0)

    {

      if (!first)

        putchar (',');

      printf ("0x%x", r);

    }

}

/* Display the name corresponding to VAL from TABLE, using at most

   MAXLEN char (possibly passed with spaces).  */

static void

dump_value (const struct xlat_table *table, unsigned int val, int maxlen)

{

  const struct xlat_table *t;

  for (t = table; t->name; t++)

    if (t->val == val)

      {

        printf ("%-*s", maxlen, t->name);

        return;

      }

  printf ("(%*x)", maxlen - 2, val);

}

/* Names of f_flags.  */

static const struct xlat_table f_flag_xlat[] =

  {

    { F_RELFLG,    "no-rel" },

    { F_EXEC,      "exec" },

    { F_LNNO,      "lineno" },

    { F_LSYMS,     "lsyms" },

    { F_FDPR_PROF, "fdpr-prof" },

    { F_FDPR_OPTI, "fdpr-opti" },

    { F_DSA,       "dsa" },

    { F_VARPG,     "varprg" },

    { F_DYNLOAD,   "dynload" },

    { F_SHROBJ,    "shrobj" },

    { F_NONEXEC,   "nonexec" },

    { 0, NULL }

  };

/* Names of s_flags.  */

static const struct xlat_table s_flag_xlat[] =

  {

    { STYP_PAD,    "pad" },

    { STYP_DWARF,  "dwarf" },

    { STYP_TEXT,   "text" },

    { STYP_DATA,   "data" },

    { STYP_BSS,    "bss" },

    { STYP_EXCEPT, "except" },

    { STYP_INFO,   "info" },

    { STYP_TDATA,  "tdata" },

    { STYP_TBSS,   "tbss" },

    { STYP_LOADER, "loader" },

    { STYP_DEBUG,  "debug" },

    { STYP_TYPCHK, "typchk" },

    { STYP_OVRFLO, "ovrflo" },

    { 0, NULL }

  };

/* Names of storage class.  */

static const struct xlat_table sc_xlat[] =

  {

#define SC_ENTRY(X) { C_##X, #X }

    SC_ENTRY(NULL),

    SC_ENTRY(AUTO),

    SC_ENTRY(EXT),

    SC_ENTRY(STAT),

    SC_ENTRY(REG),

    SC_ENTRY(EXTDEF),

    SC_ENTRY(LABEL),

    SC_ENTRY(ULABEL),

    SC_ENTRY(MOS),

    SC_ENTRY(ARG),

    /*    SC_ENTRY(STRARG), */

    SC_ENTRY(MOU),

    SC_ENTRY(UNTAG),

    SC_ENTRY(TPDEF),

    SC_ENTRY(USTATIC),

    SC_ENTRY(ENTAG),

    SC_ENTRY(MOE),

    SC_ENTRY(REGPARM),

    SC_ENTRY(FIELD),

    SC_ENTRY(BLOCK),

    SC_ENTRY(FCN),

    SC_ENTRY(EOS),

    SC_ENTRY(FILE),

    SC_ENTRY(LINE),

    SC_ENTRY(ALIAS),

    SC_ENTRY(HIDDEN),

    SC_ENTRY(HIDEXT),

    SC_ENTRY(BINCL),

    SC_ENTRY(EINCL),

    SC_ENTRY(INFO),

    SC_ENTRY(WEAKEXT),

    SC_ENTRY(DWARF),

    /* Stabs.  */

    SC_ENTRY (GSYM),

    SC_ENTRY (LSYM),

    SC_ENTRY (PSYM),

    SC_ENTRY (RSYM),

    SC_ENTRY (RPSYM),

    SC_ENTRY (STSYM),

    SC_ENTRY (TCSYM),

    SC_ENTRY (BCOMM),

    SC_ENTRY (ECOML),

    SC_ENTRY (ECOMM),

    SC_ENTRY (DECL),

    SC_ENTRY (ENTRY),

    SC_ENTRY (FUN),

    SC_ENTRY (BSTAT),

    SC_ENTRY (ESTAT),

    { 0, NULL }

#undef SC_ENTRY

  };

/* Names for symbol type.  */

static const struct xlat_table smtyp_xlat[] =

  {

    { XTY_ER, "ER" },

    { XTY_SD, "SD" },

    { XTY_LD, "LD" },

    { XTY_CM, "CM" },

    { XTY_EM, "EM" },

    { XTY_US, "US" },

    { 0, NULL }

  };

/* Names for storage-mapping class.  */

static const struct xlat_table smclas_xlat[] =

  {

#define SMCLAS_ENTRY(X) { XMC_##X, #X }

    SMCLAS_ENTRY (PR),

    SMCLAS_ENTRY (RO),

    SMCLAS_ENTRY (DB),

    SMCLAS_ENTRY (TC),

    SMCLAS_ENTRY (UA),

    SMCLAS_ENTRY (RW),

    SMCLAS_ENTRY (GL),

    SMCLAS_ENTRY (XO),

    SMCLAS_ENTRY (SV),

    SMCLAS_ENTRY (BS),

    SMCLAS_ENTRY (DS),

    SMCLAS_ENTRY (UC),

    SMCLAS_ENTRY (TI),

    SMCLAS_ENTRY (TB),

    SMCLAS_ENTRY (TC0),

    SMCLAS_ENTRY (TD),

    SMCLAS_ENTRY (SV64),

    SMCLAS_ENTRY (SV3264),

    { 0, NULL }

#undef SMCLAS_ENTRY

  };

/* Names for relocation type.  */

static const struct xlat_table rtype_xlat[] =

  {

#define RTYPE_ENTRY(X) { R_##X, #X }

    RTYPE_ENTRY (POS),

    RTYPE_ENTRY (NEG),

    RTYPE_ENTRY (REL),

    RTYPE_ENTRY (TOC),

    RTYPE_ENTRY (TRL),

    RTYPE_ENTRY (GL),

    RTYPE_ENTRY (TCL),

    RTYPE_ENTRY (BA),

    RTYPE_ENTRY (BR),

    RTYPE_ENTRY (RL),

    RTYPE_ENTRY (RLA),

    RTYPE_ENTRY (REF),

    RTYPE_ENTRY (TRLA),

    RTYPE_ENTRY (RRTBI),

    RTYPE_ENTRY (RRTBA),

    RTYPE_ENTRY (CAI),

    RTYPE_ENTRY (CREL),

    RTYPE_ENTRY (RBA),

    RTYPE_ENTRY (RBAC),

    RTYPE_ENTRY (RBR),

    RTYPE_ENTRY (RBRC),

    RTYPE_ENTRY (TLS),

    RTYPE_ENTRY (TLS_IE),

    RTYPE_ENTRY (TLS_LD),

    RTYPE_ENTRY (TLS_LE),

    RTYPE_ENTRY (TLSM),

    RTYPE_ENTRY (TLSML),

    RTYPE_ENTRY (TOCU),

    RTYPE_ENTRY (TOCL),

    { 0, NULL }

  };

/* Simplified section header.  */

struct xcoff32_section

{

  /* NUL terminated name.  */

  char name[9];

  /* Section flags.  */

  unsigned int flags;

  /* Offsets in file.  */

  ufile_ptr scnptr;

  ufile_ptr relptr;

  ufile_ptr lnnoptr;

  /* Number of relocs and line numbers.  */

  unsigned int nreloc;

  unsigned int nlnno;

};

/* Simplified symbol.  */

union xcoff32_symbol

{

  union external_auxent aux;

  struct sym

  {

    /* Pointer to the NUL-terminated name.  */

    char *name;

    /* XCOFF symbol fields.  */

    unsigned int val;

    unsigned short scnum;

    unsigned short ntype;

    unsigned char sclass;

    unsigned char numaux;

    /* Buffer in case the name is local.  */

    union

    {

      char name[9];

      unsigned int off;

    } raw;

  } sym;

};

/* Important fields to dump the file.  */

struct xcoff_dump

{

  /* From file header.  */

  unsigned short nscns;

  unsigned int symptr;

  unsigned int nsyms;

  unsigned short opthdr;

  /* Sections.  */

  struct xcoff32_section *sects;

  /* Symbols.  */

  union xcoff32_symbol *syms;

  char *strings;

  unsigned int strings_size;

};

/* Print a symbol (if possible).  */

static void

xcoff32_print_symbol (struct xcoff_dump *data, unsigned int symndx)

{

  if (data->syms != NULL

      && symndx < data->nsyms

      && data->syms[symndx].sym.name != NULL)

    printf ("%s", data->syms[symndx].sym.name);

  else

    printf ("%u", symndx);

}

/* Dump the file header.  */

static void

dump_xcoff32_file_header (bfd *abfd, struct external_filehdr *fhdr,

                          struct xcoff_dump *data)

{

  unsigned int timdat = bfd_h_get_32 (abfd, fhdr->f_timdat);

  unsigned short flags = bfd_h_get_16 (abfd, fhdr->f_flags);

  printf (_("  nbr sections:  %d\n"), data->nscns);

  printf (_("  time and date: 0x%08x  - "), timdat);

  if (timdat == 0)

    printf (_("not set\n"));

  else

    {

      /* Not correct on all platforms, but works on unix.  */

      time_t t = timdat;

      fputs (ctime (&t), stdout);

    }

  printf (_("  symbols off:   0x%08x\n"), data->symptr);

  printf (_("  nbr symbols:   %d\n"), data->nsyms);

  printf (_("  opt hdr sz:    %d\n"), data->opthdr);

  printf (_("  flags:         0x%04x "), flags);

  dump_flags (f_flag_xlat, flags);

  putchar ('\n');

}

/* Dump the a.out header.  */

static void

dump_xcoff32_aout_header (bfd *abfd, struct xcoff_dump *data)

{

  AOUTHDR auxhdr;

  unsigned short magic;

  unsigned int sz = data->opthdr;

  printf (_("Auxiliary header:\n"));

  if (data->opthdr == 0)

    {

      printf (_("  No aux header\n"));

      return;

    }

  if (data->opthdr > sizeof (auxhdr))

    {

      printf (_("warning: optional header size too large (> %d)\n"),

              (int)sizeof (auxhdr));

      sz = sizeof (auxhdr);

    }

  if (bfd_bread (&auxhdr, sz, abfd) != sz)

    {

      non_fatal (_("cannot read auxhdr"));

      return;

    }

  magic = bfd_h_get_16 (abfd, auxhdr.magic);

  /* We don't translate these strings as they are fields name.  */

  printf ("  o_mflag (magic): 0x%04x 0%04o\n", magic, magic);

  printf ("  o_vstamp:        0x%04x\n",

          (unsigned short)bfd_h_get_16 (abfd, auxhdr.vstamp));

  printf ("  o_tsize:         0x%08x\n",

          (unsigned int)bfd_h_get_32 (abfd, auxhdr.tsize));

  printf ("  o_dsize:         0x%08x\n",

          (unsigned int)bfd_h_get_32 (abfd, auxhdr.dsize));

  printf ("  o_entry:         0x%08x\n",

          (unsigned int)bfd_h_get_32 (abfd, auxhdr.entry));

  printf ("  o_text_start:    0x%08x\n",

          (unsigned int)bfd_h_get_32 (abfd, auxhdr.text_start));

  printf ("  o_data_start:    0x%08x\n",

          (unsigned int)bfd_h_get_32 (abfd, auxhdr.data_start));

  if (sz == offsetof (AOUTHDR, o_toc))

    return;

  printf ("  o_toc:           0x%08x\n",

          (unsigned int)bfd_h_get_32 (abfd, auxhdr.o_toc));

  printf ("  o_snentry:       0x%04x\n",

          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_snentry));

  printf ("  o_sntext:        0x%04x\n",

          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_sntext));

  printf ("  o_sndata:        0x%04x\n",

          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_sndata));

  printf ("  o_sntoc:         0x%04x\n",

          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_sntoc));

  printf ("  o_snloader:      0x%04x\n",

          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_snloader));

  printf ("  o_snbss:         0x%04x\n",

          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_snbss));

  printf ("  o_algntext:      %u\n",

          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_algntext));

  printf ("  o_algndata:      %u\n",

          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_algndata));

  printf ("  o_modtype:       0x%04x",

          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_modtype));

  if (ISPRINT (auxhdr.o_modtype[0]) && ISPRINT (auxhdr.o_modtype[1]))

    printf (" (%c%c)", auxhdr.o_modtype[0], auxhdr.o_modtype[1]);

  putchar ('\n');

  printf ("  o_cputype:       0x%04x\n",

          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_cputype));

  printf ("  o_maxstack:      0x%08x\n",

          (unsigned int)bfd_h_get_32 (abfd, auxhdr.o_maxstack));

  printf ("  o_maxdata:       0x%08x\n",

          (unsigned int)bfd_h_get_32 (abfd, auxhdr.o_maxdata));

#if 0

  printf ("  o_debugger:      0x%08x\n",

          (unsigned int)bfd_h_get_32 (abfd, auxhdr.o_debugger));

#endif

}

/* Dump the sections header.  */

static void

dump_xcoff32_sections_header (bfd *abfd, struct xcoff_dump *data)

{

  unsigned int i;

  unsigned int off;

  off = sizeof (struct external_filehdr) + data->opthdr;

  printf (_("Section headers (at %u+%u=0x%08x to 0x%08x):\n"),

          (unsigned int)sizeof (struct external_filehdr), data->opthdr, off,

          off + (unsigned int)sizeof (struct external_scnhdr) * data->nscns);

  if (data->nscns == 0)

    {

      printf (_("  No section header\n"));

      return;

    }

  if (bfd_seek (abfd, off, SEEK_SET) != 0)

    {

      non_fatal (_("cannot read section header"));

      return;

    }

  /* We don't translate this string as it consists in fields name.  */

  printf (" # Name     paddr    vaddr    size     scnptr   relptr   lnnoptr  nrel  nlnno\n");

  for (i = 0; i < data->nscns; i++)

    {

      struct external_scnhdr scn;

      unsigned int flags;

      if (bfd_bread (&scn, sizeof (scn), abfd) != sizeof (scn))

        {

          non_fatal (_("cannot read section header"));

          return;

        }

      flags = bfd_h_get_32 (abfd, scn.s_flags);

      printf ("%2d %-8.8s %08x %08x %08x %08x %08x %08x %-5d %-5d\n",

              i + 1, scn.s_name,

              (unsigned int)bfd_h_get_32 (abfd, scn.s_paddr),

              (unsigned int)bfd_h_get_32 (abfd, scn.s_vaddr),

              (unsigned int)bfd_h_get_32 (abfd, scn.s_size),

              (unsigned int)bfd_h_get_32 (abfd, scn.s_scnptr),

              (unsigned int)bfd_h_get_32 (abfd, scn.s_relptr),

              (unsigned int)bfd_h_get_32 (abfd, scn.s_lnnoptr),

              (unsigned int)bfd_h_get_16 (abfd, scn.s_nreloc),

              (unsigned int)bfd_h_get_16 (abfd, scn.s_nlnno));

      printf (_("            Flags: %08x "), flags);

      if (~flags == 0)

        {

          /* Stripped executable ?  */

          putchar ('\n');

        }

      else if (flags & STYP_OVRFLO)

        printf (_("overflow - nreloc: %u, nlnno: %u\n"),

                (unsigned int)bfd_h_get_32 (abfd, scn.s_paddr),

                (unsigned int)bfd_h_get_32 (abfd, scn.s_vaddr));

      else

        {

          dump_flags (s_flag_xlat, flags);

          putchar ('\n');

        }

    }

}

/* Read section table.  */

static void

xcoff32_read_sections (bfd *abfd, struct xcoff_dump *data)

{

  int i;

  if (bfd_seek (abfd, sizeof (struct external_filehdr) + data->opthdr,

                SEEK_SET) != 0)

    {

      non_fatal (_("cannot read section headers"));

      return;

    }

  data->sects = xmalloc (data->nscns * sizeof (struct xcoff32_section));

  for (i = 0; i < data->nscns; i++)

    {

      struct external_scnhdr scn;

      struct xcoff32_section *s = &data->sects[i];

      if (bfd_bread (&scn, sizeof (scn), abfd) != sizeof (scn))

        {

          non_fatal (_("cannot read section header"));

          free (data->sects);

          data->sects = NULL;

          return;

        }

      memcpy (s->name, scn.s_name, 8);

      s->name[8] = 0;

      s->flags = bfd_h_get_32 (abfd, scn.s_flags);

      s->scnptr = bfd_h_get_32 (abfd, scn.s_scnptr);

      s->relptr = bfd_h_get_32 (abfd, scn.s_relptr);

      s->lnnoptr = bfd_h_get_32 (abfd, scn.s_lnnoptr);

      s->nreloc = bfd_h_get_16 (abfd, scn.s_nreloc);

      s->nlnno = bfd_h_get_16 (abfd, scn.s_nlnno);

      if (s->flags == STYP_OVRFLO)

        {

          if (s->nreloc > 0 && s->nreloc <= data->nscns)

            data->sects[s->nreloc - 1].nreloc =

              bfd_h_get_32 (abfd, scn.s_paddr);

          if (s->nlnno > 0 && s->nlnno <= data->nscns)

            data->sects[s->nlnno - 1].nlnno =

              bfd_h_get_32 (abfd, scn.s_vaddr);

        }

    }

}

/* Read symbols.  */

static void

xcoff32_read_symbols (bfd *abfd, struct xcoff_dump *data)

{

  unsigned int i;

  char stsz_arr[4];

  unsigned int stptr;

  if (data->nsyms == 0)

    return;

  stptr = data->symptr

    + data->nsyms * (unsigned)sizeof (struct external_syment);

  /* Read string table.  */

  if (bfd_seek (abfd, stptr, SEEK_SET) != 0

      || bfd_bread (&stsz_arr, sizeof (stsz_arr), abfd) != sizeof (stsz_arr))

    {

      non_fatal (_("cannot read strings table length"));

      data->strings_size = 0;

    }

  else

    {

      data->strings_size = bfd_h_get_32 (abfd, stsz_arr);

      if (data->strings_size > sizeof (stsz_arr))

        {

          unsigned int remsz = data->strings_size - sizeof (stsz_arr);

          data->strings = xmalloc (data->strings_size);

          memcpy (data->strings, stsz_arr, sizeof (stsz_arr));

          if (bfd_bread (data->strings + sizeof (stsz_arr), remsz, abfd)

              != remsz)

            {

              non_fatal (_("cannot read strings table"));

              goto clean;

            }

        }

    }

  if (bfd_seek (abfd, data->symptr, SEEK_SET) != 0)

    {

      non_fatal (_("cannot read symbol table"));

      goto clean;

    }

  data->syms = (union xcoff32_symbol *)

    xmalloc (data->nsyms * sizeof (union xcoff32_symbol));

  for (i = 0; i < data->nsyms; i++)

    {

      struct external_syment sym;

      int j;

      union xcoff32_symbol *s = &data->syms[i];

      if (bfd_bread (&sym, sizeof (sym), abfd) != sizeof (sym))

        {

          non_fatal (_("cannot read symbol entry"));

          goto clean;

        }

      s->sym.val = bfd_h_get_32 (abfd, sym.e_value);

      s->sym.scnum = bfd_h_get_16 (abfd, sym.e_scnum);

      s->sym.ntype = bfd_h_get_16 (abfd, sym.e_type);

      s->sym.sclass = bfd_h_get_8 (abfd, sym.e_sclass);

      s->sym.numaux = bfd_h_get_8 (abfd, sym.e_numaux);

      if (sym.e.e_name[0])

        {

          memcpy (s->sym.raw.name, sym.e.e_name, sizeof (sym.e.e_name));

          s->sym.raw.name[8] = 0;

          s->sym.name = s->sym.raw.name;

        }

      else

        {

          unsigned int soff = bfd_h_get_32 (abfd, sym.e.e.e_offset);

          if ((s->sym.sclass & DBXMASK) == 0 && soff < data->strings_size)

            s->sym.name = data->strings + soff;

          else

            {

              s->sym.name = NULL;

              s->sym.raw.off = soff;

            }

        }

      for (j = 0; j < s->sym.numaux; j++, i++)

        {

           if (bfd_bread (&s[j + 1].aux,

                          sizeof (union external_auxent), abfd)

               != sizeof (union external_auxent))

            {

              non_fatal (_("cannot read symbol aux entry"));

              goto clean;

            }

        }

    }

  return;

 clean:

  free (data->syms);

  data->syms = NULL;

  free (data->strings);

  data->strings = NULL;

}

/* Dump xcoff symbols.  */

static void

dump_xcoff32_symbols (bfd *abfd, struct xcoff_dump *data)

{

  unsigned int i;

  asection *debugsec;

  char *debug = NULL;

  printf (_("Symbols table (strtable at 0x%08x)"),

          data->symptr

          + data->nsyms * (unsigned)sizeof (struct external_syment));

  if (data->nsyms == 0 || data->syms == NULL)

    {

      printf (_(":\n  No symbols\n"));

      return;

    }

  /* Read strings table.  */

  if (data->strings_size == 0)

    printf (_(" (no strings):\n"));

  else

    printf (_(" (strings size: %08x):\n"), data->strings_size);

  /* Read debug section.  */

  debugsec = bfd_get_section_by_name (abfd, ".debug");

  if (debugsec != NULL)

    {

      bfd_size_type size;

      size = bfd_section_size (debugsec);

      debug = (char *) xmalloc (size);

      bfd_get_section_contents (abfd, debugsec, debug, 0, size);

    }

  /* Translators: 'sc' is for storage class, 'off' for offset.  */

  printf (_("  # sc         value    section  type aux name/off\n"));

  for (i = 0; i < data->nsyms; i++)

    {

      union xcoff32_symbol *s = &data->syms[i];

      int j;

      printf ("%3u ", i);

      dump_value (sc_xlat, s->sym.sclass, 10);

      printf (" %08x ", s->sym.val);

      if (s->sym.scnum > 0 && s->sym.scnum <= data->nscns)

        {

          if (data->sects != NULL)

            printf ("%-8s", data->sects[s->sym.scnum - 1].name);

          else

            printf ("%-8u", s->sym.scnum);

        }

      else

        switch ((signed short)s->sym.scnum)

          {

          case N_DEBUG:

            printf ("N_DEBUG ");

            break;

          case N_ABS:

            printf ("N_ABS   ");

            break;

          case N_UNDEF:

            printf ("N_UNDEF ");

            break;

          default:

            printf ("(%04x)  ", s->sym.scnum);

          }

      printf (" %04x %3u ", s->sym.ntype, s->sym.numaux);

      if (s->sym.name != NULL)

        printf ("%s", s->sym.name);

      else

        {

          if ((s->sym.sclass & DBXMASK) != 0 && debug != NULL)

            printf ("%s", debug + s->sym.raw.off);

          else

            printf ("%08x", s->sym.raw.off);

        }

      putchar ('\n');

      for (j = 0; j < s->sym.numaux; j++, i++)

        {

          union external_auxent *aux = &s[j + 1].aux;

          printf (" %3u ", i + 1);

          switch (s->sym.sclass)

            {

            case C_STAT:

              /* Section length, number of relocs and line number.  */

              printf (_("  scnlen: %08x  nreloc: %-6u  nlinno: %-6u\n"),

                      (unsigned)bfd_h_get_32 (abfd, aux->x_scn.x_scnlen),

                      (unsigned)bfd_h_get_16 (abfd, aux->x_scn.x_nreloc),

                      (unsigned)bfd_h_get_16 (abfd, aux->x_scn.x_nlinno));

              break;

            case C_DWARF:

              /* Section length and number of relocs.  */

              printf (_("  scnlen: %08x  nreloc: %-6u\n"),

                      (unsigned)bfd_h_get_32 (abfd, aux->x_scn.x_scnlen),

                      (unsigned)bfd_h_get_16 (abfd, aux->x_scn.x_nreloc));

              break;

            case C_EXT:

            case C_WEAKEXT:

            case C_HIDEXT:

              if (j == 0 && s->sym.numaux > 1)

                {

                  /* Function aux entry  (Do not translate).  */

                  printf ("  exptr: %08x fsize: %08x lnnoptr: %08x endndx: %u\n",

                          (unsigned)bfd_h_get_32 (abfd, aux->x_fcn.x_exptr),

                          (unsigned)bfd_h_get_32

                            (abfd, aux->x_fcn.x_fsize),

                          (unsigned)bfd_h_get_32

                            (abfd, aux->x_fcn.x_lnnoptr),

                          (unsigned)bfd_h_get_32

                            (abfd, aux->x_fcn.x_endndx));

                }

              else if (j == 1 || (j == 0 && s->sym.numaux == 1))

                {

                  /* csect aux entry.  */

                  unsigned char smtyp;

                  unsigned int scnlen;

                  smtyp = bfd_h_get_8 (abfd, aux->x_csect.x_smtyp);

                  scnlen = bfd_h_get_32 (abfd, aux->x_csect.x_scnlen);

                  if (smtyp == XTY_LD)

                    printf ("  scnsym: %-8u", scnlen);

                  else

                    printf ("  scnlen: %08x", scnlen);

                  printf (" h: parm=%08x sn=%04x al: 2**%u",

                          (unsigned)bfd_h_get_32 (abfd, aux->x_csect.x_parmhash),

                          (unsigned)bfd_h_get_16 (abfd, aux->x_csect.x_snhash),

                          SMTYP_ALIGN (smtyp));

                  printf (" typ: ");

                  dump_value (smtyp_xlat, SMTYP_SMTYP (smtyp), 2);

                  printf (" cl: ");

                  dump_value

                    (smclas_xlat,

                     (unsigned)bfd_h_get_8 (abfd, aux->x_csect.x_smclas), 6);

                  putchar ('\n');

                }

              else

                /* Do not translate - generic field name.  */

                printf ("aux\n");

              break;

            case C_FILE:

              {

                unsigned int off;

                printf (" ftype: %02x ",

                        (unsigned)bfd_h_get_8 (abfd, aux->x_file.x_ftype));

                if (aux->x_file.x_n.x_fname[0] != 0)

                  printf ("fname: %.14s", aux->x_file.x_n.x_fname);

                else

                  {

                    off = (unsigned)bfd_h_get_32

                      (abfd, aux->x_file.x_n.x_n.x_offset);

                    if (data->strings != NULL && off < data->strings_size)

                      printf (" %s", data->strings + off);

                    else

                      printf (_("offset: %08x"), off);

                  }

                putchar ('\n');

              }

              break;

            case C_BLOCK:

            case C_FCN:

              printf ("  lnno: %u\n",

                      (unsigned)bfd_h_get_16

                      (abfd, aux->x_sym.x_lnno));

              break;

            default:

              /* Do not translate - generic field name.  */

              printf ("aux\n");

              break;

            }

        }

    }

  free (debug);

}

/* Dump xcoff relocation entries.  */

static void

dump_xcoff32_relocs (bfd *abfd, struct xcoff_dump *data)

{

  unsigned int i;

  if (data->sects == NULL)

    {