?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bfd
[binutils.git] / binutils / od-xcoff.c
blob47d0248847b2edd5635c932dacd4839cdff23a3b
1 /* 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 };
git-cvsimport of binutils cvsroot