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