Commit | Line | Data |
---|---|---|
6abcee90 TG |
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 | }; |