binutils/od-xcoff.c

   1 /* od-xcoff.c -- dump information about an xcoff object file.
   2    Copyright 2011, 2012 Free Software Foundation, Inc.
   3    Written by Tristan Gingold, Adacore.
   4
   5    This file is part of GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3, or (at your option)
  10    any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include <stddef.h>
  24 #include <time.h>
  25 #include "safe-ctype.h"
  26 #include "bfd.h"
  27 #include "objdump.h"
  28 #include "bucomm.h"
  29 #include "bfdlink.h"
  30 /* Force the support of weak symbols.  */
  31 #ifndef AIX_WEAK_SUPPORT
  32 #define AIX_WEAK_SUPPORT 1
  33 #endif
  34 #include "coff/internal.h"
  35 #include "coff/rs6000.h"
  36 #include "coff/xcoff.h"
  37 #include "libcoff.h"
  38 #include "libxcoff.h"
  39
  40 /* Index of the options in the options[] array.  */
  41 #define OPT_FILE_HEADER 0
  42 #define OPT_AOUT 1
  43 #define OPT_SECTIONS 2
  44 #define OPT_SYMS 3
  45 #define OPT_RELOCS 4
  46 #define OPT_LINENO 5
  47 #define OPT_LOADER 6
  48 #define OPT_EXCEPT 7
  49 #define OPT_TYPCHK 8
  50 #define OPT_TRACEBACK 9
  51 #define OPT_TOC 10
  52
  53 /* List of actions.  */
  54 static struct objdump_private_option options[] =
  55   {
  56     { "header", 0 },
  57     { "aout", 0 },
  58     { "sections", 0 },
  59     { "syms", 0 },
  60     { "relocs", 0 },
  61     { "lineno", 0 },
  62     { "loader", 0 },
  63     { "except", 0 },
  64     { "typchk", 0 },
  65     { "traceback", 0 },
  66     { "toc", 0 },
  67     { NULL, 0 }
  68   };
  69
  70 /* Display help.  */
  71
  72 static void
  73 xcoff_help (FILE *stream)
  74 {
  75   fprintf (stream, _("\
  76 For XCOFF files:\n\
  77   header      Display the file header\n\
  78   aout        Display the auxiliary header\n\
  79   sections    Display the section headers\n\
  80   syms        Display the symbols table\n\
  81   relocs      Display the relocation entries\n\
  82   lineno      Display the line number entries\n\
  83   loader      Display loader section\n\
  84   except      Display exception table\n\
  85   typchk      Display type-check section\n\
  86   traceback   Display traceback tags\n\
  87   toc         Display toc symbols\n\
  88 "));
  89 }
  90
  91 /* Return TRUE if ABFD is handled.  */
  92
  93 static int
  94 xcoff_filter (bfd *abfd)
  95 {
  96   return bfd_get_flavour (abfd) == bfd_target_xcoff_flavour;
  97 }
  98
  99 /* Translation entry type.  The last entry must be {0, NULL}.  */
 100
 101 struct xlat_table {
 102   unsigned int val;
 103   const char *name;
 104 };
 105
 106 /* Display the list of name (from TABLE) for FLAGS, using comma to separate
 107    them.  A name is displayed if FLAGS & VAL is not 0.  */
 108
 109 static void
 110 dump_flags (const struct xlat_table *table, unsigned int flags)
 111 {
 112   unsigned int r = flags;
 113   int first = 1;
 114   const struct xlat_table *t;
 115
 116   for (t = table; t->name; t++)
 117     if ((flags & t->val) != 0)
 118       {
 119         r &= ~t->val;
 120
 121         if (first)
 122           first = 0;
 123         else
 124           putchar (',');
 125         fputs (t->name, stdout);
 126       }
 127
 128   /* Not decoded flags.  */
 129   if (r != 0)
 130     {
 131       if (!first)
 132         putchar (',');
 133       printf ("0x%x", r);
 134     }
 135 }
 136
 137 /* Display the name corresponding to VAL from TABLE, using at most
 138    MAXLEN char (possibly passed with spaces).  */
 139
 140 static void
 141 dump_value (const struct xlat_table *table, unsigned int val, int maxlen)
 142 {
 143   const struct xlat_table *t;
 144
 145   for (t = table; t->name; t++)
 146     if (t->val == val)
 147       {
 148         printf ("%-*s", maxlen, t->name);
 149         return;
 150       }
 151   printf ("(%*x)", maxlen - 2, val);
 152 }
 153
 154 /* Names of f_flags.  */
 155 static const struct xlat_table f_flag_xlat[] =
 156   {
 157     { F_RELFLG,    "no-rel" },
 158     { F_EXEC,      "exec" },
 159     { F_LNNO,      "lineno" },
 160     { F_LSYMS,     "lsyms" },
 161
 162     { F_FDPR_PROF, "fdpr-prof" },
 163     { F_FDPR_OPTI, "fdpr-opti" },
 164     { F_DSA,       "dsa" },
 165
 166     { F_VARPG,     "varprg" },
 167
 168     { F_DYNLOAD,   "dynload" },
 169     { F_SHROBJ,    "shrobj" },
 170     { F_NONEXEC,   "nonexec" },
 171
 172     { 0, NULL }
 173   };
 174
 175 /* Names of s_flags.  */
 176 static const struct xlat_table s_flag_xlat[] =
 177   {
 178     { STYP_PAD,    "pad" },
 179     { STYP_DWARF,  "dwarf" },
 180     { STYP_TEXT,   "text" },
 181     { STYP_DATA,   "data" },
 182     { STYP_BSS,    "bss" },
 183
 184     { STYP_EXCEPT, "except" },
 185     { STYP_INFO,   "info" },
 186     { STYP_TDATA,  "tdata" },
 187     { STYP_TBSS,   "tbss" },
 188
 189     { STYP_LOADER, "loader" },
 190     { STYP_DEBUG,  "debug" },
 191     { STYP_TYPCHK, "typchk" },
 192     { STYP_OVRFLO, "ovrflo" },
 193     { 0, NULL }
 194   };
 195
 196 /* Names of storage class.  */
 197 static const struct xlat_table sc_xlat[] =
 198   {
 199 #define SC_ENTRY(X) { C_##X, #X }
 200     SC_ENTRY(NULL),
 201     SC_ENTRY(AUTO),
 202     SC_ENTRY(EXT),
 203     SC_ENTRY(STAT),
 204     SC_ENTRY(REG),
 205     SC_ENTRY(EXTDEF),
 206     SC_ENTRY(LABEL),
 207     SC_ENTRY(ULABEL),
 208     SC_ENTRY(MOS),
 209     SC_ENTRY(ARG),
 210     /*    SC_ENTRY(STRARG), */
 211     SC_ENTRY(MOU),
 212     SC_ENTRY(UNTAG),
 213     SC_ENTRY(TPDEF),
 214     SC_ENTRY(USTATIC),
 215     SC_ENTRY(ENTAG),
 216     SC_ENTRY(MOE),
 217     SC_ENTRY(REGPARM),
 218     SC_ENTRY(FIELD),
 219     SC_ENTRY(BLOCK),
 220     SC_ENTRY(FCN),
 221     SC_ENTRY(EOS),
 222     SC_ENTRY(FILE),
 223     SC_ENTRY(LINE),
 224     SC_ENTRY(ALIAS),
 225     SC_ENTRY(HIDDEN),
 226     SC_ENTRY(HIDEXT),
 227     SC_ENTRY(BINCL),
 228     SC_ENTRY(EINCL),
 229     SC_ENTRY(INFO),
 230     SC_ENTRY(WEAKEXT),
 231     SC_ENTRY(DWARF),
 232
 233     /* Stabs.  */
 234     SC_ENTRY (GSYM),
 235     SC_ENTRY (LSYM),
 236     SC_ENTRY (PSYM),
 237     SC_ENTRY (RSYM),
 238     SC_ENTRY (RPSYM),
 239     SC_ENTRY (STSYM),
 240     SC_ENTRY (TCSYM),
 241     SC_ENTRY (BCOMM),
 242     SC_ENTRY (ECOML),
 243     SC_ENTRY (ECOMM),
 244     SC_ENTRY (DECL),
 245     SC_ENTRY (ENTRY),
 246     SC_ENTRY (FUN),
 247     SC_ENTRY (BSTAT),
 248     SC_ENTRY (ESTAT),
 249
 250     { 0, NULL }
 251 #undef SC_ENTRY
 252   };
 253
 254 /* Names for symbol type.  */
 255 static const struct xlat_table smtyp_xlat[] =
 256   {
 257     { XTY_ER, "ER" },
 258     { XTY_SD, "SD" },
 259     { XTY_LD, "LD" },
 260     { XTY_CM, "CM" },
 261     { XTY_EM, "EM" },
 262     { XTY_US, "US" },
 263     { 0, NULL }
 264   };
 265
 266 /* Names for storage-mapping class.  */
 267 static const struct xlat_table smclas_xlat[] =
 268   {
 269 #define SMCLAS_ENTRY(X) { XMC_##X, #X }
 270     SMCLAS_ENTRY (PR),
 271     SMCLAS_ENTRY (RO),
 272     SMCLAS_ENTRY (DB),
 273     SMCLAS_ENTRY (TC),
 274     SMCLAS_ENTRY (UA),
 275     SMCLAS_ENTRY (RW),
 276     SMCLAS_ENTRY (GL),
 277     SMCLAS_ENTRY (XO),
 278     SMCLAS_ENTRY (SV),
 279     SMCLAS_ENTRY (BS),
 280     SMCLAS_ENTRY (DS),
 281     SMCLAS_ENTRY (UC),
 282     SMCLAS_ENTRY (TI),
 283     SMCLAS_ENTRY (TB),
 284     SMCLAS_ENTRY (TC0),
 285     SMCLAS_ENTRY (TD),
 286     SMCLAS_ENTRY (SV64),
 287     SMCLAS_ENTRY (SV3264),
 288     { 0, NULL }
 289 #undef SMCLAS_ENTRY
 290   };
 291
 292 /* Names for relocation type.  */
 293 static const struct xlat_table rtype_xlat[] =
 294   {
 295 #define RTYPE_ENTRY(X) { R_##X, #X }
 296     RTYPE_ENTRY (POS),
 297     RTYPE_ENTRY (NEG),
 298     RTYPE_ENTRY (REL),
 299     RTYPE_ENTRY (TOC),
 300     RTYPE_ENTRY (RTB),
 301     RTYPE_ENTRY (GL),
 302     RTYPE_ENTRY (TCL),
 303     RTYPE_ENTRY (BA),
 304     RTYPE_ENTRY (BR),
 305     RTYPE_ENTRY (RL),
 306     RTYPE_ENTRY (RLA),
 307     RTYPE_ENTRY (REF),
 308     RTYPE_ENTRY (TRL),
 309     RTYPE_ENTRY (TRLA),
 310     RTYPE_ENTRY (RRTBI),
 311     RTYPE_ENTRY (RRTBA),
 312     RTYPE_ENTRY (CAI),
 313     RTYPE_ENTRY (CREL),
 314     RTYPE_ENTRY (RBA),
 315     RTYPE_ENTRY (RBAC),
 316     RTYPE_ENTRY (RBR),
 317     RTYPE_ENTRY (RBRC),
 318     RTYPE_ENTRY (TLS),
 319     RTYPE_ENTRY (TLS_IE),
 320     RTYPE_ENTRY (TLS_LD),
 321     RTYPE_ENTRY (TLS_LE),
 322     RTYPE_ENTRY (TLSM),
 323     RTYPE_ENTRY (TLSML),
 324     RTYPE_ENTRY (TOCU),
 325     RTYPE_ENTRY (TOCL),
 326     { 0, NULL }
 327   };
 328
 329 /* Simplified section header.  */
 330 struct xcoff32_section
 331 {
 332   /* NUL terminated name.  */
 333   char name[9];
 334
 335   /* Section flags.  */
 336   unsigned int flags;
 337
 338   /* Offsets in file.  */
 339   ufile_ptr scnptr;
 340   ufile_ptr relptr;
 341   ufile_ptr lnnoptr;
 342
 343   /* Number of relocs and line numbers.  */
 344   unsigned int nreloc;
 345   unsigned int nlnno;
 346 };
 347
 348 /* Simplified symbol.  */
 349
 350 union xcoff32_symbol
 351 {
 352   union external_auxent aux;
 353
 354   struct sym
 355   {
 356     /* Pointer the the NUL-terminated name.  */
 357     char *name;
 358
 359     /* XCOFF symbol fields.  */
 360     unsigned int val;
 361     unsigned short scnum;
 362     unsigned short ntype;
 363     unsigned char sclass;
 364     unsigned char numaux;
 365
 366     /* Buffer in case the name is local.  */
 367     union
 368     {
 369       char name[9];
 370       unsigned int off;
 371     } raw;
 372   } sym;
 373 };
 374
 375 /* Important fields to dump the file.  */
 376
 377 struct xcoff_dump
 378 {
 379   /* From file header.  */
 380   unsigned short nscns;
 381   unsigned int symptr;
 382   unsigned int nsyms;
 383   unsigned short opthdr;
 384
 385   /* Sections.  */
 386   struct xcoff32_section *sects;
 387
 388   /* Symbols.  */
 389   union xcoff32_symbol *syms;
 390   char *strings;
 391   unsigned int strings_size;
 392 };
 393
 394 /* Print a symbol (if possible).  */
 395
 396 static void
 397 xcoff32_print_symbol (struct xcoff_dump *data, unsigned int symndx)
 398 {
 399   if (data->syms != NULL
 400       && symndx < data->nsyms
 401       && data->syms[symndx].sym.name != NULL)
 402     printf ("%s", data->syms[symndx].sym.name);
 403   else
 404     printf ("%u", symndx);
 405 }
 406
 407 /* Dump the file header.  */
 408
 409 static void
 410 dump_xcoff32_file_header (bfd *abfd, struct external_filehdr *fhdr,
 411                           struct xcoff_dump *data)
 412 {
 413   unsigned int timdat = bfd_h_get_32 (abfd, fhdr->f_timdat);
 414   unsigned short flags = bfd_h_get_16 (abfd, fhdr->f_flags);
 415
 416   printf (_("  nbr sections:  %d\n"), data->nscns);
 417   printf (_("  time and date: 0x%08x  - "), timdat);
 418   if (timdat == 0)
 419     printf (_("not set\n"));
 420   else
 421     {
 422       /* Not correct on all platforms, but works on unix.  */
 423       time_t t = timdat;
 424       fputs (ctime (&t), stdout);
 425     }
 426   printf (_("  symbols off:   0x%08x\n"), data->symptr);
 427   printf (_("  nbr symbols:   %d\n"), data->nsyms);
 428   printf (_("  opt hdr sz:    %d\n"), data->opthdr);
 429   printf (_("  flags:         0x%04x "), flags);
 430   dump_flags (f_flag_xlat, flags);
 431   putchar ('\n');
 432 }
 433
 434 /* Dump the a.out header.  */
 435
 436 static void
 437 dump_xcoff32_aout_header (bfd *abfd, struct xcoff_dump *data)
 438 {
 439   AOUTHDR auxhdr;
 440   unsigned short magic;
 441   unsigned int sz = data->opthdr;
 442
 443   printf (_("Auxiliary header:\n"));
 444   if (data->opthdr == 0)
 445     {
 446       printf (_("  No aux header\n"));
 447       return;
 448     }
 449   if (data->opthdr > sizeof (auxhdr))
 450     {
 451       printf (_("warning: optionnal header size too large (> %d)\n"),
 452               (int)sizeof (auxhdr));
 453       sz = sizeof (auxhdr);
 454     }
 455   if (bfd_bread (&auxhdr, sz, abfd) != sz)
 456     {
 457       non_fatal (_("cannot read auxhdr"));
 458       return;
 459     }
 460
 461   magic = bfd_h_get_16 (abfd, auxhdr.magic);
 462   /* We don't translate these strings as they are fields name.  */
 463   printf ("  o_mflag (magic): 0x%04x 0%04o\n", magic, magic);
 464   printf ("  o_vstamp:        0x%04x\n",
 465           (unsigned short)bfd_h_get_16 (abfd, auxhdr.vstamp));
 466   printf ("  o_tsize:         0x%08x\n",
 467           (unsigned int)bfd_h_get_32 (abfd, auxhdr.tsize));
 468   printf ("  o_dsize:         0x%08x\n",
 469           (unsigned int)bfd_h_get_32 (abfd, auxhdr.dsize));
 470   printf ("  o_entry:         0x%08x\n",
 471           (unsigned int)bfd_h_get_32 (abfd, auxhdr.entry));
 472   printf ("  o_text_start:    0x%08x\n",
 473           (unsigned int)bfd_h_get_32 (abfd, auxhdr.text_start));
 474   printf ("  o_data_start:    0x%08x\n",
 475           (unsigned int)bfd_h_get_32 (abfd, auxhdr.data_start));
 476   if (sz == offsetof (AOUTHDR, o_toc))
 477     return;
 478   printf ("  o_toc:           0x%08x\n",
 479           (unsigned int)bfd_h_get_32 (abfd, auxhdr.o_toc));
 480   printf ("  o_snentry:       0x%04x\n",
 481           (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_snentry));
 482   printf ("  o_sntext:        0x%04x\n",
 483           (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_sntext));
 484   printf ("  o_sndata:        0x%04x\n",
 485           (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_sndata));
 486   printf ("  o_sntoc:         0x%04x\n",
 487           (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_sntoc));
 488   printf ("  o_snloader:      0x%04x\n",
 489           (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_snloader));
 490   printf ("  o_snbss:         0x%04x\n",
 491           (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_snbss));
 492   printf ("  o_algntext:      %u\n",
 493           (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_algntext));
 494   printf ("  o_algndata:      %u\n",
 495           (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_algndata));
 496   printf ("  o_modtype:       0x%04x",
 497           (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_modtype));
 498   if (ISPRINT (auxhdr.o_modtype[0]) && ISPRINT (auxhdr.o_modtype[1]))
 499     printf (" (%c%c)", auxhdr.o_modtype[0], auxhdr.o_modtype[1]);
 500   putchar ('\n');
 501   printf ("  o_cputype:       0x%04x\n",
 502           (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_cputype));
 503   printf ("  o_maxstack:      0x%08x\n",
 504           (unsigned int)bfd_h_get_32 (abfd, auxhdr.o_maxstack));
 505   printf ("  o_maxdata:       0x%08x\n",
 506           (unsigned int)bfd_h_get_32 (abfd, auxhdr.o_maxdata));
 507 #if 0
 508   printf ("  o_debugger:      0x%08x\n",
 509           (unsigned int)bfd_h_get_32 (abfd, auxhdr.o_debugger));
 510 #endif
 511 }
 512
 513 /* Dump the sections header.  */
 514
 515 static void
 516 dump_xcoff32_sections_header (bfd *abfd, struct xcoff_dump *data)
 517 {
 518   unsigned int i;
 519   unsigned int off;
 520
 521   off = sizeof (struct external_filehdr) + data->opthdr;
 522   printf (_("Section headers (at %u+%u=0x%08x to 0x%08x):\n"),
 523           (unsigned int)sizeof (struct external_filehdr), data->opthdr, off,
 524           off + (unsigned int)sizeof (struct external_scnhdr) * data->nscns);
 525   if (data->nscns == 0)
 526     {
 527       printf (_("  No section header\n"));
 528       return;
 529     }
 530   if (bfd_seek (abfd, off, SEEK_SET) != 0)
 531     {
 532       non_fatal (_("cannot read section header"));
 533       return;
 534     }
 535   /* We don't translate this string as it consists in fields name.  */
 536   printf (" # Name     paddr    vaddr    size     scnptr   relptr   lnnoptr  nrel  nlnno\n");
 537   for (i = 0; i < data->nscns; i++)
 538     {
 539       struct external_scnhdr scn;
 540       unsigned int flags;
 541
 542       if (bfd_bread (&scn, sizeof (scn), abfd) != sizeof (scn))
 543         {
 544           non_fatal (_("cannot read section header"));
 545           return;
 546         }
 547       flags = bfd_h_get_32 (abfd, scn.s_flags);
 548       printf ("%2d %-8.8s %08x %08x %08x %08x %08x %08x %-5d %-5d\n",
 549               i + 1, scn.s_name,
 550               (unsigned int)bfd_h_get_32 (abfd, scn.s_paddr),
 551               (unsigned int)bfd_h_get_32 (abfd, scn.s_vaddr),
 552               (unsigned int)bfd_h_get_32 (abfd, scn.s_size),
 553               (unsigned int)bfd_h_get_32 (abfd, scn.s_scnptr),
 554               (unsigned int)bfd_h_get_32 (abfd, scn.s_relptr),
 555               (unsigned int)bfd_h_get_32 (abfd, scn.s_lnnoptr),
 556               (unsigned int)bfd_h_get_16 (abfd, scn.s_nreloc),
 557               (unsigned int)bfd_h_get_16 (abfd, scn.s_nlnno));
 558       printf (_("            Flags: %08x "), flags);
 559
 560       if (~flags == 0)
 561         {
 562           /* Stripped executable ?  */
 563           putchar ('\n');
 564         }
 565       else if (flags & STYP_OVRFLO)
 566         printf (_("overflow - nreloc: %u, nlnno: %u\n"),
 567                 (unsigned int)bfd_h_get_32 (abfd, scn.s_paddr),
 568                 (unsigned int)bfd_h_get_32 (abfd, scn.s_vaddr));
 569       else
 570         {
 571           dump_flags (s_flag_xlat, flags);
 572           putchar ('\n');
 573         }
 574     }
 575 }
 576
 577 /* Read section table.  */
 578
 579 static void
 580 xcoff32_read_sections (bfd *abfd, struct xcoff_dump *data)
 581 {
 582   int i;
 583
 584   if (bfd_seek (abfd, sizeof (struct external_filehdr) + data->opthdr,
 585                 SEEK_SET) != 0)
 586     {
 587       non_fatal (_("cannot read section headers"));
 588       return;
 589     }
 590
 591   data->sects = xmalloc (data->nscns * sizeof (struct xcoff32_section));
 592   for (i = 0; i < data->nscns; i++)
 593     {
 594       struct external_scnhdr scn;
 595       struct xcoff32_section *s = &data->sects[i];
 596
 597       if (bfd_bread (&scn, sizeof (scn), abfd) != sizeof (scn))
 598         {
 599           non_fatal (_("cannot read section header"));
 600           free (data->sects);
 601           data->sects = NULL;
 602           return;
 603         }
 604       memcpy (s->name, scn.s_name, 8);
 605       s->name[8] = 0;
 606       s->flags = bfd_h_get_32 (abfd, scn.s_flags);
 607
 608       s->scnptr = bfd_h_get_32 (abfd, scn.s_scnptr);
 609       s->relptr = bfd_h_get_32 (abfd, scn.s_relptr);
 610       s->lnnoptr = bfd_h_get_32 (abfd, scn.s_lnnoptr);
 611
 612       s->nreloc = bfd_h_get_16 (abfd, scn.s_nreloc);
 613       s->nlnno = bfd_h_get_16 (abfd, scn.s_nlnno);
 614
 615       if (s->flags == STYP_OVRFLO)
 616         {
 617           if (s->nreloc > 0 && s->nreloc <= data->nscns)
 618             data->sects[s->nreloc - 1].nreloc =
 619               bfd_h_get_32 (abfd, scn.s_paddr);
 620           if (s->nlnno > 0 && s->nlnno <= data->nscns)
 621             data->sects[s->nlnno - 1].nlnno =
 622               bfd_h_get_32 (abfd, scn.s_vaddr);
 623         }
 624     }
 625 }
 626
 627 /* Read symbols.  */
 628
 629 static void
 630 xcoff32_read_symbols (bfd *abfd, struct xcoff_dump *data)
 631 {
 632   unsigned int i;
 633   char stsz_arr[4];
 634   unsigned int stptr;
 635
 636   if (data->nsyms == 0)
 637     return;
 638
 639   stptr = data->symptr
 640     + data->nsyms * (unsigned)sizeof (struct external_syment);
 641
 642   /* Read string table.  */
 643   if (bfd_seek (abfd, stptr, SEEK_SET) != 0
 644       || bfd_bread (&stsz_arr, sizeof (stsz_arr), abfd) != sizeof (stsz_arr))
 645     {
 646       non_fatal (_("cannot read strings table length"));
 647       data->strings_size = 0;
 648     }
 649   else
 650     {
 651       data->strings_size = bfd_h_get_32 (abfd, stsz_arr);
 652       if (data->strings_size > sizeof (stsz_arr))
 653         {
 654           unsigned int remsz = data->strings_size - sizeof (stsz_arr);
 655
 656           data->strings = xmalloc (data->strings_size);
 657
 658           memcpy (data->strings, stsz_arr, sizeof (stsz_arr));
 659           if (bfd_bread (data->strings + sizeof (stsz_arr), remsz, abfd)
 660               != remsz)
 661             {
 662               non_fatal (_("cannot read strings table"));
 663               goto clean;
 664             }
 665         }
 666     }
 667
 668   if (bfd_seek (abfd, data->symptr, SEEK_SET) != 0)
 669     {
 670       non_fatal (_("cannot read symbol table"));
 671       goto clean;
 672     }
 673
 674   data->syms = (union xcoff32_symbol *)
 675     xmalloc (data->nsyms * sizeof (union xcoff32_symbol));
 676
 677   for (i = 0; i < data->nsyms; i++)
 678     {
 679       struct external_syment sym;
 680       int j;
 681       union xcoff32_symbol *s = &data->syms[i];
 682
 683       if (bfd_bread (&sym, sizeof (sym), abfd) != sizeof (sym))
 684         {
 685           non_fatal (_("cannot read symbol entry"));
 686           goto clean;
 687         }
 688
 689       s->sym.val = bfd_h_get_32 (abfd, sym.e_value);
 690       s->sym.scnum = bfd_h_get_16 (abfd, sym.e_scnum);
 691       s->sym.ntype = bfd_h_get_16 (abfd, sym.e_type);
 692       s->sym.sclass = bfd_h_get_8 (abfd, sym.e_sclass);
 693       s->sym.numaux = bfd_h_get_8 (abfd, sym.e_numaux);
 694
 695       if (sym.e.e_name[0])
 696         {
 697           memcpy (s->sym.raw.name, sym.e.e_name, sizeof (sym.e.e_name));
 698           s->sym.raw.name[8] = 0;
 699           s->sym.name = s->sym.raw.name;
 700         }
 701       else
 702         {
 703           unsigned int soff = bfd_h_get_32 (abfd, sym.e.e.e_offset);
 704
 705           if ((s->sym.sclass & DBXMASK) == 0 && soff < data->strings_size)
 706             s->sym.name = data->strings + soff;
 707           else
 708             {
 709               s->sym.name = NULL;
 710               s->sym.raw.off = soff;
 711             }
 712         }
 713
 714       for (j = 0; j < s->sym.numaux; j++, i++)
 715         {
 716            if (bfd_bread (&s[j + 1].aux,
 717                           sizeof (union external_auxent), abfd)
 718                != sizeof (union external_auxent))
 719             {
 720               non_fatal (_("cannot read symbol aux entry"));
 721               goto clean;
 722             }
 723         }
 724     }
 725   return;
 726  clean:
 727   free (data->syms);
 728   data->syms = NULL;
 729   free (data->strings);
 730   data->strings = NULL;
 731 }
 732
 733 /* Dump xcoff symbols.  */
 734
 735 static void
 736 dump_xcoff32_symbols (bfd *abfd, struct xcoff_dump *data)
 737 {
 738   unsigned int i;
 739   asection *debugsec;
 740   char *debug = NULL;
 741
 742   printf (_("Symbols table (strtable at 0x%08x)"),
 743           data->symptr
 744           + data->nsyms * (unsigned)sizeof (struct external_syment));
 745   if (data->nsyms == 0 || data->syms == NULL)
 746     {
 747       printf (_(":\n  No symbols\n"));
 748       return;
 749     }
 750
 751   /* Read strings table.  */
 752   if (data->strings_size == 0)
 753     printf (_(" (no strings):\n"));
 754   else
 755     printf (_(" (strings size: %08x):\n"), data->strings_size);
 756
 757   /* Read debug section.  */
 758   debugsec = bfd_get_section_by_name (abfd, ".debug");
 759   if (debugsec != NULL)
 760     {
 761       bfd_size_type size;
 762
 763       size = bfd_get_section_size (debugsec);
 764       debug = (char *) xmalloc (size);
 765       bfd_get_section_contents (abfd, debugsec, debug, 0, size);
 766     }
 767
 768   /* Translators: 'sc' is for storage class, 'off' for offset.  */
 769   printf (_("  # sc         value    section  type aux name/off\n"));
 770   for (i = 0; i < data->nsyms; i++)
 771     {
 772       union xcoff32_symbol *s = &data->syms[i];
 773       int j;
 774
 775       printf ("%3u ", i);
 776       dump_value (sc_xlat, s->sym.sclass, 10);
 777       printf (" %08x ", s->sym.val);
 778       if (s->sym.scnum > 0 && s->sym.scnum <= data->nscns)
 779         {
 780           if (data->sects != NULL)
 781             printf ("%-8s", data->sects[s->sym.scnum - 1].name);
 782           else
 783             printf ("%-8u", s->sym.scnum);
 784         }
 785       else
 786         switch ((signed short)s->sym.scnum)
 787           {
 788           case N_DEBUG:
 789             printf ("N_DEBUG ");
 790             break;
 791           case N_ABS:
 792             printf ("N_ABS   ");
 793             break;
 794           case N_UNDEF:
 795             printf ("N_UNDEF ");
 796             break;
 797           default:
 798             printf ("(%04x)  ", s->sym.scnum);
 799           }
 800       printf (" %04x %3u ", s->sym.ntype, s->sym.numaux);
 801       if (s->sym.name != NULL)
 802         printf ("%s", s->sym.name);
 803       else
 804         {
 805           if ((s->sym.sclass & DBXMASK) != 0 && debug != NULL)
 806             printf ("%s", debug + s->sym.raw.off);
 807           else
 808             printf ("%08x", s->sym.raw.off);
 809         }
 810       putchar ('\n');
 811
 812       for (j = 0; j < s->sym.numaux; j++, i++)
 813         {
 814           union external_auxent *aux = &s[j + 1].aux;
 815
 816           printf (" %3u ", i + 1);
 817           switch (s->sym.sclass)
 818             {
 819             case C_STAT:
 820               /* Section length, number of relocs and line number.  */
 821               printf (_("  scnlen: %08x  nreloc: %-6u  nlinno: %-6u\n"),
 822                       (unsigned)bfd_h_get_32 (abfd, aux->x_scn.x_scnlen),
 823                       (unsigned)bfd_h_get_16 (abfd, aux->x_scn.x_nreloc),
 824                       (unsigned)bfd_h_get_16 (abfd, aux->x_scn.x_nlinno));
 825               break;
 826             case C_DWARF:
 827               /* Section length and number of relocs.  */
 828               printf (_("  scnlen: %08x  nreloc: %-6u\n"),
 829                       (unsigned)bfd_h_get_32 (abfd, aux->x_scn.x_scnlen),
 830                       (unsigned)bfd_h_get_16 (abfd, aux->x_scn.x_nreloc));
 831               break;
 832             case C_EXT:
 833             case C_WEAKEXT:
 834             case C_HIDEXT:
 835               if (j == 0 && s->sym.numaux > 1)
 836                 {
 837                   /* Function aux entry  (Do not translate).  */
 838                   printf ("  exptr: %08x fsize: %08x lnnoptr: %08x endndx: %u\n",
 839                           (unsigned)bfd_h_get_32 (abfd, aux->x_sym.x_tagndx),
 840                           (unsigned)bfd_h_get_32
 841                             (abfd, aux->x_sym.x_misc.x_fsize),
 842                           (unsigned)bfd_h_get_32
 843                             (abfd, aux->x_sym.x_fcnary.x_fcn.x_lnnoptr),
 844                           (unsigned)bfd_h_get_32
 845                             (abfd, aux->x_sym.x_fcnary.x_fcn.x_endndx));
 846                 }
 847               else if (j == 1 || (j == 0 && s->sym.numaux == 1))
 848                 {
 849                   /* csect aux entry.  */
 850                   unsigned char smtyp;
 851                   unsigned int scnlen;
 852
 853                   smtyp = bfd_h_get_8 (abfd, aux->x_csect.x_smtyp);
 854                   scnlen = bfd_h_get_32 (abfd, aux->x_csect.x_scnlen);
 855
 856                   if (smtyp == XTY_LD)
 857                     printf ("  scnsym: %-8u", scnlen);
 858                   else
 859                     printf ("  scnlen: %08x", scnlen);
 860                   printf (" h: parm=%08x sn=%04x al: 2**%u",
 861                           (unsigned)bfd_h_get_32 (abfd, aux->x_csect.x_parmhash),
 862                           (unsigned)bfd_h_get_16 (abfd, aux->x_csect.x_snhash),
 863                           SMTYP_ALIGN (smtyp));
 864                   printf (" typ: ");
 865                   dump_value (smtyp_xlat, SMTYP_SMTYP (smtyp), 2);
 866                   printf (" cl: ");
 867                   dump_value
 868                     (smclas_xlat,
 869                      (unsigned)bfd_h_get_8 (abfd, aux->x_csect.x_smclas), 6);
 870                   putchar ('\n');
 871                 }
 872               else
 873                 /* Do not translate - generic field name.  */
 874                 printf ("aux\n");
 875               break;
 876             case C_FILE:
 877               {
 878                 unsigned int off;
 879
 880                 printf (" ftype: %02x ",
 881                         (unsigned)bfd_h_get_8 (abfd, aux->x_file.x_ftype));
 882                 if (aux->x_file.x_n.x_fname[0] != 0)
 883                   printf ("fname: %.14s", aux->x_file.x_n.x_fname);
 884                 else
 885                   {
 886                     off = (unsigned)bfd_h_get_32
 887                       (abfd, aux->x_file.x_n.x_n.x_offset);
 888                     if (data->strings != NULL && off < data->strings_size)
 889                       printf (" %s", data->strings + off);
 890                     else
 891                       printf (_("offset: %08x"), off);
 892                   }
 893                 putchar ('\n');
 894               }
 895               break;
 896             case C_BLOCK:
 897             case C_FCN:
 898               printf ("  lnno: %u\n",
 899                       (unsigned)bfd_h_get_16
 900                       (abfd, aux->x_sym.x_misc.x_lnsz.x_lnno));
 901               break;
 902             default:
 903               /* Do not translate - generic field name.  */
 904               printf ("aux\n");
 905               break;
 906             }
 907         }
 908
 909     }
 910   free (debug);
 911 }
 912
 913 /* Dump xcoff relocation entries.  */
 914
 915 static void
 916 dump_xcoff32_relocs (bfd *abfd, struct xcoff_dump *data)
 917 {
 918   unsigned int i;
 919
 920   if (data->sects == NULL)
 921     {
 922       non_fatal (_("cannot read section headers"));
 923       return;
 924     }
 925
 926   for (i = 0; i < data->nscns; i++)
 927     {
 928       struct xcoff32_section *sect = &data->sects[i];
 929       unsigned int nrel = sect->nreloc;
 930       unsigned int j;
 931
 932       if (nrel == 0)
 933         continue;
 934       printf (_("Relocations for %s (%u)\n"), sect->name, nrel);
 935       if (bfd_seek (abfd, sect->relptr, SEEK_SET) != 0)
 936         {
 937           non_fatal (_("cannot read relocations"));
 938           continue;
 939         }
 940       /* Do not translate: fields name.  */
 941       printf ("vaddr    sgn mod sz type  symndx symbol\n");
 942       for (j = 0; j < nrel; j++)
 943         {
 944           struct external_reloc rel;
 945           unsigned char rsize;
 946           unsigned int symndx;
 947
 948           if (bfd_bread (&rel, sizeof (rel), abfd) != sizeof (rel))
 949             {
 950               non_fatal (_("cannot read relocation entry"));
 951               return;
 952             }
 953           rsize = bfd_h_get_8 (abfd, rel.r_size);
 954           printf ("%08x  %c   %c  %-2u ",
 955                   (unsigned int)bfd_h_get_32 (abfd, rel.r_vaddr),
 956                   rsize & 0x80 ? 'S' : 'U',
 957                   rsize & 0x40 ? 'm' : ' ',
 958                   (rsize & 0x3f) + 1);
 959           dump_value (rtype_xlat, bfd_h_get_8 (abfd, rel.r_type), 6);
 960           symndx = bfd_h_get_32 (abfd, rel.r_symndx);
 961           printf ("%-6u ", symndx);
 962           xcoff32_print_symbol (data, symndx);
 963           putchar ('\n');
 964         }
 965       putchar ('\n');
 966     }
 967 }
 968
 969 /* Dump xcoff line number entries.  */
 970
 971 static void
 972 dump_xcoff32_lineno (bfd *abfd, struct xcoff_dump *data)
 973 {
 974   unsigned int i;
 975
 976   if (data->sects == NULL)
 977     {
 978       non_fatal (_("cannot read section headers"));
 979       return;
 980     }
 981
 982   for (i = 0; i < data->nscns; i++)
 983     {
 984       struct xcoff32_section *sect = &data->sects[i];
 985       unsigned int nlnno = sect->nlnno;
 986       unsigned int j;
 987
 988       if (nlnno == 0)
 989         continue;
 990       printf (_("Line numbers for %s (%u)\n"), sect->name, nlnno);
 991       if (bfd_seek (abfd, sect->lnnoptr, SEEK_SET) != 0)
 992         {
 993           non_fatal (_("cannot read line numbers"));
 994           continue;
 995         }
 996       /* Line number, symbol index and physical address.  */
 997       printf (_("lineno  symndx/paddr\n"));
 998       for (j = 0; j < nlnno; j++)
 999         {
1000           struct external_lineno ln;
1001           unsigned int no;
1002
1003           if (bfd_bread (&ln, sizeof (ln), abfd) != sizeof (ln))
1004             {
1005               non_fatal (_("cannot read line number entry"));
1006               return;
1007             }
1008           no = bfd_h_get_16 (abfd, ln.l_lnno);
1009           printf (" %-6u ", no);
1010           if (no == 0)
1011             {
1012               unsigned int symndx = bfd_h_get_32 (abfd, ln.l_addr.l_symndx);
1013               xcoff32_print_symbol (data, symndx);
1014             }
1015           else
1016             printf ("0x%08x",
1017                     (unsigned int)bfd_h_get_32 (abfd, ln.l_addr.l_paddr));
1018           putchar ('\n');
1019         }
1020     }
1021 }
1022
1023 /* Dump xcoff loader section.  */
1024
1025 static void
1026 dump_xcoff32_loader (bfd *abfd)
1027 {
1028   asection *loader;
1029   bfd_size_type size = 0;
1030   struct external_ldhdr *lhdr;
1031   struct external_ldsym *ldsym;
1032   struct external_ldrel *ldrel;
1033   bfd_byte *ldr_data;
1034   unsigned int version;
1035   unsigned int ndsyms;
1036   unsigned int ndrel;
1037   unsigned int stlen;
1038   unsigned int stoff;
1039   unsigned int impoff;
1040   unsigned int nimpid;
1041   unsigned int i;
1042   const char *p;
1043
1044   loader = bfd_get_section_by_name (abfd, ".loader");
1045
1046   if (loader == NULL)
1047     {
1048       printf (_("no .loader section in file\n"));
1049       return;
1050     }
1051   size = bfd_get_section_size (loader);
1052   if (size < sizeof (*lhdr))
1053     {
1054       printf (_("section .loader is too short\n"));
1055       return;
1056     }
1057
1058   ldr_data = (bfd_byte *) xmalloc (size);
1059   bfd_get_section_contents (abfd, loader, ldr_data, 0, size);
1060   lhdr = (struct external_ldhdr *)ldr_data;
1061   printf (_("Loader header:\n"));
1062   version = bfd_h_get_32 (abfd, lhdr->l_version);
1063   printf (_("  version:           %u\n"), version);
1064   if (version != 1)
1065     {
1066       printf (_(" Unhandled version\n"));
1067       free (ldr_data);
1068       return;
1069     }
1070   ndsyms = bfd_h_get_32 (abfd, lhdr->l_nsyms);
1071   printf (_("  nbr symbols:       %u\n"), ndsyms);
1072   ndrel = bfd_h_get_32 (abfd, lhdr->l_nreloc);
1073   printf (_("  nbr relocs:        %u\n"), ndrel);
1074   /* Import string table length.  */
1075   printf (_("  import strtab len: %u\n"),
1076           (unsigned) bfd_h_get_32 (abfd, lhdr->l_istlen));
1077   nimpid = bfd_h_get_32 (abfd, lhdr->l_nimpid);
1078   printf (_("  nbr import files:  %u\n"), nimpid);
1079   impoff = bfd_h_get_32 (abfd, lhdr->l_impoff);
1080   printf (_("  import file off:   %u\n"), impoff);
1081   stlen = bfd_h_get_32 (abfd, lhdr->l_stlen);
1082   printf (_("  string table len:  %u\n"), stlen);
1083   stoff = bfd_h_get_32 (abfd, lhdr->l_stoff);
1084   printf (_("  string table off:  %u\n"), stoff);
1085
1086   ldsym = (struct external_ldsym *)(ldr_data + sizeof (*lhdr));
1087   printf (_("Dynamic symbols:\n"));
1088   /* Do not translate: field names.  */
1089   printf ("     # value     sc IFEW ty class file  pa name\n");
1090   for (i = 0; i < ndsyms; i++, ldsym++)
1091     {
1092       unsigned char smtype;
1093
1094       printf (_("  %4u %08x %3u "), i,
1095               (unsigned)bfd_h_get_32 (abfd, ldsym->l_value),
1096               (unsigned)bfd_h_get_16 (abfd, ldsym->l_scnum));
1097       smtype = bfd_h_get_8 (abfd, ldsym->l_smtype);
1098       putchar (smtype & 0x40 ? 'I' : ' ');
1099       putchar (smtype & 0x20 ? 'F' : ' ');
1100       putchar (smtype & 0x10 ? 'E' : ' ');
1101       putchar (smtype & 0x08 ? 'W' : ' ');
1102       putchar (' ');
1103       dump_value (smtyp_xlat, SMTYP_SMTYP (smtype), 2);
1104       putchar (' ');
1105       dump_value
1106         (smclas_xlat, (unsigned)bfd_h_get_8 (abfd, ldsym->l_smclas), 6);
1107       printf (_(" %3u %3u "),
1108               (unsigned)bfd_h_get_32 (abfd, ldsym->l_ifile),
1109               (unsigned)bfd_h_get_32 (abfd, ldsym->l_parm));
1110       if (ldsym->_l._l_name[0] != 0)
1111         printf ("%-.8s", ldsym->_l._l_name);
1112       else
1113         {
1114           unsigned int off = bfd_h_get_32 (abfd, ldsym->_l._l_l._l_offset);
1115           if (off > stlen)
1116             printf (_("(bad offset: %u)"), off);
1117           else
1118             printf ("%s", ldr_data + stoff + off);
1119         }
1120       putchar ('\n');
1121     }
1122
1123   printf (_("Dynamic relocs:\n"));
1124   /* Do not translate fields name.  */
1125   printf ("  vaddr    sec    sz typ   sym\n");
1126   ldrel = (struct external_ldrel *)(ldr_data + sizeof (*lhdr)
1127                                     + ndsyms * sizeof (*ldsym));
1128   for (i = 0; i < ndrel; i++, ldrel++)
1129     {
1130       unsigned int rsize;
1131       unsigned int rtype;
1132       unsigned int symndx;
1133
1134       rsize = bfd_h_get_8 (abfd, ldrel->l_rtype + 0);
1135       rtype = bfd_h_get_8 (abfd, ldrel->l_rtype + 1);
1136
1137       printf ("  %08x %3u %c%c %2u ",
1138               (unsigned)bfd_h_get_32 (abfd, ldrel->l_vaddr),
1139               (unsigned)bfd_h_get_16 (abfd, ldrel->l_rsecnm),
1140               rsize & 0x80 ? 'S' : 'U',
1141               rsize & 0x40 ? 'm' : ' ',
1142               (rsize & 0x3f) + 1);
1143       dump_value (rtype_xlat, rtype, 6);
1144       symndx = bfd_h_get_32 (abfd, ldrel->l_symndx);
1145       switch (symndx)
1146         {
1147         case 0:
1148           printf (".text");
1149           break;
1150         case 1:
1151           printf (".data");
1152           break;
1153         case 2:
1154           printf (".bss");
1155           break;
1156         default:
1157           printf ("%u", symndx - 3);
1158           break;
1159         }
1160       putchar ('\n');
1161     }
1162
1163   printf (_("Import files:\n"));
1164   p = (char *)ldr_data + impoff;
1165   for (i = 0; i < nimpid; i++)
1166     {
1167       int n1, n2, n3;
1168
1169       n1 = strlen (p);
1170       n2 = strlen (p + n1 + 1);
1171       n3 = strlen (p + n1 + 1 + n2+ 1);
1172       printf (" %2u: %s,%s,%s\n", i,
1173               p, p + n1 + 1, p + n1 + n2 + 2);
1174       p += n1 + n2 + n3 + 3;
1175     }
1176
1177   free (ldr_data);
1178 }
1179
1180 /* Dump xcoff exception section.  */
1181
1182 static void
1183 dump_xcoff32_except (bfd *abfd, struct xcoff_dump *data)
1184 {
1185   asection *sec;
1186   bfd_size_type size = 0;
1187   bfd_byte *excp_data;
1188   struct external_exceptab *exceptab;
1189   unsigned int i;
1190
1191   sec = bfd_get_section_by_name (abfd, ".except");
1192
1193   if (sec == NULL)
1194     {
1195       printf (_("no .except section in file\n"));
1196       return;
1197     }
1198   size = bfd_get_section_size (sec);
1199   excp_data = (bfd_byte *) xmalloc (size);
1200   bfd_get_section_contents (abfd, sec, excp_data, 0, size);
1201   exceptab = (struct external_exceptab *)excp_data;
1202
1203   printf (_("Exception table:\n"));
1204   /* Do not translate fields name.  */
1205   printf ("lang reason sym/addr\n");
1206   for (i = 0; i * sizeof (*exceptab) < size; i++, exceptab++)
1207     {
1208       unsigned int reason;
1209       unsigned int addr;
1210
1211       addr = bfd_get_32 (abfd, exceptab->e_addr.e_paddr);
1212       reason = bfd_get_8 (abfd, exceptab->e_reason);
1213       printf ("  %02x     %02x ",
1214               (unsigned) bfd_get_8 (abfd, exceptab->e_lang), reason);
1215       if (reason == 0)
1216         xcoff32_print_symbol (data, addr);
1217       else
1218         printf ("@%08x", addr);
1219       putchar ('\n');
1220     }
1221   free (excp_data);
1222 }
1223
1224 /* Dump xcoff type-check section.  */
1225
1226 static void
1227 dump_xcoff32_typchk (bfd *abfd)
1228 {
1229   asection *sec;
1230   bfd_size_type size = 0;
1231   bfd_byte *data;
1232   unsigned int i;
1233
1234   sec = bfd_get_section_by_name (abfd, ".typchk");
1235
1236   if (sec == NULL)
1237     {
1238       printf (_("no .typchk section in file\n"));
1239       return;
1240     }
1241   size = bfd_get_section_size (sec);
1242   data = (bfd_byte *) xmalloc (size);
1243   bfd_get_section_contents (abfd, sec, data, 0, size);
1244
1245   printf (_("Type-check section:\n"));
1246   /* Do not translate field names.  */
1247   printf ("offset    len  lang-id general-hash language-hash\n");
1248   for (i = 0; i < size;)
1249     {
1250       unsigned int len;
1251
1252       len = bfd_get_16 (abfd, data + i);
1253       printf ("%08x: %-4u ", i, len);
1254       i += 2;
1255
1256       if (len == 10)
1257         {
1258           /* Expected format.  */
1259           printf ("%04x    %08x     %08x\n",
1260                   (unsigned) bfd_get_16 (abfd, data + i),
1261                   (unsigned) bfd_get_32 (abfd, data + i + 2),
1262                   (unsigned) bfd_get_32 (abfd, data + i + 2 + 4));
1263         }
1264       else
1265         {
1266           unsigned int j;
1267
1268           for (j = 0; j < len; j++)
1269             {
1270               if (j % 16 == 0)
1271                 printf ("\n    ");
1272               printf (" %02x", (unsigned char)data[i + j]);
1273             }
1274           putchar ('\n');
1275         }
1276       i += len;
1277     }
1278   free (data);
1279 }
1280
1281 /* Dump xcoff traceback tags section.  */
1282
1283 static void
1284 dump_xcoff32_tbtags (bfd *abfd,
1285                      const char *text, bfd_size_type text_size,
1286                      unsigned int text_start, unsigned int func_start)
1287 {
1288   unsigned int i;
1289
1290   if (func_start - text_start > text_size)
1291     {
1292       printf (_(" address beyond section size\n"));
1293       return;
1294     }
1295   for (i = func_start - text_start; i < text_size; i+= 4)
1296     if (bfd_get_32 (abfd, text + i) == 0)
1297       {
1298         unsigned int tb1;
1299         unsigned int tb2;
1300         unsigned int off;
1301
1302         printf (_(" tags at %08x\n"), i + 4);
1303         if (i + 8 >= text_size)
1304           goto truncated;
1305
1306         tb1 = bfd_get_32 (abfd, text + i + 4);
1307         tb2 = bfd_get_32 (abfd, text + i + 8);
1308         off = i + 12;
1309         printf (" version: %u, lang: %u, global_link: %u, is_eprol: %u, has_tboff: %u, int_proc: %u\n",
1310                 (tb1 >> 24) & 0xff,
1311                 (tb1 >> 16) & 0xff,
1312                 (tb1 >> 15) & 1,
1313                 (tb1 >> 14) & 1,
1314                 (tb1 >> 13) & 1,
1315                 (tb1 >> 12) & 1);
1316         printf (" has_ctl: %u, tocless: %u, fp_pres: %u, log_abort: %u, int_hndl: %u\n",
1317                 (tb1 >> 11) & 1,
1318                 (tb1 >> 10) & 1,
1319                 (tb1 >> 9) & 1,
1320                 (tb1 >> 8) & 1,
1321                 (tb1 >> 7) & 1);
1322         printf (" name_pres: %u, uses_alloca: %u, cl_dis_inv: %u, saves_cr: %u, saves_lr: %u\n",
1323                 (tb1 >> 6) & 1,
1324                 (tb1 >> 5) & 1,
1325                 (tb1 >> 2) & 7,
1326                 (tb1 >> 1) & 1,
1327                 (tb1 >> 0) & 1);
1328         printf (" stores_bc: %u, fixup: %u, fpr_saved: %-2u, spare3: %u, gpr_saved: %-2u\n",
1329                 (tb2 >> 31) & 1,
1330                 (tb2 >> 30) & 1,
1331                 (tb2 >> 24) & 63,
1332                 (tb2 >> 22) & 3,
1333                 (tb2 >> 16) & 63);
1334         printf (" fixparms: %-3u  floatparms: %-3u  parm_on_stk: %u\n",
1335                 (tb2 >> 8) & 0xff,
1336                 (tb2 >> 1) & 0x7f,
1337                 (tb2 >> 0) & 1);
1338
1339         if (((tb2 >> 1) & 0x7fff) != 0)
1340           {
1341             unsigned int parminfo;
1342
1343             if (off >= text_size)
1344               goto truncated;
1345             parminfo = bfd_get_32 (abfd, text + off);
1346             off += 4;
1347             printf (" parminfo: 0x%08x\n", parminfo);
1348           }
1349
1350         if ((tb1 >> 13) & 1)
1351           {
1352             unsigned int tboff;
1353
1354             if (off >= text_size)
1355               goto truncated;
1356             tboff = bfd_get_32 (abfd, text + off);
1357             off += 4;
1358             printf (" tb_offset: 0x%08x (start=0x%08x)\n",
1359                     tboff, text_start + i - tboff);
1360           }
1361         if ((tb1 >> 7) & 1)
1362           {
1363             unsigned int hand_mask;
1364
1365             if (off >= text_size)
1366               goto truncated;
1367             hand_mask = bfd_get_32 (abfd, text + off);
1368             off += 4;
1369             printf (" hand_mask_offset: 0x%08x\n", hand_mask);
1370           }
1371         if ((tb1 >> 11) & 1)
1372           {
1373             unsigned int ctl_info;
1374             unsigned int j;
1375
1376             if (off >= text_size)
1377               goto truncated;
1378             ctl_info = bfd_get_32 (abfd, text + off);
1379             off += 4;
1380             printf (_(" number of CTL anchors: %u\n"), ctl_info);
1381             for (j = 0; j < ctl_info; j++)
1382               {
1383                 if (off >= text_size)
1384                   goto truncated;
1385                 printf ("  CTL[%u]: %08x\n",
1386                         j, (unsigned)bfd_get_32 (abfd, text + off));
1387                 off += 4;
1388               }
1389           }
1390         if ((tb1 >> 6) & 1)
1391           {
1392             unsigned int name_len;
1393             unsigned int j;
1394
1395             if (off >= text_size)
1396               goto truncated;
1397             name_len = bfd_get_16 (abfd, text + off);
1398             off += 2;
1399             printf (_(" Name (len: %u): "), name_len);
1400             if (off + name_len >= text_size)
1401               {
1402                 printf (_("[truncated]\n"));
1403                 goto truncated;
1404               }
1405             for (j = 0; j < name_len; j++)
1406               if (ISPRINT (text[off + j]))
1407                 putchar (text[off + j]);
1408               else
1409                 printf ("[%02x]", (unsigned char)text[off + j]);
1410             putchar ('\n');
1411             off += name_len;
1412           }
1413         if ((tb1 >> 5) & 1)
1414           {
1415             if (off >= text_size)
1416               goto truncated;
1417             printf (" alloca reg: %u\n",
1418                     (unsigned) bfd_get_8 (abfd, text + off));
1419             off++;
1420           }
1421         printf (_(" (end of tags at %08x)\n"), text_start + off);
1422         return;
1423       }
1424   printf (_(" no tags found\n"));
1425   return;
1426
1427  truncated:
1428   printf (_(" Truncated .text section\n"));
1429   return;
1430 }
1431
1432 static void
1433 dump_xcoff32_traceback (bfd *abfd, struct xcoff_dump *data)
1434 {
1435   unsigned int i;
1436   unsigned int scnum_text = -1;
1437   unsigned int text_vma;
1438   asection *text_sec;
1439   bfd_size_type text_size;
1440   char *text;
1441
1442   if (data->syms == NULL || data->sects == NULL)
1443     return;
1444
1445   /* Read text section.  */
1446   text_sec = bfd_get_section_by_name (abfd, ".text");
1447   if (text_sec == NULL)
1448     return;
1449   text_vma = bfd_get_section_vma (abfd, text_sec);
1450
1451   text_size = bfd_get_section_size (text_sec);
1452   text = (char *) xmalloc (text_size);
1453   bfd_get_section_contents (abfd, text_sec, text, 0, text_size);
1454
1455   for (i = 0; i < data->nscns; i++)
1456     if (data->sects[i].flags == STYP_TEXT)
1457       {
1458         scnum_text = i + 1;
1459         break;
1460       }
1461   if (scnum_text == (unsigned int)-1)
1462     return;
1463
1464   for (i = 0; i < data->nsyms; i++)
1465     {
1466       union xcoff32_symbol *s = &data->syms[i];
1467
1468       switch (s->sym.sclass)
1469         {
1470         case C_EXT:
1471         case C_HIDEXT:
1472         case C_WEAKEXT:
1473           if (s->sym.scnum == scnum_text
1474               && s->sym.numaux > 0)
1475             {
1476               union external_auxent *aux = &s[s->sym.numaux].aux;
1477
1478               unsigned int smtyp;
1479               unsigned int smclas;
1480
1481               smtyp = bfd_h_get_8 (abfd, aux->x_csect.x_smtyp);
1482               smclas = bfd_h_get_8 (abfd, aux->x_csect.x_smclas);
1483               if (SMTYP_SMTYP (smtyp) == XTY_LD
1484                   && (smclas == XMC_PR
1485                       || smclas == XMC_GL
1486                       || smclas == XMC_XO))
1487                 {
1488                   printf ("%08x: ", s->sym.val);
1489                   xcoff32_print_symbol (data, i);
1490                   putchar ('\n');
1491                   dump_xcoff32_tbtags (abfd, text, text_size,
1492                                        text_vma, s->sym.val);
1493                 }
1494             }
1495           break;
1496         default:
1497           break;
1498         }
1499       i += s->sym.numaux;
1500     }
1501   free (text);
1502 }
1503
1504 /* Dump the TOC symbols.  */
1505
1506 static void
1507 dump_xcoff32_toc (bfd *abfd, struct xcoff_dump *data)
1508 {
1509   unsigned int i;
1510   unsigned int nbr_ent;
1511   unsigned int size;
1512
1513   printf (_("TOC:\n"));
1514
1515   if (data->syms == NULL)
1516     return;
1517
1518   nbr_ent = 0;
1519   size = 0;
1520
1521   for (i = 0; i < data->nsyms; i++)
1522     {
1523       union xcoff32_symbol *s = &data->syms[i];
1524
1525       switch (s->sym.sclass)
1526         {
1527         case C_EXT:
1528         case C_HIDEXT:
1529         case C_WEAKEXT:
1530           if (s->sym.numaux > 0)
1531             {
1532               union external_auxent *aux = &s[s->sym.numaux].aux;
1533               unsigned int smclas;
1534               unsigned int ent_sz;
1535
1536               smclas = bfd_h_get_8 (abfd, aux->x_csect.x_smclas);
1537               if (smclas == XMC_TC
1538                   || smclas == XMC_TD
1539                   || smclas == XMC_TC0)
1540                 {
1541                   ent_sz = bfd_h_get_32 (abfd, aux->x_scn.x_scnlen);
1542                   printf ("%08x %08x ",
1543                           s->sym.val, ent_sz);
1544                   xcoff32_print_symbol (data, i);
1545                   putchar ('\n');
1546                   nbr_ent++;
1547                   size += ent_sz;
1548                 }
1549             }
1550           break;
1551         default:
1552           break;
1553         }
1554       i += s->sym.numaux;
1555     }
1556   printf (_("Nbr entries: %-8u Size: %08x (%u)\n"),
1557           nbr_ent, size, size);
1558 }
1559
1560 /* Handle an rs6000 xcoff file.  */
1561
1562 static void
1563 dump_xcoff32 (bfd *abfd, struct external_filehdr *fhdr)
1564 {
1565   struct xcoff_dump data;
1566
1567   data.nscns = bfd_h_get_16 (abfd, fhdr->f_nscns);
1568   data.symptr = bfd_h_get_32 (abfd, fhdr->f_symptr);
1569   data.nsyms = bfd_h_get_32 (abfd, fhdr->f_nsyms);
1570   data.opthdr = bfd_h_get_16 (abfd, fhdr->f_opthdr);
1571   data.sects = NULL;
1572   data.syms = NULL;
1573   data.strings = NULL;
1574   data.strings_size = 0;
1575
1576   if (options[OPT_FILE_HEADER].selected)
1577     dump_xcoff32_file_header (abfd, fhdr, &data);
1578
1579   if (options[OPT_AOUT].selected)
1580     dump_xcoff32_aout_header (abfd, &data);
1581
1582   if (options[OPT_SYMS].selected
1583       || options[OPT_RELOCS].selected
1584       || options[OPT_LINENO].selected
1585       || options[OPT_TRACEBACK].selected)
1586     xcoff32_read_sections (abfd, &data);
1587
1588   if (options[OPT_SECTIONS].selected)
1589     dump_xcoff32_sections_header (abfd, &data);
1590
1591   if (options[OPT_SYMS].selected
1592       || options[OPT_RELOCS].selected
1593       || options[OPT_LINENO].selected
1594       || options[OPT_EXCEPT].selected
1595       || options[OPT_TRACEBACK].selected
1596       || options[OPT_TOC].selected)
1597     xcoff32_read_symbols (abfd, &data);
1598
1599   if (options[OPT_SYMS].selected)
1600     dump_xcoff32_symbols (abfd, &data);
1601
1602   if (options[OPT_RELOCS].selected)
1603     dump_xcoff32_relocs (abfd, &data);
1604
1605   if (options[OPT_LINENO].selected)
1606     dump_xcoff32_lineno (abfd, &data);
1607
1608   if (options[OPT_LOADER].selected)
1609     dump_xcoff32_loader (abfd);
1610
1611   if (options[OPT_EXCEPT].selected)
1612     dump_xcoff32_except (abfd, &data);
1613
1614   if (options[OPT_TYPCHK].selected)
1615     dump_xcoff32_typchk (abfd);
1616
1617   if (options[OPT_TRACEBACK].selected)
1618     dump_xcoff32_traceback (abfd, &data);
1619
1620   if (options[OPT_TOC].selected)
1621     dump_xcoff32_toc (abfd, &data);
1622
1623   free (data.sects);
1624   free (data.strings);
1625   free (data.syms);
1626 }
1627
1628 /* Dump ABFD (according to the options[] array).  */
1629
1630 static void
1631 xcoff_dump (bfd *abfd)
1632 {
1633   struct external_filehdr fhdr;
1634   unsigned short magic;
1635
1636   /* Read file header.  */
1637   if (bfd_seek (abfd, 0, SEEK_SET) != 0
1638       || bfd_bread (&fhdr, sizeof (fhdr), abfd) != sizeof (fhdr))
1639     {
1640       non_fatal (_("cannot read header"));
1641       return;
1642     }
1643
1644   /* Decoding.  We don't use the bfd/coff function to get all the fields.  */
1645   magic = bfd_h_get_16 (abfd, fhdr.f_magic);
1646   if (options[OPT_FILE_HEADER].selected)
1647     {
1648       printf (_("File header:\n"));
1649       printf (_("  magic:         0x%04x (0%04o)  "), magic, magic);
1650       switch (magic)
1651         {
1652         case U802WRMAGIC:
1653           printf (_("(WRMAGIC: writable text segments)"));
1654           break;
1655         case U802ROMAGIC:
1656           printf (_("(ROMAGIC: readonly sharablee text segments)"));
1657           break;
1658         case U802TOCMAGIC:
1659           printf (_("(TOCMAGIC: readonly text segments and TOC)"));
1660           break;
1661         default:
1662           printf (_("unknown magic"));
1663         }
1664       putchar ('\n');
1665     }
1666   if (magic == U802ROMAGIC || magic == U802WRMAGIC || magic == U802TOCMAGIC)
1667     dump_xcoff32 (abfd, &fhdr);
1668   else
1669     printf (_("  Unhandled magic\n"));
1670 }
1671
1672 /* Vector for xcoff.  */
1673
1674 const struct objdump_private_desc objdump_private_desc_xcoff =
1675   {
1676     xcoff_help,
1677     xcoff_filter,
1678     xcoff_dump,
1679     options
1680   };