OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [binutils/] [od-xcoff.c] - Blame information for rev 133

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 15 khays 
/* od-xcoff.c -- dump information about an xcoff object file.
2 
   Copyright 2011 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 <stddef.h>
23 
#include <time.h>
24 
#include "sysdep.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 
  printf (_("  o_mflag (magic): 0x%04x 0%04o\n"), magic, magic);
463 
  printf (_("  o_vstamp:        0x%04x\n"),
464 
          (unsigned short)bfd_h_get_16 (abfd, auxhdr.vstamp));
465 
  printf (_("  o_tsize:         0x%08x\n"),
466 
          (unsigned int)bfd_h_get_32 (abfd, auxhdr.tsize));
467 
  printf (_("  o_dsize:         0x%08x\n"),
468 
          (unsigned int)bfd_h_get_32 (abfd, auxhdr.dsize));
469 
  printf (_("  o_entry:         0x%08x\n"),
470 
          (unsigned int)bfd_h_get_32 (abfd, auxhdr.entry));
471 
  printf (_("  o_text_start:    0x%08x\n"),
472 
          (unsigned int)bfd_h_get_32 (abfd, auxhdr.text_start));
473 
  printf (_("  o_data_start:    0x%08x\n"),
474 
          (unsigned int)bfd_h_get_32 (abfd, auxhdr.data_start));
475 
  if (sz == offsetof (AOUTHDR, o_toc))
476 
    return;
477 
  printf (_("  o_toc:           0x%08x\n"),
478 
          (unsigned int)bfd_h_get_32 (abfd, auxhdr.o_toc));
479 
  printf (_("  o_snentry:       0x%04x\n"),
480 
          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_snentry));
481 
  printf (_("  o_sntext:        0x%04x\n"),
482 
          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_sntext));
483 
  printf (_("  o_sndata:        0x%04x\n"),
484 
          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_sndata));
485 
  printf (_("  o_sntoc:         0x%04x\n"),
486 
          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_sntoc));
487 
  printf (_("  o_snloader:      0x%04x\n"),
488 
          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_snloader));
489 
  printf (_("  o_snbss:         0x%04x\n"),
490 
          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_snbss));
491 
  printf (_("  o_algntext:      %u\n"),
492 
          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_algntext));
493 
  printf (_("  o_algndata:      %u\n"),
494 
          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_algndata));
495 
  printf (_("  o_modtype:       0x%04x"),
496 
          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_modtype));
497 
  if (ISPRINT (auxhdr.o_modtype[0]) && ISPRINT (auxhdr.o_modtype[1]))
498 
    printf (" (%c%c)", auxhdr.o_modtype[0], auxhdr.o_modtype[1]);
499 
  putchar ('\n');
500 
  printf (_("  o_cputype:       0x%04x\n"),
501 
          (unsigned int)bfd_h_get_16 (abfd, auxhdr.o_cputype));
502 
  printf (_("  o_maxstack:      0x%08x\n"),
503 
          (unsigned int)bfd_h_get_32 (abfd, auxhdr.o_maxstack));
504 
  printf (_("  o_maxdata:       0x%08x\n"),
505 
          (unsigned int)bfd_h_get_32 (abfd, auxhdr.o_maxdata));
506 
#if 0
507 
  printf (_("  o_debugger:      0x%08x\n"),
508 
          (unsigned int)bfd_h_get_32 (abfd, auxhdr.o_debugger));
509 
#endif
510 
}
511 
 
512 
/* Dump the sections header.  */
513 
 
514 
static void
515 
dump_xcoff32_sections_header (bfd *abfd, struct xcoff_dump *data)
516 
{
517 
  unsigned int i;
518 
  unsigned int off;
519 
 
520 
  off = sizeof (struct external_filehdr) + data->opthdr;
521 
  printf (_("Section headers (at %u+%u=0x%08x to 0x%08x):\n"),
522 
          (unsigned int)sizeof (struct external_filehdr), data->opthdr, off,
523 
          off + (unsigned int)sizeof (struct external_scnhdr) * data->nscns);
524 
  if (data->nscns == 0)
525 
    {
526 
      printf (_("  No section header\n"));
527 
      return;
528 
    }
529 
  if (bfd_seek (abfd, off, SEEK_SET) != 0)
530 
    {
531 
      non_fatal (_("cannot read section header"));
532 
      return;
533 
    }
534 
  printf (_(" # Name     paddr    vaddr    size     scnptr   relptr   lnnoptr  nrel  nlnno\n"));
535 
  for (i = 0; i < data->nscns; i++)
536 
    {
537 
      struct external_scnhdr scn;
538 
      unsigned int flags;
539 
 
540 
      if (bfd_bread (&scn, sizeof (scn), abfd) != sizeof (scn))
541 
        {
542 
          non_fatal (_("cannot read section header"));
543 
          return;
544 
        }
545 
      flags = bfd_h_get_32 (abfd, scn.s_flags);
546 
      printf (_("%2d %-8.8s %08x %08x %08x %08x %08x %08x "
547 
                "%-5d %-5d\n"),
548 
              i + 1, scn.s_name,
549 
              (unsigned int)bfd_h_get_32 (abfd, scn.s_paddr),
550 
              (unsigned int)bfd_h_get_32 (abfd, scn.s_vaddr),
551 
              (unsigned int)bfd_h_get_32 (abfd, scn.s_size),
552 
              (unsigned int)bfd_h_get_32 (abfd, scn.s_scnptr),
553 
              (unsigned int)bfd_h_get_32 (abfd, scn.s_relptr),
554 
              (unsigned int)bfd_h_get_32 (abfd, scn.s_lnnoptr),
555 
              (unsigned int)bfd_h_get_16 (abfd, scn.s_nreloc),
556 
              (unsigned int)bfd_h_get_16 (abfd, scn.s_nlnno));
557 
      printf (_("            Flags: %08x "), flags);
558 
 
559 
      if (~flags == 0)
560 
        {
561 
          /* Stripped executable ?  */
562 
          putchar ('\n');
563 
        }
564 
      else if (flags & STYP_OVRFLO)
565 
        printf (_("overflow - nreloc: %u, nlnno: %u\n"),
566 
                (unsigned int)bfd_h_get_32 (abfd, scn.s_paddr),
567 
                (unsigned int)bfd_h_get_32 (abfd, scn.s_vaddr));
568 
      else
569 
        {
570 
          dump_flags (s_flag_xlat, flags);
571 
          putchar ('\n');
572 
        }
573 
    }
574 
}
575 
 
576 
/* Read section table.  */
577 
 
578 
static void
579 
xcoff32_read_sections (bfd *abfd, struct xcoff_dump *data)
580 
{
581 
  int i;
582 
 
583 
  if (bfd_seek (abfd, sizeof (struct external_filehdr) + data->opthdr,
584 
                SEEK_SET) != 0)
585 
    {
586 
      non_fatal (_("cannot read section headers"));
587 
      return;
588 
    }
589 
 
590 
  data->sects = xmalloc (data->nscns * sizeof (struct xcoff32_section));
591 
  for (i = 0; i < data->nscns; i++)
592 
    {
593 
      struct external_scnhdr scn;
594 
      struct xcoff32_section *s = &data->sects[i];
595 
 
596 
      if (bfd_bread (&scn, sizeof (scn), abfd) != sizeof (scn))
597 
        {
598 
          non_fatal (_("cannot read section header"));
599 
          free (data->sects);
600 
          data->sects = NULL;
601 
          return;
602 
        }
603 
      memcpy (s->name, scn.s_name, 8);
604 
      s->name[8] = 0;
605 
      s->flags = bfd_h_get_32 (abfd, scn.s_flags);
606 
 
607 
      s->scnptr = bfd_h_get_32 (abfd, scn.s_scnptr);
608 
      s->relptr = bfd_h_get_32 (abfd, scn.s_relptr);
609 
      s->lnnoptr = bfd_h_get_32 (abfd, scn.s_lnnoptr);
610 
 
611 
      s->nreloc = bfd_h_get_16 (abfd, scn.s_nreloc);
612 
      s->nlnno = bfd_h_get_16 (abfd, scn.s_nlnno);
613 
 
614 
      if (s->flags == STYP_OVRFLO)
615 
        {
616 
          if (s->nreloc > 0 && s->nreloc <= data->nscns)
617 
            data->sects[s->nreloc - 1].nreloc =
618 
              bfd_h_get_32 (abfd, scn.s_paddr);
619 
          if (s->nlnno > 0 && s->nlnno <= data->nscns)
620 
            data->sects[s->nlnno - 1].nlnno =
621 
              bfd_h_get_32 (abfd, scn.s_vaddr);
622 
        }
623 
    }
624 
}
625 
 
626 
/* Read symbols.  */
627 
 
628 
static void
629 
xcoff32_read_symbols (bfd *abfd, struct xcoff_dump *data)
630 
{
631 
  unsigned int i;
632 
  char stsz_arr[4];
633 
  unsigned int stptr;
634 
 
635 
  if (data->nsyms == 0)
636 
    return;
637 
 
638 
  stptr = data->symptr
639 
    + data->nsyms * (unsigned)sizeof (struct external_syment);
640 
 
641 
  /* Read string table.  */
642 
  if (bfd_seek (abfd, stptr, SEEK_SET) != 0)
643 
    {
644 
      data->strings_size = 0;
645 
    }
646 
  else
647 
    {
648 
      if (bfd_bread (&stsz_arr, sizeof (stsz_arr), abfd) != sizeof (stsz_arr))
649 
        {
650 
          non_fatal (_("cannot read strings table len"));
651 
          return;
652 
        }
653 
      data->strings_size = bfd_h_get_32 (abfd, stsz_arr);
654 
      if (data->strings_size > sizeof (stsz_arr))
655 
        {
656 
          unsigned int remsz = data->strings_size - sizeof (stsz_arr);
657 
 
658 
          data->strings = xmalloc (data->strings_size);
659 
 
660 
          memcpy (data->strings, stsz_arr, sizeof (stsz_arr));
661 
          if (bfd_bread (data->strings + sizeof (stsz_arr), remsz, abfd)
662 
              != remsz)
663 
            {
664 
              non_fatal (_("cannot read strings table"));
665 
              goto clean;
666 
            }
667 
        }
668 
    }
669 
 
670 
  if (bfd_seek (abfd, data->symptr, SEEK_SET) != 0)
671 
    {
672 
      non_fatal (_("cannot read symbol table"));
673 
      goto clean;
674 
    }
675 
 
676 
  data->syms = (union xcoff32_symbol *)
677 
    xmalloc (data->nsyms * sizeof (union xcoff32_symbol));
678 
 
679 
  for (i = 0; i < data->nsyms; i++)
680 
    {
681 
      struct external_syment sym;
682 
      int j;
683 
      union xcoff32_symbol *s = &data->syms[i];
684 
 
685 
      if (bfd_bread (&sym, sizeof (sym), abfd) != sizeof (sym))
686 
        {
687 
          non_fatal (_("cannot read symbol entry"));
688 
          goto clean;
689 
        }
690 
 
691 
      s->sym.val = bfd_h_get_32 (abfd, sym.e_value);
692 
      s->sym.scnum = bfd_h_get_16 (abfd, sym.e_scnum);
693 
      s->sym.ntype = bfd_h_get_16 (abfd, sym.e_type);
694 
      s->sym.sclass = bfd_h_get_8 (abfd, sym.e_sclass);
695 
      s->sym.numaux = bfd_h_get_8 (abfd, sym.e_numaux);
696 
 
697 
      if (sym.e.e_name[0])
698 
        {
699 
          memcpy (s->sym.raw.name, sym.e.e_name, sizeof (sym.e.e_name));
700 
          s->sym.raw.name[8] = 0;
701 
          s->sym.name = s->sym.raw.name;
702 
        }
703 
      else
704 
        {
705 
          unsigned int soff = bfd_h_get_32 (abfd, sym.e.e.e_offset);
706 
 
707 
          if ((s->sym.sclass & DBXMASK) == 0 && soff < data->strings_size)
708 
            s->sym.name = data->strings + soff;
709 
          else
710 
            {
711 
              s->sym.name = NULL;
712 
              s->sym.raw.off = soff;
713 
            }
714 
        }
715 
 
716 
      for (j = 0; j < s->sym.numaux; j++, i++)
717 
        {
718 
           if (bfd_bread (&s[j + 1].aux,
719 
                          sizeof (union external_auxent), abfd)
720 
               != sizeof (union external_auxent))
721 
            {
722 
              non_fatal (_("cannot read symbol aux entry"));
723 
              goto clean;
724 
            }
725 
        }
726 
    }
727 
  return;
728 
 clean:
729 
  free (data->syms);
730 
  data->syms = NULL;
731 
  free (data->strings);
732 
  data->strings = NULL;
733 
}
734 
 
735 
/* Dump xcoff symbols.  */
736 
 
737 
static void
738 
dump_xcoff32_symbols (bfd *abfd, struct xcoff_dump *data)
739 
{
740 
  unsigned int i;
741 
  asection *debugsec;
742 
  char *debug = NULL;
743 
 
744 
  printf (_("Symbols table (strtable at 0x%08x)"),
745 
          data->symptr
746 
          + data->nsyms * (unsigned)sizeof (struct external_syment));
747 
  if (data->nsyms == 0 || data->syms == NULL)
748 
    {
749 
      printf (_(":\n  No symbols\n"));
750 
      return;
751 
    }
752 
 
753 
  /* Read string table.  */
754 
  if (data->strings_size == 0)
755 
    printf (_(" (no strings):\n"));
756 
  else
757 
    printf (_(" (strings size: %08x):\n"), data->strings_size);
758 
 
759 
  /* Read debug section.  */
760 
  debugsec = bfd_get_section_by_name (abfd, ".debug");
761 
  if (debugsec != NULL)
762 
    {
763 
      bfd_size_type size;
764 
 
765 
      size = bfd_get_section_size (debugsec);
766 
      debug = (char *) xmalloc (size);
767 
      bfd_get_section_contents (abfd, debugsec, debug, 0, size);
768 
    }
769 
 
770 
  printf (_("  # sc         value    section  type aux name/off\n"));
771 
  for (i = 0; i < data->nsyms; i++)
772 
    {
773 
      union xcoff32_symbol *s = &data->syms[i];
774 
      int j;
775 
 
776 
      printf ("%3u ", i);
777 
      dump_value (sc_xlat, s->sym.sclass, 10);
778 
      printf (" %08x ", s->sym.val);
779 
      if (s->sym.scnum > 0 && s->sym.scnum <= data->nscns)
780 
        {
781 
          if (data->sects != NULL)
782 
            printf ("%-8s", data->sects[s->sym.scnum - 1].name);
783 
          else
784 
            printf ("%-8u", s->sym.scnum);
785 
        }
786 
      else
787 
        switch ((signed short)s->sym.scnum)
788 
          {
789 
          case N_DEBUG:
790 
            printf ("N_DEBUG ");
791 
            break;
792 
          case N_ABS:
793 
            printf ("N_ABS   ");
794 
            break;
795 
          case N_UNDEF:
796 
            printf ("N_UNDEF ");
797 
            break;
798 
          default:
799 
            printf ("(%04x)  ", s->sym.scnum);
800 
          }
801 
      printf (" %04x %3u ", s->sym.ntype, s->sym.numaux);
802 
      if (s->sym.name != NULL)
803 
        printf ("%s", s->sym.name);
804 
      else
805 
        {
806 
          if ((s->sym.sclass & DBXMASK) != 0 && debug != NULL)
807 
            printf ("%s", debug + s->sym.raw.off);
808 
          else
809 
            printf ("%08x", s->sym.raw.off);
810 
        }
811 
      putchar ('\n');
812 
 
813 
      for (j = 0; j < s->sym.numaux; j++, i++)
814 
        {
815 
          union external_auxent *aux = &s[j + 1].aux;
816 
 
817 
          printf (" %3u ", i + 1);
818 
          switch (s->sym.sclass)
819 
            {
820 
            case C_STAT:
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 
              printf (_("  scnlen: %08x  nreloc: %-6u\n"),
828 
                      (unsigned)bfd_h_get_32 (abfd, aux->x_scn.x_scnlen),
829 
                      (unsigned)bfd_h_get_16 (abfd, aux->x_scn.x_nreloc));
830 
              break;
831 
            case C_EXT:
832 
            case C_WEAKEXT:
833 
            case C_HIDEXT:
834 
              if (j == 0 && s->sym.numaux > 1)
835 
                {
836 
                  /* Function aux entry.  */
837 
                  printf (_("  exptr: %08x fsize: %08x lnnoptr: %08x endndx: %u\n"),
838 
                          (unsigned)bfd_h_get_32 (abfd, aux->x_sym.x_tagndx),
839 
                          (unsigned)bfd_h_get_32
840 
                            (abfd, aux->x_sym.x_misc.x_fsize),
841 
                          (unsigned)bfd_h_get_32
842 
                            (abfd, aux->x_sym.x_fcnary.x_fcn.x_lnnoptr),
843 
                          (unsigned)bfd_h_get_32
844 
                            (abfd, aux->x_sym.x_fcnary.x_fcn.x_endndx));
845 
                }
846 
              else if (j == 1 || (j == 0 && s->sym.numaux == 1))
847 
                {
848 
                  /* csect aux entry.  */
849 
                  unsigned char smtyp;
850 
                  unsigned int scnlen;
851 
 
852 
                  smtyp = bfd_h_get_8 (abfd, aux->x_csect.x_smtyp);
853 
                  scnlen = bfd_h_get_32 (abfd, aux->x_csect.x_scnlen);
854 
 
855 
                  if (smtyp == XTY_LD)
856 
                    printf (_("  scnsym: %-8u"), scnlen);
857 
                  else
858 
                    printf (_("  scnlen: %08x"), scnlen);
859 
                  printf (_(" h: parm=%08x sn=%04x al: 2**%u"),
860 
                          (unsigned)bfd_h_get_32 (abfd, aux->x_csect.x_parmhash),
861 
                          (unsigned)bfd_h_get_16 (abfd, aux->x_csect.x_snhash),
862 
                          SMTYP_ALIGN (smtyp));
863 
                  printf (_(" typ: "));
864 
                  dump_value (smtyp_xlat, SMTYP_SMTYP (smtyp), 2);
865 
                  printf (_(" cl: "));
866 
                  dump_value
867 
                    (smclas_xlat,
868 
                     (unsigned)bfd_h_get_8 (abfd, aux->x_csect.x_smclas), 6);
869 
                  putchar ('\n');
870 
                }
871 
              else
872 
                printf ("aux\n");
873 
              break;
874 
            case C_FILE:
875 
              {
876 
                unsigned int off;
877 
 
878 
                printf (_(" ftype: %02x "),
879 
                        (unsigned)bfd_h_get_8 (abfd, aux->x_file.x_ftype));
880 
                if (aux->x_file.x_n.x_fname[0] != 0)
881 
                  printf (_("fname: %.14s"), aux->x_file.x_n.x_fname);
882 
                else
883 
                  {
884 
                    off = (unsigned)bfd_h_get_32
885 
                      (abfd, aux->x_file.x_n.x_n.x_offset);
886 
                    if (data->strings != NULL && off < data->strings_size)
887 
                      printf (_(" %s"), data->strings + off);
888 
                    else
889 
                      printf (_("offset: %08x"), off);
890 
                  }
891 
                putchar ('\n');
892 
              }
893 
              break;
894 
            case C_BLOCK:
895 
            case C_FCN:
896 
              printf (_("  lnno: %u\n"),
897 
                      (unsigned)bfd_h_get_16
898 
                      (abfd, aux->x_sym.x_misc.x_lnsz.x_lnno));
899 
              break;
900 
            default:
901 
              printf ("aux\n");
902 
              break;
903 
            }
904 
        }
905 
 
906 
    }
907 
  free (debug);
908 
}
909 
 
910 
/* Dump xcoff relocation entries.  */
911 
 
912 
static void
913 
dump_xcoff32_relocs (bfd *abfd, struct xcoff_dump *data)
914 
{
915 
  unsigned int i;
916 
 
917 
  if (data->sects == NULL)
918 
    {
919 
      non_fatal (_("cannot read section headers"));
920 
      return;
921 
    }
922 
 
923 
  for (i = 0; i < data->nscns; i++)
924 
    {
925 
      struct xcoff32_section *sect = &data->sects[i];
926 
      unsigned int nrel = sect->nreloc;
927 
      unsigned int j;
928 
 
929 
      if (nrel == 0)
930 
        continue;
931 
      printf (_("Relocations for %s (%u)\n"), sect->name, nrel);
932 
      if (bfd_seek (abfd, sect->relptr, SEEK_SET) != 0)
933 
        {
934 
          non_fatal (_("cannot read relocations"));
935 
          continue;
936 
        }
937 
      printf (_("vaddr    sgn mod sz type  symndx symbol\n"));
938 
      for (j = 0; j < nrel; j++)
939 
        {
940 
          struct external_reloc rel;
941 
          unsigned char rsize;
942 
          unsigned int symndx;
943 
 
944 
          if (bfd_bread (&rel, sizeof (rel), abfd) != sizeof (rel))
945 
            {
946 
              non_fatal (_("cannot read relocation entry"));
947 
              return;
948 
            }
949 
          rsize = bfd_h_get_8 (abfd, rel.r_size);
950 
          printf (_("%08x  %c   %c  %-2u "),
951 
                  (unsigned int)bfd_h_get_32 (abfd, rel.r_vaddr),
952 
                  rsize & 0x80 ? 'S' : 'U',
953 
                  rsize & 0x40 ? 'm' : ' ',
954 
                  (rsize & 0x3f) + 1);
955 
          dump_value (rtype_xlat, bfd_h_get_8 (abfd, rel.r_type), 6);
956 
          symndx = bfd_h_get_32 (abfd, rel.r_symndx);
957 
          printf ("%-6u ", symndx);
958 
          xcoff32_print_symbol (data, symndx);
959 
          putchar ('\n');
960 
        }
961 
      putchar ('\n');
962 
    }
963 
}
964 
 
965 
/* Dump xcoff line number entries.  */
966 
 
967 
static void
968 
dump_xcoff32_lineno (bfd *abfd, struct xcoff_dump *data)
969 
{
970 
  unsigned int i;
971 
 
972 
  if (data->sects == NULL)
973 
    {
974 
      non_fatal (_("cannot read section headers"));
975 
      return;
976 
    }
977 
 
978 
  for (i = 0; i < data->nscns; i++)
979 
    {
980 
      struct xcoff32_section *sect = &data->sects[i];
981 
      unsigned int nlnno = sect->nlnno;
982 
      unsigned int j;
983 
 
984 
      if (nlnno == 0)
985 
        continue;
986 
      printf (_("Line numbers for %s (%u)\n"), sect->name, nlnno);
987 
      if (bfd_seek (abfd, sect->lnnoptr, SEEK_SET) != 0)
988 
        {
989 
          non_fatal (_("cannot read line numbers"));
990 
          continue;
991 
        }
992 
      printf (_("lineno  symndx/paddr\n"));
993 
      for (j = 0; j < nlnno; j++)
994 
        {
995 
          struct external_lineno ln;
996 
          unsigned int no;
997 
 
998 
          if (bfd_bread (&ln, sizeof (ln), abfd) != sizeof (ln))
999 
            {
1000 
              non_fatal (_("cannot read line number entry"));
1001 
              return;
1002 
            }
1003 
          no = bfd_h_get_16 (abfd, ln.l_lnno);
1004 
          printf (_(" %-6u "), no);
1005 
          if (no == 0)
1006 
            {
1007 
              unsigned int symndx = bfd_h_get_32 (abfd, ln.l_addr.l_symndx);
1008 
              xcoff32_print_symbol (data, symndx);
1009 
            }
1010 
          else
1011 
            printf ("0x%08x",
1012 
                    (unsigned int)bfd_h_get_32 (abfd, ln.l_addr.l_paddr));
1013 
          putchar ('\n');
1014 
        }
1015 
    }
1016 
}
1017 
 
1018 
/* Dump xcoff loader section.  */
1019 
 
1020 
static void
1021 
dump_xcoff32_loader (bfd *abfd)
1022 
{
1023 
  asection *loader;
1024 
  bfd_size_type size = 0;
1025 
  struct external_ldhdr *lhdr;
1026 
  struct external_ldsym *ldsym;
1027 
  struct external_ldrel *ldrel;
1028 
  bfd_byte *ldr_data;
1029 
  unsigned int version;
1030 
  unsigned int ndsyms;
1031 
  unsigned int ndrel;
1032 
  unsigned int stlen;
1033 
  unsigned int stoff;
1034 
  unsigned int impoff;
1035 
  unsigned int nimpid;
1036 
  unsigned int i;
1037 
  const char *p;
1038 
 
1039 
  loader = bfd_get_section_by_name (abfd, ".loader");
1040 
 
1041 
  if (loader == NULL)
1042 
    {
1043 
      printf (_("no .loader section in file\n"));
1044 
      return;
1045 
    }
1046 
  size = bfd_get_section_size (loader);
1047 
  if (size < sizeof (*lhdr))
1048 
    {
1049 
      printf (_("section .loader is too short\n"));
1050 
      return;
1051 
    }
1052 
 
1053 
  ldr_data = (bfd_byte *) xmalloc (size);
1054 
  bfd_get_section_contents (abfd, loader, ldr_data, 0, size);
1055 
  lhdr = (struct external_ldhdr *)ldr_data;
1056 
  printf (_("Loader header:\n"));
1057 
  version = bfd_h_get_32 (abfd, lhdr->l_version);
1058 
  printf (_("  version:           %u\n"), version);
1059 
  if (version != 1)
1060 
    {
1061 
      printf (_(" Unhandled version\n"));
1062 
      free (ldr_data);
1063 
      return;
1064 
    }
1065 
  ndsyms = bfd_h_get_32 (abfd, lhdr->l_nsyms);
1066 
  printf (_("  nbr symbols:       %u\n"), ndsyms);
1067 
  ndrel = bfd_h_get_32 (abfd, lhdr->l_nreloc);
1068 
  printf (_("  nbr relocs:        %u\n"), ndrel);
1069 
  printf (_("  import strtab len: %u\n"),
1070 
          (unsigned) bfd_h_get_32 (abfd, lhdr->l_istlen));
1071 
  nimpid = bfd_h_get_32 (abfd, lhdr->l_nimpid);
1072 
  printf (_("  nbr import files:  %u\n"), nimpid);
1073 
  impoff = bfd_h_get_32 (abfd, lhdr->l_impoff);
1074 
  printf (_("  import file off:   %u\n"), impoff);
1075 
  stlen = bfd_h_get_32 (abfd, lhdr->l_stlen);
1076 
  printf (_("  string table len:  %u\n"), stlen);
1077 
  stoff = bfd_h_get_32 (abfd, lhdr->l_stoff);
1078 
  printf (_("  string table off:  %u\n"), stoff);
1079 
 
1080 
  ldsym = (struct external_ldsym *)(ldr_data + sizeof (*lhdr));
1081 
  printf (_("Dynamic symbols:\n"));
1082 
  printf (_("     # value     sc IFEW ty class file  pa name\n"));
1083 
  for (i = 0; i < ndsyms; i++, ldsym++)
1084 
    {
1085 
      unsigned char smtype;
1086 
 
1087 
      printf (_("  %4u %08x %3u "), i,
1088 
              (unsigned)bfd_h_get_32 (abfd, ldsym->l_value),
1089 
              (unsigned)bfd_h_get_16 (abfd, ldsym->l_scnum));
1090 
      smtype = bfd_h_get_8 (abfd, ldsym->l_smtype);
1091 
      putchar (smtype & 0x40 ? 'I' : ' ');
1092 
      putchar (smtype & 0x20 ? 'F' : ' ');
1093 
      putchar (smtype & 0x10 ? 'E' : ' ');
1094 
      putchar (smtype & 0x08 ? 'W' : ' ');
1095 
      putchar (' ');
1096 
      dump_value (smtyp_xlat, SMTYP_SMTYP (smtype), 2);
1097 
      putchar (' ');
1098 
      dump_value
1099 
        (smclas_xlat, (unsigned)bfd_h_get_8 (abfd, ldsym->l_smclas), 6);
1100 
      printf (_(" %3u %3u "),
1101 
              (unsigned)bfd_h_get_32 (abfd, ldsym->l_ifile),
1102 
              (unsigned)bfd_h_get_32 (abfd, ldsym->l_parm));
1103 
      if (ldsym->_l._l_name[0] != 0)
1104 
        printf ("%-.8s", ldsym->_l._l_name);
1105 
      else
1106 
        {
1107 
          unsigned int off = bfd_h_get_32 (abfd, ldsym->_l._l_l._l_offset);
1108 
          if (off > stlen)
1109 
            printf (_("(bad offset: %u)"), off);
1110 
          else
1111 
            printf ("%s", ldr_data + stoff + off);
1112 
        }
1113 
      putchar ('\n');
1114 
    }
1115 
 
1116 
  printf (_("Dynamic relocs:\n"));
1117 
  printf (_("  vaddr    sec    sz typ   sym\n"));
1118 
  ldrel = (struct external_ldrel *)(ldr_data + sizeof (*lhdr)
1119 
                                    + ndsyms * sizeof (*ldsym));
1120 
  for (i = 0; i < ndrel; i++, ldrel++)
1121 
    {
1122 
      unsigned int rsize;
1123 
      unsigned int rtype;
1124 
      unsigned int symndx;
1125 
 
1126 
      rsize = bfd_h_get_8 (abfd, ldrel->l_rtype + 0);
1127 
      rtype = bfd_h_get_8 (abfd, ldrel->l_rtype + 1);
1128 
 
1129 
      printf (_("  %08x %3u %c%c %2u "),
1130 
              (unsigned)bfd_h_get_32 (abfd, ldrel->l_vaddr),
1131 
              (unsigned)bfd_h_get_16 (abfd, ldrel->l_rsecnm),
1132 
              rsize & 0x80 ? 'S' : 'U',
1133 
              rsize & 0x40 ? 'm' : ' ',
1134 
              (rsize & 0x3f) + 1);
1135 
      dump_value (rtype_xlat, rtype, 6);
1136 
      symndx = bfd_h_get_32 (abfd, ldrel->l_symndx);
1137 
      switch (symndx)
1138 
        {
1139 
        case 0:
1140 
          printf (_(".text"));
1141 
          break;
1142 
        case 1:
1143 
          printf (_(".data"));
1144 
          break;
1145 
        case 2:
1146 
          printf (_(".bss"));
1147 
          break;
1148 
        default:
1149 
          printf (_("%u"), symndx - 3);
1150 
          break;
1151 
        }
1152 
      putchar ('\n');
1153 
    }
1154 
 
1155 
  printf (_("Import files:\n"));
1156 
  p = (char *)ldr_data + impoff;
1157 
  for (i = 0; i < nimpid; i++)
1158 
    {
1159 
      int n1, n2, n3;
1160 
 
1161 
      n1 = strlen (p);
1162 
      n2 = strlen (p + n1 + 1);
1163 
      n3 = strlen (p + n1 + 1 + n2+ 1);
1164 
      printf (" %2u: %s,%s,%s\n", i,
1165 
              p, p + n1 + 1, p + n1 + n2 + 2);
1166 
      p += n1 + n2 + n3 + 3;
1167 
    }
1168 
 
1169 
  free (ldr_data);
1170 
}
1171 
 
1172 
/* Dump xcoff exception section.  */
1173 
 
1174 
static void
1175 
dump_xcoff32_except (bfd *abfd, struct xcoff_dump *data)
1176 
{
1177 
  asection *sec;
1178 
  bfd_size_type size = 0;
1179 
  bfd_byte *excp_data;
1180 
  struct external_exceptab *exceptab;
1181 
  unsigned int i;
1182 
 
1183 
  sec = bfd_get_section_by_name (abfd, ".except");
1184 
 
1185 
  if (sec == NULL)
1186 
    {
1187 
      printf (_("no .except section in file\n"));
1188 
      return;
1189 
    }
1190 
  size = bfd_get_section_size (sec);
1191 
  excp_data = (bfd_byte *) xmalloc (size);
1192 
  bfd_get_section_contents (abfd, sec, excp_data, 0, size);
1193 
  exceptab = (struct external_exceptab *)excp_data;
1194 
 
1195 
  printf (_("Exception table:\n"));
1196 
  printf (_("lang reason sym/addr\n"));
1197 
  for (i = 0; i * sizeof (*exceptab) < size; i++, exceptab++)
1198 
    {
1199 
      unsigned int reason;
1200 
      unsigned int addr;
1201 
 
1202 
      addr = bfd_get_32 (abfd, exceptab->e_addr.e_paddr);
1203 
      reason = bfd_get_8 (abfd, exceptab->e_reason);
1204 
      printf (_("  %02x     %02x "),
1205 
              (unsigned) bfd_get_8 (abfd, exceptab->e_lang), reason);
1206 
      if (reason == 0)
1207 
        xcoff32_print_symbol (data, addr);
1208 
      else
1209 
        printf (_("@%08x"), addr);
1210 
      putchar ('\n');
1211 
    }
1212 
  free (excp_data);
1213 
}
1214 
 
1215 
/* Dump xcoff type-check section.  */
1216 
 
1217 
static void
1218 
dump_xcoff32_typchk (bfd *abfd)
1219 
{
1220 
  asection *sec;
1221 
  bfd_size_type size = 0;
1222 
  bfd_byte *data;
1223 
  unsigned int i;
1224 
 
1225 
  sec = bfd_get_section_by_name (abfd, ".typchk");
1226 
 
1227 
  if (sec == NULL)
1228 
    {
1229 
      printf (_("no .typchk section in file\n"));
1230 
      return;
1231 
    }
1232 
  size = bfd_get_section_size (sec);
1233 
  data = (bfd_byte *) xmalloc (size);
1234 
  bfd_get_section_contents (abfd, sec, data, 0, size);
1235 
 
1236 
  printf (_("Type-check section:\n"));
1237 
  printf (_("offset    len  lang-id general-hash language-hash\n"));
1238 
  for (i = 0; i < size;)
1239 
    {
1240 
      unsigned int len;
1241 
 
1242 
      len = bfd_get_16 (abfd, data + i);
1243 
      printf ("%08x: %-4u ", i, len);
1244 
      i += 2;
1245 
 
1246 
      if (len == 10)
1247 
        {
1248 
          /* Expected format.  */
1249 
          printf ("%04x    %08x     %08x\n",
1250 
                  (unsigned) bfd_get_16 (abfd, data + i),
1251 
                  (unsigned) bfd_get_32 (abfd, data + i + 2),
1252 
                  (unsigned) bfd_get_32 (abfd, data + i + 2 + 4));
1253 
        }
1254 
      else
1255 
        {
1256 
          unsigned int j;
1257 
 
1258 
          for (j = 0; j < len; j++)
1259 
            {
1260 
              if (j % 16 == 0)
1261 
                printf ("\n    ");
1262 
              printf (" %02x", (unsigned char)data[i + j]);
1263 
            }
1264 
          putchar ('\n');
1265 
        }
1266 
      i += len;
1267 
    }
1268 
  free (data);
1269 
}
1270 
 
1271 
/* Dump xcoff traceback tags section.  */
1272 
 
1273 
static void
1274 
dump_xcoff32_tbtags (bfd *abfd,
1275 
                     const char *text, bfd_size_type text_size,
1276 
                     unsigned int text_start, unsigned int func_start)
1277 
{
1278 
  unsigned int i;
1279 
 
1280 
  if (func_start - text_start > text_size)
1281 
    {
1282 
      printf (_(" address beyond section size\n"));
1283 
      return;
1284 
    }
1285 
  for (i = func_start - text_start; i < text_size; i+= 4)
1286 
    if (bfd_get_32 (abfd, text + i) == 0)
1287 
      {
1288 
        unsigned int tb1;
1289 
        unsigned int tb2;
1290 
        unsigned int off;
1291 
 
1292 
        printf (_(" tags at %08x\n"), i + 4);
1293 
        if (i + 8 >= text_size)
1294 
          goto truncated;
1295 
 
1296 
        tb1 = bfd_get_32 (abfd, text + i + 4);
1297 
        tb2 = bfd_get_32 (abfd, text + i + 8);
1298 
        off = i + 12;
1299 
        printf (_(" version: %u, lang: %u, global_link: %u, is_eprol: %u, has_tboff: %u, int_proc: %u\n"),
1300 
                (tb1 >> 24) & 0xff,
1301 
                (tb1 >> 16) & 0xff,
1302 
                (tb1 >> 15) & 1,
1303 
                (tb1 >> 14) & 1,
1304 
                (tb1 >> 13) & 1,
1305 
                (tb1 >> 12) & 1);
1306 
        printf (_(" has_ctl: %u, tocless: %u, fp_pres: %u, log_abort: %u, int_hndl: %u\n"),
1307 
                (tb1 >> 11) & 1,
1308 
                (tb1 >> 10) & 1,
1309 
                (tb1 >> 9) & 1,
1310 
                (tb1 >> 8) & 1,
1311 
                (tb1 >> 7) & 1);
1312 
        printf (_(" name_pres: %u, uses_alloca: %u, cl_dis_inv: %u, saves_cr: %u, saves_lr: %u\n"),
1313 
                (tb1 >> 6) & 1,
1314 
                (tb1 >> 5) & 1,
1315 
                (tb1 >> 2) & 7,
1316 
                (tb1 >> 1) & 1,
1317 
                (tb1 >> 0) & 1);
1318 
        printf (_(" stores_bc: %u, fixup: %u, fpr_saved: %-2u, spare3: %u, gpr_saved: %-2u\n"),
1319 
                (tb2 >> 31) & 1,
1320 
                (tb2 >> 30) & 1,
1321 
                (tb2 >> 24) & 63,
1322 
                (tb2 >> 22) & 3,
1323 
                (tb2 >> 16) & 63);
1324 
        printf (_(" fixparms: %-3u  floatparms: %-3u  parm_on_stk: %u\n"),
1325 
                (tb2 >> 8) & 0xff,
1326 
                (tb2 >> 1) & 0x7f,
1327 
                (tb2 >> 0) & 1);
1328 
 
1329 
        if (((tb2 >> 1) & 0x7fff) != 0)
1330 
          {
1331 
            unsigned int parminfo;
1332 
 
1333 
            if (off >= text_size)
1334 
              goto truncated;
1335 
            parminfo = bfd_get_32 (abfd, text + off);
1336 
            off += 4;
1337 
            printf (_(" parminfo: 0x%08x\n"), parminfo);
1338 
          }
1339 
 
1340 
        if ((tb1 >> 13) & 1)
1341 
          {
1342 
            unsigned int tboff;
1343 
 
1344 
            if (off >= text_size)
1345 
              goto truncated;
1346 
            tboff = bfd_get_32 (abfd, text + off);
1347 
            off += 4;
1348 
            printf (_(" tb_offset: 0x%08x (start=0x%08x)\n"),
1349 
                    tboff, text_start + i - tboff);
1350 
          }
1351 
        if ((tb1 >> 7) & 1)
1352 
          {
1353 
            unsigned int hand_mask;
1354 
 
1355 
            if (off >= text_size)
1356 
              goto truncated;
1357 
            hand_mask = bfd_get_32 (abfd, text + off);
1358 
            off += 4;
1359 
            printf (_(" hand_mask_offset: 0x%08x\n"), hand_mask);
1360 
          }
1361 
        if ((tb1 >> 11) & 1)
1362 
          {
1363 
            unsigned int ctl_info;
1364 
            unsigned int j;
1365 
 
1366 
            if (off >= text_size)
1367 
              goto truncated;
1368 
            ctl_info = bfd_get_32 (abfd, text + off);
1369 
            off += 4;
1370 
            printf (_(" number of CTL anchors: %u\n"), ctl_info);
1371 
            for (j = 0; j < ctl_info; j++)
1372 
              {
1373 
                if (off >= text_size)
1374 
                  goto truncated;
1375 
                printf (_("  CTL[%u]: %08x\n"),
1376 
                          j, (unsigned)bfd_get_32 (abfd, text + off));
1377 
                off += 4;
1378 
              }
1379 
          }
1380 
        if ((tb1 >> 6) & 1)
1381 
          {
1382 
            unsigned int name_len;
1383 
            unsigned int j;
1384 
 
1385 
            if (off >= text_size)
1386 
              goto truncated;
1387 
            name_len = bfd_get_16 (abfd, text + off);
1388 
            off += 2;
1389 
            printf (_(" Name (len: %u): "), name_len);
1390 
            if (off + name_len >= text_size)
1391 
              {
1392 
                printf (_("[truncated]\n"));
1393 
                goto truncated;
1394 
              }
1395 
            for (j = 0; j < name_len; j++)
1396 
              if (ISPRINT (text[off + j]))
1397 
                putchar (text[off + j]);
1398 
              else
1399 
                printf ("[%02x]", (unsigned char)text[off + j]);
1400 
            putchar ('\n');
1401 
            off += name_len;
1402 
          }
1403 
        if ((tb1 >> 5) & 1)
1404 
          {
1405 
            if (off >= text_size)
1406 
              goto truncated;
1407 
            printf (_(" alloca reg: %u\n"),
1408 
                    (unsigned) bfd_get_8 (abfd, text + off));
1409 
            off++;
1410 
          }
1411 
        printf (_(" (end of tags at %08x)\n"), text_start + off);
1412 
        return;
1413 
      }
1414 
  printf (_(" no tags found\n"));
1415 
  return;
1416 
 
1417 
 truncated:
1418 
  printf (_(" Truncated .text section\n"));
1419 
  return;
1420 
}
1421 
 
1422 
static void
1423 
dump_xcoff32_traceback (bfd *abfd, struct xcoff_dump *data)
1424 
{
1425 
  unsigned int i;
1426 
  unsigned int scnum_text = -1;
1427 
  unsigned int text_vma;
1428 
  asection *text_sec;
1429 
  bfd_size_type text_size;
1430 
  char *text;
1431 
 
1432 
  if (data->syms == NULL || data->sects == NULL)
1433 
    return;
1434 
 
1435 
  /* Read text section.  */
1436 
  text_sec = bfd_get_section_by_name (abfd, ".text");
1437 
  if (text_sec == NULL)
1438 
    return;
1439 
  text_vma = bfd_get_section_vma (abfd, text_sec);
1440 
 
1441 
  text_size = bfd_get_section_size (text_sec);
1442 
  text = (char *) xmalloc (text_size);
1443 
  bfd_get_section_contents (abfd, text_sec, text, 0, text_size);
1444 
 
1445 
  for (i = 0; i < data->nscns; i++)
1446 
    if (data->sects[i].flags == STYP_TEXT)
1447 
      {
1448 
        scnum_text = i + 1;
1449 
        break;
1450 
      }
1451 
  if (scnum_text == (unsigned int)-1)
1452 
    return;
1453 
 
1454 
  for (i = 0; i < data->nsyms; i++)
1455 
    {
1456 
      union xcoff32_symbol *s = &data->syms[i];
1457 
 
1458 
      switch (s->sym.sclass)
1459 
        {
1460 
        case C_EXT:
1461 
        case C_HIDEXT:
1462 
        case C_WEAKEXT:
1463 
          if (s->sym.scnum == scnum_text
1464 
              && s->sym.numaux > 0)
1465 
            {
1466 
              union external_auxent *aux = &s[s->sym.numaux].aux;
1467 
 
1468 
              unsigned int smtyp;
1469 
              unsigned int smclas;
1470 
 
1471 
              smtyp = bfd_h_get_8 (abfd, aux->x_csect.x_smtyp);
1472 
              smclas = bfd_h_get_8 (abfd, aux->x_csect.x_smclas);
1473 
              if (SMTYP_SMTYP (smtyp) == XTY_LD
1474 
                  && (smclas == XMC_PR
1475 
                      || smclas == XMC_GL
1476 
                      || smclas == XMC_XO))
1477 
                {
1478 
                  printf ("%08x: ", s->sym.val);
1479 
                  xcoff32_print_symbol (data, i);
1480 
                  putchar ('\n');
1481 
                  dump_xcoff32_tbtags (abfd, text, text_size,
1482 
                                       text_vma, s->sym.val);
1483 
                }
1484 
            }
1485 
          break;
1486 
        default:
1487 
          break;
1488 
        }
1489 
      i += s->sym.numaux;
1490 
    }
1491 
  free (text);
1492 
}
1493 
 
1494 
/* Dump the TOC symbols.  */
1495 
 
1496 
static void
1497 
dump_xcoff32_toc (bfd *abfd, struct xcoff_dump *data)
1498 
{
1499 
  unsigned int i;
1500 
  unsigned int nbr_ent;
1501 
  unsigned int size;
1502 
 
1503 
  printf (_("TOC:\n"));
1504 
 
1505 
  if (data->syms == NULL)
1506 
    return;
1507 
 
1508 
  nbr_ent = 0;
1509 
  size = 0;
1510 
 
1511 
  for (i = 0; i < data->nsyms; i++)
1512 
    {
1513 
      union xcoff32_symbol *s = &data->syms[i];
1514 
 
1515 
      switch (s->sym.sclass)
1516 
        {
1517 
        case C_EXT:
1518 
        case C_HIDEXT:
1519 
        case C_WEAKEXT:
1520 
          if (s->sym.numaux > 0)
1521 
            {
1522 
              union external_auxent *aux = &s[s->sym.numaux].aux;
1523 
              unsigned int smclas;
1524 
              unsigned int ent_sz;
1525 
 
1526 
              smclas = bfd_h_get_8 (abfd, aux->x_csect.x_smclas);
1527 
              if (smclas == XMC_TC
1528 
                  || smclas == XMC_TD
1529 
                  || smclas == XMC_TC0)
1530 
                {
1531 
                  ent_sz = bfd_h_get_32 (abfd, aux->x_scn.x_scnlen);
1532 
                  printf ("%08x %08x ",
1533 
                          s->sym.val, ent_sz);
1534 
                  xcoff32_print_symbol (data, i);
1535 
                  putchar ('\n');
1536 
                  nbr_ent++;
1537 
                  size += ent_sz;
1538 
                }
1539 
            }
1540 
          break;
1541 
        default:
1542 
          break;
1543 
        }
1544 
      i += s->sym.numaux;
1545 
    }
1546 
  printf (_("Nbr entries: %-8u Size: %08x (%u)\n"),
1547 
          nbr_ent, size, size);
1548 
}
1549 
 
1550 
/* Handle an rs6000 xcoff file.  */
1551 
 
1552 
static void
1553 
dump_xcoff32 (bfd *abfd, struct external_filehdr *fhdr)
1554 
{
1555 
  struct xcoff_dump data;
1556 
 
1557 
  data.nscns = bfd_h_get_16 (abfd, fhdr->f_nscns);
1558 
  data.symptr = bfd_h_get_32 (abfd, fhdr->f_symptr);
1559 
  data.nsyms = bfd_h_get_32 (abfd, fhdr->f_nsyms);
1560 
  data.opthdr = bfd_h_get_16 (abfd, fhdr->f_opthdr);
1561 
  data.sects = NULL;
1562 
  data.syms = NULL;
1563 
  data.strings = NULL;
1564 
  data.strings_size = 0;
1565 
 
1566 
  if (options[OPT_FILE_HEADER].selected)
1567 
    dump_xcoff32_file_header (abfd, fhdr, &data);
1568 
 
1569 
  if (options[OPT_AOUT].selected)
1570 
    dump_xcoff32_aout_header (abfd, &data);
1571 
 
1572 
  if (options[OPT_SYMS].selected
1573 
      || options[OPT_RELOCS].selected
1574 
      || options[OPT_LINENO].selected
1575 
      || options[OPT_TRACEBACK].selected)
1576 
    xcoff32_read_sections (abfd, &data);
1577 
 
1578 
  if (options[OPT_SECTIONS].selected)
1579 
    dump_xcoff32_sections_header (abfd, &data);
1580 
 
1581 
  if (options[OPT_SYMS].selected
1582 
      || options[OPT_RELOCS].selected
1583 
      || options[OPT_LINENO].selected
1584 
      || options[OPT_EXCEPT].selected
1585 
      || options[OPT_TRACEBACK].selected
1586 
      || options[OPT_TOC].selected)
1587 
    xcoff32_read_symbols (abfd, &data);
1588 
 
1589 
  if (options[OPT_SYMS].selected)
1590 
    dump_xcoff32_symbols (abfd, &data);
1591 
 
1592 
  if (options[OPT_RELOCS].selected)
1593 
    dump_xcoff32_relocs (abfd, &data);
1594 
 
1595 
  if (options[OPT_LINENO].selected)
1596 
    dump_xcoff32_lineno (abfd, &data);
1597 
 
1598 
  if (options[OPT_LOADER].selected)
1599 
    dump_xcoff32_loader (abfd);
1600 
 
1601 
  if (options[OPT_EXCEPT].selected)
1602 
    dump_xcoff32_except (abfd, &data);
1603 
 
1604 
  if (options[OPT_TYPCHK].selected)
1605 
    dump_xcoff32_typchk (abfd);
1606 
 
1607 
  if (options[OPT_TRACEBACK].selected)
1608 
    dump_xcoff32_traceback (abfd, &data);
1609 
 
1610 
  if (options[OPT_TOC].selected)
1611 
    dump_xcoff32_toc (abfd, &data);
1612 
 
1613 
  free (data.sects);
1614 
  free (data.strings);
1615 
  free (data.syms);
1616 
}
1617 
 
1618 
/* Dump ABFD (according to the options[] array).  */
1619 
 
1620 
static void
1621 
xcoff_dump (bfd *abfd)
1622 
{
1623 
  struct external_filehdr fhdr;
1624 
  unsigned short magic;
1625 
 
1626 
  /* Read file header.  */
1627 
  if (bfd_seek (abfd, 0, SEEK_SET) != 0
1628 
      || bfd_bread (&fhdr, sizeof (fhdr), abfd) != sizeof (fhdr))
1629 
    {
1630 
      non_fatal (_("cannot read header"));
1631 
      return;
1632 
    }
1633 
 
1634 
  /* Decoding.  We don't use the bfd/coff function to get all the fields.  */
1635 
  magic = bfd_h_get_16 (abfd, fhdr.f_magic);
1636 
  if (options[OPT_FILE_HEADER].selected)
1637 
    {
1638 
      printf (_("File header:\n"));
1639 
      printf (_("  magic:         0x%04x (0%04o)  "), magic, magic);
1640 
      switch (magic)
1641 
        {
1642 
        case U802WRMAGIC:
1643 
          printf (_("(WRMAGIC: writable text segments)"));
1644 
          break;
1645 
        case U802ROMAGIC:
1646 
          printf (_("(ROMAGIC: readonly sharablee text segments)"));
1647 
          break;
1648 
        case U802TOCMAGIC:
1649 
          printf (_("(TOCMAGIC: readonly text segments and TOC)"));
1650 
          break;
1651 
        default:
1652 
          printf (_("unknown magic"));
1653 
        }
1654 
      putchar ('\n');
1655 
    }
1656 
  if (magic == U802ROMAGIC || magic == U802WRMAGIC || magic == U802TOCMAGIC)
1657 
    dump_xcoff32 (abfd, &fhdr);
1658 
  else
1659 
    printf (_("  Unhandled magic\n"));
1660 
}
1661 
 
1662 
/* Vector for xcoff.  */
1663 
 
1664 
const struct objdump_private_desc objdump_private_desc_xcoff =
1665 
  {
1666 
    xcoff_help,
1667 
    xcoff_filter,
1668 
    xcoff_dump,
1669 
    options
1670 
  };

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.