?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bfd/
[binutils.git] / binutils / readelf.c
blobb900b76e22fc5ba891fc0d51da496be1c8866b70
1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
4
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
7
8 This file is part of GNU Binutils.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 02110-1301, USA. */
24 \f
25 /* The difference between readelf and objdump:
26
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
29
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
36
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
39
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
43 \f
44 #include <assert.h>
45 #include <sys/types.h>
46 #include <sys/stat.h>
47 #include <stdio.h>
48 #include <time.h>
49
50 #if __GNUC__ >= 2
51 /* Define BFD64 here, even if our default architecture is 32 bit ELF
52 as this will allow us to read in and parse 64bit and 32bit ELF files.
53 Only do this if we believe that the compiler can support a 64 bit
54 data type. For now we only rely on GCC being able to do this. */
55 #define BFD64
56 #endif
57
58 #include "dwarf.h"
59
60 #include "elf/common.h"
61 #include "elf/external.h"
62 #include "elf/internal.h"
63
64 /* The following headers use the elf/reloc-macros.h file to
65 automatically generate relocation recognition functions
66 such as elf_mips_reloc_type() */
67
68 #define RELOC_MACROS_GEN_FUNC
69
70 #include "elf/alpha.h"
71 #include "elf/arc.h"
72 #include "elf/arm.h"
73 #include "elf/avr.h"
74 #include "elf/bfin.h"
75 #include "elf/cris.h"
76 #include "elf/d10v.h"
77 #include "elf/d30v.h"
78 #include "elf/dlx.h"
79 #include "elf/fr30.h"
80 #include "elf/frv.h"
81 #include "elf/h8.h"
82 #include "elf/hppa.h"
83 #include "elf/i386.h"
84 #include "elf/i370.h"
85 #include "elf/i860.h"
86 #include "elf/i960.h"
87 #include "elf/ia64.h"
88 #include "elf/ip2k.h"
89 #include "elf/m32c.h"
90 #include "elf/m32r.h"
91 #include "elf/m68k.h"
92 #include "elf/m68hc11.h"
93 #include "elf/mcore.h"
94 #include "elf/mips.h"
95 #include "elf/mmix.h"
96 #include "elf/mn10200.h"
97 #include "elf/mn10300.h"
98 #include "elf/mt.h"
99 #include "elf/msp430.h"
100 #include "elf/or32.h"
101 #include "elf/pj.h"
102 #include "elf/ppc.h"
103 #include "elf/ppc64.h"
104 #include "elf/s390.h"
105 #include "elf/sh.h"
106 #include "elf/sparc.h"
107 #include "elf/v850.h"
108 #include "elf/vax.h"
109 #include "elf/x86-64.h"
110 #include "elf/xstormy16.h"
111 #include "elf/crx.h"
112 #include "elf/iq2000.h"
113 #include "elf/xtensa.h"
114
115 #include "aout/ar.h"
116
117 #include "bucomm.h"
118 #include "getopt.h"
119 #include "libiberty.h"
120
121 char *program_name = "readelf";
122 static long archive_file_offset;
123 static unsigned long archive_file_size;
124 static unsigned long dynamic_addr;
125 static bfd_size_type dynamic_size;
126 static unsigned int dynamic_nent;
127 static char *dynamic_strings;
128 static unsigned long dynamic_strings_length;
129 static char *string_table;
130 static unsigned long string_table_length;
131 static unsigned long num_dynamic_syms;
132 static Elf_Internal_Sym *dynamic_symbols;
133 static Elf_Internal_Syminfo *dynamic_syminfo;
134 static unsigned long dynamic_syminfo_offset;
135 static unsigned int dynamic_syminfo_nent;
136 static char program_interpreter[64];
137 static bfd_vma dynamic_info[DT_JMPREL + 1];
138 static bfd_vma version_info[16];
139 static Elf_Internal_Ehdr elf_header;
140 static Elf_Internal_Shdr *section_headers;
141 static Elf_Internal_Phdr *program_headers;
142 static Elf_Internal_Dyn *dynamic_section;
143 static Elf_Internal_Shdr *symtab_shndx_hdr;
144 static int show_name;
145 static int do_dynamic;
146 static int do_syms;
147 static int do_reloc;
148 static int do_sections;
149 static int do_section_groups;
150 static int do_section_details;
151 static int do_segments;
152 static int do_unwind;
153 static int do_using_dynamic;
154 static int do_header;
155 static int do_dump;
156 static int do_version;
157 static int do_wide;
158 static int do_histogram;
159 static int do_debugging;
160 static int do_arch;
161 static int do_notes;
162 static int is_32bit_elf;
163
164 struct group_list
165 {
166 struct group_list *next;
167 unsigned int section_index;
168 };
169
170 struct group
171 {
172 struct group_list *root;
173 unsigned int group_index;
174 };
175
176 static size_t group_count;
177 static struct group *section_groups;
178 static struct group **section_headers_groups;
179
180 /* A linked list of the section names for which dumps were requested
181 by name. */
182 struct dump_list_entry
183 {
184 char *name;
185 int type;
186 struct dump_list_entry *next;
187 };
188 static struct dump_list_entry *dump_sects_byname;
189
190 /* A dynamic array of flags indicating for which sections a hex dump
191 has been requested (via the -x switch) and/or a disassembly dump
192 (via the -i switch). */
193 char *cmdline_dump_sects = NULL;
194 unsigned num_cmdline_dump_sects = 0;
195
196 /* A dynamic array of flags indicating for which sections a dump of
197 some kind has been requested. It is reset on a per-object file
198 basis and then initialised from the cmdline_dump_sects array,
199 the results of interpreting the -w switch, and the
200 dump_sects_byname list. */
201 char *dump_sects = NULL;
202 unsigned int num_dump_sects = 0;
203
204 #define HEX_DUMP (1 << 0)
205 #define DISASS_DUMP (1 << 1)
206 #define DEBUG_DUMP (1 << 2)
207
208 /* How to print a vma value. */
209 typedef enum print_mode
210 {
211 HEX,
212 DEC,
213 DEC_5,
214 UNSIGNED,
215 PREFIX_HEX,
216 FULL_HEX,
217 LONG_HEX
218 }
219 print_mode;
220
221 static void (*byte_put) (unsigned char *, bfd_vma, int);
222
223 #define UNKNOWN -1
224
225 #define SECTION_NAME(X) \
226 ((X) == NULL ? "<none>" \
227 : string_table == NULL ? "<no-name>" \
228 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
229 : string_table + (X)->sh_name))
230
231 /* Given st_shndx I, map to section_headers index. */
232 #define SECTION_HEADER_INDEX(I) \
233 ((I) < SHN_LORESERVE \
234 ? (I) \
235 : ((I) <= SHN_HIRESERVE \
236 ? 0 \
237 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
238
239 /* Reverse of the above. */
240 #define SECTION_HEADER_NUM(N) \
241 ((N) < SHN_LORESERVE \
242 ? (N) \
243 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
244
245 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
246
247 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
248
249 #define BYTE_GET(field) byte_get (field, sizeof (field))
250
251 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
252
253 #define GET_ELF_SYMBOLS(file, section) \
254 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
255 : get_64bit_elf_symbols (file, section))
256
257 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
258 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
259 already been called and verified that the string exists. */
260 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
261
262 /* This is just a bit of syntatic sugar. */
263 #define streq(a,b) (strcmp ((a), (b)) == 0)
264 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
265 \f
266 static void *
267 get_data (void *var, FILE *file, long offset, size_t size, size_t nmemb,
268 const char *reason)
269 {
270 void *mvar;
271
272 if (size == 0 || nmemb == 0)
273 return NULL;
274
275 if (fseek (file, archive_file_offset + offset, SEEK_SET))
276 {
277 error (_("Unable to seek to 0x%lx for %s\n"),
278 archive_file_offset + offset, reason);
279 return NULL;
280 }
281
282 mvar = var;
283 if (mvar == NULL)
284 {
285 /* Check for overflow. */
286 if (nmemb < (~(size_t) 0 - 1) / size)
287 /* + 1 so that we can '\0' terminate invalid string table sections. */
288 mvar = malloc (size * nmemb + 1);
289
290 if (mvar == NULL)
291 {
292 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
293 (unsigned long)(size * nmemb), reason);
294 return NULL;
295 }
296
297 ((char *) mvar)[size * nmemb] = '\0';
298 }
299
300 if (fread (mvar, size, nmemb, file) != nmemb)
301 {
302 error (_("Unable to read in 0x%lx bytes of %s\n"),
303 (unsigned long)(size * nmemb), reason);
304 if (mvar != var)
305 free (mvar);
306 return NULL;
307 }
308
309 return mvar;
310 }
311
312 static void
313 byte_put_little_endian (unsigned char *field, bfd_vma value, int size)
314 {
315 switch (size)
316 {
317 case 8:
318 field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
319 field[6] = ((value >> 24) >> 24) & 0xff;
320 field[5] = ((value >> 24) >> 16) & 0xff;
321 field[4] = ((value >> 24) >> 8) & 0xff;
322 /* Fall through. */
323 case 4:
324 field[3] = (value >> 24) & 0xff;
325 field[2] = (value >> 16) & 0xff;
326 /* Fall through. */
327 case 2:
328 field[1] = (value >> 8) & 0xff;
329 /* Fall through. */
330 case 1:
331 field[0] = value & 0xff;
332 break;
333
334 default:
335 error (_("Unhandled data length: %d\n"), size);
336 abort ();
337 }
338 }
339
340 #if defined BFD64 && !BFD_HOST_64BIT_LONG
341 static int
342 print_dec_vma (bfd_vma vma, int is_signed)
343 {
344 char buf[40];
345 char *bufp = buf;
346 int nc = 0;
347
348 if (is_signed && (bfd_signed_vma) vma < 0)
349 {
350 vma = -vma;
351 putchar ('-');
352 nc = 1;
353 }
354
355 do
356 {
357 *bufp++ = '0' + vma % 10;
358 vma /= 10;
359 }
360 while (vma != 0);
361 nc += bufp - buf;
362
363 while (bufp > buf)
364 putchar (*--bufp);
365 return nc;
366 }
367
368 static int
369 print_hex_vma (bfd_vma vma)
370 {
371 char buf[32];
372 char *bufp = buf;
373 int nc;
374
375 do
376 {
377 char digit = '0' + (vma & 0x0f);
378 if (digit > '9')
379 digit += 'a' - '0' - 10;
380 *bufp++ = digit;
381 vma >>= 4;
382 }
383 while (vma != 0);
384 nc = bufp - buf;
385
386 while (bufp > buf)
387 putchar (*--bufp);
388 return nc;
389 }
390 #endif
391
392 /* Print a VMA value. */
393 static int
394 print_vma (bfd_vma vma, print_mode mode)
395 {
396 #ifdef BFD64
397 if (is_32bit_elf)
398 #endif
399 {
400 switch (mode)
401 {
402 case FULL_HEX:
403 return printf ("0x%8.8lx", (unsigned long) vma);
404
405 case LONG_HEX:
406 return printf ("%8.8lx", (unsigned long) vma);
407
408 case DEC_5:
409 if (vma <= 99999)
410 return printf ("%5ld", (long) vma);
411 /* Drop through. */
412
413 case PREFIX_HEX:
414 return printf ("0x%lx", (unsigned long) vma);
415
416 case HEX:
417 return printf ("%lx", (unsigned long) vma);
418
419 case DEC:
420 return printf ("%ld", (unsigned long) vma);
421
422 case UNSIGNED:
423 return printf ("%lu", (unsigned long) vma);
424 }
425 }
426 #ifdef BFD64
427 else
428 {
429 int nc = 0;
430
431 switch (mode)
432 {
433 case FULL_HEX:
434 nc = printf ("0x");
435 /* Drop through. */
436
437 case LONG_HEX:
438 printf_vma (vma);
439 return nc + 16;
440
441 case PREFIX_HEX:
442 nc = printf ("0x");
443 /* Drop through. */
444
445 case HEX:
446 #if BFD_HOST_64BIT_LONG
447 return nc + printf ("%lx", vma);
448 #else
449 return nc + print_hex_vma (vma);
450 #endif
451
452 case DEC:
453 #if BFD_HOST_64BIT_LONG
454 return printf ("%ld", vma);
455 #else
456 return print_dec_vma (vma, 1);
457 #endif
458
459 case DEC_5:
460 #if BFD_HOST_64BIT_LONG
461 if (vma <= 99999)
462 return printf ("%5ld", vma);
463 else
464 return printf ("%#lx", vma);
465 #else
466 if (vma <= 99999)
467 return printf ("%5ld", _bfd_int64_low (vma));
468 else
469 return print_hex_vma (vma);
470 #endif
471
472 case UNSIGNED:
473 #if BFD_HOST_64BIT_LONG
474 return printf ("%lu", vma);
475 #else
476 return print_dec_vma (vma, 0);
477 #endif
478 }
479 }
480 #endif
481 return 0;
482 }
483
484 /* Display a symbol on stdout. If do_wide is not true then
485 format the symbol to be at most WIDTH characters,
486 truncating as necessary. If WIDTH is negative then
487 format the string to be exactly - WIDTH characters,
488 truncating or padding as necessary. */
489
490 static void
491 print_symbol (int width, const char *symbol)
492 {
493 if (do_wide)
494 printf ("%s", symbol);
495 else if (width < 0)
496 printf ("%-*.*s", width, width, symbol);
497 else
498 printf ("%-.*s", width, symbol);
499 }
500
501 static void
502 byte_put_big_endian (unsigned char *field, bfd_vma value, int size)
503 {
504 switch (size)
505 {
506 case 8:
507 field[7] = value & 0xff;
508 field[6] = (value >> 8) & 0xff;
509 field[5] = (value >> 16) & 0xff;
510 field[4] = (value >> 24) & 0xff;
511 value >>= 16;
512 value >>= 16;
513 /* Fall through. */
514 case 4:
515 field[3] = value & 0xff;
516 field[2] = (value >> 8) & 0xff;
517 value >>= 16;
518 /* Fall through. */
519 case 2:
520 field[1] = value & 0xff;
521 value >>= 8;
522 /* Fall through. */
523 case 1:
524 field[0] = value & 0xff;
525 break;
526
527 default:
528 error (_("Unhandled data length: %d\n"), size);
529 abort ();
530 }
531 }
532
533 /* Return a pointer to section NAME, or NULL if no such section exists. */
534
535 static Elf_Internal_Shdr *
536 find_section (const char *name)
537 {
538 unsigned int i;
539
540 for (i = 0; i < elf_header.e_shnum; i++)
541 if (streq (SECTION_NAME (section_headers + i), name))
542 return section_headers + i;
543
544 return NULL;
545 }
546
547 /* Guess the relocation size commonly used by the specific machines. */
548
549 static int
550 guess_is_rela (unsigned long e_machine)
551 {
552 switch (e_machine)
553 {
554 /* Targets that use REL relocations. */
555 case EM_ARM:
556 case EM_386:
557 case EM_486:
558 case EM_960:
559 case EM_DLX:
560 case EM_OPENRISC:
561 case EM_OR32:
562 case EM_CYGNUS_M32R:
563 case EM_D10V:
564 case EM_CYGNUS_D10V:
565 case EM_MIPS:
566 case EM_MIPS_RS3_LE:
567 return FALSE;
568
569 /* Targets that use RELA relocations. */
570 case EM_68K:
571 case EM_H8_300:
572 case EM_H8_300H:
573 case EM_H8S:
574 case EM_SPARC32PLUS:
575 case EM_SPARCV9:
576 case EM_SPARC:
577 case EM_PPC:
578 case EM_PPC64:
579 case EM_V850:
580 case EM_CYGNUS_V850:
581 case EM_D30V:
582 case EM_CYGNUS_D30V:
583 case EM_MN10200:
584 case EM_CYGNUS_MN10200:
585 case EM_MN10300:
586 case EM_CYGNUS_MN10300:
587 case EM_FR30:
588 case EM_CYGNUS_FR30:
589 case EM_CYGNUS_FRV:
590 case EM_SH:
591 case EM_ALPHA:
592 case EM_MCORE:
593 case EM_IA_64:
594 case EM_AVR:
595 case EM_AVR_OLD:
596 case EM_CRIS:
597 case EM_860:
598 case EM_X86_64:
599 case EM_S390:
600 case EM_S390_OLD:
601 case EM_MMIX:
602 case EM_MSP430:
603 case EM_MSP430_OLD:
604 case EM_XSTORMY16:
605 case EM_CRX:
606 case EM_VAX:
607 case EM_IP2K:
608 case EM_IP2K_OLD:
609 case EM_IQ2000:
610 case EM_XTENSA:
611 case EM_XTENSA_OLD:
612 case EM_M32R:
613 case EM_M32C:
614 case EM_MT:
615 case EM_BLACKFIN:
616 case EM_NIOS32:
617 case EM_ALTERA_NIOS2:
618 return TRUE;
619
620 case EM_MMA:
621 case EM_PCP:
622 case EM_NCPU:
623 case EM_NDR1:
624 case EM_STARCORE:
625 case EM_ME16:
626 case EM_ST100:
627 case EM_TINYJ:
628 case EM_FX66:
629 case EM_ST9PLUS:
630 case EM_ST7:
631 case EM_68HC16:
632 case EM_68HC11:
633 case EM_68HC08:
634 case EM_68HC05:
635 case EM_SVX:
636 case EM_ST19:
637 default:
638 warn (_("Don't know about relocations on this machine architecture\n"));
639 return FALSE;
640 }
641 }
642
643 static int
644 slurp_rela_relocs (FILE *file,
645 unsigned long rel_offset,
646 unsigned long rel_size,
647 Elf_Internal_Rela **relasp,
648 unsigned long *nrelasp)
649 {
650 Elf_Internal_Rela *relas;
651 unsigned long nrelas;
652 unsigned int i;
653
654 if (is_32bit_elf)
655 {
656 Elf32_External_Rela *erelas;
657
658 erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
659 if (!erelas)
660 return 0;
661
662 nrelas = rel_size / sizeof (Elf32_External_Rela);
663
664 relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela));
665
666 if (relas == NULL)
667 {
668 free (erelas);
669 error (_("out of memory parsing relocs"));
670 return 0;
671 }
672
673 for (i = 0; i < nrelas; i++)
674 {
675 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
676 relas[i].r_info = BYTE_GET (erelas[i].r_info);
677 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
678 }
679
680 free (erelas);
681 }
682 else
683 {
684 Elf64_External_Rela *erelas;
685
686 erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
687 if (!erelas)
688 return 0;
689
690 nrelas = rel_size / sizeof (Elf64_External_Rela);
691
692 relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela));
693
694 if (relas == NULL)
695 {
696 free (erelas);
697 error (_("out of memory parsing relocs"));
698 return 0;
699 }
700
701 for (i = 0; i < nrelas; i++)
702 {
703 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
704 relas[i].r_info = BYTE_GET (erelas[i].r_info);
705 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
706 }
707
708 free (erelas);
709 }
710 *relasp = relas;
711 *nrelasp = nrelas;
712 return 1;
713 }
714
715 static int
716 slurp_rel_relocs (FILE *file,
717 unsigned long rel_offset,
718 unsigned long rel_size,
719 Elf_Internal_Rela **relsp,
720 unsigned long *nrelsp)
721 {
722 Elf_Internal_Rela *rels;
723 unsigned long nrels;
724 unsigned int i;
725
726 if (is_32bit_elf)
727 {
728 Elf32_External_Rel *erels;
729
730 erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
731 if (!erels)
732 return 0;
733
734 nrels = rel_size / sizeof (Elf32_External_Rel);
735
736 rels = cmalloc (nrels, sizeof (Elf_Internal_Rela));
737
738 if (rels == NULL)
739 {
740 free (erels);
741 error (_("out of memory parsing relocs"));
742 return 0;
743 }
744
745 for (i = 0; i < nrels; i++)
746 {
747 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
748 rels[i].r_info = BYTE_GET (erels[i].r_info);
749 rels[i].r_addend = 0;
750 }
751
752 free (erels);
753 }
754 else
755 {
756 Elf64_External_Rel *erels;
757
758 erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
759 if (!erels)
760 return 0;
761
762 nrels = rel_size / sizeof (Elf64_External_Rel);
763
764 rels = cmalloc (nrels, sizeof (Elf_Internal_Rela));
765
766 if (rels == NULL)
767 {
768 free (erels);
769 error (_("out of memory parsing relocs"));
770 return 0;
771 }
772
773 for (i = 0; i < nrels; i++)
774 {
775 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
776 rels[i].r_info = BYTE_GET (erels[i].r_info);
777 rels[i].r_addend = 0;
778 }
779
780 free (erels);
781 }
782 *relsp = rels;
783 *nrelsp = nrels;
784 return 1;
785 }
786
787 /* Display the contents of the relocation data found at the specified
788 offset. */
789
790 static int
791 dump_relocations (FILE *file,
792 unsigned long rel_offset,
793 unsigned long rel_size,
794 Elf_Internal_Sym *symtab,
795 unsigned long nsyms,
796 char *strtab,
797 unsigned long strtablen,
798 int is_rela)
799 {
800 unsigned int i;
801 Elf_Internal_Rela *rels;
802
803
804 if (is_rela == UNKNOWN)
805 is_rela = guess_is_rela (elf_header.e_machine);
806
807 if (is_rela)
808 {
809 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
810 return 0;
811 }
812 else
813 {
814 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
815 return 0;
816 }
817
818 if (is_32bit_elf)
819 {
820 if (is_rela)
821 {
822 if (do_wide)
823 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
824 else
825 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
826 }
827 else
828 {
829 if (do_wide)
830 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
831 else
832 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
833 }
834 }
835 else
836 {
837 if (is_rela)
838 {
839 if (do_wide)
840 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
841 else
842 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
843 }
844 else
845 {
846 if (do_wide)
847 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
848 else
849 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
850 }
851 }
852
853 for (i = 0; i < rel_size; i++)
854 {
855 const char *rtype;
856 const char *rtype2 = NULL;
857 const char *rtype3 = NULL;
858 bfd_vma offset;
859 bfd_vma info;
860 bfd_vma symtab_index;
861 bfd_vma type;
862 bfd_vma type2 = 0;
863 bfd_vma type3 = 0;
864
865 offset = rels[i].r_offset;
866 info = rels[i].r_info;
867
868 if (is_32bit_elf)
869 {
870 type = ELF32_R_TYPE (info);
871 symtab_index = ELF32_R_SYM (info);
872 }
873 else
874 {
875 /* The #ifdef BFD64 below is to prevent a compile time warning.
876 We know that if we do not have a 64 bit data type that we
877 will never execute this code anyway. */
878 #ifdef BFD64
879 if (elf_header.e_machine == EM_MIPS)
880 {
881 /* In little-endian objects, r_info isn't really a 64-bit
882 little-endian value: it has a 32-bit little-endian
883 symbol index followed by four individual byte fields.
884 Reorder INFO accordingly. */
885 if (elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
886 info = (((info & 0xffffffff) << 32)
887 | ((info >> 56) & 0xff)
888 | ((info >> 40) & 0xff00)
889 | ((info >> 24) & 0xff0000)
890 | ((info >> 8) & 0xff000000));
891 type = ELF64_MIPS_R_TYPE (info);
892 type2 = ELF64_MIPS_R_TYPE2 (info);
893 type3 = ELF64_MIPS_R_TYPE3 (info);
894 }
895 else if (elf_header.e_machine == EM_SPARCV9)
896 type = ELF64_R_TYPE_ID (info);
897 else
898 type = ELF64_R_TYPE (info);
899
900 symtab_index = ELF64_R_SYM (info);
901 #endif
902 }
903
904 if (is_32bit_elf)
905 {
906 #ifdef _bfd_int64_low
907 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
908 #else
909 printf ("%8.8lx %8.8lx ", offset, info);
910 #endif
911 }
912 else
913 {
914 #ifdef _bfd_int64_low
915 printf (do_wide
916 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
917 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
918 _bfd_int64_high (offset),
919 _bfd_int64_low (offset),
920 _bfd_int64_high (info),
921 _bfd_int64_low (info));
922 #else
923 printf (do_wide
924 ? "%16.16lx %16.16lx "
925 : "%12.12lx %12.12lx ",
926 offset, info);
927 #endif
928 }
929
930 switch (elf_header.e_machine)
931 {
932 default:
933 rtype = NULL;
934 break;
935
936 case EM_M32R:
937 case EM_CYGNUS_M32R:
938 rtype = elf_m32r_reloc_type (type);
939 break;
940
941 case EM_386:
942 case EM_486:
943 rtype = elf_i386_reloc_type (type);
944 break;
945
946 case EM_68HC11:
947 case EM_68HC12:
948 rtype = elf_m68hc11_reloc_type (type);
949 break;
950
951 case EM_68K:
952 rtype = elf_m68k_reloc_type (type);
953 break;
954
955 case EM_960:
956 rtype = elf_i960_reloc_type (type);
957 break;
958
959 case EM_AVR:
960 case EM_AVR_OLD:
961 rtype = elf_avr_reloc_type (type);
962 break;
963
964 case EM_OLD_SPARCV9:
965 case EM_SPARC32PLUS:
966 case EM_SPARCV9:
967 case EM_SPARC:
968 rtype = elf_sparc_reloc_type (type);
969 break;
970
971 case EM_V850:
972 case EM_CYGNUS_V850:
973 rtype = v850_reloc_type (type);
974 break;
975
976 case EM_D10V:
977 case EM_CYGNUS_D10V:
978 rtype = elf_d10v_reloc_type (type);
979 break;
980
981 case EM_D30V:
982 case EM_CYGNUS_D30V:
983 rtype = elf_d30v_reloc_type (type);
984 break;
985
986 case EM_DLX:
987 rtype = elf_dlx_reloc_type (type);
988 break;
989
990 case EM_SH:
991 rtype = elf_sh_reloc_type (type);
992 break;
993
994 case EM_MN10300:
995 case EM_CYGNUS_MN10300:
996 rtype = elf_mn10300_reloc_type (type);
997 break;
998
999 case EM_MN10200:
1000 case EM_CYGNUS_MN10200:
1001 rtype = elf_mn10200_reloc_type (type);
1002 break;
1003
1004 case EM_FR30:
1005 case EM_CYGNUS_FR30:
1006 rtype = elf_fr30_reloc_type (type);
1007 break;
1008
1009 case EM_CYGNUS_FRV:
1010 rtype = elf_frv_reloc_type (type);
1011 break;
1012
1013 case EM_MCORE:
1014 rtype = elf_mcore_reloc_type (type);
1015 break;
1016
1017 case EM_MMIX:
1018 rtype = elf_mmix_reloc_type (type);
1019 break;
1020
1021 case EM_MSP430:
1022 case EM_MSP430_OLD:
1023 rtype = elf_msp430_reloc_type (type);
1024 break;
1025
1026 case EM_PPC:
1027 rtype = elf_ppc_reloc_type (type);
1028 break;
1029
1030 case EM_PPC64:
1031 rtype = elf_ppc64_reloc_type (type);
1032 break;
1033
1034 case EM_MIPS:
1035 case EM_MIPS_RS3_LE:
1036 rtype = elf_mips_reloc_type (type);
1037 if (!is_32bit_elf)
1038 {
1039 rtype2 = elf_mips_reloc_type (type2);
1040 rtype3 = elf_mips_reloc_type (type3);
1041 }
1042 break;
1043
1044 case EM_ALPHA:
1045 rtype = elf_alpha_reloc_type (type);
1046 break;
1047
1048 case EM_ARM:
1049 rtype = elf_arm_reloc_type (type);
1050 break;
1051
1052 case EM_ARC:
1053 rtype = elf_arc_reloc_type (type);
1054 break;
1055
1056 case EM_PARISC:
1057 rtype = elf_hppa_reloc_type (type);
1058 break;
1059
1060 case EM_H8_300:
1061 case EM_H8_300H:
1062 case EM_H8S:
1063 rtype = elf_h8_reloc_type (type);
1064 break;
1065
1066 case EM_OPENRISC:
1067 case EM_OR32:
1068 rtype = elf_or32_reloc_type (type);
1069 break;
1070
1071 case EM_PJ:
1072 case EM_PJ_OLD:
1073 rtype = elf_pj_reloc_type (type);
1074 break;
1075 case EM_IA_64:
1076 rtype = elf_ia64_reloc_type (type);
1077 break;
1078
1079 case EM_CRIS:
1080 rtype = elf_cris_reloc_type (type);
1081 break;
1082
1083 case EM_860:
1084 rtype = elf_i860_reloc_type (type);
1085 break;
1086
1087 case EM_X86_64:
1088 rtype = elf_x86_64_reloc_type (type);
1089 break;
1090
1091 case EM_S370:
1092 rtype = i370_reloc_type (type);
1093 break;
1094
1095 case EM_S390_OLD:
1096 case EM_S390:
1097 rtype = elf_s390_reloc_type (type);
1098 break;
1099
1100 case EM_XSTORMY16:
1101 rtype = elf_xstormy16_reloc_type (type);
1102 break;
1103
1104 case EM_CRX:
1105 rtype = elf_crx_reloc_type (type);
1106 break;
1107
1108 case EM_VAX:
1109 rtype = elf_vax_reloc_type (type);
1110 break;
1111
1112 case EM_IP2K:
1113 case EM_IP2K_OLD:
1114 rtype = elf_ip2k_reloc_type (type);
1115 break;
1116
1117 case EM_IQ2000:
1118 rtype = elf_iq2000_reloc_type (type);
1119 break;
1120
1121 case EM_XTENSA_OLD:
1122 case EM_XTENSA:
1123 rtype = elf_xtensa_reloc_type (type);
1124 break;
1125
1126 case EM_M32C:
1127 rtype = elf_m32c_reloc_type (type);
1128 break;
1129
1130 case EM_MT:
1131 rtype = elf_mt_reloc_type (type);
1132 break;
1133
1134 case EM_BLACKFIN:
1135 rtype = elf_bfin_reloc_type (type);
1136 break;
1137
1138 }
1139
1140 if (rtype == NULL)
1141 #ifdef _bfd_int64_low
1142 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type));
1143 #else
1144 printf (_("unrecognized: %-7lx"), type);
1145 #endif
1146 else
1147 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1148
1149 if (elf_header.e_machine == EM_ALPHA
1150 && streq (rtype, "R_ALPHA_LITUSE")
1151 && is_rela)
1152 {
1153 switch (rels[i].r_addend)
1154 {
1155 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1156 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1157 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1158 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1159 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1160 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1161 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1162 default: rtype = NULL;
1163 }
1164 if (rtype)
1165 printf (" (%s)", rtype);
1166 else
1167 {
1168 putchar (' ');
1169 printf (_("<unknown addend: %lx>"),
1170 (unsigned long) rels[i].r_addend);
1171 }
1172 }
1173 else if (symtab_index)
1174 {
1175 if (symtab == NULL || symtab_index >= nsyms)
1176 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1177 else
1178 {
1179 Elf_Internal_Sym *psym;
1180
1181 psym = symtab + symtab_index;
1182
1183 printf (" ");
1184 print_vma (psym->st_value, LONG_HEX);
1185 printf (is_32bit_elf ? " " : " ");
1186
1187 if (psym->st_name == 0)
1188 {
1189 const char *sec_name = "<null>";
1190 char name_buf[40];
1191
1192 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1193 {
1194 bfd_vma sec_index = (bfd_vma) -1;
1195
1196 if (psym->st_shndx < SHN_LORESERVE)
1197 sec_index = psym->st_shndx;
1198 else if (psym->st_shndx > SHN_HIRESERVE)
1199 sec_index = psym->st_shndx - (SHN_HIRESERVE + 1
1200 - SHN_LORESERVE);
1201
1202 if (sec_index != (bfd_vma) -1)
1203 sec_name = SECTION_NAME (section_headers + sec_index);
1204 else if (psym->st_shndx == SHN_ABS)
1205 sec_name = "ABS";
1206 else if (psym->st_shndx == SHN_COMMON)
1207 sec_name = "COMMON";
1208 else if (elf_header.e_machine == EM_X86_64
1209 && psym->st_shndx == SHN_X86_64_LCOMMON)
1210 sec_name = "LARGE_COMMON";
1211 else if (elf_header.e_machine == EM_IA_64
1212 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1213 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1214 sec_name = "ANSI_COM";
1215 else
1216 {
1217 sprintf (name_buf, "<section 0x%x>",
1218 (unsigned int) psym->st_shndx);
1219 sec_name = name_buf;
1220 }
1221 }
1222 print_symbol (22, sec_name);
1223 }
1224 else if (strtab == NULL)
1225 printf (_("<string table index: %3ld>"), psym->st_name);
1226 else if (psym->st_name >= strtablen)
1227 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1228 else
1229 print_symbol (22, strtab + psym->st_name);
1230
1231 if (is_rela)
1232 printf (" + %lx", (unsigned long) rels[i].r_addend);
1233 }
1234 }
1235 else if (is_rela)
1236 {
1237 printf ("%*c", is_32bit_elf ?
1238 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1239 print_vma (rels[i].r_addend, LONG_HEX);
1240 }
1241
1242 if (elf_header.e_machine == EM_SPARCV9 && streq (rtype, "R_SPARC_OLO10"))
1243 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1244
1245 putchar ('\n');
1246
1247 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1248 {
1249 printf (" Type2: ");
1250
1251 if (rtype2 == NULL)
1252 #ifdef _bfd_int64_low
1253 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2));
1254 #else
1255 printf (_("unrecognized: %-7lx"), type2);
1256 #endif
1257 else
1258 printf ("%-17.17s", rtype2);
1259
1260 printf ("\n Type3: ");
1261
1262 if (rtype3 == NULL)
1263 #ifdef _bfd_int64_low
1264 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3));
1265 #else
1266 printf (_("unrecognized: %-7lx"), type3);
1267 #endif
1268 else
1269 printf ("%-17.17s", rtype3);
1270
1271 putchar ('\n');
1272 }
1273 }
1274
1275 free (rels);
1276
1277 return 1;
1278 }
1279
1280 static const char *
1281 get_mips_dynamic_type (unsigned long type)
1282 {
1283 switch (type)
1284 {
1285 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1286 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1287 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1288 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1289 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1290 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1291 case DT_MIPS_MSYM: return "MIPS_MSYM";
1292 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1293 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1294 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1295 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1296 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1297 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1298 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1299 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1300 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1301 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1302 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1303 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1304 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1305 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1306 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1307 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1308 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1309 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1310 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1311 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1312 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1313 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1314 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1315 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1316 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1317 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1318 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1319 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1320 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1321 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1322 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1323 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1324 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1325 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1326 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1327 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1328 default:
1329 return NULL;
1330 }
1331 }
1332
1333 static const char *
1334 get_sparc64_dynamic_type (unsigned long type)
1335 {
1336 switch (type)
1337 {
1338 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1339 default:
1340 return NULL;
1341 }
1342 }
1343
1344 static const char *
1345 get_ppc_dynamic_type (unsigned long type)
1346 {
1347 switch (type)
1348 {
1349 case DT_PPC_GOT: return "PPC_GOT";
1350 default:
1351 return NULL;
1352 }
1353 }
1354
1355 static const char *
1356 get_ppc64_dynamic_type (unsigned long type)
1357 {
1358 switch (type)
1359 {
1360 case DT_PPC64_GLINK: return "PPC64_GLINK";
1361 case DT_PPC64_OPD: return "PPC64_OPD";
1362 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1363 default:
1364 return NULL;
1365 }
1366 }
1367
1368 static const char *
1369 get_parisc_dynamic_type (unsigned long type)
1370 {
1371 switch (type)
1372 {
1373 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1374 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1375 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1376 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1377 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1378 case DT_HP_PREINIT: return "HP_PREINIT";
1379 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1380 case DT_HP_NEEDED: return "HP_NEEDED";
1381 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1382 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1383 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1384 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1385 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1386 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1387 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1388 case DT_HP_FILTERED: return "HP_FILTERED";
1389 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1390 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1391 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1392 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1393 case DT_PLT: return "PLT";
1394 case DT_PLT_SIZE: return "PLT_SIZE";
1395 case DT_DLT: return "DLT";
1396 case DT_DLT_SIZE: return "DLT_SIZE";
1397 default:
1398 return NULL;
1399 }
1400 }
1401
1402 static const char *
1403 get_ia64_dynamic_type (unsigned long type)
1404 {
1405 switch (type)
1406 {
1407 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1408 default:
1409 return NULL;
1410 }
1411 }
1412
1413 static const char *
1414 get_alpha_dynamic_type (unsigned long type)
1415 {
1416 switch (type)
1417 {
1418 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1419 default:
1420 return NULL;
1421 }
1422 }
1423
1424 static const char *
1425 get_dynamic_type (unsigned long type)
1426 {
1427 static char buff[64];
1428
1429 switch (type)
1430 {
1431 case DT_NULL: return "NULL";
1432 case DT_NEEDED: return "NEEDED";
1433 case DT_PLTRELSZ: return "PLTRELSZ";
1434 case DT_PLTGOT: return "PLTGOT";
1435 case DT_HASH: return "HASH";
1436 case DT_STRTAB: return "STRTAB";
1437 case DT_SYMTAB: return "SYMTAB";
1438 case DT_RELA: return "RELA";
1439 case DT_RELASZ: return "RELASZ";
1440 case DT_RELAENT: return "RELAENT";
1441 case DT_STRSZ: return "STRSZ";
1442 case DT_SYMENT: return "SYMENT";
1443 case DT_INIT: return "INIT";
1444 case DT_FINI: return "FINI";
1445 case DT_SONAME: return "SONAME";
1446 case DT_RPATH: return "RPATH";
1447 case DT_SYMBOLIC: return "SYMBOLIC";
1448 case DT_REL: return "REL";
1449 case DT_RELSZ: return "RELSZ";
1450 case DT_RELENT: return "RELENT";
1451 case DT_PLTREL: return "PLTREL";
1452 case DT_DEBUG: return "DEBUG";
1453 case DT_TEXTREL: return "TEXTREL";
1454 case DT_JMPREL: return "JMPREL";
1455 case DT_BIND_NOW: return "BIND_NOW";
1456 case DT_INIT_ARRAY: return "INIT_ARRAY";
1457 case DT_FINI_ARRAY: return "FINI_ARRAY";
1458 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1459 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1460 case DT_RUNPATH: return "RUNPATH";
1461 case DT_FLAGS: return "FLAGS";
1462
1463 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1464 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1465
1466 case DT_CHECKSUM: return "CHECKSUM";
1467 case DT_PLTPADSZ: return "PLTPADSZ";
1468 case DT_MOVEENT: return "MOVEENT";
1469 case DT_MOVESZ: return "MOVESZ";
1470 case DT_FEATURE: return "FEATURE";
1471 case DT_POSFLAG_1: return "POSFLAG_1";
1472 case DT_SYMINSZ: return "SYMINSZ";
1473 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1474
1475 case DT_ADDRRNGLO: return "ADDRRNGLO";
1476 case DT_CONFIG: return "CONFIG";
1477 case DT_DEPAUDIT: return "DEPAUDIT";
1478 case DT_AUDIT: return "AUDIT";
1479 case DT_PLTPAD: return "PLTPAD";
1480 case DT_MOVETAB: return "MOVETAB";
1481 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1482
1483 case DT_VERSYM: return "VERSYM";
1484
1485 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1486 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1487 case DT_RELACOUNT: return "RELACOUNT";
1488 case DT_RELCOUNT: return "RELCOUNT";
1489 case DT_FLAGS_1: return "FLAGS_1";
1490 case DT_VERDEF: return "VERDEF";
1491 case DT_VERDEFNUM: return "VERDEFNUM";
1492 case DT_VERNEED: return "VERNEED";
1493 case DT_VERNEEDNUM: return "VERNEEDNUM";
1494
1495 case DT_AUXILIARY: return "AUXILIARY";
1496 case DT_USED: return "USED";
1497 case DT_FILTER: return "FILTER";
1498
1499 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1500 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1501 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1502 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1503 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1504
1505 default:
1506 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1507 {
1508 const char *result;
1509
1510 switch (elf_header.e_machine)
1511 {
1512 case EM_MIPS:
1513 case EM_MIPS_RS3_LE:
1514 result = get_mips_dynamic_type (type);
1515 break;
1516 case EM_SPARCV9:
1517 result = get_sparc64_dynamic_type (type);
1518 break;
1519 case EM_PPC:
1520 result = get_ppc_dynamic_type (type);
1521 break;
1522 case EM_PPC64:
1523 result = get_ppc64_dynamic_type (type);
1524 break;
1525 case EM_IA_64:
1526 result = get_ia64_dynamic_type (type);
1527 break;
1528 case EM_ALPHA:
1529 result = get_alpha_dynamic_type (type);
1530 break;
1531 default:
1532 result = NULL;
1533 break;
1534 }
1535
1536 if (result != NULL)
1537 return result;
1538
1539 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1540 }
1541 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1542 || (elf_header.e_machine == EM_PARISC
1543 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1544 {
1545 const char *result;
1546
1547 switch (elf_header.e_machine)
1548 {
1549 case EM_PARISC:
1550 result = get_parisc_dynamic_type (type);
1551 break;
1552 default:
1553 result = NULL;
1554 break;
1555 }
1556
1557 if (result != NULL)
1558 return result;
1559
1560 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1561 type);
1562 }
1563 else
1564 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1565
1566 return buff;
1567 }
1568 }
1569
1570 static char *
1571 get_file_type (unsigned e_type)
1572 {
1573 static char buff[32];
1574
1575 switch (e_type)
1576 {
1577 case ET_NONE: return _("NONE (None)");
1578 case ET_REL: return _("REL (Relocatable file)");
1579 case ET_EXEC: return _("EXEC (Executable file)");
1580 case ET_DYN: return _("DYN (Shared object file)");
1581 case ET_CORE: return _("CORE (Core file)");
1582
1583 default:
1584 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1585 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1586 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1587 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1588 else
1589 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1590 return buff;
1591 }
1592 }
1593
1594 static char *
1595 get_machine_name (unsigned e_machine)
1596 {
1597 static char buff[64]; /* XXX */
1598
1599 switch (e_machine)
1600 {
1601 case EM_NONE: return _("None");
1602 case EM_M32: return "WE32100";
1603 case EM_SPARC: return "Sparc";
1604 case EM_386: return "Intel 80386";
1605 case EM_68K: return "MC68000";
1606 case EM_88K: return "MC88000";
1607 case EM_486: return "Intel 80486";
1608 case EM_860: return "Intel 80860";
1609 case EM_MIPS: return "MIPS R3000";
1610 case EM_S370: return "IBM System/370";
1611 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1612 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1613 case EM_PARISC: return "HPPA";
1614 case EM_PPC_OLD: return "Power PC (old)";
1615 case EM_SPARC32PLUS: return "Sparc v8+" ;
1616 case EM_960: return "Intel 90860";
1617 case EM_PPC: return "PowerPC";
1618 case EM_PPC64: return "PowerPC64";
1619 case EM_V800: return "NEC V800";
1620 case EM_FR20: return "Fujitsu FR20";
1621 case EM_RH32: return "TRW RH32";
1622 case EM_MCORE: return "MCORE";
1623 case EM_ARM: return "ARM";
1624 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1625 case EM_SH: return "Renesas / SuperH SH";
1626 case EM_SPARCV9: return "Sparc v9";
1627 case EM_TRICORE: return "Siemens Tricore";
1628 case EM_ARC: return "ARC";
1629 case EM_H8_300: return "Renesas H8/300";
1630 case EM_H8_300H: return "Renesas H8/300H";
1631 case EM_H8S: return "Renesas H8S";
1632 case EM_H8_500: return "Renesas H8/500";
1633 case EM_IA_64: return "Intel IA-64";
1634 case EM_MIPS_X: return "Stanford MIPS-X";
1635 case EM_COLDFIRE: return "Motorola Coldfire";
1636 case EM_68HC12: return "Motorola M68HC12";
1637 case EM_ALPHA: return "Alpha";
1638 case EM_CYGNUS_D10V:
1639 case EM_D10V: return "d10v";
1640 case EM_CYGNUS_D30V:
1641 case EM_D30V: return "d30v";
1642 case EM_CYGNUS_M32R:
1643 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1644 case EM_CYGNUS_V850:
1645 case EM_V850: return "NEC v850";
1646 case EM_CYGNUS_MN10300:
1647 case EM_MN10300: return "mn10300";
1648 case EM_CYGNUS_MN10200:
1649 case EM_MN10200: return "mn10200";
1650 case EM_CYGNUS_FR30:
1651 case EM_FR30: return "Fujitsu FR30";
1652 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1653 case EM_PJ_OLD:
1654 case EM_PJ: return "picoJava";
1655 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1656 case EM_PCP: return "Siemens PCP";
1657 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1658 case EM_NDR1: return "Denso NDR1 microprocesspr";
1659 case EM_STARCORE: return "Motorola Star*Core processor";
1660 case EM_ME16: return "Toyota ME16 processor";
1661 case EM_ST100: return "STMicroelectronics ST100 processor";
1662 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1663 case EM_FX66: return "Siemens FX66 microcontroller";
1664 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1665 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1666 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1667 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1668 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1669 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1670 case EM_SVX: return "Silicon Graphics SVx";
1671 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1672 case EM_VAX: return "Digital VAX";
1673 case EM_AVR_OLD:
1674 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1675 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1676 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1677 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1678 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1679 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1680 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1681 case EM_PRISM: return "Vitesse Prism";
1682 case EM_X86_64: return "Advanced Micro Devices X86-64";
1683 case EM_S390_OLD:
1684 case EM_S390: return "IBM S/390";
1685 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
1686 case EM_OPENRISC:
1687 case EM_OR32: return "OpenRISC";
1688 case EM_CRX: return "National Semiconductor CRX microprocessor";
1689 case EM_DLX: return "OpenDLX";
1690 case EM_IP2K_OLD:
1691 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1692 case EM_IQ2000: return "Vitesse IQ2000";
1693 case EM_XTENSA_OLD:
1694 case EM_XTENSA: return "Tensilica Xtensa Processor";
1695 case EM_M32C: return "Renesas M32c";
1696 case EM_MT: return "Morpho Techologies MT processor";
1697 case EM_BLACKFIN: return "Analog Devices Blackfin";
1698 case EM_NIOS32: return "Altera Nios";
1699 case EM_ALTERA_NIOS2: return "Altera Nios II";
1700 case EM_XC16X: return "Infineon Technologies xc16x";
1701 default:
1702 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_machine);
1703 return buff;
1704 }
1705 }
1706
1707 static void
1708 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1709 {
1710 unsigned eabi;
1711 int unknown = 0;
1712
1713 eabi = EF_ARM_EABI_VERSION (e_flags);
1714 e_flags &= ~ EF_ARM_EABIMASK;
1715
1716 /* Handle "generic" ARM flags. */
1717 if (e_flags & EF_ARM_RELEXEC)
1718 {
1719 strcat (buf, ", relocatable executable");
1720 e_flags &= ~ EF_ARM_RELEXEC;
1721 }
1722
1723 if (e_flags & EF_ARM_HASENTRY)
1724 {
1725 strcat (buf, ", has entry point");
1726 e_flags &= ~ EF_ARM_HASENTRY;
1727 }
1728
1729 /* Now handle EABI specific flags. */
1730 switch (eabi)
1731 {
1732 default:
1733 strcat (buf, ", <unrecognized EABI>");
1734 if (e_flags)
1735 unknown = 1;
1736 break;
1737
1738 case EF_ARM_EABI_VER1:
1739 strcat (buf, ", Version1 EABI");
1740 while (e_flags)
1741 {
1742 unsigned flag;
1743
1744 /* Process flags one bit at a time. */
1745 flag = e_flags & - e_flags;
1746 e_flags &= ~ flag;
1747
1748 switch (flag)
1749 {
1750 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1751 strcat (buf, ", sorted symbol tables");
1752 break;
1753
1754 default:
1755 unknown = 1;
1756 break;
1757 }
1758 }
1759 break;
1760
1761 case EF_ARM_EABI_VER2:
1762 strcat (buf, ", Version2 EABI");
1763 while (e_flags)
1764 {
1765 unsigned flag;
1766
1767 /* Process flags one bit at a time. */
1768 flag = e_flags & - e_flags;
1769 e_flags &= ~ flag;
1770
1771 switch (flag)
1772 {
1773 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1774 strcat (buf, ", sorted symbol tables");
1775 break;
1776
1777 case EF_ARM_DYNSYMSUSESEGIDX:
1778 strcat (buf, ", dynamic symbols use segment index");
1779 break;
1780
1781 case EF_ARM_MAPSYMSFIRST:
1782 strcat (buf, ", mapping symbols precede others");
1783 break;
1784
1785 default:
1786 unknown = 1;
1787 break;
1788 }
1789 }
1790 break;
1791
1792 case EF_ARM_EABI_VER3:
1793 strcat (buf, ", Version3 EABI");
1794 break;
1795
1796 case EF_ARM_EABI_VER4:
1797 strcat (buf, ", Version4 EABI");
1798 goto eabi;
1799
1800 case EF_ARM_EABI_VER5:
1801 strcat (buf, ", Version5 EABI");
1802 eabi:
1803 while (e_flags)
1804 {
1805 unsigned flag;
1806
1807 /* Process flags one bit at a time. */
1808 flag = e_flags & - e_flags;
1809 e_flags &= ~ flag;
1810
1811 switch (flag)
1812 {
1813 case EF_ARM_BE8:
1814 strcat (buf, ", BE8");
1815 break;
1816
1817 case EF_ARM_LE8:
1818 strcat (buf, ", LE8");
1819 break;
1820
1821 default:
1822 unknown = 1;
1823 break;
1824 }
1825 }
1826 break;
1827
1828 case EF_ARM_EABI_UNKNOWN:
1829 strcat (buf, ", GNU EABI");
1830 while (e_flags)
1831 {
1832 unsigned flag;
1833
1834 /* Process flags one bit at a time. */
1835 flag = e_flags & - e_flags;
1836 e_flags &= ~ flag;
1837
1838 switch (flag)
1839 {
1840 case EF_ARM_INTERWORK:
1841 strcat (buf, ", interworking enabled");
1842 break;
1843
1844 case EF_ARM_APCS_26:
1845 strcat (buf, ", uses APCS/26");
1846 break;
1847
1848 case EF_ARM_APCS_FLOAT:
1849 strcat (buf, ", uses APCS/float");
1850 break;
1851
1852 case EF_ARM_PIC:
1853 strcat (buf, ", position independent");
1854 break;
1855
1856 case EF_ARM_ALIGN8:
1857 strcat (buf, ", 8 bit structure alignment");
1858 break;
1859
1860 case EF_ARM_NEW_ABI:
1861 strcat (buf, ", uses new ABI");
1862 break;
1863
1864 case EF_ARM_OLD_ABI:
1865 strcat (buf, ", uses old ABI");
1866 break;
1867
1868 case EF_ARM_SOFT_FLOAT:
1869 strcat (buf, ", software FP");
1870 break;
1871
1872 case EF_ARM_VFP_FLOAT:
1873 strcat (buf, ", VFP");
1874 break;
1875
1876 case EF_ARM_MAVERICK_FLOAT:
1877 strcat (buf, ", Maverick FP");
1878 break;
1879
1880 default:
1881 unknown = 1;
1882 break;
1883 }
1884 }
1885 }
1886
1887 if (unknown)
1888 strcat (buf,", <unknown>");
1889 }
1890
1891 static char *
1892 get_machine_flags (unsigned e_flags, unsigned e_machine)
1893 {
1894 static char buf[1024];
1895
1896 buf[0] = '\0';
1897
1898 if (e_flags)
1899 {
1900 switch (e_machine)
1901 {
1902 default:
1903 break;
1904
1905 case EM_ARM:
1906 decode_ARM_machine_flags (e_flags, buf);
1907 break;
1908
1909 case EM_CYGNUS_FRV:
1910 switch (e_flags & EF_FRV_CPU_MASK)
1911 {
1912 case EF_FRV_CPU_GENERIC:
1913 break;
1914
1915 default:
1916 strcat (buf, ", fr???");
1917 break;
1918
1919 case EF_FRV_CPU_FR300:
1920 strcat (buf, ", fr300");
1921 break;
1922
1923 case EF_FRV_CPU_FR400:
1924 strcat (buf, ", fr400");
1925 break;
1926 case EF_FRV_CPU_FR405:
1927 strcat (buf, ", fr405");
1928 break;
1929
1930 case EF_FRV_CPU_FR450:
1931 strcat (buf, ", fr450");
1932 break;
1933
1934 case EF_FRV_CPU_FR500:
1935 strcat (buf, ", fr500");
1936 break;
1937 case EF_FRV_CPU_FR550:
1938 strcat (buf, ", fr550");
1939 break;
1940
1941 case EF_FRV_CPU_SIMPLE:
1942 strcat (buf, ", simple");
1943 break;
1944 case EF_FRV_CPU_TOMCAT:
1945 strcat (buf, ", tomcat");
1946 break;
1947 }
1948 break;
1949
1950 case EM_68K:
1951 if (e_flags & EF_M68K_CPU32)
1952 strcat (buf, ", cpu32");
1953 if (e_flags & EF_M68K_M68000)
1954 strcat (buf, ", m68000");
1955 if (e_flags & EF_M68K_ISA_MASK)
1956 {
1957 char const *isa = _("unknown");
1958 char const *mac = _("unknown mac");
1959 char const *additional = NULL;
1960
1961 switch (e_flags & EF_M68K_ISA_MASK)
1962 {
1963 case EF_M68K_ISA_A_NODIV:
1964 isa = "A";
1965 additional = ", nodiv";
1966 break;
1967 case EF_M68K_ISA_A:
1968 isa = "A";
1969 break;
1970 case EF_M68K_ISA_A_PLUS:
1971 isa = "A+";
1972 break;
1973 case EF_M68K_ISA_B_NOUSP:
1974 isa = "B";
1975 additional = ", nousp";
1976 break;
1977 case EF_M68K_ISA_B:
1978 isa = "B";
1979 break;
1980 }
1981 strcat (buf, ", cf, isa ");
1982 strcat (buf, isa);
1983 if (additional)
1984 strcat (buf, additional);
1985 if (e_flags & EF_M68K_FLOAT)
1986 strcat (buf, ", float");
1987 switch (e_flags & EF_M68K_MAC_MASK)
1988 {
1989 case 0:
1990 mac = NULL;
1991 break;
1992 case EF_M68K_MAC:
1993 mac = "mac";
1994 break;
1995 case EF_M68K_EMAC:
1996 mac = "emac";
1997 break;
1998 }
1999 if (mac)
2000 {
2001 strcat (buf, ", ");
2002 strcat (buf, mac);
2003 }
2004 }
2005 break;
2006
2007 case EM_PPC:
2008 if (e_flags & EF_PPC_EMB)
2009 strcat (buf, ", emb");
2010
2011 if (e_flags & EF_PPC_RELOCATABLE)
2012 strcat (buf, ", relocatable");
2013
2014 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2015 strcat (buf, ", relocatable-lib");
2016 break;
2017
2018 case EM_V850:
2019 case EM_CYGNUS_V850:
2020 switch (e_flags & EF_V850_ARCH)
2021 {
2022 case E_V850E1_ARCH:
2023 strcat (buf, ", v850e1");
2024 break;
2025 case E_V850E_ARCH:
2026 strcat (buf, ", v850e");
2027 break;
2028 case E_V850_ARCH:
2029 strcat (buf, ", v850");
2030 break;
2031 default:
2032 strcat (buf, ", unknown v850 architecture variant");
2033 break;
2034 }
2035 break;
2036
2037 case EM_M32R:
2038 case EM_CYGNUS_M32R:
2039 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2040 strcat (buf, ", m32r");
2041
2042 break;
2043
2044 case EM_MIPS:
2045 case EM_MIPS_RS3_LE:
2046 if (e_flags & EF_MIPS_NOREORDER)
2047 strcat (buf, ", noreorder");
2048
2049 if (e_flags & EF_MIPS_PIC)
2050 strcat (buf, ", pic");
2051
2052 if (e_flags & EF_MIPS_CPIC)
2053 strcat (buf, ", cpic");
2054
2055 if (e_flags & EF_MIPS_UCODE)
2056 strcat (buf, ", ugen_reserved");
2057
2058 if (e_flags & EF_MIPS_ABI2)
2059 strcat (buf, ", abi2");
2060
2061 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2062 strcat (buf, ", odk first");
2063
2064 if (e_flags & EF_MIPS_32BITMODE)
2065 strcat (buf, ", 32bitmode");
2066
2067 switch ((e_flags & EF_MIPS_MACH))
2068 {
2069 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2070 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2071 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2072 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2073 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2074 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2075 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2076 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2077 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2078 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2079 case 0:
2080 /* We simply ignore the field in this case to avoid confusion:
2081 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2082 extension. */
2083 break;
2084 default: strcat (buf, ", unknown CPU"); break;
2085 }
2086
2087 switch ((e_flags & EF_MIPS_ABI))
2088 {
2089 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2090 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2091 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2092 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2093 case 0:
2094 /* We simply ignore the field in this case to avoid confusion:
2095 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2096 This means it is likely to be an o32 file, but not for
2097 sure. */
2098 break;
2099 default: strcat (buf, ", unknown ABI"); break;
2100 }
2101
2102 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2103 strcat (buf, ", mdmx");
2104
2105 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2106 strcat (buf, ", mips16");
2107
2108 switch ((e_flags & EF_MIPS_ARCH))
2109 {
2110 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2111 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2112 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2113 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2114 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2115 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2116 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2117 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2118 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2119 default: strcat (buf, ", unknown ISA"); break;
2120 }
2121
2122 break;
2123
2124 case EM_SH:
2125 switch ((e_flags & EF_SH_MACH_MASK))
2126 {
2127 case EF_SH1: strcat (buf, ", sh1"); break;
2128 case EF_SH2: strcat (buf, ", sh2"); break;
2129 case EF_SH3: strcat (buf, ", sh3"); break;
2130 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2131 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2132 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2133 case EF_SH3E: strcat (buf, ", sh3e"); break;
2134 case EF_SH4: strcat (buf, ", sh4"); break;
2135 case EF_SH5: strcat (buf, ", sh5"); break;
2136 case EF_SH2E: strcat (buf, ", sh2e"); break;
2137 case EF_SH4A: strcat (buf, ", sh4a"); break;
2138 case EF_SH2A: strcat (buf, ", sh2a"); break;
2139 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2140 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2141 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2142 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2143 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2144 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2145 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2146 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2147 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2148 default: strcat (buf, ", unknown ISA"); break;
2149 }
2150
2151 break;
2152
2153 case EM_SPARCV9:
2154 if (e_flags & EF_SPARC_32PLUS)
2155 strcat (buf, ", v8+");
2156
2157 if (e_flags & EF_SPARC_SUN_US1)
2158 strcat (buf, ", ultrasparcI");
2159
2160 if (e_flags & EF_SPARC_SUN_US3)
2161 strcat (buf, ", ultrasparcIII");
2162
2163 if (e_flags & EF_SPARC_HAL_R1)
2164 strcat (buf, ", halr1");
2165
2166 if (e_flags & EF_SPARC_LEDATA)
2167 strcat (buf, ", ledata");
2168
2169 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2170 strcat (buf, ", tso");
2171
2172 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2173 strcat (buf, ", pso");
2174
2175 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2176 strcat (buf, ", rmo");
2177 break;
2178
2179 case EM_PARISC:
2180 switch (e_flags & EF_PARISC_ARCH)
2181 {
2182 case EFA_PARISC_1_0:
2183 strcpy (buf, ", PA-RISC 1.0");
2184 break;
2185 case EFA_PARISC_1_1:
2186 strcpy (buf, ", PA-RISC 1.1");
2187 break;
2188 case EFA_PARISC_2_0:
2189 strcpy (buf, ", PA-RISC 2.0");
2190 break;
2191 default:
2192 break;
2193 }
2194 if (e_flags & EF_PARISC_TRAPNIL)
2195 strcat (buf, ", trapnil");
2196 if (e_flags & EF_PARISC_EXT)
2197 strcat (buf, ", ext");
2198 if (e_flags & EF_PARISC_LSB)
2199 strcat (buf, ", lsb");
2200 if (e_flags & EF_PARISC_WIDE)
2201 strcat (buf, ", wide");
2202 if (e_flags & EF_PARISC_NO_KABP)
2203 strcat (buf, ", no kabp");
2204 if (e_flags & EF_PARISC_LAZYSWAP)
2205 strcat (buf, ", lazyswap");
2206 break;
2207
2208 case EM_PJ:
2209 case EM_PJ_OLD:
2210 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2211 strcat (buf, ", new calling convention");
2212
2213 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2214 strcat (buf, ", gnu calling convention");
2215 break;
2216
2217 case EM_IA_64:
2218 if ((e_flags & EF_IA_64_ABI64))
2219 strcat (buf, ", 64-bit");
2220 else
2221 strcat (buf, ", 32-bit");
2222 if ((e_flags & EF_IA_64_REDUCEDFP))
2223 strcat (buf, ", reduced fp model");
2224 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2225 strcat (buf, ", no function descriptors, constant gp");
2226 else if ((e_flags & EF_IA_64_CONS_GP))
2227 strcat (buf, ", constant gp");
2228 if ((e_flags & EF_IA_64_ABSOLUTE))
2229 strcat (buf, ", absolute");
2230 break;
2231
2232 case EM_VAX:
2233 if ((e_flags & EF_VAX_NONPIC))
2234 strcat (buf, ", non-PIC");
2235 if ((e_flags & EF_VAX_DFLOAT))
2236 strcat (buf, ", D-Float");
2237 if ((e_flags & EF_VAX_GFLOAT))
2238 strcat (buf, ", G-Float");
2239 break;
2240 }
2241 }
2242
2243 return buf;
2244 }
2245
2246 static const char *
2247 get_osabi_name (unsigned int osabi)
2248 {
2249 static char buff[32];
2250
2251 switch (osabi)
2252 {
2253 case ELFOSABI_NONE: return "UNIX - System V";
2254 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2255 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2256 case ELFOSABI_LINUX: return "UNIX - Linux";
2257 case ELFOSABI_HURD: return "GNU/Hurd";
2258 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2259 case ELFOSABI_AIX: return "UNIX - AIX";
2260 case ELFOSABI_IRIX: return "UNIX - IRIX";
2261 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2262 case ELFOSABI_TRU64: return "UNIX - TRU64";
2263 case ELFOSABI_MODESTO: return "Novell - Modesto";
2264 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2265 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2266 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2267 case ELFOSABI_AROS: return "Amiga Research OS";
2268 case ELFOSABI_STANDALONE: return _("Standalone App");
2269 case ELFOSABI_ARM: return "ARM";
2270 default:
2271 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2272 return buff;
2273 }
2274 }
2275
2276 static const char *
2277 get_arm_segment_type (unsigned long type)
2278 {
2279 switch (type)
2280 {
2281 case PT_ARM_EXIDX:
2282 return "EXIDX";
2283 default:
2284 break;
2285 }
2286
2287 return NULL;
2288 }
2289
2290 static const char *
2291 get_mips_segment_type (unsigned long type)
2292 {
2293 switch (type)
2294 {
2295 case PT_MIPS_REGINFO:
2296 return "REGINFO";
2297 case PT_MIPS_RTPROC:
2298 return "RTPROC";
2299 case PT_MIPS_OPTIONS:
2300 return "OPTIONS";
2301 default:
2302 break;
2303 }
2304
2305 return NULL;
2306 }
2307
2308 static const char *
2309 get_parisc_segment_type (unsigned long type)
2310 {
2311 switch (type)
2312 {
2313 case PT_HP_TLS: return "HP_TLS";
2314 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2315 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2316 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2317 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2318 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2319 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2320 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2321 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2322 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2323 case PT_HP_PARALLEL: return "HP_PARALLEL";
2324 case PT_HP_FASTBIND: return "HP_FASTBIND";
2325 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2326 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2327 case PT_HP_STACK: return "HP_STACK";
2328 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2329 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2330 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2331 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2332 default:
2333 break;
2334 }
2335
2336 return NULL;
2337 }
2338
2339 static const char *
2340 get_ia64_segment_type (unsigned long type)
2341 {
2342 switch (type)
2343 {
2344 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2345 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2346 case PT_HP_TLS: return "HP_TLS";
2347 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2348 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2349 case PT_IA_64_HP_STACK: return "HP_STACK";
2350 default:
2351 break;
2352 }
2353
2354 return NULL;
2355 }
2356
2357 static const char *
2358 get_segment_type (unsigned long p_type)
2359 {
2360 static char buff[32];
2361
2362 switch (p_type)
2363 {
2364 case PT_NULL: return "NULL";
2365 case PT_LOAD: return "LOAD";
2366 case PT_DYNAMIC: return "DYNAMIC";
2367 case PT_INTERP: return "INTERP";
2368 case PT_NOTE: return "NOTE";
2369 case PT_SHLIB: return "SHLIB";
2370 case PT_PHDR: return "PHDR";
2371 case PT_TLS: return "TLS";
2372
2373 case PT_GNU_EH_FRAME:
2374 return "GNU_EH_FRAME";
2375 case PT_GNU_STACK: return "GNU_STACK";
2376 case PT_GNU_RELRO: return "GNU_RELRO";
2377
2378 default:
2379 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2380 {
2381 const char *result;
2382
2383 switch (elf_header.e_machine)
2384 {
2385 case EM_ARM:
2386 result = get_arm_segment_type (p_type);
2387 break;
2388 case EM_MIPS:
2389 case EM_MIPS_RS3_LE:
2390 result = get_mips_segment_type (p_type);
2391 break;
2392 case EM_PARISC:
2393 result = get_parisc_segment_type (p_type);
2394 break;
2395 case EM_IA_64:
2396 result = get_ia64_segment_type (p_type);
2397 break;
2398 default:
2399 result = NULL;
2400 break;
2401 }
2402
2403 if (result != NULL)
2404 return result;
2405
2406 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2407 }
2408 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2409 {
2410 const char *result;
2411
2412 switch (elf_header.e_machine)
2413 {
2414 case EM_PARISC:
2415 result = get_parisc_segment_type (p_type);
2416 break;
2417 case EM_IA_64:
2418 result = get_ia64_segment_type (p_type);
2419 break;
2420 default:
2421 result = NULL;
2422 break;
2423 }
2424
2425 if (result != NULL)
2426 return result;
2427
2428 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2429 }
2430 else
2431 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2432
2433 return buff;
2434 }
2435 }
2436
2437 static const char *
2438 get_mips_section_type_name (unsigned int sh_type)
2439 {
2440 switch (sh_type)
2441 {
2442 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2443 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2444 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2445 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2446 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2447 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2448 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2449 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2450 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2451 case SHT_MIPS_RELD: return "MIPS_RELD";
2452 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2453 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2454 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2455 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2456 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2457 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2458 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2459 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2460 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2461 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2462 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2463 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2464 case SHT_MIPS_LINE: return "MIPS_LINE";
2465 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2466 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2467 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2468 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2469 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2470 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2471 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2472 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2473 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2474 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2475 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2476 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2477 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2478 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2479 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2480 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2481 default:
2482 break;
2483 }
2484 return NULL;
2485 }
2486
2487 static const char *
2488 get_parisc_section_type_name (unsigned int sh_type)
2489 {
2490 switch (sh_type)
2491 {
2492 case SHT_PARISC_EXT: return "PARISC_EXT";
2493 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2494 case SHT_PARISC_DOC: return "PARISC_DOC";
2495 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2496 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2497 case SHT_PARISC_STUBS: return "PARISC_STUBS";
2498 case SHT_PARISC_DLKM: return "PARISC_DLKM";
2499 default:
2500 break;
2501 }
2502 return NULL;
2503 }
2504
2505 static const char *
2506 get_ia64_section_type_name (unsigned int sh_type)
2507 {
2508 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2509 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2510 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2511
2512 switch (sh_type)
2513 {
2514 case SHT_IA_64_EXT: return "IA_64_EXT";
2515 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2516 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2517 default:
2518 break;
2519 }
2520 return NULL;
2521 }
2522
2523 static const char *
2524 get_x86_64_section_type_name (unsigned int sh_type)
2525 {
2526 switch (sh_type)
2527 {
2528 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2529 default:
2530 break;
2531 }
2532 return NULL;
2533 }
2534
2535 static const char *
2536 get_arm_section_type_name (unsigned int sh_type)
2537 {
2538 switch (sh_type)
2539 {
2540 case SHT_ARM_EXIDX:
2541 return "ARM_EXIDX";
2542 case SHT_ARM_PREEMPTMAP:
2543 return "ARM_PREEMPTMAP";
2544 case SHT_ARM_ATTRIBUTES:
2545 return "ARM_ATTRIBUTES";
2546 default:
2547 break;
2548 }
2549 return NULL;
2550 }
2551
2552 static const char *
2553 get_section_type_name (unsigned int sh_type)
2554 {
2555 static char buff[32];
2556
2557 switch (sh_type)
2558 {
2559 case SHT_NULL: return "NULL";
2560 case SHT_PROGBITS: return "PROGBITS";
2561 case SHT_SYMTAB: return "SYMTAB";
2562 case SHT_STRTAB: return "STRTAB";
2563 case SHT_RELA: return "RELA";
2564 case SHT_HASH: return "HASH";
2565 case SHT_DYNAMIC: return "DYNAMIC";
2566 case SHT_NOTE: return "NOTE";
2567 case SHT_NOBITS: return "NOBITS";
2568 case SHT_REL: return "REL";
2569 case SHT_SHLIB: return "SHLIB";
2570 case SHT_DYNSYM: return "DYNSYM";
2571 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2572 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2573 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2574 case SHT_GROUP: return "GROUP";
2575 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2576 case SHT_GNU_verdef: return "VERDEF";
2577 case SHT_GNU_verneed: return "VERNEED";
2578 case SHT_GNU_versym: return "VERSYM";
2579 case 0x6ffffff0: return "VERSYM";
2580 case 0x6ffffffc: return "VERDEF";
2581 case 0x7ffffffd: return "AUXILIARY";
2582 case 0x7fffffff: return "FILTER";
2583 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
2584
2585 default:
2586 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2587 {
2588 const char *result;
2589
2590 switch (elf_header.e_machine)
2591 {
2592 case EM_MIPS:
2593 case EM_MIPS_RS3_LE:
2594 result = get_mips_section_type_name (sh_type);
2595 break;
2596 case EM_PARISC:
2597 result = get_parisc_section_type_name (sh_type);
2598 break;
2599 case EM_IA_64:
2600 result = get_ia64_section_type_name (sh_type);
2601 break;
2602 case EM_X86_64:
2603 result = get_x86_64_section_type_name (sh_type);
2604 break;
2605 case EM_ARM:
2606 result = get_arm_section_type_name (sh_type);
2607 break;
2608 default:
2609 result = NULL;
2610 break;
2611 }
2612
2613 if (result != NULL)
2614 return result;
2615
2616 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2617 }
2618 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2619 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2620 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2621 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2622 else
2623 snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
2624
2625 return buff;
2626 }
2627 }
2628
2629 #define OPTION_DEBUG_DUMP 512
2630
2631 static struct option options[] =
2632 {
2633 {"all", no_argument, 0, 'a'},
2634 {"file-header", no_argument, 0, 'h'},
2635 {"program-headers", no_argument, 0, 'l'},
2636 {"headers", no_argument, 0, 'e'},
2637 {"histogram", no_argument, 0, 'I'},
2638 {"segments", no_argument, 0, 'l'},
2639 {"sections", no_argument, 0, 'S'},
2640 {"section-headers", no_argument, 0, 'S'},
2641 {"section-groups", no_argument, 0, 'g'},
2642 {"section-details", no_argument, 0, 't'},
2643 {"full-section-name",no_argument, 0, 'N'},
2644 {"symbols", no_argument, 0, 's'},
2645 {"syms", no_argument, 0, 's'},
2646 {"relocs", no_argument, 0, 'r'},
2647 {"notes", no_argument, 0, 'n'},
2648 {"dynamic", no_argument, 0, 'd'},
2649 {"arch-specific", no_argument, 0, 'A'},
2650 {"version-info", no_argument, 0, 'V'},
2651 {"use-dynamic", no_argument, 0, 'D'},
2652 {"hex-dump", required_argument, 0, 'x'},
2653 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
2654 {"unwind", no_argument, 0, 'u'},
2655 #ifdef SUPPORT_DISASSEMBLY
2656 {"instruction-dump", required_argument, 0, 'i'},
2657 #endif
2658
2659 {"version", no_argument, 0, 'v'},
2660 {"wide", no_argument, 0, 'W'},
2661 {"help", no_argument, 0, 'H'},
2662 {0, no_argument, 0, 0}
2663 };
2664
2665 static void
2666 usage (void)
2667 {
2668 fprintf (stdout, _("Usage: readelf <option(s)> elf-file(s)\n"));
2669 fprintf (stdout, _(" Display information about the contents of ELF format files\n"));
2670 fprintf (stdout, _(" Options are:\n\
2671 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2672 -h --file-header Display the ELF file header\n\
2673 -l --program-headers Display the program headers\n\
2674 --segments An alias for --program-headers\n\
2675 -S --section-headers Display the sections' header\n\
2676 --sections An alias for --section-headers\n\
2677 -g --section-groups Display the section groups\n\
2678 -t --section-details Display the section details\n\
2679 -e --headers Equivalent to: -h -l -S\n\
2680 -s --syms Display the symbol table\n\
2681 --symbols An alias for --syms\n\
2682 -n --notes Display the core notes (if present)\n\
2683 -r --relocs Display the relocations (if present)\n\
2684 -u --unwind Display the unwind info (if present)\n\
2685 -d --dynamic Display the dynamic section (if present)\n\
2686 -V --version-info Display the version sections (if present)\n\
2687 -A --arch-specific Display architecture specific information (if any).\n\
2688 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2689 -x --hex-dump=<number> Dump the contents of section <number>\n\
2690 -w[liaprmfFsoR] or\n\
2691 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2692 Display the contents of DWARF2 debug sections\n"));
2693 #ifdef SUPPORT_DISASSEMBLY
2694 fprintf (stdout, _("\
2695 -i --instruction-dump=<number>\n\
2696 Disassemble the contents of section <number>\n"));
2697 #endif
2698 fprintf (stdout, _("\
2699 -I --histogram Display histogram of bucket list lengths\n\
2700 -W --wide Allow output width to exceed 80 characters\n\
2701 @<file> Read options from <file>\n\
2702 -H --help Display this information\n\
2703 -v --version Display the version number of readelf\n"));
2704 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2705
2706 exit (0);
2707 }
2708
2709 /* Record the fact that the user wants the contents of section number
2710 SECTION to be displayed using the method(s) encoded as flags bits
2711 in TYPE. Note, TYPE can be zero if we are creating the array for
2712 the first time. */
2713
2714 static void
2715 request_dump (unsigned int section, int type)
2716 {
2717 if (section >= num_dump_sects)
2718 {
2719 char *new_dump_sects;
2720
2721 new_dump_sects = calloc (section + 1, 1);
2722
2723 if (new_dump_sects == NULL)
2724 error (_("Out of memory allocating dump request table."));
2725 else
2726 {
2727 /* Copy current flag settings. */
2728 memcpy (new_dump_sects, dump_sects, num_dump_sects);
2729
2730 free (dump_sects);
2731
2732 dump_sects = new_dump_sects;
2733 num_dump_sects = section + 1;
2734 }
2735 }
2736
2737 if (dump_sects)
2738 dump_sects[section] |= type;
2739
2740 return;
2741 }
2742
2743 /* Request a dump by section name. */
2744
2745 static void
2746 request_dump_byname (const char *section, int type)
2747 {
2748 struct dump_list_entry *new_request;
2749
2750 new_request = malloc (sizeof (struct dump_list_entry));
2751 if (!new_request)
2752 error (_("Out of memory allocating dump request table."));
2753
2754 new_request->name = strdup (section);
2755 if (!new_request->name)
2756 error (_("Out of memory allocating dump request table."));
2757
2758 new_request->type = type;
2759
2760 new_request->next = dump_sects_byname;
2761 dump_sects_byname = new_request;
2762 }
2763
2764 static void
2765 parse_args (int argc, char **argv)
2766 {
2767 int c;
2768
2769 if (argc < 2)
2770 usage ();
2771
2772 while ((c = getopt_long
2773 (argc, argv, "ersuahnldSDAINtgw::x:i:vVWH", options, NULL)) != EOF)
2774 {
2775 char *cp;
2776 int section;
2777
2778 switch (c)
2779 {
2780 case 0:
2781 /* Long options. */
2782 break;
2783 case 'H':
2784 usage ();
2785 break;
2786
2787 case 'a':
2788 do_syms++;
2789 do_reloc++;
2790 do_unwind++;
2791 do_dynamic++;
2792 do_header++;
2793 do_sections++;
2794 do_section_groups++;
2795 do_segments++;
2796 do_version++;
2797 do_histogram++;
2798 do_arch++;
2799 do_notes++;
2800 break;
2801 case 'g':
2802 do_section_groups++;
2803 break;
2804 case 't':
2805 case 'N':
2806 do_sections++;
2807 do_section_details++;
2808 break;
2809 case 'e':
2810 do_header++;
2811 do_sections++;
2812 do_segments++;
2813 break;
2814 case 'A':
2815 do_arch++;
2816 break;
2817 case 'D':
2818 do_using_dynamic++;
2819 break;
2820 case 'r':
2821 do_reloc++;
2822 break;
2823 case 'u':
2824 do_unwind++;
2825 break;
2826 case 'h':
2827 do_header++;
2828 break;
2829 case 'l':
2830 do_segments++;
2831 break;
2832 case 's':
2833 do_syms++;
2834 break;
2835 case 'S':
2836 do_sections++;
2837 break;
2838 case 'd':
2839 do_dynamic++;
2840 break;
2841 case 'I':
2842 do_histogram++;
2843 break;
2844 case 'n':
2845 do_notes++;
2846 break;
2847 case 'x':
2848 do_dump++;
2849 section = strtoul (optarg, & cp, 0);
2850 if (! *cp && section >= 0)
2851 request_dump (section, HEX_DUMP);
2852 else
2853 request_dump_byname (optarg, HEX_DUMP);
2854 break;
2855 case 'w':
2856 do_dump++;
2857 if (optarg == 0)
2858 do_debugging = 1;
2859 else
2860 {
2861 unsigned int index = 0;
2862
2863 do_debugging = 0;
2864
2865 while (optarg[index])
2866 switch (optarg[index++])
2867 {
2868 case 'i':
2869 case 'I':
2870 do_debug_info = 1;
2871 break;
2872
2873 case 'a':
2874 case 'A':
2875 do_debug_abbrevs = 1;
2876 break;
2877
2878 case 'l':
2879 case 'L':
2880 do_debug_lines = 1;
2881 break;
2882
2883 case 'p':
2884 case 'P':
2885 do_debug_pubnames = 1;
2886 break;
2887
2888 case 'r':
2889 do_debug_aranges = 1;
2890 break;
2891
2892 case 'R':
2893 do_debug_ranges = 1;
2894 break;
2895
2896 case 'F':
2897 do_debug_frames_interp = 1;
2898 case 'f':
2899 do_debug_frames = 1;
2900 break;
2901
2902 case 'm':
2903 case 'M':
2904 do_debug_macinfo = 1;
2905 break;
2906
2907 case 's':
2908 case 'S':
2909 do_debug_str = 1;
2910 break;
2911
2912 case 'o':
2913 case 'O':
2914 do_debug_loc = 1;
2915 break;
2916
2917 default:
2918 warn (_("Unrecognized debug option '%s'\n"), optarg);
2919 break;
2920 }
2921 }
2922 break;
2923 case OPTION_DEBUG_DUMP:
2924 do_dump++;
2925 if (optarg == 0)
2926 do_debugging = 1;
2927 else
2928 {
2929 typedef struct
2930 {
2931 const char * option;
2932 int * variable;
2933 }
2934 debug_dump_long_opts;
2935
2936 debug_dump_long_opts opts_table [] =
2937 {
2938 /* Please keep this table alpha- sorted. */
2939 { "Ranges", & do_debug_ranges },
2940 { "abbrev", & do_debug_abbrevs },
2941 { "aranges", & do_debug_aranges },
2942 { "frames", & do_debug_frames },
2943 { "frames-interp", & do_debug_frames_interp },
2944 { "info", & do_debug_info },
2945 { "line", & do_debug_lines },
2946 { "loc", & do_debug_loc },
2947 { "macro", & do_debug_macinfo },
2948 { "pubnames", & do_debug_pubnames },
2949 /* This entry is for compatability
2950 with earlier versions of readelf. */
2951 { "ranges", & do_debug_aranges },
2952 { "str", & do_debug_str },
2953 { NULL, NULL }
2954 };
2955
2956 const char *p;
2957
2958 do_debugging = 0;
2959
2960 p = optarg;
2961 while (*p)
2962 {
2963 debug_dump_long_opts * entry;
2964
2965 for (entry = opts_table; entry->option; entry++)
2966 {
2967 size_t len = strlen (entry->option);
2968
2969 if (strneq (p, entry->option, len)
2970 && (p[len] == ',' || p[len] == '\0'))
2971 {
2972 * entry->variable = 1;
2973
2974 /* The --debug-dump=frames-interp option also
2975 enables the --debug-dump=frames option. */
2976 if (do_debug_frames_interp)
2977 do_debug_frames = 1;
2978
2979 p += len;
2980 break;
2981 }
2982 }
2983
2984 if (entry->option == NULL)
2985 {
2986 warn (_("Unrecognized debug option '%s'\n"), p);
2987 p = strchr (p, ',');
2988 if (p == NULL)
2989 break;
2990 }
2991
2992 if (*p == ',')
2993 p++;
2994 }
2995 }
2996 break;
2997 #ifdef SUPPORT_DISASSEMBLY
2998 case 'i':
2999 do_dump++;
3000 section = strtoul (optarg, & cp, 0);
3001 if (! *cp && section >= 0)
3002 {
3003 request_dump (section, DISASS_DUMP);
3004 break;
3005 }
3006 goto oops;
3007 #endif
3008 case 'v':
3009 print_version (program_name);
3010 break;
3011 case 'V':
3012 do_version++;
3013 break;
3014 case 'W':
3015 do_wide++;
3016 break;
3017 default:
3018 #ifdef SUPPORT_DISASSEMBLY
3019 oops:
3020 #endif
3021 /* xgettext:c-format */
3022 error (_("Invalid option '-%c'\n"), c);
3023 /* Drop through. */
3024 case '?':
3025 usage ();
3026 }
3027 }
3028
3029 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3030 && !do_segments && !do_header && !do_dump && !do_version
3031 && !do_histogram && !do_debugging && !do_arch && !do_notes
3032 && !do_section_groups)
3033 usage ();
3034 else if (argc < 3)
3035 {
3036 warn (_("Nothing to do.\n"));
3037 usage ();
3038 }
3039 }
3040
3041 static const char *
3042 get_elf_class (unsigned int elf_class)
3043 {
3044 static char buff[32];
3045
3046 switch (elf_class)
3047 {
3048 case ELFCLASSNONE: return _("none");
3049 case ELFCLASS32: return "ELF32";
3050 case ELFCLASS64: return "ELF64";
3051 default:
3052 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3053 return buff;
3054 }
3055 }
3056
3057 static const char *
3058 get_data_encoding (unsigned int encoding)
3059 {
3060 static char buff[32];
3061
3062 switch (encoding)
3063 {
3064 case ELFDATANONE: return _("none");
3065 case ELFDATA2LSB: return _("2's complement, little endian");
3066 case ELFDATA2MSB: return _("2's complement, big endian");
3067 default:
3068 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3069 return buff;
3070 }
3071 }
3072
3073 /* Decode the data held in 'elf_header'. */
3074
3075 static int
3076 process_file_header (void)
3077 {
3078 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3079 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3080 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3081 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3082 {
3083 error
3084 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3085 return 0;
3086 }
3087
3088 if (do_header)
3089 {
3090 int i;
3091
3092 printf (_("ELF Header:\n"));
3093 printf (_(" Magic: "));
3094 for (i = 0; i < EI_NIDENT; i++)
3095 printf ("%2.2x ", elf_header.e_ident[i]);
3096 printf ("\n");
3097 printf (_(" Class: %s\n"),
3098 get_elf_class (elf_header.e_ident[EI_CLASS]));
3099 printf (_(" Data: %s\n"),
3100 get_data_encoding (elf_header.e_ident[EI_DATA]));
3101 printf (_(" Version: %d %s\n"),
3102 elf_header.e_ident[EI_VERSION],
3103 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3104 ? "(current)"
3105 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3106 ? "<unknown: %lx>"
3107 : "")));
3108 printf (_(" OS/ABI: %s\n"),
3109 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3110 printf (_(" ABI Version: %d\n"),
3111 elf_header.e_ident[EI_ABIVERSION]);
3112 printf (_(" Type: %s\n"),
3113 get_file_type (elf_header.e_type));
3114 printf (_(" Machine: %s\n"),
3115 get_machine_name (elf_header.e_machine));
3116 printf (_(" Version: 0x%lx\n"),
3117 (unsigned long) elf_header.e_version);
3118
3119 printf (_(" Entry point address: "));
3120 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3121 printf (_("\n Start of program headers: "));
3122 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3123 printf (_(" (bytes into file)\n Start of section headers: "));
3124 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3125 printf (_(" (bytes into file)\n"));
3126
3127 printf (_(" Flags: 0x%lx%s\n"),
3128 (unsigned long) elf_header.e_flags,
3129 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3130 printf (_(" Size of this header: %ld (bytes)\n"),
3131 (long) elf_header.e_ehsize);
3132 printf (_(" Size of program headers: %ld (bytes)\n"),
3133 (long) elf_header.e_phentsize);
3134 printf (_(" Number of program headers: %ld\n"),
3135 (long) elf_header.e_phnum);
3136 printf (_(" Size of section headers: %ld (bytes)\n"),
3137 (long) elf_header.e_shentsize);
3138 printf (_(" Number of section headers: %ld"),
3139 (long) elf_header.e_shnum);
3140 if (section_headers != NULL && elf_header.e_shnum == 0)
3141 printf (" (%ld)", (long) section_headers[0].sh_size);
3142 putc ('\n', stdout);
3143 printf (_(" Section header string table index: %ld"),
3144 (long) elf_header.e_shstrndx);
3145 if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX)
3146 printf (" (%ld)", (long) section_headers[0].sh_link);
3147 else if (elf_header.e_shstrndx != SHN_UNDEF
3148 && (elf_header.e_shstrndx >= elf_header.e_shnum
3149 || (elf_header.e_shstrndx >= SHN_LORESERVE
3150 && elf_header.e_shstrndx <= SHN_HIRESERVE)))
3151 printf (" <corrupt: out of range>");
3152 putc ('\n', stdout);
3153 }
3154
3155 if (section_headers != NULL)
3156 {
3157 if (elf_header.e_shnum == 0)
3158 elf_header.e_shnum = section_headers[0].sh_size;
3159 if (elf_header.e_shstrndx == SHN_XINDEX)
3160 elf_header.e_shstrndx = section_headers[0].sh_link;
3161 else if (elf_header.e_shstrndx != SHN_UNDEF
3162 && (elf_header.e_shstrndx >= elf_header.e_shnum
3163 || (elf_header.e_shstrndx >= SHN_LORESERVE
3164 && elf_header.e_shstrndx <= SHN_HIRESERVE)))
3165 elf_header.e_shstrndx = SHN_UNDEF;
3166 free (section_headers);
3167 section_headers = NULL;
3168 }
3169
3170 return 1;
3171 }
3172
3173
3174 static int
3175 get_32bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3176 {
3177 Elf32_External_Phdr *phdrs;
3178 Elf32_External_Phdr *external;
3179 Elf_Internal_Phdr *internal;
3180 unsigned int i;
3181
3182 phdrs = get_data (NULL, file, elf_header.e_phoff,
3183 elf_header.e_phentsize, elf_header.e_phnum,
3184 _("program headers"));
3185 if (!phdrs)
3186 return 0;
3187
3188 for (i = 0, internal = program_headers, external = phdrs;
3189 i < elf_header.e_phnum;
3190 i++, internal++, external++)
3191 {
3192 internal->p_type = BYTE_GET (external->p_type);
3193 internal->p_offset = BYTE_GET (external->p_offset);
3194 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3195 internal->p_paddr = BYTE_GET (external->p_paddr);
3196 internal->p_filesz = BYTE_GET (external->p_filesz);
3197 internal->p_memsz = BYTE_GET (external->p_memsz);
3198 internal->p_flags = BYTE_GET (external->p_flags);
3199 internal->p_align = BYTE_GET (external->p_align);
3200 }
3201
3202 free (phdrs);
3203
3204 return 1;
3205 }
3206
3207 static int
3208 get_64bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3209 {
3210 Elf64_External_Phdr *phdrs;
3211 Elf64_External_Phdr *external;
3212 Elf_Internal_Phdr *internal;
3213 unsigned int i;
3214
3215 phdrs = get_data (NULL, file, elf_header.e_phoff,
3216 elf_header.e_phentsize, elf_header.e_phnum,
3217 _("program headers"));
3218 if (!phdrs)
3219 return 0;
3220
3221 for (i = 0, internal = program_headers, external = phdrs;
3222 i < elf_header.e_phnum;
3223 i++, internal++, external++)
3224 {
3225 internal->p_type = BYTE_GET (external->p_type);
3226 internal->p_flags = BYTE_GET (external->p_flags);
3227 internal->p_offset = BYTE_GET (external->p_offset);
3228 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3229 internal->p_paddr = BYTE_GET (external->p_paddr);
3230 internal->p_filesz = BYTE_GET (external->p_filesz);
3231 internal->p_memsz = BYTE_GET (external->p_memsz);
3232 internal->p_align = BYTE_GET (external->p_align);
3233 }
3234
3235 free (phdrs);
3236
3237 return 1;
3238 }
3239
3240 /* Returns 1 if the program headers were read into `program_headers'. */
3241
3242 static int
3243 get_program_headers (FILE *file)
3244 {
3245 Elf_Internal_Phdr *phdrs;
3246
3247 /* Check cache of prior read. */
3248 if (program_headers != NULL)
3249 return 1;
3250
3251 phdrs = cmalloc (elf_header.e_phnum, sizeof (Elf_Internal_Phdr));
3252
3253 if (phdrs == NULL)
3254 {
3255 error (_("Out of memory\n"));
3256 return 0;
3257 }
3258
3259 if (is_32bit_elf
3260 ? get_32bit_program_headers (file, phdrs)
3261 : get_64bit_program_headers (file, phdrs))
3262 {
3263 program_headers = phdrs;
3264 return 1;
3265 }
3266
3267 free (phdrs);
3268 return 0;
3269 }
3270
3271 /* Returns 1 if the program headers were loaded. */
3272
3273 static int
3274 process_program_headers (FILE *file)
3275 {
3276 Elf_Internal_Phdr *segment;
3277 unsigned int i;
3278
3279 if (elf_header.e_phnum == 0)
3280 {
3281 if (do_segments)
3282 printf (_("\nThere are no program headers in this file.\n"));
3283 return 0;
3284 }
3285
3286 if (do_segments && !do_header)
3287 {
3288 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3289 printf (_("Entry point "));
3290 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3291 printf (_("\nThere are %d program headers, starting at offset "),
3292 elf_header.e_phnum);
3293 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3294 printf ("\n");
3295 }
3296
3297 if (! get_program_headers (file))
3298 return 0;
3299
3300 if (do_segments)
3301 {
3302 if (elf_header.e_phnum > 1)
3303 printf (_("\nProgram Headers:\n"));
3304 else
3305 printf (_("\nProgram Headers:\n"));
3306
3307 if (is_32bit_elf)
3308 printf
3309 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3310 else if (do_wide)
3311 printf
3312 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3313 else
3314 {
3315 printf
3316 (_(" Type Offset VirtAddr PhysAddr\n"));
3317 printf
3318 (_(" FileSiz MemSiz Flags Align\n"));
3319 }
3320 }
3321
3322 dynamic_addr = 0;
3323 dynamic_size = 0;
3324
3325 for (i = 0, segment = program_headers;
3326 i < elf_header.e_phnum;
3327 i++, segment++)
3328 {
3329 if (do_segments)
3330 {
3331 printf (" %-14.14s ", get_segment_type (segment->p_type));
3332
3333 if (is_32bit_elf)
3334 {
3335 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3336 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3337 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3338 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3339 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3340 printf ("%c%c%c ",
3341 (segment->p_flags & PF_R ? 'R' : ' '),
3342 (segment->p_flags & PF_W ? 'W' : ' '),
3343 (segment->p_flags & PF_X ? 'E' : ' '));
3344 printf ("%#lx", (unsigned long) segment->p_align);
3345 }
3346 else if (do_wide)
3347 {
3348 if ((unsigned long) segment->p_offset == segment->p_offset)
3349 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3350 else
3351 {
3352 print_vma (segment->p_offset, FULL_HEX);
3353 putchar (' ');
3354 }
3355
3356 print_vma (segment->p_vaddr, FULL_HEX);
3357 putchar (' ');
3358 print_vma (segment->p_paddr, FULL_HEX);
3359 putchar (' ');
3360
3361 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3362 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3363 else
3364 {
3365 print_vma (segment->p_filesz, FULL_HEX);
3366 putchar (' ');
3367 }
3368
3369 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3370 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3371 else
3372 {
3373 print_vma (segment->p_offset, FULL_HEX);
3374 }
3375
3376 printf (" %c%c%c ",
3377 (segment->p_flags & PF_R ? 'R' : ' '),
3378 (segment->p_flags & PF_W ? 'W' : ' '),
3379 (segment->p_flags & PF_X ? 'E' : ' '));
3380
3381 if ((unsigned long) segment->p_align == segment->p_align)
3382 printf ("%#lx", (unsigned long) segment->p_align);
3383 else
3384 {
3385 print_vma (segment->p_align, PREFIX_HEX);
3386 }
3387 }
3388 else
3389 {
3390 print_vma (segment->p_offset, FULL_HEX);
3391 putchar (' ');
3392 print_vma (segment->p_vaddr, FULL_HEX);
3393 putchar (' ');
3394 print_vma (segment->p_paddr, FULL_HEX);
3395 printf ("\n ");
3396 print_vma (segment->p_filesz, FULL_HEX);
3397 putchar (' ');
3398 print_vma (segment->p_memsz, FULL_HEX);
3399 printf (" %c%c%c ",
3400 (segment->p_flags & PF_R ? 'R' : ' '),
3401 (segment->p_flags & PF_W ? 'W' : ' '),
3402 (segment->p_flags & PF_X ? 'E' : ' '));
3403 print_vma (segment->p_align, HEX);
3404 }
3405 }
3406
3407 switch (segment->p_type)
3408 {
3409 case PT_DYNAMIC:
3410 if (dynamic_addr)
3411 error (_("more than one dynamic segment\n"));
3412
3413 /* Try to locate the .dynamic section. If there is
3414 a section header table, we can easily locate it. */
3415 if (section_headers != NULL)
3416 {
3417 Elf_Internal_Shdr *sec;
3418
3419 sec = find_section (".dynamic");
3420 if (sec == NULL || sec->sh_size == 0)
3421 {
3422 error (_("no .dynamic section in the dynamic segment"));
3423 break;
3424 }
3425
3426 dynamic_addr = sec->sh_offset;
3427 dynamic_size = sec->sh_size;
3428
3429 if (dynamic_addr < segment->p_offset
3430 || dynamic_addr > segment->p_offset + segment->p_filesz)
3431 warn (_("the .dynamic section is not contained within the dynamic segment"));
3432 else if (dynamic_addr > segment->p_offset)
3433 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3434 }
3435 else
3436 {
3437 /* Otherwise, we can only assume that the .dynamic
3438 section is the first section in the DYNAMIC segment. */
3439 dynamic_addr = segment->p_offset;
3440 dynamic_size = segment->p_filesz;
3441 }
3442 break;
3443
3444 case PT_INTERP:
3445 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3446 SEEK_SET))
3447 error (_("Unable to find program interpreter name\n"));
3448 else
3449 {
3450 program_interpreter[0] = 0;
3451 fscanf (file, "%63s", program_interpreter);
3452
3453 if (do_segments)
3454 printf (_("\n [Requesting program interpreter: %s]"),
3455 program_interpreter);
3456 }
3457 break;
3458 }
3459
3460 if (do_segments)
3461 putc ('\n', stdout);
3462 }
3463
3464 if (do_segments && section_headers != NULL && string_table != NULL)
3465 {
3466 printf (_("\n Section to Segment mapping:\n"));
3467 printf (_(" Segment Sections...\n"));
3468
3469 for (i = 0; i < elf_header.e_phnum; i++)
3470 {
3471 unsigned int j;
3472 Elf_Internal_Shdr *section;
3473
3474 segment = program_headers + i;
3475 section = section_headers;
3476
3477 printf (" %2.2d ", i);
3478
3479 for (j = 1; j < elf_header.e_shnum; j++, section++)
3480 {
3481 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section, segment))
3482 printf ("%s ", SECTION_NAME (section));
3483 }
3484
3485 putc ('\n',stdout);
3486 }
3487 }
3488
3489 return 1;
3490 }
3491
3492
3493 /* Find the file offset corresponding to VMA by using the program headers. */
3494
3495 static long
3496 offset_from_vma (FILE *file, bfd_vma vma, bfd_size_type size)
3497 {
3498 Elf_Internal_Phdr *seg;
3499
3500 if (! get_program_headers (file))
3501 {
3502 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3503 return (long) vma;
3504 }
3505
3506 for (seg = program_headers;
3507 seg < program_headers + elf_header.e_phnum;
3508 ++seg)
3509 {
3510 if (seg->p_type != PT_LOAD)
3511 continue;
3512
3513 if (vma >= (seg->p_vaddr & -seg->p_align)
3514 && vma + size <= seg->p_vaddr + seg->p_filesz)
3515 return vma - seg->p_vaddr + seg->p_offset;
3516 }
3517
3518 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3519 (long) vma);
3520 return (long) vma;
3521 }
3522
3523
3524 static int
3525 get_32bit_section_headers (FILE *file, unsigned int num)
3526 {
3527 Elf32_External_Shdr *shdrs;
3528 Elf_Internal_Shdr *internal;
3529 unsigned int i;
3530
3531 shdrs = get_data (NULL, file, elf_header.e_shoff,
3532 elf_header.e_shentsize, num, _("section headers"));
3533 if (!shdrs)
3534 return 0;
3535
3536 section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3537
3538 if (section_headers == NULL)
3539 {
3540 error (_("Out of memory\n"));
3541 return 0;
3542 }
3543
3544 for (i = 0, internal = section_headers;
3545 i < num;
3546 i++, internal++)
3547 {
3548 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3549 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3550 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3551 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3552 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3553 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3554 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3555 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3556 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3557 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3558 }
3559
3560 free (shdrs);
3561
3562 return 1;
3563 }
3564
3565 static int
3566 get_64bit_section_headers (FILE *file, unsigned int num)
3567 {
3568 Elf64_External_Shdr *shdrs;
3569 Elf_Internal_Shdr *internal;
3570 unsigned int i;
3571
3572 shdrs = get_data (NULL, file, elf_header.e_shoff,
3573 elf_header.e_shentsize, num, _("section headers"));
3574 if (!shdrs)
3575 return 0;
3576
3577 section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3578
3579 if (section_headers == NULL)
3580 {
3581 error (_("Out of memory\n"));
3582 return 0;
3583 }
3584
3585 for (i = 0, internal = section_headers;
3586 i < num;
3587 i++, internal++)
3588 {
3589 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3590 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3591 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3592 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3593 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3594 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3595 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3596 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3597 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3598 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3599 }
3600
3601 free (shdrs);
3602
3603 return 1;
3604 }
3605
3606 static Elf_Internal_Sym *
3607 get_32bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3608 {
3609 unsigned long number;
3610 Elf32_External_Sym *esyms;
3611 Elf_External_Sym_Shndx *shndx;
3612 Elf_Internal_Sym *isyms;
3613 Elf_Internal_Sym *psym;
3614 unsigned int j;
3615
3616 esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3617 _("symbols"));
3618 if (!esyms)
3619 return NULL;
3620
3621 shndx = NULL;
3622 if (symtab_shndx_hdr != NULL
3623 && (symtab_shndx_hdr->sh_link
3624 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3625 {
3626 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3627 1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3628 if (!shndx)
3629 {
3630 free (esyms);
3631 return NULL;
3632 }
3633 }
3634
3635 number = section->sh_size / section->sh_entsize;
3636 isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3637
3638 if (isyms == NULL)
3639 {
3640 error (_("Out of memory\n"));
3641 if (shndx)
3642 free (shndx);
3643 free (esyms);
3644 return NULL;
3645 }
3646
3647 for (j = 0, psym = isyms;
3648 j < number;
3649 j++, psym++)
3650 {
3651 psym->st_name = BYTE_GET (esyms[j].st_name);
3652 psym->st_value = BYTE_GET (esyms[j].st_value);
3653 psym->st_size = BYTE_GET (esyms[j].st_size);
3654 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3655 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3656 psym->st_shndx
3657 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3658 psym->st_info = BYTE_GET (esyms[j].st_info);
3659 psym->st_other = BYTE_GET (esyms[j].st_other);
3660 }
3661
3662 if (shndx)
3663 free (shndx);
3664 free (esyms);
3665
3666 return isyms;
3667 }
3668
3669 static Elf_Internal_Sym *
3670 get_64bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3671 {
3672 unsigned long number;
3673 Elf64_External_Sym *esyms;
3674 Elf_External_Sym_Shndx *shndx;
3675 Elf_Internal_Sym *isyms;
3676 Elf_Internal_Sym *psym;
3677 unsigned int j;
3678
3679 esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3680 _("symbols"));
3681 if (!esyms)
3682 return NULL;
3683
3684 shndx = NULL;
3685 if (symtab_shndx_hdr != NULL
3686 && (symtab_shndx_hdr->sh_link
3687 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3688 {
3689 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3690 1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3691 if (!shndx)
3692 {
3693 free (esyms);
3694 return NULL;
3695 }
3696 }
3697
3698 number = section->sh_size / section->sh_entsize;
3699 isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3700
3701 if (isyms == NULL)
3702 {
3703 error (_("Out of memory\n"));
3704 if (shndx)
3705 free (shndx);
3706 free (esyms);
3707 return NULL;
3708 }
3709
3710 for (j = 0, psym = isyms;
3711 j < number;
3712 j++, psym++)
3713 {
3714 psym->st_name = BYTE_GET (esyms[j].st_name);
3715 psym->st_info = BYTE_GET (esyms[j].st_info);
3716 psym->st_other = BYTE_GET (esyms[j].st_other);
3717 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3718 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3719 psym->st_shndx
3720 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3721 psym->st_value = BYTE_GET (esyms[j].st_value);
3722 psym->st_size = BYTE_GET (esyms[j].st_size);
3723 }
3724
3725 if (shndx)
3726 free (shndx);
3727 free (esyms);
3728
3729 return isyms;
3730 }
3731
3732 static const char *
3733 get_elf_section_flags (bfd_vma sh_flags)
3734 {
3735 static char buff[1024];
3736 char *p = buff;
3737 int field_size = is_32bit_elf ? 8 : 16;
3738 int index, size = sizeof (buff) - (field_size + 4 + 1);
3739 bfd_vma os_flags = 0;
3740 bfd_vma proc_flags = 0;
3741 bfd_vma unknown_flags = 0;
3742 const struct
3743 {
3744 const char *str;
3745 int len;
3746 }
3747 flags [] =
3748 {
3749 { "WRITE", 5 },
3750 { "ALLOC", 5 },
3751 { "EXEC", 4 },
3752 { "MERGE", 5 },
3753 { "STRINGS", 7 },
3754 { "INFO LINK", 9 },
3755 { "LINK ORDER", 10 },
3756 { "OS NONCONF", 10 },
3757 { "GROUP", 5 },
3758 { "TLS", 3 }
3759 };
3760
3761 if (do_section_details)
3762 {
3763 sprintf (buff, "[%*.*lx]: ",
3764 field_size, field_size, (unsigned long) sh_flags);
3765 p += field_size + 4;
3766 }
3767
3768 while (sh_flags)
3769 {
3770 bfd_vma flag;
3771
3772 flag = sh_flags & - sh_flags;
3773 sh_flags &= ~ flag;
3774
3775 if (do_section_details)
3776 {
3777 switch (flag)
3778 {
3779 case SHF_WRITE: index = 0; break;
3780 case SHF_ALLOC: index = 1; break;
3781 case SHF_EXECINSTR: index = 2; break;
3782 case SHF_MERGE: index = 3; break;
3783 case SHF_STRINGS: index = 4; break;
3784 case SHF_INFO_LINK: index = 5; break;
3785 case SHF_LINK_ORDER: index = 6; break;
3786 case SHF_OS_NONCONFORMING: index = 7; break;
3787 case SHF_GROUP: index = 8; break;
3788 case SHF_TLS: index = 9; break;
3789
3790 default:
3791 index = -1;
3792 break;
3793 }
3794
3795 if (index != -1)
3796 {
3797 if (p != buff + field_size + 4)
3798 {
3799 if (size < (10 + 2))
3800 abort ();
3801 size -= 2;
3802 *p++ = ',';
3803 *p++ = ' ';
3804 }
3805
3806 size -= flags [index].len;
3807 p = stpcpy (p, flags [index].str);
3808 }
3809 else if (flag & SHF_MASKOS)
3810 os_flags |= flag;
3811 else if (flag & SHF_MASKPROC)
3812 proc_flags |= flag;
3813 else
3814 unknown_flags |= flag;
3815 }
3816 else
3817 {
3818 switch (flag)
3819 {
3820 case SHF_WRITE: *p = 'W'; break;
3821 case SHF_ALLOC: *p = 'A'; break;
3822 case SHF_EXECINSTR: *p = 'X'; break;
3823 case SHF_MERGE: *p = 'M'; break;
3824 case SHF_STRINGS: *p = 'S'; break;
3825 case SHF_INFO_LINK: *p = 'I'; break;
3826 case SHF_LINK_ORDER: *p = 'L'; break;
3827 case SHF_OS_NONCONFORMING: *p = 'O'; break;
3828 case SHF_GROUP: *p = 'G'; break;
3829 case SHF_TLS: *p = 'T'; break;
3830
3831 default:
3832 if (elf_header.e_machine == EM_X86_64
3833 && flag == SHF_X86_64_LARGE)
3834 *p = 'l';
3835 else if (flag & SHF_MASKOS)
3836 {
3837 *p = 'o';
3838 sh_flags &= ~ SHF_MASKOS;
3839 }
3840 else if (flag & SHF_MASKPROC)
3841 {
3842 *p = 'p';
3843 sh_flags &= ~ SHF_MASKPROC;
3844 }
3845 else
3846 *p = 'x';
3847 break;
3848 }
3849 p++;
3850 }
3851 }
3852
3853 if (do_section_details)
3854 {
3855 if (os_flags)
3856 {
3857 size -= 5 + field_size;
3858 if (p != buff + field_size + 4)
3859 {
3860 if (size < (2 + 1))
3861 abort ();
3862 size -= 2;
3863 *p++ = ',';
3864 *p++ = ' ';
3865 }
3866 sprintf (p, "OS (%*.*lx)", field_size, field_size,
3867 (unsigned long) os_flags);
3868 p += 5 + field_size;
3869 }
3870 if (proc_flags)
3871 {
3872 size -= 7 + field_size;
3873 if (p != buff + field_size + 4)
3874 {
3875 if (size < (2 + 1))
3876 abort ();
3877 size -= 2;
3878 *p++ = ',';
3879 *p++ = ' ';
3880 }
3881 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
3882 (unsigned long) proc_flags);
3883 p += 7 + field_size;
3884 }
3885 if (unknown_flags)
3886 {
3887 size -= 10 + field_size;
3888 if (p != buff + field_size + 4)
3889 {
3890 if (size < (2 + 1))
3891 abort ();
3892 size -= 2;
3893 *p++ = ',';
3894 *p++ = ' ';
3895 }
3896 sprintf (p, "UNKNOWN (%*.*lx)", field_size, field_size,
3897 (unsigned long) unknown_flags);
3898 p += 10 + field_size;
3899 }
3900 }
3901
3902 *p = '\0';
3903 return buff;
3904 }
3905
3906 static int
3907 process_section_headers (FILE *file)
3908 {
3909 Elf_Internal_Shdr *section;
3910 unsigned int i;
3911
3912 section_headers = NULL;
3913
3914 if (elf_header.e_shnum == 0)
3915 {
3916 if (do_sections)
3917 printf (_("\nThere are no sections in this file.\n"));
3918
3919 return 1;
3920 }
3921
3922 if (do_sections && !do_header)
3923 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3924 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
3925
3926 if (is_32bit_elf)
3927 {
3928 if (! get_32bit_section_headers (file, elf_header.e_shnum))
3929 return 0;
3930 }
3931 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
3932 return 0;
3933
3934 /* Read in the string table, so that we have names to display. */
3935 if (elf_header.e_shstrndx != SHN_UNDEF
3936 && SECTION_HEADER_INDEX (elf_header.e_shstrndx) < elf_header.e_shnum)
3937 {
3938 section = SECTION_HEADER (elf_header.e_shstrndx);
3939
3940 if (section->sh_size != 0)
3941 {
3942 string_table = get_data (NULL, file, section->sh_offset,
3943 1, section->sh_size, _("string table"));
3944
3945 string_table_length = string_table != NULL ? section->sh_size : 0;
3946 }
3947 }
3948
3949 /* Scan the sections for the dynamic symbol table
3950 and dynamic string table and debug sections. */
3951 dynamic_symbols = NULL;
3952 dynamic_strings = NULL;
3953 dynamic_syminfo = NULL;
3954 symtab_shndx_hdr = NULL;
3955
3956 eh_addr_size = is_32bit_elf ? 4 : 8;
3957 switch (elf_header.e_machine)
3958 {
3959 case EM_MIPS:
3960 case EM_MIPS_RS3_LE:
3961 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3962 FDE addresses. However, the ABI also has a semi-official ILP32
3963 variant for which the normal FDE address size rules apply.
3964
3965 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3966 section, where XX is the size of longs in bits. Unfortunately,
3967 earlier compilers provided no way of distinguishing ILP32 objects
3968 from LP64 objects, so if there's any doubt, we should assume that
3969 the official LP64 form is being used. */
3970 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
3971 && find_section (".gcc_compiled_long32") == NULL)
3972 eh_addr_size = 8;
3973 break;
3974 }
3975
3976 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
3977 do \
3978 { \
3979 size_t expected_entsize \
3980 = is_32bit_elf ? size32 : size64; \
3981 if (section->sh_entsize != expected_entsize) \
3982 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
3983 i, (unsigned long int) section->sh_entsize, \
3984 (unsigned long int) expected_entsize); \
3985 section->sh_entsize = expected_entsize; \
3986 } \
3987 while (0)
3988 #define CHECK_ENTSIZE(section, i, type) \
3989 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
3990 sizeof (Elf64_External_##type))
3991
3992 for (i = 0, section = section_headers;
3993 i < elf_header.e_shnum;
3994 i++, section++)
3995 {
3996 char *name = SECTION_NAME (section);
3997
3998 if (section->sh_type == SHT_DYNSYM)
3999 {
4000 if (dynamic_symbols != NULL)
4001 {
4002 error (_("File contains multiple dynamic symbol tables\n"));
4003 continue;
4004 }
4005
4006 CHECK_ENTSIZE (section, i, Sym);
4007 num_dynamic_syms = section->sh_size / section->sh_entsize;
4008 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4009 }
4010 else if (section->sh_type == SHT_STRTAB
4011 && streq (name, ".dynstr"))
4012 {
4013 if (dynamic_strings != NULL)
4014 {
4015 error (_("File contains multiple dynamic string tables\n"));
4016 continue;
4017 }
4018
4019 dynamic_strings = get_data (NULL, file, section->sh_offset,
4020 1, section->sh_size, _("dynamic strings"));
4021 dynamic_strings_length = section->sh_size;
4022 }
4023 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4024 {
4025 if (symtab_shndx_hdr != NULL)
4026 {
4027 error (_("File contains multiple symtab shndx tables\n"));
4028 continue;
4029 }
4030 symtab_shndx_hdr = section;
4031 }
4032 else if (section->sh_type == SHT_SYMTAB)
4033 CHECK_ENTSIZE (section, i, Sym);
4034 else if (section->sh_type == SHT_GROUP)
4035 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4036 else if (section->sh_type == SHT_REL)
4037 CHECK_ENTSIZE (section, i, Rel);
4038 else if (section->sh_type == SHT_RELA)
4039 CHECK_ENTSIZE (section, i, Rela);
4040 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4041 || do_debug_lines || do_debug_pubnames || do_debug_aranges
4042 || do_debug_frames || do_debug_macinfo || do_debug_str
4043 || do_debug_loc || do_debug_ranges)
4044 && strneq (name, ".debug_", 7))
4045 {
4046 name += 7;
4047
4048 if (do_debugging
4049 || (do_debug_info && streq (name, "info"))
4050 || (do_debug_abbrevs && streq (name, "abbrev"))
4051 || (do_debug_lines && streq (name, "line"))
4052 || (do_debug_pubnames && streq (name, "pubnames"))
4053 || (do_debug_aranges && streq (name, "aranges"))
4054 || (do_debug_ranges && streq (name, "ranges"))
4055 || (do_debug_frames && streq (name, "frame"))
4056 || (do_debug_macinfo && streq (name, "macinfo"))
4057 || (do_debug_str && streq (name, "str"))
4058 || (do_debug_loc && streq (name, "loc"))
4059 )
4060 request_dump (i, DEBUG_DUMP);
4061 }
4062 /* linkonce section to be combined with .debug_info at link time. */
4063 else if ((do_debugging || do_debug_info)
4064 && strneq (name, ".gnu.linkonce.wi.", 17))
4065 request_dump (i, DEBUG_DUMP);
4066 else if (do_debug_frames && streq (name, ".eh_frame"))
4067 request_dump (i, DEBUG_DUMP);
4068 }
4069
4070 if (! do_sections)
4071 return 1;
4072
4073 if (elf_header.e_shnum > 1)
4074 printf (_("\nSection Headers:\n"));
4075 else
4076 printf (_("\nSection Header:\n"));
4077
4078 if (is_32bit_elf)
4079 {
4080 if (do_section_details)
4081 {
4082 printf (_(" [Nr] Name\n"));
4083 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4084 }
4085 else
4086 printf
4087 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4088 }
4089 else if (do_wide)
4090 {
4091 if (do_section_details)
4092 {
4093 printf (_(" [Nr] Name\n"));
4094 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4095 }
4096 else
4097 printf
4098 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4099 }
4100 else
4101 {
4102 if (do_section_details)
4103 {
4104 printf (_(" [Nr] Name\n"));
4105 printf (_(" Type Address Offset Link\n"));
4106 printf (_(" Size EntSize Info Align\n"));
4107 }
4108 else
4109 {
4110 printf (_(" [Nr] Name Type Address Offset\n"));
4111 printf (_(" Size EntSize Flags Link Info Align\n"));
4112 }
4113 }
4114
4115 if (do_section_details)
4116 printf (_(" Flags\n"));
4117
4118 for (i = 0, section = section_headers;
4119 i < elf_header.e_shnum;
4120 i++, section++)
4121 {
4122 if (do_section_details)
4123 {
4124 printf (" [%2u] %s\n",
4125 SECTION_HEADER_NUM (i),
4126 SECTION_NAME (section));
4127 if (is_32bit_elf || do_wide)
4128 printf (" %-15.15s ",
4129 get_section_type_name (section->sh_type));
4130 }
4131 else
4132 printf (" [%2u] %-17.17s %-15.15s ",
4133 SECTION_HEADER_NUM (i),
4134 SECTION_NAME (section),
4135 get_section_type_name (section->sh_type));
4136
4137 if (is_32bit_elf)
4138 {
4139 print_vma (section->sh_addr, LONG_HEX);
4140
4141 printf ( " %6.6lx %6.6lx %2.2lx",
4142 (unsigned long) section->sh_offset,
4143 (unsigned long) section->sh_size,
4144 (unsigned long) section->sh_entsize);
4145
4146 if (do_section_details)
4147 fputs (" ", stdout);
4148 else
4149 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4150
4151 printf ("%2ld %3lu %2ld\n",
4152 (unsigned long) section->sh_link,
4153 (unsigned long) section->sh_info,
4154 (unsigned long) section->sh_addralign);
4155 }
4156 else if (do_wide)
4157 {
4158 print_vma (section->sh_addr, LONG_HEX);
4159
4160 if ((long) section->sh_offset == section->sh_offset)
4161 printf (" %6.6lx", (unsigned long) section->sh_offset);
4162 else
4163 {
4164 putchar (' ');
4165 print_vma (section->sh_offset, LONG_HEX);
4166 }
4167
4168 if ((unsigned long) section->sh_size == section->sh_size)
4169 printf (" %6.6lx", (unsigned long) section->sh_size);
4170 else
4171 {
4172 putchar (' ');
4173 print_vma (section->sh_size, LONG_HEX);
4174 }
4175
4176 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4177 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4178 else
4179 {
4180 putchar (' ');
4181 print_vma (section->sh_entsize, LONG_HEX);
4182 }
4183
4184 if (do_section_details)
4185 fputs (" ", stdout);
4186 else
4187 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4188
4189 printf ("%2ld %3lu ",
4190 (unsigned long) section->sh_link,
4191 (unsigned long) section->sh_info);
4192
4193 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4194 printf ("%2ld\n", (unsigned long) section->sh_addralign);
4195 else
4196 {
4197 print_vma (section->sh_addralign, DEC);
4198 putchar ('\n');
4199 }
4200 }
4201 else if (do_section_details)
4202 {
4203 printf (" %-15.15s ",
4204 get_section_type_name (section->sh_type));
4205 print_vma (section->sh_addr, LONG_HEX);
4206 if ((long) section->sh_offset == section->sh_offset)
4207 printf (" %16.16lx", (unsigned long) section->sh_offset);
4208 else
4209 {
4210 printf (" ");
4211 print_vma (section->sh_offset, LONG_HEX);
4212 }
4213 printf (" %ld\n ", (unsigned long) section->sh_link);
4214 print_vma (section->sh_size, LONG_HEX);
4215 putchar (' ');
4216 print_vma (section->sh_entsize, LONG_HEX);
4217
4218 printf (" %-16lu %ld\n",
4219 (unsigned long) section->sh_info,
4220 (unsigned long) section->sh_addralign);
4221 }
4222 else
4223 {
4224 putchar (' ');
4225 print_vma (section->sh_addr, LONG_HEX);
4226 if ((long) section->sh_offset == section->sh_offset)
4227 printf (" %8.8lx", (unsigned long) section->sh_offset);
4228 else
4229 {
4230 printf (" ");
4231 print_vma (section->sh_offset, LONG_HEX);
4232 }
4233 printf ("\n ");
4234 print_vma (section->sh_size, LONG_HEX);
4235 printf (" ");
4236 print_vma (section->sh_entsize, LONG_HEX);
4237
4238 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4239
4240 printf (" %2ld %3lu %ld\n",
4241 (unsigned long) section->sh_link,
4242 (unsigned long) section->sh_info,
4243 (unsigned long) section->sh_addralign);
4244 }
4245
4246 if (do_section_details)
4247 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4248 }
4249
4250 if (!do_section_details)
4251 printf (_("Key to Flags:\n\
4252 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4253 I (info), L (link order), G (group), x (unknown)\n\
4254 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4255
4256 return 1;
4257 }
4258
4259 static const char *
4260 get_group_flags (unsigned int flags)
4261 {
4262 static char buff[32];
4263 switch (flags)
4264 {
4265 case GRP_COMDAT:
4266 return "COMDAT";
4267
4268 default:
4269 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags);
4270 break;
4271 }
4272 return buff;
4273 }
4274
4275 static int
4276 process_section_groups (FILE *file)
4277 {
4278 Elf_Internal_Shdr *section;
4279 unsigned int i;
4280 struct group *group;
4281 Elf_Internal_Shdr *symtab_sec, *strtab_sec;
4282 Elf_Internal_Sym *symtab;
4283 char *strtab;
4284 size_t strtab_size;
4285
4286 /* Don't process section groups unless needed. */
4287 if (!do_unwind && !do_section_groups)
4288 return 1;
4289
4290 if (elf_header.e_shnum == 0)
4291 {
4292 if (do_section_groups)
4293 printf (_("\nThere are no sections in this file.\n"));
4294
4295 return 1;
4296 }
4297
4298 if (section_headers == NULL)
4299 {
4300 error (_("Section headers are not available!\n"));
4301 abort ();
4302 }
4303
4304 section_headers_groups = calloc (elf_header.e_shnum,
4305 sizeof (struct group *));
4306
4307 if (section_headers_groups == NULL)
4308 {
4309 error (_("Out of memory\n"));
4310 return 0;
4311 }
4312
4313 /* Scan the sections for the group section. */
4314 group_count = 0;
4315 for (i = 0, section = section_headers;
4316 i < elf_header.e_shnum;
4317 i++, section++)
4318 if (section->sh_type == SHT_GROUP)
4319 group_count++;
4320
4321 if (group_count == 0)
4322 {
4323 if (do_section_groups)
4324 printf (_("\nThere are no section groups in this file.\n"));
4325
4326 return 1;
4327 }
4328
4329 section_groups = calloc (group_count, sizeof (struct group));
4330
4331 if (section_groups == NULL)
4332 {
4333 error (_("Out of memory\n"));
4334 return 0;
4335 }
4336
4337 symtab_sec = NULL;
4338 strtab_sec = NULL;
4339 symtab = NULL;
4340 strtab = NULL;
4341 strtab_size = 0;
4342 for (i = 0, section = section_headers, group = section_groups;
4343 i < elf_header.e_shnum;
4344 i++, section++)
4345 {
4346 if (section->sh_type == SHT_GROUP)
4347 {
4348 char *name = SECTION_NAME (section);
4349 char *group_name;
4350 unsigned char *start, *indices;
4351 unsigned int entry, j, size;
4352 Elf_Internal_Shdr *sec;
4353 Elf_Internal_Sym *sym;
4354
4355 /* Get the symbol table. */
4356 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum
4357 || ((sec = SECTION_HEADER (section->sh_link))->sh_type
4358 != SHT_SYMTAB))
4359 {
4360 error (_("Bad sh_link in group section `%s'\n"), name);
4361 continue;
4362 }
4363
4364 if (symtab_sec != sec)
4365 {
4366 symtab_sec = sec;
4367 if (symtab)
4368 free (symtab);
4369 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4370 }
4371
4372 sym = symtab + section->sh_info;
4373
4374 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4375 {
4376 bfd_vma sec_index = SECTION_HEADER_INDEX (sym->st_shndx);
4377 if (sec_index == 0)
4378 {
4379 error (_("Bad sh_info in group section `%s'\n"), name);
4380 continue;
4381 }
4382
4383 group_name = SECTION_NAME (section_headers + sec_index);
4384 strtab_sec = NULL;
4385 if (strtab)
4386 free (strtab);
4387 strtab = NULL;
4388 strtab_size = 0;
4389 }
4390 else
4391 {
4392 /* Get the string table. */
4393 if (SECTION_HEADER_INDEX (symtab_sec->sh_link)
4394 >= elf_header.e_shnum)
4395 {
4396 strtab_sec = NULL;
4397 if (strtab)
4398 free (strtab);
4399 strtab = NULL;
4400 strtab_size = 0;
4401 }
4402 else if (strtab_sec
4403 != (sec = SECTION_HEADER (symtab_sec->sh_link)))
4404 {
4405 strtab_sec = sec;
4406 if (strtab)
4407 free (strtab);
4408 strtab = get_data (NULL, file, strtab_sec->sh_offset,
4409 1, strtab_sec->sh_size,
4410 _("string table"));
4411 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
4412 }
4413 group_name = sym->st_name < strtab_size
4414 ? strtab + sym->st_name : "<corrupt>";
4415 }
4416
4417 start = get_data (NULL, file, section->sh_offset,
4418 1, section->sh_size, _("section data"));
4419
4420 indices = start;
4421 size = (section->sh_size / section->sh_entsize) - 1;
4422 entry = byte_get (indices, 4);
4423 indices += 4;
4424
4425 if (do_section_groups)
4426 {
4427 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4428 get_group_flags (entry), i, name, group_name, size);
4429
4430 printf (_(" [Index] Name\n"));
4431 }
4432
4433 group->group_index = i;
4434
4435 for (j = 0; j < size; j++)
4436 {
4437 struct group_list *g;
4438
4439 entry = byte_get (indices, 4);
4440 indices += 4;
4441
4442 if (SECTION_HEADER_INDEX (entry) >= elf_header.e_shnum)
4443 {
4444 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4445 entry, i, elf_header.e_shnum - 1);
4446 continue;
4447 }
4448 else if (entry >= SHN_LORESERVE && entry <= SHN_HIRESERVE)
4449 {
4450 error (_("invalid section [%5u] in group section [%5u]\n"),
4451 entry, i);
4452 continue;
4453 }
4454
4455 if (section_headers_groups [SECTION_HEADER_INDEX (entry)]
4456 != NULL)
4457 {
4458 if (entry)
4459 {
4460 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4461 entry, i,
4462 section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index);
4463 continue;
4464 }
4465 else
4466 {
4467 /* Intel C/C++ compiler may put section 0 in a
4468 section group. We just warn it the first time
4469 and ignore it afterwards. */
4470 static int warned = 0;
4471 if (!warned)
4472 {
4473 error (_("section 0 in group section [%5u]\n"),
4474 section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index);
4475 warned++;
4476 }
4477 }
4478 }
4479
4480 section_headers_groups [SECTION_HEADER_INDEX (entry)]
4481 = group;
4482
4483 if (do_section_groups)
4484 {
4485 sec = SECTION_HEADER (entry);
4486 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
4487 }
4488
4489 g = xmalloc (sizeof (struct group_list));
4490 g->section_index = entry;
4491 g->next = group->root;
4492 group->root = g;
4493 }
4494
4495 if (start)
4496 free (start);
4497
4498 group++;
4499 }
4500 }
4501
4502 if (symtab)
4503 free (symtab);
4504 if (strtab)
4505 free (strtab);
4506 return 1;
4507 }
4508
4509 static struct
4510 {
4511 const char *name;
4512 int reloc;
4513 int size;
4514 int rela;
4515 } dynamic_relocations [] =
4516 {
4517 { "REL", DT_REL, DT_RELSZ, FALSE },
4518 { "RELA", DT_RELA, DT_RELASZ, TRUE },
4519 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
4520 };
4521
4522 /* Process the reloc section. */
4523
4524 static int
4525 process_relocs (FILE *file)
4526 {
4527 unsigned long rel_size;
4528 unsigned long rel_offset;
4529
4530
4531 if (!do_reloc)
4532 return 1;
4533
4534 if (do_using_dynamic)
4535 {
4536 int is_rela;
4537 const char *name;
4538 int has_dynamic_reloc;
4539 unsigned int i;
4540
4541 has_dynamic_reloc = 0;
4542
4543 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
4544 {
4545 is_rela = dynamic_relocations [i].rela;
4546 name = dynamic_relocations [i].name;
4547 rel_size = dynamic_info [dynamic_relocations [i].size];
4548 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
4549
4550 has_dynamic_reloc |= rel_size;
4551
4552 if (is_rela == UNKNOWN)
4553 {
4554 if (dynamic_relocations [i].reloc == DT_JMPREL)
4555 switch (dynamic_info[DT_PLTREL])
4556 {
4557 case DT_REL:
4558 is_rela = FALSE;
4559 break;
4560 case DT_RELA:
4561 is_rela = TRUE;
4562 break;
4563 }
4564 }
4565
4566 if (rel_size)
4567 {
4568 printf
4569 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4570 name, rel_offset, rel_size);
4571
4572 dump_relocations (file,
4573 offset_from_vma (file, rel_offset, rel_size),
4574 rel_size,
4575 dynamic_symbols, num_dynamic_syms,
4576 dynamic_strings, dynamic_strings_length, is_rela);
4577 }
4578 }
4579
4580 if (! has_dynamic_reloc)
4581 printf (_("\nThere are no dynamic relocations in this file.\n"));
4582 }
4583 else
4584 {
4585 Elf_Internal_Shdr *section;
4586 unsigned long i;
4587 int found = 0;
4588
4589 for (i = 0, section = section_headers;
4590 i < elf_header.e_shnum;
4591 i++, section++)
4592 {
4593 if ( section->sh_type != SHT_RELA
4594 && section->sh_type != SHT_REL)
4595 continue;
4596
4597 rel_offset = section->sh_offset;
4598 rel_size = section->sh_size;
4599
4600 if (rel_size)
4601 {
4602 Elf_Internal_Shdr *strsec;
4603 int is_rela;
4604
4605 printf (_("\nRelocation section "));
4606
4607 if (string_table == NULL)
4608 printf ("%d", section->sh_name);
4609 else
4610 printf (_("'%s'"), SECTION_NAME (section));
4611
4612 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4613 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
4614
4615 is_rela = section->sh_type == SHT_RELA;
4616
4617 if (section->sh_link
4618 && SECTION_HEADER_INDEX (section->sh_link)
4619 < elf_header.e_shnum)
4620 {
4621 Elf_Internal_Shdr *symsec;
4622 Elf_Internal_Sym *symtab;
4623 unsigned long nsyms;
4624 unsigned long strtablen = 0;
4625 char *strtab = NULL;
4626
4627 symsec = SECTION_HEADER (section->sh_link);
4628 if (symsec->sh_type != SHT_SYMTAB
4629 && symsec->sh_type != SHT_DYNSYM)
4630 continue;
4631
4632 nsyms = symsec->sh_size / symsec->sh_entsize;
4633 symtab = GET_ELF_SYMBOLS (file, symsec);
4634
4635 if (symtab == NULL)
4636 continue;
4637
4638 if (SECTION_HEADER_INDEX (symsec->sh_link)
4639 < elf_header.e_shnum)
4640 {
4641 strsec = SECTION_HEADER (symsec->sh_link);
4642
4643 strtab = get_data (NULL, file, strsec->sh_offset,
4644 1, strsec->sh_size,
4645 _("string table"));
4646 strtablen = strtab == NULL ? 0 : strsec->sh_size;
4647 }
4648
4649 dump_relocations (file, rel_offset, rel_size,
4650 symtab, nsyms, strtab, strtablen, is_rela);
4651 if (strtab)
4652 free (strtab);
4653 free (symtab);
4654 }
4655 else
4656 dump_relocations (file, rel_offset, rel_size,
4657 NULL, 0, NULL, 0, is_rela);
4658
4659 found = 1;
4660 }
4661 }
4662
4663 if (! found)
4664 printf (_("\nThere are no relocations in this file.\n"));
4665 }
4666
4667 return 1;
4668 }
4669
4670 /* Process the unwind section. */
4671
4672 #include "unwind-ia64.h"
4673
4674 /* An absolute address consists of a section and an offset. If the
4675 section is NULL, the offset itself is the address, otherwise, the
4676 address equals to LOAD_ADDRESS(section) + offset. */
4677
4678 struct absaddr
4679 {
4680 unsigned short section;
4681 bfd_vma offset;
4682 };
4683
4684 #define ABSADDR(a) \
4685 ((a).section \
4686 ? section_headers [(a).section].sh_addr + (a).offset \
4687 : (a).offset)
4688
4689 struct ia64_unw_aux_info
4690 {
4691 struct ia64_unw_table_entry
4692 {
4693 struct absaddr start;
4694 struct absaddr end;
4695 struct absaddr info;
4696 }
4697 *table; /* Unwind table. */
4698 unsigned long table_len; /* Length of unwind table. */
4699 unsigned char *info; /* Unwind info. */
4700 unsigned long info_size; /* Size of unwind info. */
4701 bfd_vma info_addr; /* starting address of unwind info. */
4702 bfd_vma seg_base; /* Starting address of segment. */
4703 Elf_Internal_Sym *symtab; /* The symbol table. */
4704 unsigned long nsyms; /* Number of symbols. */
4705 char *strtab; /* The string table. */
4706 unsigned long strtab_size; /* Size of string table. */
4707 };
4708
4709 static void
4710 find_symbol_for_address (Elf_Internal_Sym *symtab,
4711 unsigned long nsyms,
4712 const char *strtab,
4713 unsigned long strtab_size,
4714 struct absaddr addr,
4715 const char **symname,
4716 bfd_vma *offset)
4717 {
4718 bfd_vma dist = 0x100000;
4719 Elf_Internal_Sym *sym, *best = NULL;
4720 unsigned long i;
4721
4722 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4723 {
4724 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
4725 && sym->st_name != 0
4726 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
4727 && addr.offset >= sym->st_value
4728 && addr.offset - sym->st_value < dist)
4729 {
4730 best = sym;
4731 dist = addr.offset - sym->st_value;
4732 if (!dist)
4733 break;
4734 }
4735 }
4736 if (best)
4737 {
4738 *symname = (best->st_name >= strtab_size
4739 ? "<corrupt>" : strtab + best->st_name);
4740 *offset = dist;
4741 return;
4742 }
4743 *symname = NULL;
4744 *offset = addr.offset;
4745 }
4746
4747 static void
4748 dump_ia64_unwind (struct ia64_unw_aux_info *aux)
4749 {
4750 struct ia64_unw_table_entry *tp;
4751 int in_body;
4752
4753 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
4754 {
4755 bfd_vma stamp;
4756 bfd_vma offset;
4757 const unsigned char *dp;
4758 const unsigned char *head;
4759 const char *procname;
4760
4761 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
4762 aux->strtab_size, tp->start, &procname, &offset);
4763
4764 fputs ("\n<", stdout);
4765
4766 if (procname)
4767 {
4768 fputs (procname, stdout);
4769
4770 if (offset)
4771 printf ("+%lx", (unsigned long) offset);
4772 }
4773
4774 fputs (">: [", stdout);
4775 print_vma (tp->start.offset, PREFIX_HEX);
4776 fputc ('-', stdout);
4777 print_vma (tp->end.offset, PREFIX_HEX);
4778 printf ("], info at +0x%lx\n",
4779 (unsigned long) (tp->info.offset - aux->seg_base));
4780
4781 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
4782 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4783
4784 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4785 (unsigned) UNW_VER (stamp),
4786 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
4787 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
4788 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
4789 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4790
4791 if (UNW_VER (stamp) != 1)
4792 {
4793 printf ("\tUnknown version.\n");
4794 continue;
4795 }
4796
4797 in_body = 0;
4798 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4799 dp = unw_decode (dp, in_body, & in_body);
4800 }
4801 }
4802
4803 static int
4804 slurp_ia64_unwind_table (FILE *file,
4805 struct ia64_unw_aux_info *aux,
4806 Elf_Internal_Shdr *sec)
4807 {
4808 unsigned long size, nrelas, i;
4809 Elf_Internal_Phdr *seg;
4810 struct ia64_unw_table_entry *tep;
4811 Elf_Internal_Shdr *relsec;
4812 Elf_Internal_Rela *rela, *rp;
4813 unsigned char *table, *tp;
4814 Elf_Internal_Sym *sym;
4815 const char *relname;
4816
4817 /* First, find the starting address of the segment that includes
4818 this section: */
4819
4820 if (elf_header.e_phnum)
4821 {
4822 if (! get_program_headers (file))
4823 return 0;
4824
4825 for (seg = program_headers;
4826 seg < program_headers + elf_header.e_phnum;
4827 ++seg)
4828 {
4829 if (seg->p_type != PT_LOAD)
4830 continue;
4831
4832 if (sec->sh_addr >= seg->p_vaddr
4833 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
4834 {
4835 aux->seg_base = seg->p_vaddr;
4836 break;
4837 }
4838 }
4839 }
4840
4841 /* Second, build the unwind table from the contents of the unwind section: */
4842 size = sec->sh_size;
4843 table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
4844 if (!table)
4845 return 0;
4846
4847 aux->table = xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
4848 tep = aux->table;
4849 for (tp = table; tp < table + size; tp += 3 * eh_addr_size, ++tep)
4850 {
4851 tep->start.section = SHN_UNDEF;
4852 tep->end.section = SHN_UNDEF;
4853 tep->info.section = SHN_UNDEF;
4854 if (is_32bit_elf)
4855 {
4856 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
4857 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
4858 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
4859 }
4860 else
4861 {
4862 tep->start.offset = BYTE_GET ((unsigned char *) tp + 0);
4863 tep->end.offset = BYTE_GET ((unsigned char *) tp + 8);
4864 tep->info.offset = BYTE_GET ((unsigned char *) tp + 16);
4865 }
4866 tep->start.offset += aux->seg_base;
4867 tep->end.offset += aux->seg_base;
4868 tep->info.offset += aux->seg_base;
4869 }
4870 free (table);
4871
4872 /* Third, apply any relocations to the unwind table: */
4873
4874 for (relsec = section_headers;
4875 relsec < section_headers + elf_header.e_shnum;
4876 ++relsec)
4877 {
4878 if (relsec->sh_type != SHT_RELA
4879 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
4880 || SECTION_HEADER (relsec->sh_info) != sec)
4881 continue;
4882
4883 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
4884 & rela, & nrelas))
4885 return 0;
4886
4887 for (rp = rela; rp < rela + nrelas; ++rp)
4888 {
4889 if (is_32bit_elf)
4890 {
4891 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
4892 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
4893 }
4894 else
4895 {
4896 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
4897 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
4898 }
4899
4900 if (! strneq (relname, "R_IA64_SEGREL", 13))
4901 {
4902 warn (_("Skipping unexpected relocation type %s\n"), relname);
4903 continue;
4904 }
4905
4906 i = rp->r_offset / (3 * eh_addr_size);
4907
4908 switch (rp->r_offset/eh_addr_size % 3)
4909 {
4910 case 0:
4911 aux->table[i].start.section = sym->st_shndx;
4912 aux->table[i].start.offset += rp->r_addend + sym->st_value;
4913 break;
4914 case 1:
4915 aux->table[i].end.section = sym->st_shndx;
4916 aux->table[i].end.offset += rp->r_addend + sym->st_value;
4917 break;
4918 case 2:
4919 aux->table[i].info.section = sym->st_shndx;
4920 aux->table[i].info.offset += rp->r_addend + sym->st_value;
4921 break;
4922 default:
4923 break;
4924 }
4925 }
4926
4927 free (rela);
4928 }
4929
4930 aux->table_len = size / (3 * eh_addr_size);
4931 return 1;
4932 }
4933
4934 static int
4935 ia64_process_unwind (FILE *file)
4936 {
4937 Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
4938 unsigned long i, unwcount = 0, unwstart = 0;
4939 struct ia64_unw_aux_info aux;
4940
4941 memset (& aux, 0, sizeof (aux));
4942
4943 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
4944 {
4945 if (sec->sh_type == SHT_SYMTAB
4946 && SECTION_HEADER_INDEX (sec->sh_link) < elf_header.e_shnum)
4947 {
4948 aux.nsyms = sec->sh_size / sec->sh_entsize;
4949 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4950
4951 strsec = SECTION_HEADER (sec->sh_link);
4952 aux.strtab = get_data (NULL, file, strsec->sh_offset,
4953 1, strsec->sh_size, _("string table"));
4954 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4955 }
4956 else if (sec->sh_type == SHT_IA_64_UNWIND)
4957 unwcount++;
4958 }
4959
4960 if (!unwcount)
4961 printf (_("\nThere are no unwind sections in this file.\n"));
4962
4963 while (unwcount-- > 0)
4964 {
4965 char *suffix;
4966 size_t len, len2;
4967
4968 for (i = unwstart, sec = section_headers + unwstart;
4969 i < elf_header.e_shnum; ++i, ++sec)
4970 if (sec->sh_type == SHT_IA_64_UNWIND)
4971 {
4972 unwsec = sec;
4973 break;
4974 }
4975
4976 unwstart = i + 1;
4977 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
4978
4979 if ((unwsec->sh_flags & SHF_GROUP) != 0)
4980 {
4981 /* We need to find which section group it is in. */
4982 struct group_list *g = section_headers_groups [i]->root;
4983
4984 for (; g != NULL; g = g->next)
4985 {
4986 sec = SECTION_HEADER (g->section_index);
4987
4988 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
4989 break;
4990 }
4991
4992 if (g == NULL)
4993 i = elf_header.e_shnum;
4994 }
4995 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
4996 {
4997 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4998 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
4999 suffix = SECTION_NAME (unwsec) + len;
5000 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5001 ++i, ++sec)
5002 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5003 && streq (SECTION_NAME (sec) + len2, suffix))
5004 break;
5005 }
5006 else
5007 {
5008 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5009 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5010 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5011 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5012 suffix = "";
5013 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5014 suffix = SECTION_NAME (unwsec) + len;
5015 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5016 ++i, ++sec)
5017 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5018 && streq (SECTION_NAME (sec) + len2, suffix))
5019 break;
5020 }
5021
5022 if (i == elf_header.e_shnum)
5023 {
5024 printf (_("\nCould not find unwind info section for "));
5025
5026 if (string_table == NULL)
5027 printf ("%d", unwsec->sh_name);
5028 else
5029 printf (_("'%s'"), SECTION_NAME (unwsec));
5030 }
5031 else
5032 {
5033 aux.info_size = sec->sh_size;
5034 aux.info_addr = sec->sh_addr;
5035 aux.info = get_data (NULL, file, sec->sh_offset, 1, aux.info_size,
5036 _("unwind info"));
5037
5038 printf (_("\nUnwind section "));
5039
5040 if (string_table == NULL)
5041 printf ("%d", unwsec->sh_name);
5042 else
5043 printf (_("'%s'"), SECTION_NAME (unwsec));
5044
5045 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5046 (unsigned long) unwsec->sh_offset,
5047 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5048
5049 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5050
5051 if (aux.table_len > 0)
5052 dump_ia64_unwind (& aux);
5053
5054 if (aux.table)
5055 free ((char *) aux.table);
5056 if (aux.info)
5057 free ((char *) aux.info);
5058 aux.table = NULL;
5059 aux.info = NULL;
5060 }
5061 }
5062
5063 if (aux.symtab)
5064 free (aux.symtab);
5065 if (aux.strtab)
5066 free ((char *) aux.strtab);
5067
5068 return 1;
5069 }
5070
5071 struct hppa_unw_aux_info
5072 {
5073 struct hppa_unw_table_entry
5074 {
5075 struct absaddr start;
5076 struct absaddr end;
5077 unsigned int Cannot_unwind:1; /* 0 */
5078 unsigned int Millicode:1; /* 1 */
5079 unsigned int Millicode_save_sr0:1; /* 2 */
5080 unsigned int Region_description:2; /* 3..4 */
5081 unsigned int reserved1:1; /* 5 */
5082 unsigned int Entry_SR:1; /* 6 */
5083 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5084 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5085 unsigned int Args_stored:1; /* 16 */
5086 unsigned int Variable_Frame:1; /* 17 */
5087 unsigned int Separate_Package_Body:1; /* 18 */
5088 unsigned int Frame_Extension_Millicode:1; /* 19 */
5089 unsigned int Stack_Overflow_Check:1; /* 20 */
5090 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5091 unsigned int Ada_Region:1; /* 22 */
5092 unsigned int cxx_info:1; /* 23 */
5093 unsigned int cxx_try_catch:1; /* 24 */
5094 unsigned int sched_entry_seq:1; /* 25 */
5095 unsigned int reserved2:1; /* 26 */
5096 unsigned int Save_SP:1; /* 27 */
5097 unsigned int Save_RP:1; /* 28 */
5098 unsigned int Save_MRP_in_frame:1; /* 29 */
5099 unsigned int extn_ptr_defined:1; /* 30 */
5100 unsigned int Cleanup_defined:1; /* 31 */
5101
5102 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5103 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5104 unsigned int Large_frame:1; /* 2 */
5105 unsigned int Pseudo_SP_Set:1; /* 3 */
5106 unsigned int reserved4:1; /* 4 */
5107 unsigned int Total_frame_size:27; /* 5..31 */
5108 }
5109 *table; /* Unwind table. */
5110 unsigned long table_len; /* Length of unwind table. */
5111 bfd_vma seg_base; /* Starting address of segment. */
5112 Elf_Internal_Sym *symtab; /* The symbol table. */
5113 unsigned long nsyms; /* Number of symbols. */
5114 char *strtab; /* The string table. */
5115 unsigned long strtab_size; /* Size of string table. */
5116 };
5117
5118 static void
5119 dump_hppa_unwind (struct hppa_unw_aux_info *aux)
5120 {
5121 struct hppa_unw_table_entry *tp;
5122
5123 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5124 {
5125 bfd_vma offset;
5126 const char *procname;
5127
5128 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5129 aux->strtab_size, tp->start, &procname,
5130 &offset);
5131
5132 fputs ("\n<", stdout);
5133
5134 if (procname)
5135 {
5136 fputs (procname, stdout);
5137
5138 if (offset)
5139 printf ("+%lx", (unsigned long) offset);
5140 }
5141
5142 fputs (">: [", stdout);
5143 print_vma (tp->start.offset, PREFIX_HEX);
5144 fputc ('-', stdout);
5145 print_vma (tp->end.offset, PREFIX_HEX);
5146 printf ("]\n\t");
5147
5148 #define PF(_m) if (tp->_m) printf (#_m " ");
5149 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5150 PF(Cannot_unwind);
5151 PF(Millicode);
5152 PF(Millicode_save_sr0);
5153 /* PV(Region_description); */
5154 PF(Entry_SR);
5155 PV(Entry_FR);
5156 PV(Entry_GR);
5157 PF(Args_stored);
5158 PF(Variable_Frame);
5159 PF(Separate_Package_Body);
5160 PF(Frame_Extension_Millicode);
5161 PF(Stack_Overflow_Check);
5162 PF(Two_Instruction_SP_Increment);
5163 PF(Ada_Region);
5164 PF(cxx_info);
5165 PF(cxx_try_catch);
5166 PF(sched_entry_seq);
5167 PF(Save_SP);
5168 PF(Save_RP);
5169 PF(Save_MRP_in_frame);
5170 PF(extn_ptr_defined);
5171 PF(Cleanup_defined);
5172 PF(MPE_XL_interrupt_marker);
5173 PF(HP_UX_interrupt_marker);
5174 PF(Large_frame);
5175 PF(Pseudo_SP_Set);
5176 PV(Total_frame_size);
5177 #undef PF
5178 #undef PV
5179 }
5180
5181 printf ("\n");
5182 }
5183
5184 static int
5185 slurp_hppa_unwind_table (FILE *file,
5186 struct hppa_unw_aux_info *aux,
5187 Elf_Internal_Shdr *sec)
5188 {
5189 unsigned long size, unw_ent_size, nentries, nrelas, i;
5190 Elf_Internal_Phdr *seg;
5191 struct hppa_unw_table_entry *tep;
5192 Elf_Internal_Shdr *relsec;
5193 Elf_Internal_Rela *rela, *rp;
5194 unsigned char *table, *tp;
5195 Elf_Internal_Sym *sym;
5196 const char *relname;
5197
5198 /* First, find the starting address of the segment that includes
5199 this section. */
5200
5201 if (elf_header.e_phnum)
5202 {
5203 if (! get_program_headers (file))
5204 return 0;
5205
5206 for (seg = program_headers;
5207 seg < program_headers + elf_header.e_phnum;
5208 ++seg)
5209 {
5210 if (seg->p_type != PT_LOAD)
5211 continue;
5212
5213 if (sec->sh_addr >= seg->p_vaddr
5214 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5215 {
5216 aux->seg_base = seg->p_vaddr;
5217 break;
5218 }
5219 }
5220 }
5221
5222 /* Second, build the unwind table from the contents of the unwind
5223 section. */
5224 size = sec->sh_size;
5225 table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
5226 if (!table)
5227 return 0;
5228
5229 unw_ent_size = 16;
5230 nentries = size / unw_ent_size;
5231 size = unw_ent_size * nentries;
5232
5233 tep = aux->table = xcmalloc (nentries, sizeof (aux->table[0]));
5234
5235 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
5236 {
5237 unsigned int tmp1, tmp2;
5238
5239 tep->start.section = SHN_UNDEF;
5240 tep->end.section = SHN_UNDEF;
5241
5242 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5243 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5244 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5245 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5246
5247 tep->start.offset += aux->seg_base;
5248 tep->end.offset += aux->seg_base;
5249
5250 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5251 tep->Millicode = (tmp1 >> 30) & 0x1;
5252 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5253 tep->Region_description = (tmp1 >> 27) & 0x3;
5254 tep->reserved1 = (tmp1 >> 26) & 0x1;
5255 tep->Entry_SR = (tmp1 >> 25) & 0x1;
5256 tep->Entry_FR = (tmp1 >> 21) & 0xf;
5257 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5258 tep->Args_stored = (tmp1 >> 15) & 0x1;
5259 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5260 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5261 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5262 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5263 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5264 tep->Ada_Region = (tmp1 >> 9) & 0x1;
5265 tep->cxx_info = (tmp1 >> 8) & 0x1;
5266 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5267 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5268 tep->reserved2 = (tmp1 >> 5) & 0x1;
5269 tep->Save_SP = (tmp1 >> 4) & 0x1;
5270 tep->Save_RP = (tmp1 >> 3) & 0x1;
5271 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5272 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5273 tep->Cleanup_defined = tmp1 & 0x1;
5274
5275 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5276 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5277 tep->Large_frame = (tmp2 >> 29) & 0x1;
5278 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5279 tep->reserved4 = (tmp2 >> 27) & 0x1;
5280 tep->Total_frame_size = tmp2 & 0x7ffffff;
5281 }
5282 free (table);
5283
5284 /* Third, apply any relocations to the unwind table. */
5285
5286 for (relsec = section_headers;
5287 relsec < section_headers + elf_header.e_shnum;
5288 ++relsec)
5289 {
5290 if (relsec->sh_type != SHT_RELA
5291 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
5292 || SECTION_HEADER (relsec->sh_info) != sec)
5293 continue;
5294
5295 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5296 & rela, & nrelas))
5297 return 0;
5298
5299 for (rp = rela; rp < rela + nrelas; ++rp)
5300 {
5301 if (is_32bit_elf)
5302 {
5303 relname = elf_hppa_reloc_type (ELF32_R_TYPE (rp->r_info));
5304 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
5305 }
5306 else
5307 {
5308 relname = elf_hppa_reloc_type (ELF64_R_TYPE (rp->r_info));
5309 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
5310 }
5311
5312 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5313 if (strncmp (relname, "R_PARISC_SEGREL", 15) != 0)
5314 {
5315 warn (_("Skipping unexpected relocation type %s\n"), relname);
5316 continue;
5317 }
5318
5319 i = rp->r_offset / unw_ent_size;
5320
5321 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
5322 {
5323 case 0:
5324 aux->table[i].start.section = sym->st_shndx;
5325 aux->table[i].start.offset += sym->st_value + rp->r_addend;
5326 break;
5327 case 1:
5328 aux->table[i].end.section = sym->st_shndx;
5329 aux->table[i].end.offset += sym->st_value + rp->r_addend;
5330 break;
5331 default:
5332 break;
5333 }
5334 }
5335
5336 free (rela);
5337 }
5338
5339 aux->table_len = nentries;
5340
5341 return 1;
5342 }
5343
5344 static int
5345 hppa_process_unwind (FILE *file)
5346 {
5347 struct hppa_unw_aux_info aux;
5348 Elf_Internal_Shdr *unwsec = NULL;
5349 Elf_Internal_Shdr *strsec;
5350 Elf_Internal_Shdr *sec;
5351 unsigned long i;
5352
5353 memset (& aux, 0, sizeof (aux));
5354
5355 if (string_table == NULL)
5356 return 1;
5357
5358 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5359 {
5360 if (sec->sh_type == SHT_SYMTAB
5361 && SECTION_HEADER_INDEX (sec->sh_link) < elf_header.e_shnum)
5362 {
5363 aux.nsyms = sec->sh_size / sec->sh_entsize;
5364 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5365
5366 strsec = SECTION_HEADER (sec->sh_link);
5367 aux.strtab = get_data (NULL, file, strsec->sh_offset,
5368 1, strsec->sh_size, _("string table"));
5369 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5370 }
5371 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5372 unwsec = sec;
5373 }
5374
5375 if (!unwsec)
5376 printf (_("\nThere are no unwind sections in this file.\n"));
5377
5378 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5379 {
5380 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5381 {
5382 printf (_("\nUnwind section "));
5383 printf (_("'%s'"), SECTION_NAME (sec));
5384
5385 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5386 (unsigned long) sec->sh_offset,
5387 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
5388
5389 slurp_hppa_unwind_table (file, &aux, sec);
5390 if (aux.table_len > 0)
5391 dump_hppa_unwind (&aux);
5392
5393 if (aux.table)
5394 free ((char *) aux.table);
5395 aux.table = NULL;
5396 }
5397 }
5398
5399 if (aux.symtab)
5400 free (aux.symtab);
5401 if (aux.strtab)
5402 free ((char *) aux.strtab);
5403
5404 return 1;
5405 }
5406
5407 static int
5408 process_unwind (FILE *file)
5409 {
5410 struct unwind_handler {
5411 int machtype;
5412 int (*handler)(FILE *file);
5413 } handlers[] = {
5414 { EM_IA_64, ia64_process_unwind },
5415 { EM_PARISC, hppa_process_unwind },
5416 { 0, 0 }
5417 };
5418 int i;
5419
5420 if (!do_unwind)
5421 return 1;
5422
5423 for (i = 0; handlers[i].handler != NULL; i++)
5424 if (elf_header.e_machine == handlers[i].machtype)
5425 return handlers[i].handler (file);
5426
5427 printf (_("\nThere are no unwind sections in this file.\n"));
5428 return 1;
5429 }
5430
5431 static void
5432 dynamic_section_mips_val (Elf_Internal_Dyn *entry)
5433 {
5434 switch (entry->d_tag)
5435 {
5436 case DT_MIPS_FLAGS:
5437 if (entry->d_un.d_val == 0)
5438 printf ("NONE\n");
5439 else
5440 {
5441 static const char * opts[] =
5442 {
5443 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5444 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5445 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5446 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5447 "RLD_ORDER_SAFE"
5448 };
5449 unsigned int cnt;
5450 int first = 1;
5451 for (cnt = 0; cnt < NUM_ELEM (opts); ++cnt)
5452 if (entry->d_un.d_val & (1 << cnt))
5453 {
5454 printf ("%s%s", first ? "" : " ", opts[cnt]);
5455 first = 0;
5456 }
5457 puts ("");
5458 }
5459 break;
5460
5461 case DT_MIPS_IVERSION:
5462 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5463 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5464 else
5465 printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
5466 break;
5467
5468 case DT_MIPS_TIME_STAMP:
5469 {
5470 char timebuf[20];
5471 struct tm *tmp;
5472
5473 time_t time = entry->d_un.d_val;
5474 tmp = gmtime (&time);
5475 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
5476 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5477 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5478 printf ("Time Stamp: %s\n", timebuf);
5479 }
5480 break;
5481
5482 case DT_MIPS_RLD_VERSION:
5483 case DT_MIPS_LOCAL_GOTNO:
5484 case DT_MIPS_CONFLICTNO:
5485 case DT_MIPS_LIBLISTNO:
5486 case DT_MIPS_SYMTABNO:
5487 case DT_MIPS_UNREFEXTNO:
5488 case DT_MIPS_HIPAGENO:
5489 case DT_MIPS_DELTA_CLASS_NO:
5490 case DT_MIPS_DELTA_INSTANCE_NO:
5491 case DT_MIPS_DELTA_RELOC_NO:
5492 case DT_MIPS_DELTA_SYM_NO:
5493 case DT_MIPS_DELTA_CLASSSYM_NO:
5494 case DT_MIPS_COMPACT_SIZE:
5495 printf ("%ld\n", (long) entry->d_un.d_ptr);
5496 break;
5497
5498 default:
5499 printf ("%#lx\n", (long) entry->d_un.d_ptr);
5500 }
5501 }
5502
5503
5504 static void
5505 dynamic_section_parisc_val (Elf_Internal_Dyn *entry)
5506 {
5507 switch (entry->d_tag)
5508 {
5509 case DT_HP_DLD_FLAGS:
5510 {
5511 static struct
5512 {
5513 long int bit;
5514 const char *str;
5515 }
5516 flags[] =
5517 {
5518 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
5519 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
5520 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
5521 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
5522 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
5523 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
5524 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
5525 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
5526 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
5527 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
5528 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
5529 { DT_HP_GST, "HP_GST" },
5530 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
5531 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
5532 { DT_HP_NODELETE, "HP_NODELETE" },
5533 { DT_HP_GROUP, "HP_GROUP" },
5534 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5535 };
5536 int first = 1;
5537 size_t cnt;
5538 bfd_vma val = entry->d_un.d_val;
5539
5540 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
5541 if (val & flags[cnt].bit)
5542 {
5543 if (! first)
5544 putchar (' ');
5545 fputs (flags[cnt].str, stdout);
5546 first = 0;
5547 val ^= flags[cnt].bit;
5548 }
5549
5550 if (val != 0 || first)
5551 {
5552 if (! first)
5553 putchar (' ');
5554 print_vma (val, HEX);
5555 }
5556 }
5557 break;
5558
5559 default:
5560 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5561 break;
5562 }
5563 putchar ('\n');
5564 }
5565
5566 static void
5567 dynamic_section_ia64_val (Elf_Internal_Dyn *entry)
5568 {
5569 switch (entry->d_tag)
5570 {
5571 case DT_IA_64_PLT_RESERVE:
5572 /* First 3 slots reserved. */
5573 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5574 printf (" -- ");
5575 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
5576 break;
5577
5578 default:
5579 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5580 break;
5581 }
5582 putchar ('\n');
5583 }
5584
5585 static int
5586 get_32bit_dynamic_section (FILE *file)
5587 {
5588 Elf32_External_Dyn *edyn, *ext;
5589 Elf_Internal_Dyn *entry;
5590
5591 edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5592 _("dynamic section"));
5593 if (!edyn)
5594 return 0;
5595
5596 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5597 might not have the luxury of section headers. Look for the DT_NULL
5598 terminator to determine the number of entries. */
5599 for (ext = edyn, dynamic_nent = 0;
5600 (char *) ext < (char *) edyn + dynamic_size;
5601 ext++)
5602 {
5603 dynamic_nent++;
5604 if (BYTE_GET (ext->d_tag) == DT_NULL)
5605 break;
5606 }
5607
5608 dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5609 if (dynamic_section == NULL)
5610 {
5611 error (_("Out of memory\n"));
5612 free (edyn);
5613 return 0;
5614 }
5615
5616 for (ext = edyn, entry = dynamic_section;
5617 entry < dynamic_section + dynamic_nent;
5618 ext++, entry++)
5619 {
5620 entry->d_tag = BYTE_GET (ext->d_tag);
5621 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5622 }
5623
5624 free (edyn);
5625
5626 return 1;
5627 }
5628
5629 static int
5630 get_64bit_dynamic_section (FILE *file)
5631 {
5632 Elf64_External_Dyn *edyn, *ext;
5633 Elf_Internal_Dyn *entry;
5634
5635 edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5636 _("dynamic section"));
5637 if (!edyn)
5638 return 0;
5639
5640 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5641 might not have the luxury of section headers. Look for the DT_NULL
5642 terminator to determine the number of entries. */
5643 for (ext = edyn, dynamic_nent = 0;
5644 (char *) ext < (char *) edyn + dynamic_size;
5645 ext++)
5646 {
5647 dynamic_nent++;
5648 if (BYTE_GET (ext->d_tag) == DT_NULL)
5649 break;
5650 }
5651
5652 dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5653 if (dynamic_section == NULL)
5654 {
5655 error (_("Out of memory\n"));
5656 free (edyn);
5657 return 0;
5658 }
5659
5660 for (ext = edyn, entry = dynamic_section;
5661 entry < dynamic_section + dynamic_nent;
5662 ext++, entry++)
5663 {
5664 entry->d_tag = BYTE_GET (ext->d_tag);
5665 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5666 }
5667
5668 free (edyn);
5669
5670 return 1;
5671 }
5672
5673 static void
5674 print_dynamic_flags (bfd_vma flags)
5675 {
5676 int first = 1;
5677
5678 while (flags)
5679 {
5680 bfd_vma flag;
5681
5682 flag = flags & - flags;
5683 flags &= ~ flag;
5684
5685 if (first)
5686 first = 0;
5687 else
5688 putc (' ', stdout);
5689
5690 switch (flag)
5691 {
5692 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
5693 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
5694 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
5695 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
5696 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
5697 default: fputs ("unknown", stdout); break;
5698 }
5699 }
5700 puts ("");
5701 }
5702
5703 /* Parse and display the contents of the dynamic section. */
5704
5705 static int
5706 process_dynamic_section (FILE *file)
5707 {
5708 Elf_Internal_Dyn *entry;
5709
5710 if (dynamic_size == 0)
5711 {
5712 if (do_dynamic)
5713 printf (_("\nThere is no dynamic section in this file.\n"));
5714
5715 return 1;
5716 }
5717
5718 if (is_32bit_elf)
5719 {
5720 if (! get_32bit_dynamic_section (file))
5721 return 0;
5722 }
5723 else if (! get_64bit_dynamic_section (file))
5724 return 0;
5725
5726 /* Find the appropriate symbol table. */
5727 if (dynamic_symbols == NULL)
5728 {
5729 for (entry = dynamic_section;
5730 entry < dynamic_section + dynamic_nent;
5731 ++entry)
5732 {
5733 Elf_Internal_Shdr section;
5734
5735 if (entry->d_tag != DT_SYMTAB)
5736 continue;
5737
5738 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
5739
5740 /* Since we do not know how big the symbol table is,
5741 we default to reading in the entire file (!) and
5742 processing that. This is overkill, I know, but it
5743 should work. */
5744 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
5745
5746 if (archive_file_offset != 0)
5747 section.sh_size = archive_file_size - section.sh_offset;
5748 else
5749 {
5750 if (fseek (file, 0, SEEK_END))
5751 error (_("Unable to seek to end of file!"));
5752
5753 section.sh_size = ftell (file) - section.sh_offset;
5754 }
5755
5756 if (is_32bit_elf)
5757 section.sh_entsize = sizeof (Elf32_External_Sym);
5758 else
5759 section.sh_entsize = sizeof (Elf64_External_Sym);
5760
5761 num_dynamic_syms = section.sh_size / section.sh_entsize;
5762 if (num_dynamic_syms < 1)
5763 {
5764 error (_("Unable to determine the number of symbols to load\n"));
5765 continue;
5766 }
5767
5768 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
5769 }
5770 }
5771
5772 /* Similarly find a string table. */
5773 if (dynamic_strings == NULL)
5774 {
5775 for (entry = dynamic_section;
5776 entry < dynamic_section + dynamic_nent;
5777 ++entry)
5778 {
5779 unsigned long offset;
5780 long str_tab_len;
5781
5782 if (entry->d_tag != DT_STRTAB)
5783 continue;
5784
5785 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
5786
5787 /* Since we do not know how big the string table is,
5788 we default to reading in the entire file (!) and
5789 processing that. This is overkill, I know, but it
5790 should work. */
5791
5792 offset = offset_from_vma (file, entry->d_un.d_val, 0);
5793
5794 if (archive_file_offset != 0)
5795 str_tab_len = archive_file_size - offset;
5796 else
5797 {
5798 if (fseek (file, 0, SEEK_END))
5799 error (_("Unable to seek to end of file\n"));
5800 str_tab_len = ftell (file) - offset;
5801 }
5802
5803 if (str_tab_len < 1)
5804 {
5805 error
5806 (_("Unable to determine the length of the dynamic string table\n"));
5807 continue;
5808 }
5809
5810 dynamic_strings = get_data (NULL, file, offset, 1, str_tab_len,
5811 _("dynamic string table"));
5812 dynamic_strings_length = str_tab_len;
5813 break;
5814 }
5815 }
5816
5817 /* And find the syminfo section if available. */
5818 if (dynamic_syminfo == NULL)
5819 {
5820 unsigned long syminsz = 0;
5821
5822 for (entry = dynamic_section;
5823 entry < dynamic_section + dynamic_nent;
5824 ++entry)
5825 {
5826 if (entry->d_tag == DT_SYMINENT)
5827 {
5828 /* Note: these braces are necessary to avoid a syntax
5829 error from the SunOS4 C compiler. */
5830 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
5831 }
5832 else if (entry->d_tag == DT_SYMINSZ)
5833 syminsz = entry->d_un.d_val;
5834 else if (entry->d_tag == DT_SYMINFO)
5835 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
5836 syminsz);
5837 }
5838
5839 if (dynamic_syminfo_offset != 0 && syminsz != 0)
5840 {
5841 Elf_External_Syminfo *extsyminfo, *extsym;
5842 Elf_Internal_Syminfo *syminfo;
5843
5844 /* There is a syminfo section. Read the data. */
5845 extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, 1,
5846 syminsz, _("symbol information"));
5847 if (!extsyminfo)
5848 return 0;
5849
5850 dynamic_syminfo = malloc (syminsz);
5851 if (dynamic_syminfo == NULL)
5852 {
5853 error (_("Out of memory\n"));
5854 return 0;
5855 }
5856
5857 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
5858 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
5859 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
5860 ++syminfo, ++extsym)
5861 {
5862 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
5863 syminfo->si_flags = BYTE_GET (extsym->si_flags);
5864 }
5865
5866 free (extsyminfo);
5867 }
5868 }
5869
5870 if (do_dynamic && dynamic_addr)
5871 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5872 dynamic_addr, dynamic_nent);
5873 if (do_dynamic)
5874 printf (_(" Tag Type Name/Value\n"));
5875
5876 for (entry = dynamic_section;
5877 entry < dynamic_section + dynamic_nent;
5878 entry++)
5879 {
5880 if (do_dynamic)
5881 {
5882 const char *dtype;
5883
5884 putchar (' ');
5885 print_vma (entry->d_tag, FULL_HEX);
5886 dtype = get_dynamic_type (entry->d_tag);
5887 printf (" (%s)%*s", dtype,
5888 ((is_32bit_elf ? 27 : 19)
5889 - (int) strlen (dtype)),
5890 " ");
5891 }
5892
5893 switch (entry->d_tag)
5894 {
5895 case DT_FLAGS:
5896 if (do_dynamic)
5897 print_dynamic_flags (entry->d_un.d_val);
5898 break;
5899
5900 case DT_AUXILIARY:
5901 case DT_FILTER:
5902 case DT_CONFIG:
5903 case DT_DEPAUDIT:
5904 case DT_AUDIT:
5905 if (do_dynamic)
5906 {
5907 switch (entry->d_tag)
5908 {
5909 case DT_AUXILIARY:
5910 printf (_("Auxiliary library"));
5911 break;
5912
5913 case DT_FILTER:
5914 printf (_("Filter library"));
5915 break;
5916
5917 case DT_CONFIG:
5918 printf (_("Configuration file"));
5919 break;
5920
5921 case DT_DEPAUDIT:
5922 printf (_("Dependency audit library"));
5923 break;
5924
5925 case DT_AUDIT:
5926 printf (_("Audit library"));
5927 break;
5928 }
5929
5930 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5931 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5932 else
5933 {
5934 printf (": ");
5935 print_vma (entry->d_un.d_val, PREFIX_HEX);
5936 putchar ('\n');
5937 }
5938 }
5939 break;
5940
5941 case DT_FEATURE:
5942 if (do_dynamic)
5943 {
5944 printf (_("Flags:"));
5945
5946 if (entry->d_un.d_val == 0)
5947 printf (_(" None\n"));
5948 else
5949 {
5950 unsigned long int val = entry->d_un.d_val;
5951
5952 if (val & DTF_1_PARINIT)
5953 {
5954 printf (" PARINIT");
5955 val ^= DTF_1_PARINIT;
5956 }
5957 if (val & DTF_1_CONFEXP)
5958 {
5959 printf (" CONFEXP");
5960 val ^= DTF_1_CONFEXP;
5961 }
5962 if (val != 0)
5963 printf (" %lx", val);
5964 puts ("");
5965 }
5966 }
5967 break;
5968
5969 case DT_POSFLAG_1:
5970 if (do_dynamic)
5971 {
5972 printf (_("Flags:"));
5973
5974 if (entry->d_un.d_val == 0)
5975 printf (_(" None\n"));
5976 else
5977 {
5978 unsigned long int val = entry->d_un.d_val;
5979
5980 if (val & DF_P1_LAZYLOAD)
5981 {
5982 printf (" LAZYLOAD");
5983 val ^= DF_P1_LAZYLOAD;
5984 }
5985 if (val & DF_P1_GROUPPERM)
5986 {
5987 printf (" GROUPPERM");
5988 val ^= DF_P1_GROUPPERM;
5989 }
5990 if (val != 0)
5991 printf (" %lx", val);
5992 puts ("");
5993 }
5994 }
5995 break;
5996
5997 case DT_FLAGS_1:
5998 if (do_dynamic)
5999 {
6000 printf (_("Flags:"));
6001 if (entry->d_un.d_val == 0)
6002 printf (_(" None\n"));
6003 else
6004 {
6005 unsigned long int val = entry->d_un.d_val;
6006
6007 if (val & DF_1_NOW)
6008 {
6009 printf (" NOW");
6010 val ^= DF_1_NOW;
6011 }
6012 if (val & DF_1_GLOBAL)
6013 {
6014 printf (" GLOBAL");
6015 val ^= DF_1_GLOBAL;
6016 }
6017 if (val & DF_1_GROUP)
6018 {
6019 printf (" GROUP");
6020 val ^= DF_1_GROUP;
6021 }
6022 if (val & DF_1_NODELETE)
6023 {
6024 printf (" NODELETE");
6025 val ^= DF_1_NODELETE;
6026 }
6027 if (val & DF_1_LOADFLTR)
6028 {
6029 printf (" LOADFLTR");
6030 val ^= DF_1_LOADFLTR;
6031 }
6032 if (val & DF_1_INITFIRST)
6033 {
6034 printf (" INITFIRST");
6035 val ^= DF_1_INITFIRST;
6036 }
6037 if (val & DF_1_NOOPEN)
6038 {
6039 printf (" NOOPEN");
6040 val ^= DF_1_NOOPEN;
6041 }
6042 if (val & DF_1_ORIGIN)
6043 {
6044 printf (" ORIGIN");
6045 val ^= DF_1_ORIGIN;
6046 }
6047 if (val & DF_1_DIRECT)
6048 {
6049 printf (" DIRECT");
6050 val ^= DF_1_DIRECT;
6051 }
6052 if (val & DF_1_TRANS)
6053 {
6054 printf (" TRANS");
6055 val ^= DF_1_TRANS;
6056 }
6057 if (val & DF_1_INTERPOSE)
6058 {
6059 printf (" INTERPOSE");
6060 val ^= DF_1_INTERPOSE;
6061 }
6062 if (val & DF_1_NODEFLIB)
6063 {
6064 printf (" NODEFLIB");
6065 val ^= DF_1_NODEFLIB;
6066 }
6067 if (val & DF_1_NODUMP)
6068 {
6069 printf (" NODUMP");
6070 val ^= DF_1_NODUMP;
6071 }
6072 if (val & DF_1_CONLFAT)
6073 {
6074 printf (" CONLFAT");
6075 val ^= DF_1_CONLFAT;
6076 }
6077 if (val != 0)
6078 printf (" %lx", val);
6079 puts ("");
6080 }
6081 }
6082 break;
6083
6084 case DT_PLTREL:
6085 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6086 if (do_dynamic)
6087 puts (get_dynamic_type (entry->d_un.d_val));
6088 break;
6089
6090 case DT_NULL :
6091 case DT_NEEDED :
6092 case DT_PLTGOT :
6093 case DT_HASH :
6094 case DT_STRTAB :
6095 case DT_SYMTAB :
6096 case DT_RELA :
6097 case DT_INIT :
6098 case DT_FINI :
6099 case DT_SONAME :
6100 case DT_RPATH :
6101 case DT_SYMBOLIC:
6102 case DT_REL :
6103 case DT_DEBUG :
6104 case DT_TEXTREL :
6105 case DT_JMPREL :
6106 case DT_RUNPATH :
6107 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6108
6109 if (do_dynamic)
6110 {
6111 char *name;
6112
6113 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6114 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6115 else
6116 name = NULL;
6117
6118 if (name)
6119 {
6120 switch (entry->d_tag)
6121 {
6122 case DT_NEEDED:
6123 printf (_("Shared library: [%s]"), name);
6124
6125 if (streq (name, program_interpreter))
6126 printf (_(" program interpreter"));
6127 break;
6128
6129 case DT_SONAME:
6130 printf (_("Library soname: [%s]"), name);
6131 break;
6132
6133 case DT_RPATH:
6134 printf (_("Library rpath: [%s]"), name);
6135 break;
6136
6137 case DT_RUNPATH:
6138 printf (_("Library runpath: [%s]"), name);
6139 break;
6140
6141 default:
6142 print_vma (entry->d_un.d_val, PREFIX_HEX);
6143 break;
6144 }
6145 }
6146 else
6147 print_vma (entry->d_un.d_val, PREFIX_HEX);
6148
6149 putchar ('\n');
6150 }
6151 break;
6152
6153 case DT_PLTRELSZ:
6154 case DT_RELASZ :
6155 case DT_STRSZ :
6156 case DT_RELSZ :
6157 case DT_RELAENT :
6158 case DT_SYMENT :
6159 case DT_RELENT :
6160 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6161 case DT_PLTPADSZ:
6162 case DT_MOVEENT :
6163 case DT_MOVESZ :
6164 case DT_INIT_ARRAYSZ:
6165 case DT_FINI_ARRAYSZ:
6166 case DT_GNU_CONFLICTSZ:
6167 case DT_GNU_LIBLISTSZ:
6168 if (do_dynamic)
6169 {
6170 print_vma (entry->d_un.d_val, UNSIGNED);
6171 printf (" (bytes)\n");
6172 }
6173 break;
6174
6175 case DT_VERDEFNUM:
6176 case DT_VERNEEDNUM:
6177 case DT_RELACOUNT:
6178 case DT_RELCOUNT:
6179 if (do_dynamic)
6180 {
6181 print_vma (entry->d_un.d_val, UNSIGNED);
6182 putchar ('\n');
6183 }
6184 break;
6185
6186 case DT_SYMINSZ:
6187 case DT_SYMINENT:
6188 case DT_SYMINFO:
6189 case DT_USED:
6190 case DT_INIT_ARRAY:
6191 case DT_FINI_ARRAY:
6192 if (do_dynamic)
6193 {
6194 if (entry->d_tag == DT_USED
6195 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
6196 {
6197 char *name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6198
6199 if (*name)
6200 {
6201 printf (_("Not needed object: [%s]\n"), name);
6202 break;
6203 }
6204 }
6205
6206 print_vma (entry->d_un.d_val, PREFIX_HEX);
6207 putchar ('\n');
6208 }
6209 break;
6210
6211 case DT_BIND_NOW:
6212 /* The value of this entry is ignored. */
6213 if (do_dynamic)
6214 putchar ('\n');
6215 break;
6216
6217 case DT_GNU_PRELINKED:
6218 if (do_dynamic)
6219 {
6220 struct tm *tmp;
6221 time_t time = entry->d_un.d_val;
6222
6223 tmp = gmtime (&time);
6224 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6225 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6226 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6227
6228 }
6229 break;
6230
6231 default:
6232 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
6233 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
6234 entry->d_un.d_val;
6235
6236 if (do_dynamic)
6237 {
6238 switch (elf_header.e_machine)
6239 {
6240 case EM_MIPS:
6241 case EM_MIPS_RS3_LE:
6242 dynamic_section_mips_val (entry);
6243 break;
6244 case EM_PARISC:
6245 dynamic_section_parisc_val (entry);
6246 break;
6247 case EM_IA_64:
6248 dynamic_section_ia64_val (entry);
6249 break;
6250 default:
6251 print_vma (entry->d_un.d_val, PREFIX_HEX);
6252 putchar ('\n');
6253 }
6254 }
6255 break;
6256 }
6257 }
6258
6259 return 1;
6260 }
6261
6262 static char *
6263 get_ver_flags (unsigned int flags)
6264 {
6265 static char buff[32];
6266
6267 buff[0] = 0;
6268
6269 if (flags == 0)
6270 return _("none");
6271
6272 if (flags & VER_FLG_BASE)
6273 strcat (buff, "BASE ");
6274
6275 if (flags & VER_FLG_WEAK)
6276 {
6277 if (flags & VER_FLG_BASE)
6278 strcat (buff, "| ");
6279
6280 strcat (buff, "WEAK ");
6281 }
6282
6283 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
6284 strcat (buff, "| <unknown>");
6285
6286 return buff;
6287 }
6288
6289 /* Display the contents of the version sections. */
6290 static int
6291 process_version_sections (FILE *file)
6292 {
6293 Elf_Internal_Shdr *section;
6294 unsigned i;
6295 int found = 0;
6296
6297 if (! do_version)
6298 return 1;
6299
6300 for (i = 0, section = section_headers;
6301 i < elf_header.e_shnum;
6302 i++, section++)
6303 {
6304 switch (section->sh_type)
6305 {
6306 case SHT_GNU_verdef:
6307 {
6308 Elf_External_Verdef *edefs;
6309 unsigned int idx;
6310 unsigned int cnt;
6311
6312 found = 1;
6313
6314 printf
6315 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6316 SECTION_NAME (section), section->sh_info);
6317
6318 printf (_(" Addr: 0x"));
6319 printf_vma (section->sh_addr);
6320 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6321 (unsigned long) section->sh_offset, section->sh_link,
6322 SECTION_HEADER_INDEX (section->sh_link)
6323 < elf_header.e_shnum
6324 ? SECTION_NAME (SECTION_HEADER (section->sh_link))
6325 : "<corrupt>");
6326
6327 edefs = get_data (NULL, file, section->sh_offset, 1,
6328 section->sh_size,
6329 _("version definition section"));
6330 if (!edefs)
6331 break;
6332
6333 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6334 {
6335 char *vstart;
6336 Elf_External_Verdef *edef;
6337 Elf_Internal_Verdef ent;
6338 Elf_External_Verdaux *eaux;
6339 Elf_Internal_Verdaux aux;
6340 int j;
6341 int isum;
6342
6343 vstart = ((char *) edefs) + idx;
6344
6345 edef = (Elf_External_Verdef *) vstart;
6346
6347 ent.vd_version = BYTE_GET (edef->vd_version);
6348 ent.vd_flags = BYTE_GET (edef->vd_flags);
6349 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
6350 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
6351 ent.vd_hash = BYTE_GET (edef->vd_hash);
6352 ent.vd_aux = BYTE_GET (edef->vd_aux);
6353 ent.vd_next = BYTE_GET (edef->vd_next);
6354
6355 printf (_(" %#06x: Rev: %d Flags: %s"),
6356 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
6357
6358 printf (_(" Index: %d Cnt: %d "),
6359 ent.vd_ndx, ent.vd_cnt);
6360
6361 vstart += ent.vd_aux;
6362
6363 eaux = (Elf_External_Verdaux *) vstart;
6364
6365 aux.vda_name = BYTE_GET (eaux->vda_name);
6366 aux.vda_next = BYTE_GET (eaux->vda_next);
6367
6368 if (VALID_DYNAMIC_NAME (aux.vda_name))
6369 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
6370 else
6371 printf (_("Name index: %ld\n"), aux.vda_name);
6372
6373 isum = idx + ent.vd_aux;
6374
6375 for (j = 1; j < ent.vd_cnt; j++)
6376 {
6377 isum += aux.vda_next;
6378 vstart += aux.vda_next;
6379
6380 eaux = (Elf_External_Verdaux *) vstart;
6381
6382 aux.vda_name = BYTE_GET (eaux->vda_name);
6383 aux.vda_next = BYTE_GET (eaux->vda_next);
6384
6385 if (VALID_DYNAMIC_NAME (aux.vda_name))
6386 printf (_(" %#06x: Parent %d: %s\n"),
6387 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
6388 else
6389 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6390 isum, j, aux.vda_name);
6391 }
6392
6393 idx += ent.vd_next;
6394 }
6395
6396 free (edefs);
6397 }
6398 break;
6399
6400 case SHT_GNU_verneed:
6401 {
6402 Elf_External_Verneed *eneed;
6403 unsigned int idx;
6404 unsigned int cnt;
6405
6406 found = 1;
6407
6408 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6409 SECTION_NAME (section), section->sh_info);
6410
6411 printf (_(" Addr: 0x"));
6412 printf_vma (section->sh_addr);
6413 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6414 (unsigned long) section->sh_offset, section->sh_link,
6415 SECTION_HEADER_INDEX (section->sh_link)
6416 < elf_header.e_shnum
6417 ? SECTION_NAME (SECTION_HEADER (section->sh_link))
6418 : "<corrupt>");
6419
6420 eneed = get_data (NULL, file, section->sh_offset, 1,
6421 section->sh_size,
6422 _("version need section"));
6423 if (!eneed)
6424 break;
6425
6426 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6427 {
6428 Elf_External_Verneed *entry;
6429 Elf_Internal_Verneed ent;
6430 int j;
6431 int isum;
6432 char *vstart;
6433
6434 vstart = ((char *) eneed) + idx;
6435
6436 entry = (Elf_External_Verneed *) vstart;
6437
6438 ent.vn_version = BYTE_GET (entry->vn_version);
6439 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
6440 ent.vn_file = BYTE_GET (entry->vn_file);
6441 ent.vn_aux = BYTE_GET (entry->vn_aux);
6442 ent.vn_next = BYTE_GET (entry->vn_next);
6443
6444 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
6445
6446 if (VALID_DYNAMIC_NAME (ent.vn_file))
6447 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
6448 else
6449 printf (_(" File: %lx"), ent.vn_file);
6450
6451 printf (_(" Cnt: %d\n"), ent.vn_cnt);
6452
6453 vstart += ent.vn_aux;
6454
6455 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
6456 {
6457 Elf_External_Vernaux *eaux;
6458 Elf_Internal_Vernaux aux;
6459
6460 eaux = (Elf_External_Vernaux *) vstart;
6461
6462 aux.vna_hash = BYTE_GET (eaux->vna_hash);
6463 aux.vna_flags = BYTE_GET (eaux->vna_flags);
6464 aux.vna_other = BYTE_GET (eaux->vna_other);
6465 aux.vna_name = BYTE_GET (eaux->vna_name);
6466 aux.vna_next = BYTE_GET (eaux->vna_next);
6467
6468 if (VALID_DYNAMIC_NAME (aux.vna_name))
6469 printf (_(" %#06x: Name: %s"),
6470 isum, GET_DYNAMIC_NAME (aux.vna_name));
6471 else
6472 printf (_(" %#06x: Name index: %lx"),
6473 isum, aux.vna_name);
6474
6475 printf (_(" Flags: %s Version: %d\n"),
6476 get_ver_flags (aux.vna_flags), aux.vna_other);
6477
6478 isum += aux.vna_next;
6479 vstart += aux.vna_next;
6480 }
6481
6482 idx += ent.vn_next;
6483 }
6484
6485 free (eneed);
6486 }
6487 break;
6488
6489 case SHT_GNU_versym:
6490 {
6491 Elf_Internal_Shdr *link_section;
6492 int total;
6493 int cnt;
6494 unsigned char *edata;
6495 unsigned short *data;
6496 char *strtab;
6497 Elf_Internal_Sym *symbols;
6498 Elf_Internal_Shdr *string_sec;
6499 long off;
6500
6501 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum)
6502 break;
6503
6504 link_section = SECTION_HEADER (section->sh_link);
6505 total = section->sh_size / sizeof (Elf_External_Versym);
6506
6507 if (SECTION_HEADER_INDEX (link_section->sh_link)
6508 >= elf_header.e_shnum)
6509 break;
6510
6511 found = 1;
6512
6513 symbols = GET_ELF_SYMBOLS (file, link_section);
6514
6515 string_sec = SECTION_HEADER (link_section->sh_link);
6516
6517 strtab = get_data (NULL, file, string_sec->sh_offset, 1,
6518 string_sec->sh_size, _("version string table"));
6519 if (!strtab)
6520 break;
6521
6522 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6523 SECTION_NAME (section), total);
6524
6525 printf (_(" Addr: "));
6526 printf_vma (section->sh_addr);
6527 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6528 (unsigned long) section->sh_offset, section->sh_link,
6529 SECTION_NAME (link_section));
6530
6531 off = offset_from_vma (file,
6532 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6533 total * sizeof (short));
6534 edata = get_data (NULL, file, off, total, sizeof (short),
6535 _("version symbol data"));
6536 if (!edata)
6537 {
6538 free (strtab);
6539 break;
6540 }
6541
6542 data = cmalloc (total, sizeof (short));
6543
6544 for (cnt = total; cnt --;)
6545 data[cnt] = byte_get (edata + cnt * sizeof (short),
6546 sizeof (short));
6547
6548 free (edata);
6549
6550 for (cnt = 0; cnt < total; cnt += 4)
6551 {
6552 int j, nn;
6553 int check_def, check_need;
6554 char *name;
6555
6556 printf (" %03x:", cnt);
6557
6558 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
6559 switch (data[cnt + j])
6560 {
6561 case 0:
6562 fputs (_(" 0 (*local*) "), stdout);
6563 break;
6564
6565 case 1:
6566 fputs (_(" 1 (*global*) "), stdout);
6567 break;
6568
6569 default:
6570 nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
6571 data[cnt + j] & 0x8000 ? 'h' : ' ');
6572
6573 check_def = 1;
6574 check_need = 1;
6575 if (SECTION_HEADER_INDEX (symbols[cnt + j].st_shndx)
6576 >= elf_header.e_shnum
6577 || SECTION_HEADER (symbols[cnt + j].st_shndx)->sh_type
6578 != SHT_NOBITS)
6579 {
6580 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
6581 check_def = 0;
6582 else
6583 check_need = 0;
6584 }
6585
6586 if (check_need
6587 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
6588 {
6589 Elf_Internal_Verneed ivn;
6590 unsigned long offset;
6591
6592 offset = offset_from_vma
6593 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6594 sizeof (Elf_External_Verneed));
6595
6596 do
6597 {
6598 Elf_Internal_Vernaux ivna;
6599 Elf_External_Verneed evn;
6600 Elf_External_Vernaux evna;
6601 unsigned long a_off;
6602
6603 get_data (&evn, file, offset, sizeof (evn), 1,
6604 _("version need"));
6605
6606 ivn.vn_aux = BYTE_GET (evn.vn_aux);
6607 ivn.vn_next = BYTE_GET (evn.vn_next);
6608
6609 a_off = offset + ivn.vn_aux;
6610
6611 do
6612 {
6613 get_data (&evna, file, a_off, sizeof (evna),
6614 1, _("version need aux (2)"));
6615
6616 ivna.vna_next = BYTE_GET (evna.vna_next);
6617 ivna.vna_other = BYTE_GET (evna.vna_other);
6618
6619 a_off += ivna.vna_next;
6620 }
6621 while (ivna.vna_other != data[cnt + j]
6622 && ivna.vna_next != 0);
6623
6624 if (ivna.vna_other == data[cnt + j])
6625 {
6626 ivna.vna_name = BYTE_GET (evna.vna_name);
6627
6628 name = strtab + ivna.vna_name;
6629 nn += printf ("(%s%-*s",
6630 name,
6631 12 - (int) strlen (name),
6632 ")");
6633 check_def = 0;
6634 break;
6635 }
6636
6637 offset += ivn.vn_next;
6638 }
6639 while (ivn.vn_next);
6640 }
6641
6642 if (check_def && data[cnt + j] != 0x8001
6643 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
6644 {
6645 Elf_Internal_Verdef ivd;
6646 Elf_External_Verdef evd;
6647 unsigned long offset;
6648
6649 offset = offset_from_vma
6650 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
6651 sizeof evd);
6652
6653 do
6654 {
6655 get_data (&evd, file, offset, sizeof (evd), 1,
6656 _("version def"));
6657
6658 ivd.vd_next = BYTE_GET (evd.vd_next);
6659 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
6660
6661 offset += ivd.vd_next;
6662 }
6663 while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
6664 && ivd.vd_next != 0);
6665
6666 if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
6667 {
6668 Elf_External_Verdaux evda;
6669 Elf_Internal_Verdaux ivda;
6670
6671 ivd.vd_aux = BYTE_GET (evd.vd_aux);
6672
6673 get_data (&evda, file,
6674 offset - ivd.vd_next + ivd.vd_aux,
6675 sizeof (evda), 1,
6676 _("version def aux"));
6677
6678 ivda.vda_name = BYTE_GET (evda.vda_name);
6679
6680 name = strtab + ivda.vda_name;
6681 nn += printf ("(%s%-*s",
6682 name,
6683 12 - (int) strlen (name),
6684 ")");
6685 }
6686 }
6687
6688 if (nn < 18)
6689 printf ("%*c", 18 - nn, ' ');
6690 }
6691
6692 putchar ('\n');
6693 }
6694
6695 free (data);
6696 free (strtab);
6697 free (symbols);
6698 }
6699 break;
6700
6701 default:
6702 break;
6703 }
6704 }
6705
6706 if (! found)
6707 printf (_("\nNo version information found in this file.\n"));
6708
6709 return 1;
6710 }
6711
6712 static const char *
6713 get_symbol_binding (unsigned int binding)
6714 {
6715 static char buff[32];
6716
6717 switch (binding)
6718 {
6719 case STB_LOCAL: return "LOCAL";
6720 case STB_GLOBAL: return "GLOBAL";
6721 case STB_WEAK: return "WEAK";
6722 default:
6723 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
6724 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
6725 binding);
6726 else if (binding >= STB_LOOS && binding <= STB_HIOS)
6727 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
6728 else
6729 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
6730 return buff;
6731 }
6732 }
6733
6734 static const char *
6735 get_symbol_type (unsigned int type)
6736 {
6737 static char buff[32];
6738
6739 switch (type)
6740 {
6741 case STT_NOTYPE: return "NOTYPE";
6742 case STT_OBJECT: return "OBJECT";
6743 case STT_FUNC: return "FUNC";
6744 case STT_SECTION: return "SECTION";
6745 case STT_FILE: return "FILE";
6746 case STT_COMMON: return "COMMON";
6747 case STT_TLS: return "TLS";
6748 default:
6749 if (type >= STT_LOPROC && type <= STT_HIPROC)
6750 {
6751 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
6752 return "THUMB_FUNC";
6753
6754 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
6755 return "REGISTER";
6756
6757 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
6758 return "PARISC_MILLI";
6759
6760 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
6761 }
6762 else if (type >= STT_LOOS && type <= STT_HIOS)
6763 {
6764 if (elf_header.e_machine == EM_PARISC)
6765 {
6766 if (type == STT_HP_OPAQUE)
6767 return "HP_OPAQUE";
6768 if (type == STT_HP_STUB)
6769 return "HP_STUB";
6770 }
6771
6772 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
6773 }
6774 else
6775 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
6776 return buff;
6777 }
6778 }
6779
6780 static const char *
6781 get_symbol_visibility (unsigned int visibility)
6782 {
6783 switch (visibility)
6784 {
6785 case STV_DEFAULT: return "DEFAULT";
6786 case STV_INTERNAL: return "INTERNAL";
6787 case STV_HIDDEN: return "HIDDEN";
6788 case STV_PROTECTED: return "PROTECTED";
6789 default: abort ();
6790 }
6791 }
6792
6793 static const char *
6794 get_mips_symbol_other (unsigned int other)
6795 {
6796 switch (other)
6797 {
6798 case STO_OPTIONAL: return "OPTIONAL";
6799 case STO_MIPS16: return "MIPS16";
6800 default: return NULL;
6801 }
6802 }
6803
6804 static const char *
6805 get_symbol_other (unsigned int other)
6806 {
6807 const char * result = NULL;
6808 static char buff [32];
6809
6810 if (other == 0)
6811 return "";
6812
6813 switch (elf_header.e_machine)
6814 {
6815 case EM_MIPS:
6816 result = get_mips_symbol_other (other);
6817 default:
6818 break;
6819 }
6820
6821 if (result)
6822 return result;
6823
6824 snprintf (buff, sizeof buff, _("<other>: %x"), other);
6825 return buff;
6826 }
6827
6828 static const char *
6829 get_symbol_index_type (unsigned int type)
6830 {
6831 static char buff[32];
6832
6833 switch (type)
6834 {
6835 case SHN_UNDEF: return "UND";
6836 case SHN_ABS: return "ABS";
6837 case SHN_COMMON: return "COM";
6838 default:
6839 if (type == SHN_IA_64_ANSI_COMMON
6840 && elf_header.e_machine == EM_IA_64
6841 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
6842 return "ANSI_COM";
6843 else if (elf_header.e_machine == EM_X86_64
6844 && type == SHN_X86_64_LCOMMON)
6845 return "LARGE_COM";
6846 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
6847 sprintf (buff, "PRC[0x%04x]", type);
6848 else if (type >= SHN_LOOS && type <= SHN_HIOS)
6849 sprintf (buff, "OS [0x%04x]", type);
6850 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
6851 sprintf (buff, "RSV[0x%04x]", type);
6852 else
6853 sprintf (buff, "%3d", type);
6854 break;
6855 }
6856
6857 return buff;
6858 }
6859
6860 static bfd_vma *
6861 get_dynamic_data (FILE *file, unsigned int number, unsigned int ent_size)
6862 {
6863 unsigned char *e_data;
6864 bfd_vma *i_data;
6865
6866 e_data = cmalloc (number, ent_size);
6867
6868 if (e_data == NULL)
6869 {
6870 error (_("Out of memory\n"));
6871 return NULL;
6872 }
6873
6874 if (fread (e_data, ent_size, number, file) != number)
6875 {
6876 error (_("Unable to read in dynamic data\n"));
6877 return NULL;
6878 }
6879
6880 i_data = cmalloc (number, sizeof (*i_data));
6881
6882 if (i_data == NULL)
6883 {
6884 error (_("Out of memory\n"));
6885 free (e_data);
6886 return NULL;
6887 }
6888
6889 while (number--)
6890 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
6891
6892 free (e_data);
6893
6894 return i_data;
6895 }
6896
6897 /* Dump the symbol table. */
6898 static int
6899 process_symbol_table (FILE *file)
6900 {
6901 Elf_Internal_Shdr *section;
6902 bfd_vma nbuckets = 0;
6903 bfd_vma nchains = 0;
6904 bfd_vma *buckets = NULL;
6905 bfd_vma *chains = NULL;
6906
6907 if (! do_syms && !do_histogram)
6908 return 1;
6909
6910 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
6911 || do_histogram))
6912 {
6913 unsigned char nb[8];
6914 unsigned char nc[8];
6915 int hash_ent_size = 4;
6916
6917 if ((elf_header.e_machine == EM_ALPHA
6918 || elf_header.e_machine == EM_S390
6919 || elf_header.e_machine == EM_S390_OLD)
6920 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
6921 hash_ent_size = 8;
6922
6923 if (fseek (file,
6924 (archive_file_offset
6925 + offset_from_vma (file, dynamic_info[DT_HASH],
6926 sizeof nb + sizeof nc)),
6927 SEEK_SET))
6928 {
6929 error (_("Unable to seek to start of dynamic information"));
6930 return 0;
6931 }
6932
6933 if (fread (nb, hash_ent_size, 1, file) != 1)
6934 {
6935 error (_("Failed to read in number of buckets\n"));
6936 return 0;
6937 }
6938
6939 if (fread (nc, hash_ent_size, 1, file) != 1)
6940 {
6941 error (_("Failed to read in number of chains\n"));
6942 return 0;
6943 }
6944
6945 nbuckets = byte_get (nb, hash_ent_size);
6946 nchains = byte_get (nc, hash_ent_size);
6947
6948 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
6949 chains = get_dynamic_data (file, nchains, hash_ent_size);
6950
6951 if (buckets == NULL || chains == NULL)
6952 return 0;
6953 }
6954
6955 if (do_syms
6956 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
6957 {
6958 unsigned long hn;
6959 bfd_vma si;
6960
6961 printf (_("\nSymbol table for image:\n"));
6962 if (is_32bit_elf)
6963 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6964 else
6965 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6966
6967 for (hn = 0; hn < nbuckets; hn++)
6968 {
6969 if (! buckets[hn])
6970 continue;
6971
6972 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
6973 {
6974 Elf_Internal_Sym *psym;
6975 int n;
6976
6977 psym = dynamic_symbols + si;
6978
6979 n = print_vma (si, DEC_5);
6980 if (n < 5)
6981 fputs (" " + n, stdout);
6982 printf (" %3lu: ", hn);
6983 print_vma (psym->st_value, LONG_HEX);
6984 putchar (' ');
6985 print_vma (psym->st_size, DEC_5);
6986
6987 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
6988 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
6989 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6990 /* Check to see if any other bits in the st_other field are set.
6991 Note - displaying this information disrupts the layout of the
6992 table being generated, but for the moment this case is very rare. */
6993 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
6994 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
6995 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
6996 if (VALID_DYNAMIC_NAME (psym->st_name))
6997 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
6998 else
6999 printf (" <corrupt: %14ld>", psym->st_name);
7000 putchar ('\n');
7001 }
7002 }
7003 }
7004 else if (do_syms && !do_using_dynamic)
7005 {
7006 unsigned int i;
7007
7008 for (i = 0, section = section_headers;
7009 i < elf_header.e_shnum;
7010 i++, section++)
7011 {
7012 unsigned int si;
7013 char *strtab = NULL;
7014 unsigned long int strtab_size = 0;
7015 Elf_Internal_Sym *symtab;
7016 Elf_Internal_Sym *psym;
7017
7018
7019 if ( section->sh_type != SHT_SYMTAB
7020 && section->sh_type != SHT_DYNSYM)
7021 continue;
7022
7023 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7024 SECTION_NAME (section),
7025 (unsigned long) (section->sh_size / section->sh_entsize));
7026 if (is_32bit_elf)
7027 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7028 else
7029 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7030
7031 symtab = GET_ELF_SYMBOLS (file, section);
7032 if (symtab == NULL)
7033 continue;
7034
7035 if (section->sh_link == elf_header.e_shstrndx)
7036 {
7037 strtab = string_table;
7038 strtab_size = string_table_length;
7039 }
7040 else if (SECTION_HEADER_INDEX (section->sh_link) < elf_header.e_shnum)
7041 {
7042 Elf_Internal_Shdr *string_sec;
7043
7044 string_sec = SECTION_HEADER (section->sh_link);
7045
7046 strtab = get_data (NULL, file, string_sec->sh_offset,
7047 1, string_sec->sh_size, _("string table"));
7048 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
7049 }
7050
7051 for (si = 0, psym = symtab;
7052 si < section->sh_size / section->sh_entsize;
7053 si++, psym++)
7054 {
7055 printf ("%6d: ", si);
7056 print_vma (psym->st_value, LONG_HEX);
7057 putchar (' ');
7058 print_vma (psym->st_size, DEC_5);
7059 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7060 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7061 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7062 /* Check to see if any other bits in the st_other field are set.
7063 Note - displaying this information disrupts the layout of the
7064 table being generated, but for the moment this case is very rare. */
7065 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7066 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7067 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
7068 print_symbol (25, psym->st_name < strtab_size
7069 ? strtab + psym->st_name : "<corrupt>");
7070
7071 if (section->sh_type == SHT_DYNSYM &&
7072 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
7073 {
7074 unsigned char data[2];
7075 unsigned short vers_data;
7076 unsigned long offset;
7077 int is_nobits;
7078 int check_def;
7079
7080 offset = offset_from_vma
7081 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7082 sizeof data + si * sizeof (vers_data));
7083
7084 get_data (&data, file, offset + si * sizeof (vers_data),
7085 sizeof (data), 1, _("version data"));
7086
7087 vers_data = byte_get (data, 2);
7088
7089 is_nobits = (SECTION_HEADER_INDEX (psym->st_shndx)
7090 < elf_header.e_shnum
7091 && SECTION_HEADER (psym->st_shndx)->sh_type
7092 == SHT_NOBITS);
7093
7094 check_def = (psym->st_shndx != SHN_UNDEF);
7095
7096 if ((vers_data & 0x8000) || vers_data > 1)
7097 {
7098 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
7099 && (is_nobits || ! check_def))
7100 {
7101 Elf_External_Verneed evn;
7102 Elf_Internal_Verneed ivn;
7103 Elf_Internal_Vernaux ivna;
7104
7105 /* We must test both. */
7106 offset = offset_from_vma
7107 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7108 sizeof evn);
7109
7110 do
7111 {
7112 unsigned long vna_off;
7113
7114 get_data (&evn, file, offset, sizeof (evn), 1,
7115 _("version need"));
7116
7117 ivn.vn_aux = BYTE_GET (evn.vn_aux);
7118 ivn.vn_next = BYTE_GET (evn.vn_next);
7119
7120 vna_off = offset + ivn.vn_aux;
7121
7122 do
7123 {
7124 Elf_External_Vernaux evna;
7125
7126 get_data (&evna, file, vna_off,
7127 sizeof (evna), 1,
7128 _("version need aux (3)"));
7129
7130 ivna.vna_other = BYTE_GET (evna.vna_other);
7131 ivna.vna_next = BYTE_GET (evna.vna_next);
7132 ivna.vna_name = BYTE_GET (evna.vna_name);
7133
7134 vna_off += ivna.vna_next;
7135 }
7136 while (ivna.vna_other != vers_data
7137 && ivna.vna_next != 0);
7138
7139 if (ivna.vna_other == vers_data)
7140 break;
7141
7142 offset += ivn.vn_next;
7143 }
7144 while (ivn.vn_next != 0);
7145
7146 if (ivna.vna_other == vers_data)
7147 {
7148 printf ("@%s (%d)",
7149 ivna.vna_name < strtab_size
7150 ? strtab + ivna.vna_name : "<corrupt>",
7151 ivna.vna_other);
7152 check_def = 0;
7153 }
7154 else if (! is_nobits)
7155 error (_("bad dynamic symbol"));
7156 else
7157 check_def = 1;
7158 }
7159
7160 if (check_def)
7161 {
7162 if (vers_data != 0x8001
7163 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7164 {
7165 Elf_Internal_Verdef ivd;
7166 Elf_Internal_Verdaux ivda;
7167 Elf_External_Verdaux evda;
7168 unsigned long offset;
7169
7170 offset = offset_from_vma
7171 (file,
7172 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7173 sizeof (Elf_External_Verdef));
7174
7175 do
7176 {
7177 Elf_External_Verdef evd;
7178
7179 get_data (&evd, file, offset, sizeof (evd),
7180 1, _("version def"));
7181
7182 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7183 ivd.vd_aux = BYTE_GET (evd.vd_aux);
7184 ivd.vd_next = BYTE_GET (evd.vd_next);
7185
7186 offset += ivd.vd_next;
7187 }
7188 while (ivd.vd_ndx != (vers_data & 0x7fff)
7189 && ivd.vd_next != 0);
7190
7191 offset -= ivd.vd_next;
7192 offset += ivd.vd_aux;
7193
7194 get_data (&evda, file, offset, sizeof (evda),
7195 1, _("version def aux"));
7196
7197 ivda.vda_name = BYTE_GET (evda.vda_name);
7198
7199 if (psym->st_name != ivda.vda_name)
7200 printf ((vers_data & 0x8000)
7201 ? "@%s" : "@@%s",
7202 ivda.vda_name < strtab_size
7203 ? strtab + ivda.vda_name : "<corrupt>");
7204 }
7205 }
7206 }
7207 }
7208
7209 putchar ('\n');
7210 }
7211
7212 free (symtab);
7213 if (strtab != string_table)
7214 free (strtab);
7215 }
7216 }
7217 else if (do_syms)
7218 printf
7219 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7220
7221 if (do_histogram && buckets != NULL)
7222 {
7223 unsigned long *lengths;
7224 unsigned long *counts;
7225 unsigned long hn;
7226 bfd_vma si;
7227 unsigned long maxlength = 0;
7228 unsigned long nzero_counts = 0;
7229 unsigned long nsyms = 0;
7230
7231 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7232 (unsigned long) nbuckets);
7233 printf (_(" Length Number %% of total Coverage\n"));
7234
7235 lengths = calloc (nbuckets, sizeof (*lengths));
7236 if (lengths == NULL)
7237 {
7238 error (_("Out of memory"));
7239 return 0;
7240 }
7241 for (hn = 0; hn < nbuckets; ++hn)
7242 {
7243 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
7244 {
7245 ++nsyms;
7246 if (maxlength < ++lengths[hn])
7247 ++maxlength;
7248 }
7249 }
7250
7251 counts = calloc (maxlength + 1, sizeof (*counts));
7252 if (counts == NULL)
7253 {
7254 error (_("Out of memory"));
7255 return 0;
7256 }
7257
7258 for (hn = 0; hn < nbuckets; ++hn)
7259 ++counts[lengths[hn]];
7260
7261 if (nbuckets > 0)
7262 {
7263 unsigned long i;
7264 printf (" 0 %-10lu (%5.1f%%)\n",
7265 counts[0], (counts[0] * 100.0) / nbuckets);
7266 for (i = 1; i <= maxlength; ++i)
7267 {
7268 nzero_counts += counts[i] * i;
7269 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7270 i, counts[i], (counts[i] * 100.0) / nbuckets,
7271 (nzero_counts * 100.0) / nsyms);
7272 }
7273 }
7274
7275 free (counts);
7276 free (lengths);
7277 }
7278
7279 if (buckets != NULL)
7280 {
7281 free (buckets);
7282 free (chains);
7283 }
7284
7285 return 1;
7286 }
7287
7288 static int
7289 process_syminfo (FILE *file ATTRIBUTE_UNUSED)
7290 {
7291 unsigned int i;
7292
7293 if (dynamic_syminfo == NULL
7294 || !do_dynamic)
7295 /* No syminfo, this is ok. */
7296 return 1;
7297
7298 /* There better should be a dynamic symbol section. */
7299 if (dynamic_symbols == NULL || dynamic_strings == NULL)
7300 return 0;
7301
7302 if (dynamic_addr)
7303 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7304 dynamic_syminfo_offset, dynamic_syminfo_nent);
7305
7306 printf (_(" Num: Name BoundTo Flags\n"));
7307 for (i = 0; i < dynamic_syminfo_nent; ++i)
7308 {
7309 unsigned short int flags = dynamic_syminfo[i].si_flags;
7310
7311 printf ("%4d: ", i);
7312 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
7313 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
7314 else
7315 printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
7316 putchar (' ');
7317
7318 switch (dynamic_syminfo[i].si_boundto)
7319 {
7320 case SYMINFO_BT_SELF:
7321 fputs ("SELF ", stdout);
7322 break;
7323 case SYMINFO_BT_PARENT:
7324 fputs ("PARENT ", stdout);
7325 break;
7326 default:
7327 if (dynamic_syminfo[i].si_boundto > 0
7328 && dynamic_syminfo[i].si_boundto < dynamic_nent
7329 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
7330 {
7331 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
7332 putchar (' ' );
7333 }
7334 else
7335 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
7336 break;
7337 }
7338
7339 if (flags & SYMINFO_FLG_DIRECT)
7340 printf (" DIRECT");
7341 if (flags & SYMINFO_FLG_PASSTHRU)
7342 printf (" PASSTHRU");
7343 if (flags & SYMINFO_FLG_COPY)
7344 printf (" COPY");
7345 if (flags & SYMINFO_FLG_LAZYLOAD)
7346 printf (" LAZYLOAD");
7347
7348 puts ("");
7349 }
7350
7351 return 1;
7352 }
7353
7354 #ifdef SUPPORT_DISASSEMBLY
7355 static int
7356 disassemble_section (Elf_Internal_Shdr *section, FILE *file)
7357 {
7358 printf (_("\nAssembly dump of section %s\n"),
7359 SECTION_NAME (section));
7360
7361 /* XXX -- to be done --- XXX */
7362
7363 return 1;
7364 }
7365 #endif
7366
7367 static int
7368 dump_section (Elf_Internal_Shdr *section, FILE *file)
7369 {
7370 bfd_size_type bytes;
7371 bfd_vma addr;
7372 unsigned char *data;
7373 unsigned char *start;
7374
7375 bytes = section->sh_size;
7376
7377 if (bytes == 0 || section->sh_type == SHT_NOBITS)
7378 {
7379 printf (_("\nSection '%s' has no data to dump.\n"),
7380 SECTION_NAME (section));
7381 return 0;
7382 }
7383 else
7384 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
7385
7386 addr = section->sh_addr;
7387
7388 start = get_data (NULL, file, section->sh_offset, 1, bytes,
7389 _("section data"));
7390 if (!start)
7391 return 0;
7392
7393 data = start;
7394
7395 while (bytes)
7396 {
7397 int j;
7398 int k;
7399 int lbytes;
7400
7401 lbytes = (bytes > 16 ? 16 : bytes);
7402
7403 printf (" 0x%8.8lx ", (unsigned long) addr);
7404
7405 switch (elf_header.e_ident[EI_DATA])
7406 {
7407 default:
7408 case ELFDATA2LSB:
7409 for (j = 15; j >= 0; j --)
7410 {
7411 if (j < lbytes)
7412 printf ("%2.2x", data[j]);
7413 else
7414 printf (" ");
7415
7416 if (!(j & 0x3))
7417 printf (" ");
7418 }
7419 break;
7420
7421 case ELFDATA2MSB:
7422 for (j = 0; j < 16; j++)
7423 {
7424 if (j < lbytes)
7425 printf ("%2.2x", data[j]);
7426 else
7427 printf (" ");
7428
7429 if ((j & 3) == 3)
7430 printf (" ");
7431 }
7432 break;
7433 }
7434
7435 for (j = 0; j < lbytes; j++)
7436 {
7437 k = data[j];
7438 if (k >= ' ' && k < 0x7f)
7439 printf ("%c", k);
7440 else
7441 printf (".");
7442 }
7443
7444 putchar ('\n');
7445
7446 data += lbytes;
7447 addr += lbytes;
7448 bytes -= lbytes;
7449 }
7450
7451 free (start);
7452
7453 return 1;
7454 }
7455
7456 /* Apply addends of RELA relocations. */
7457
7458 static int
7459 debug_apply_rela_addends (void *file,
7460 Elf_Internal_Shdr *section,
7461 unsigned char *start)
7462 {
7463 Elf_Internal_Shdr *relsec;
7464 unsigned char *end = start + section->sh_size;
7465 /* FIXME: The relocation field size is relocation type dependent. */
7466 unsigned int reloc_size = 4;
7467
7468 if (!is_relocatable)
7469 return 1;
7470
7471 if (section->sh_size < reloc_size)
7472 return 1;
7473
7474 for (relsec = section_headers;
7475 relsec < section_headers + elf_header.e_shnum;
7476 ++relsec)
7477 {
7478 unsigned long nrelas;
7479 Elf_Internal_Rela *rela, *rp;
7480 Elf_Internal_Shdr *symsec;
7481 Elf_Internal_Sym *symtab;
7482 Elf_Internal_Sym *sym;
7483
7484 if (relsec->sh_type != SHT_RELA
7485 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
7486 || SECTION_HEADER (relsec->sh_info) != section
7487 || relsec->sh_size == 0
7488 || SECTION_HEADER_INDEX (relsec->sh_link) >= elf_header.e_shnum)
7489 continue;
7490
7491 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7492 &rela, &nrelas))
7493 return 0;
7494
7495 symsec = SECTION_HEADER (relsec->sh_link);
7496 symtab = GET_ELF_SYMBOLS (file, symsec);
7497
7498 for (rp = rela; rp < rela + nrelas; ++rp)
7499 {
7500 unsigned char *loc;
7501
7502 loc = start + rp->r_offset;
7503 if ((loc + reloc_size) > end)
7504 {
7505 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
7506 (unsigned long) rp->r_offset,
7507 SECTION_NAME (section));
7508 continue;
7509 }
7510
7511 if (is_32bit_elf)
7512 {
7513 sym = symtab + ELF32_R_SYM (rp->r_info);
7514
7515 if (ELF32_R_SYM (rp->r_info) != 0
7516 && ELF32_ST_TYPE (sym->st_info) != STT_SECTION
7517 /* Relocations against object symbols can happen,
7518 eg when referencing a global array. For an
7519 example of this see the _clz.o binary in libgcc.a. */
7520 && ELF32_ST_TYPE (sym->st_info) != STT_OBJECT)
7521 {
7522 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7523 get_symbol_type (ELF32_ST_TYPE (sym->st_info)),
7524 SECTION_NAME (section));
7525 continue;
7526 }
7527 }
7528 else
7529 {
7530 /* In MIPS little-endian objects, r_info isn't really a
7531 64-bit little-endian value: it has a 32-bit little-endian
7532 symbol index followed by four individual byte fields.
7533 Reorder INFO accordingly. */
7534 if (elf_header.e_machine == EM_MIPS
7535 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
7536 rp->r_info = (((rp->r_info & 0xffffffff) << 32)
7537 | ((rp->r_info >> 56) & 0xff)
7538 | ((rp->r_info >> 40) & 0xff00)
7539 | ((rp->r_info >> 24) & 0xff0000)
7540 | ((rp->r_info >> 8) & 0xff000000));
7541
7542 sym = symtab + ELF64_R_SYM (rp->r_info);
7543
7544 if (ELF64_R_SYM (rp->r_info) != 0
7545 && ELF64_ST_TYPE (sym->st_info) != STT_SECTION
7546 && ELF64_ST_TYPE (sym->st_info) != STT_OBJECT)
7547 {
7548 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7549 get_symbol_type (ELF64_ST_TYPE (sym->st_info)),
7550 SECTION_NAME (section));
7551 continue;
7552 }
7553 }
7554
7555 byte_put (loc, rp->r_addend, reloc_size);
7556 }
7557
7558 free (symtab);
7559 free (rela);
7560 break;
7561 }
7562 return 1;
7563 }
7564
7565 int
7566 load_debug_section (enum dwarf_section_display_enum debug, void *file)
7567 {
7568 struct dwarf_section *section = &debug_displays [debug].section;
7569 Elf_Internal_Shdr *sec;
7570 char buf [64];
7571
7572 /* If it is already loaded, do nothing. */
7573 if (section->start != NULL)
7574 return 1;
7575
7576 /* Locate the debug section. */
7577 sec = find_section (section->name);
7578 if (sec == NULL)
7579 return 0;
7580
7581 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
7582 section->address = sec->sh_addr;
7583 section->size = sec->sh_size;
7584 section->start = get_data (NULL, file, sec->sh_offset, 1,
7585 sec->sh_size, buf);
7586
7587 if (debug_displays [debug].relocate)
7588 debug_apply_rela_addends (file, sec, section->start);
7589
7590 return section->start != NULL;
7591 }
7592
7593 void
7594 free_debug_section (enum dwarf_section_display_enum debug)
7595 {
7596 struct dwarf_section *section = &debug_displays [debug].section;
7597
7598 if (section->start == NULL)
7599 return;
7600
7601 free ((char *) section->start);
7602 section->start = NULL;
7603 section->address = 0;
7604 section->size = 0;
7605 }
7606
7607 static int
7608 display_debug_section (Elf_Internal_Shdr *section, FILE *file)
7609 {
7610 char *name = SECTION_NAME (section);
7611 bfd_size_type length;
7612 int result = 1;
7613 enum dwarf_section_display_enum i;
7614
7615 length = section->sh_size;
7616 if (length == 0)
7617 {
7618 printf (_("\nSection '%s' has no debugging data.\n"), name);
7619 return 0;
7620 }
7621
7622 if (strneq (name, ".gnu.linkonce.wi.", 17))
7623 name = ".debug_info";
7624
7625 /* See if we know how to display the contents of this section. */
7626 for (i = 0; i < max; i++)
7627 if (streq (debug_displays[i].section.name, name))
7628 {
7629 struct dwarf_section *sec = &debug_displays [i].section;
7630
7631 if (load_debug_section (i, file))
7632 {
7633 result &= debug_displays[i].display (sec, file);
7634
7635 if (i != info && i != abbrev)
7636 free_debug_section (i);
7637 }
7638
7639 break;
7640 }
7641
7642 if (i == max)
7643 {
7644 printf (_("Unrecognized debug section: %s\n"), name);
7645 result = 0;
7646 }
7647
7648 return result;
7649 }
7650
7651 /* Set DUMP_SECTS for all sections where dumps were requested
7652 based on section name. */
7653
7654 static void
7655 initialise_dumps_byname (void)
7656 {
7657 struct dump_list_entry *cur;
7658
7659 for (cur = dump_sects_byname; cur; cur = cur->next)
7660 {
7661 unsigned int i;
7662 int any;
7663
7664 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
7665 if (streq (SECTION_NAME (section_headers + i), cur->name))
7666 {
7667 request_dump (i, cur->type);
7668 any = 1;
7669 }
7670
7671 if (!any)
7672 warn (_("Section '%s' was not dumped because it does not exist!\n"),
7673 cur->name);
7674 }
7675 }
7676
7677 static void
7678 process_section_contents (FILE *file)
7679 {
7680 Elf_Internal_Shdr *section;
7681 unsigned int i;
7682
7683 if (! do_dump)
7684 return;
7685
7686 initialise_dumps_byname ();
7687
7688 for (i = 0, section = section_headers;
7689 i < elf_header.e_shnum && i < num_dump_sects;
7690 i++, section++)
7691 {
7692 #ifdef SUPPORT_DISASSEMBLY
7693 if (dump_sects[i] & DISASS_DUMP)
7694 disassemble_section (section, file);
7695 #endif
7696 if (dump_sects[i] & HEX_DUMP)
7697 dump_section (section, file);
7698
7699 if (dump_sects[i] & DEBUG_DUMP)
7700 display_debug_section (section, file);
7701 }
7702
7703 /* Check to see if the user requested a
7704 dump of a section that does not exist. */
7705 while (i++ < num_dump_sects)
7706 if (dump_sects[i])
7707 warn (_("Section %d was not dumped because it does not exist!\n"), i);
7708 }
7709
7710 static void
7711 process_mips_fpe_exception (int mask)
7712 {
7713 if (mask)
7714 {
7715 int first = 1;
7716 if (mask & OEX_FPU_INEX)
7717 fputs ("INEX", stdout), first = 0;
7718 if (mask & OEX_FPU_UFLO)
7719 printf ("%sUFLO", first ? "" : "|"), first = 0;
7720 if (mask & OEX_FPU_OFLO)
7721 printf ("%sOFLO", first ? "" : "|"), first = 0;
7722 if (mask & OEX_FPU_DIV0)
7723 printf ("%sDIV0", first ? "" : "|"), first = 0;
7724 if (mask & OEX_FPU_INVAL)
7725 printf ("%sINVAL", first ? "" : "|");
7726 }
7727 else
7728 fputs ("0", stdout);
7729 }
7730
7731 /* ARM EABI attributes section. */
7732 typedef struct
7733 {
7734 int tag;
7735 const char *name;
7736 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
7737 int type;
7738 const char **table;
7739 } arm_attr_public_tag;
7740
7741 static const char *arm_attr_tag_CPU_arch[] =
7742 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
7743 "v6K", "v7"};
7744 static const char *arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
7745 static const char *arm_attr_tag_THUMB_ISA_use[] =
7746 {"No", "Thumb-1", "Thumb-2"};
7747 /* FIXME: VFPv3 encoding was extrapolated! */
7748 static const char *arm_attr_tag_VFP_arch[] = {"No", "VFPv1", "VFPv2", "VFPv3"};
7749 static const char *arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1"};
7750 static const char *arm_attr_tag_NEON_arch[] = {"No", "NEONv1"};
7751 static const char *arm_attr_tag_ABI_PCS_config[] =
7752 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
7753 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
7754 static const char *arm_attr_tag_ABI_PCS_R9_use[] =
7755 {"V6", "SB", "TLS", "Unused"};
7756 static const char *arm_attr_tag_ABI_PCS_RW_data[] =
7757 {"Absolute", "PC-relative", "SB-relative", "None"};
7758 static const char *arm_attr_tag_ABI_PCS_RO_DATA[] =
7759 {"Absolute", "PC-relative", "None"};
7760 static const char *arm_attr_tag_ABI_PCS_GOT_use[] =
7761 {"None", "direct", "GOT-indirect"};
7762 static const char *arm_attr_tag_ABI_PCS_wchar_t[] =
7763 {"None", "??? 1", "2", "??? 3", "4"};
7764 static const char *arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
7765 static const char *arm_attr_tag_ABI_FP_denormal[] = {"Unused", "Needed"};
7766 static const char *arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
7767 static const char *arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
7768 static const char *arm_attr_tag_ABI_FP_number_model[] =
7769 {"Unused", "Finite", "RTABI", "IEEE 754"};
7770 static const char *arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
7771 static const char *arm_attr_tag_ABI_align8_preserved[] =
7772 {"No", "Yes, except leaf SP", "Yes"};
7773 static const char *arm_attr_tag_ABI_enum_size[] =
7774 {"Unused", "small", "int", "forced to int"};
7775 static const char *arm_attr_tag_ABI_HardFP_use[] =
7776 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
7777 static const char *arm_attr_tag_ABI_VFP_args[] =
7778 {"AAPCS", "VFP registers", "custom"};
7779 static const char *arm_attr_tag_ABI_WMMX_args[] =
7780 {"AAPCS", "WMMX registers", "custom"};
7781 static const char *arm_attr_tag_ABI_optimization_goals[] =
7782 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
7783 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
7784 static const char *arm_attr_tag_ABI_FP_optimization_goals[] =
7785 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
7786 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
7787
7788 #define LOOKUP(id, name) \
7789 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
7790 static arm_attr_public_tag arm_attr_public_tags[] =
7791 {
7792 {4, "CPU_raw_name", 1, NULL},
7793 {5, "CPU_name", 1, NULL},
7794 LOOKUP(6, CPU_arch),
7795 {7, "CPU_arch_profile", 0, NULL},
7796 LOOKUP(8, ARM_ISA_use),
7797 LOOKUP(9, THUMB_ISA_use),
7798 LOOKUP(10, VFP_arch),
7799 LOOKUP(11, WMMX_arch),
7800 LOOKUP(12, NEON_arch),
7801 LOOKUP(13, ABI_PCS_config),
7802 LOOKUP(14, ABI_PCS_R9_use),
7803 LOOKUP(15, ABI_PCS_RW_data),
7804 LOOKUP(16, ABI_PCS_RO_DATA),
7805 LOOKUP(17, ABI_PCS_GOT_use),
7806 LOOKUP(18, ABI_PCS_wchar_t),
7807 LOOKUP(19, ABI_FP_rounding),
7808 LOOKUP(20, ABI_FP_denormal),
7809 LOOKUP(21, ABI_FP_exceptions),
7810 LOOKUP(22, ABI_FP_user_exceptions),
7811 LOOKUP(23, ABI_FP_number_model),
7812 LOOKUP(24, ABI_align8_needed),
7813 LOOKUP(25, ABI_align8_preserved),
7814 LOOKUP(26, ABI_enum_size),
7815 LOOKUP(27, ABI_HardFP_use),
7816 LOOKUP(28, ABI_VFP_args),
7817 LOOKUP(29, ABI_WMMX_args),
7818 LOOKUP(30, ABI_optimization_goals),
7819 LOOKUP(31, ABI_FP_optimization_goals),
7820 {32, "compatibility", 0, NULL}
7821 };
7822 #undef LOOKUP
7823
7824 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
7825 bytes read. */
7826 static unsigned int
7827 read_uleb128 (unsigned char *p, unsigned int *plen)
7828 {
7829 unsigned char c;
7830 unsigned int val;
7831 int shift;
7832 int len;
7833
7834 val = 0;
7835 shift = 0;
7836 len = 0;
7837 do
7838 {
7839 c = *(p++);
7840 len++;
7841 val |= ((unsigned int)c & 0x7f) << shift;
7842 shift += 7;
7843 }
7844 while (c & 0x80);
7845
7846 *plen = len;
7847 return val;
7848 }
7849
7850 static unsigned char *
7851 display_arm_attribute (unsigned char *p)
7852 {
7853 int tag;
7854 unsigned int len;
7855 int val;
7856 arm_attr_public_tag *attr;
7857 unsigned i;
7858 int type;
7859
7860 tag = read_uleb128 (p, &len);
7861 p += len;
7862 attr = NULL;
7863 for (i = 0; i < ARRAY_SIZE(arm_attr_public_tags); i++)
7864 {
7865 if (arm_attr_public_tags[i].tag == tag)
7866 {
7867 attr = &arm_attr_public_tags[i];
7868 break;
7869 }
7870 }
7871
7872 if (attr)
7873 {
7874 printf (" Tag_%s: ", attr->name);
7875 switch (attr->type)
7876 {
7877 case 0:
7878 switch (tag)
7879 {
7880 case 7: /* Tag_CPU_arch_profile. */
7881 val = read_uleb128 (p, &len);
7882 p += len;
7883 switch (val)
7884 {
7885 case 0: printf ("None\n"); break;
7886 case 'A': printf ("Application\n"); break;
7887 case 'R': printf ("Realtime\n"); break;
7888 case 'M': printf ("Microcontroller\n"); break;
7889 default: printf ("??? (%d)\n", val); break;
7890 }
7891 break;
7892
7893 case 32: /* Tag_compatibility. */
7894 val = read_uleb128 (p, &len);
7895 p += len;
7896 printf ("flag = %d, vendor = %s\n", val, p);
7897 p += strlen((char *)p) + 1;
7898 break;
7899
7900 default:
7901 abort();
7902 }
7903 return p;
7904
7905 case 1:
7906 case 2:
7907 type = attr->type;
7908 break;
7909
7910 default:
7911 assert (attr->type & 0x80);
7912 val = read_uleb128 (p, &len);
7913 p += len;
7914 type = attr->type & 0x7f;
7915 if (val >= type)
7916 printf ("??? (%d)\n", val);
7917 else
7918 printf ("%s\n", attr->table[val]);
7919 return p;
7920 }
7921 }
7922 else
7923 {
7924 if (tag & 1)
7925 type = 1; /* String. */
7926 else
7927 type = 2; /* uleb128. */
7928 printf (" Tag_unknown_%d: ", tag);
7929 }
7930
7931 if (type == 1)
7932 {
7933 printf ("\"%s\"\n", p);
7934 p += strlen((char *)p) + 1;
7935 }
7936 else
7937 {
7938 val = read_uleb128 (p, &len);
7939 p += len;
7940 printf ("%d (0x%x)\n", val, val);
7941 }
7942
7943 return p;
7944 }
7945
7946 static int
7947 process_arm_specific (FILE *file)
7948 {
7949 Elf_Internal_Shdr *sect;
7950 unsigned char *contents;
7951 unsigned char *p;
7952 unsigned char *end;
7953 bfd_vma section_len;
7954 bfd_vma len;
7955 unsigned i;
7956
7957 /* Find the section header so that we get the size. */
7958 for (i = 0, sect = section_headers;
7959 i < elf_header.e_shnum;
7960 i++, sect++)
7961 {
7962 if (sect->sh_type != SHT_ARM_ATTRIBUTES)
7963 continue;
7964
7965 contents = get_data (NULL, file, sect->sh_offset, 1, sect->sh_size,
7966 _("attributes"));
7967
7968 if (!contents)
7969 continue;
7970 p = contents;
7971 if (*p == 'A')
7972 {
7973 len = sect->sh_size - 1;
7974 p++;
7975 while (len > 0)
7976 {
7977 int namelen;
7978 bfd_boolean public_section;
7979
7980 section_len = byte_get (p, 4);
7981 p += 4;
7982 if (section_len > len)
7983 {
7984 printf (_("ERROR: Bad section length (%d > %d)\n"),
7985 (int)section_len, (int)len);
7986 section_len = len;
7987 }
7988 len -= section_len;
7989 printf ("Attribute Section: %s\n", p);
7990 if (strcmp ((char *)p, "aeabi") == 0)
7991 public_section = TRUE;
7992 else
7993 public_section = FALSE;
7994 namelen = strlen ((char *)p) + 1;
7995 p += namelen;
7996 section_len -= namelen + 4;
7997 while (section_len > 0)
7998 {
7999 int tag = *(p++);
8000 int val;
8001 bfd_vma size;
8002 size = byte_get (p, 4);
8003 if (size > section_len)
8004 {
8005 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
8006 (int)size, (int)section_len);
8007 size = section_len;
8008 }
8009 section_len -= size;
8010 end = p + size - 1;
8011 p += 4;
8012 switch (tag)
8013 {
8014 case 1:
8015 printf ("File Attributes\n");
8016 break;
8017 case 2:
8018 printf ("Section Attributes:");
8019 goto do_numlist;
8020 case 3:
8021 printf ("Symbol Attributes:");
8022 do_numlist:
8023 for (;;)
8024 {
8025 unsigned int i;
8026 val = read_uleb128 (p, &i);
8027 p += i;
8028 if (val == 0)
8029 break;
8030 printf (" %d", val);
8031 }
8032 printf ("\n");
8033 break;
8034 default:
8035 printf ("Unknown tag: %d\n", tag);
8036 public_section = FALSE;
8037 break;
8038 }
8039 if (public_section)
8040 {
8041 while (p < end)
8042 p = display_arm_attribute(p);
8043 }
8044 else
8045 {
8046 /* ??? Do something sensible, like dump hex. */
8047 printf (" Unknown section contexts\n");
8048 p = end;
8049 }
8050 }
8051 }
8052 }
8053 else
8054 {
8055 printf (_("Unknown format '%c'\n"), *p);
8056 }
8057
8058 free(contents);
8059 }
8060 return 1;
8061 }
8062
8063 static int
8064 process_mips_specific (FILE *file)
8065 {
8066 Elf_Internal_Dyn *entry;
8067 size_t liblist_offset = 0;
8068 size_t liblistno = 0;
8069 size_t conflictsno = 0;
8070 size_t options_offset = 0;
8071 size_t conflicts_offset = 0;
8072
8073 /* We have a lot of special sections. Thanks SGI! */
8074 if (dynamic_section == NULL)
8075 /* No information available. */
8076 return 0;
8077
8078 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
8079 switch (entry->d_tag)
8080 {
8081 case DT_MIPS_LIBLIST:
8082 liblist_offset
8083 = offset_from_vma (file, entry->d_un.d_val,
8084 liblistno * sizeof (Elf32_External_Lib));
8085 break;
8086 case DT_MIPS_LIBLISTNO:
8087 liblistno = entry->d_un.d_val;
8088 break;
8089 case DT_MIPS_OPTIONS:
8090 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8091 break;
8092 case DT_MIPS_CONFLICT:
8093 conflicts_offset
8094 = offset_from_vma (file, entry->d_un.d_val,
8095 conflictsno * sizeof (Elf32_External_Conflict));
8096 break;
8097 case DT_MIPS_CONFLICTNO:
8098 conflictsno = entry->d_un.d_val;
8099 break;
8100 default:
8101 break;
8102 }
8103
8104 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
8105 {
8106 Elf32_External_Lib *elib;
8107 size_t cnt;
8108
8109 elib = get_data (NULL, file, liblist_offset,
8110 liblistno, sizeof (Elf32_External_Lib),
8111 _("liblist"));
8112 if (elib)
8113 {
8114 printf ("\nSection '.liblist' contains %lu entries:\n",
8115 (unsigned long) liblistno);
8116 fputs (" Library Time Stamp Checksum Version Flags\n",
8117 stdout);
8118
8119 for (cnt = 0; cnt < liblistno; ++cnt)
8120 {
8121 Elf32_Lib liblist;
8122 time_t time;
8123 char timebuf[20];
8124 struct tm *tmp;
8125
8126 liblist.l_name = BYTE_GET (elib[cnt].l_name);
8127 time = BYTE_GET (elib[cnt].l_time_stamp);
8128 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
8129 liblist.l_version = BYTE_GET (elib[cnt].l_version);
8130 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
8131
8132 tmp = gmtime (&time);
8133 snprintf (timebuf, sizeof (timebuf),
8134 "%04u-%02u-%02uT%02u:%02u:%02u",
8135 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8136 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8137
8138 printf ("%3lu: ", (unsigned long) cnt);
8139 if (VALID_DYNAMIC_NAME (liblist.l_name))
8140 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
8141 else
8142 printf ("<corrupt: %9ld>", liblist.l_name);
8143 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
8144 liblist.l_version);
8145
8146 if (liblist.l_flags == 0)
8147 puts (" NONE");
8148 else
8149 {
8150 static const struct
8151 {
8152 const char *name;
8153 int bit;
8154 }
8155 l_flags_vals[] =
8156 {
8157 { " EXACT_MATCH", LL_EXACT_MATCH },
8158 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
8159 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
8160 { " EXPORTS", LL_EXPORTS },
8161 { " DELAY_LOAD", LL_DELAY_LOAD },
8162 { " DELTA", LL_DELTA }
8163 };
8164 int flags = liblist.l_flags;
8165 size_t fcnt;
8166
8167 for (fcnt = 0;
8168 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
8169 ++fcnt)
8170 if ((flags & l_flags_vals[fcnt].bit) != 0)
8171 {
8172 fputs (l_flags_vals[fcnt].name, stdout);
8173 flags ^= l_flags_vals[fcnt].bit;
8174 }
8175 if (flags != 0)
8176 printf (" %#x", (unsigned int) flags);
8177
8178 puts ("");
8179 }
8180 }
8181
8182 free (elib);
8183 }
8184 }
8185
8186 if (options_offset != 0)
8187 {
8188 Elf_External_Options *eopt;
8189 Elf_Internal_Shdr *sect = section_headers;
8190 Elf_Internal_Options *iopt;
8191 Elf_Internal_Options *option;
8192 size_t offset;
8193 int cnt;
8194
8195 /* Find the section header so that we get the size. */
8196 while (sect->sh_type != SHT_MIPS_OPTIONS)
8197 ++sect;
8198
8199 eopt = get_data (NULL, file, options_offset, 1, sect->sh_size,
8200 _("options"));
8201 if (eopt)
8202 {
8203 iopt = cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (*iopt));
8204 if (iopt == NULL)
8205 {
8206 error (_("Out of memory"));
8207 return 0;
8208 }
8209
8210 offset = cnt = 0;
8211 option = iopt;
8212
8213 while (offset < sect->sh_size)
8214 {
8215 Elf_External_Options *eoption;
8216
8217 eoption = (Elf_External_Options *) ((char *) eopt + offset);
8218
8219 option->kind = BYTE_GET (eoption->kind);
8220 option->size = BYTE_GET (eoption->size);
8221 option->section = BYTE_GET (eoption->section);
8222 option->info = BYTE_GET (eoption->info);
8223
8224 offset += option->size;
8225
8226 ++option;
8227 ++cnt;
8228 }
8229
8230 printf (_("\nSection '%s' contains %d entries:\n"),
8231 SECTION_NAME (sect), cnt);
8232
8233 option = iopt;
8234
8235 while (cnt-- > 0)
8236 {
8237 size_t len;
8238
8239 switch (option->kind)
8240 {
8241 case ODK_NULL:
8242 /* This shouldn't happen. */
8243 printf (" NULL %d %lx", option->section, option->info);
8244 break;
8245 case ODK_REGINFO:
8246 printf (" REGINFO ");
8247 if (elf_header.e_machine == EM_MIPS)
8248 {
8249 /* 32bit form. */
8250 Elf32_External_RegInfo *ereg;
8251 Elf32_RegInfo reginfo;
8252
8253 ereg = (Elf32_External_RegInfo *) (option + 1);
8254 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
8255 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8256 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8257 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8258 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8259 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
8260
8261 printf ("GPR %08lx GP 0x%lx\n",
8262 reginfo.ri_gprmask,
8263 (unsigned long) reginfo.ri_gp_value);
8264 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8265 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8266 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8267 }
8268 else
8269 {
8270 /* 64 bit form. */
8271 Elf64_External_RegInfo *ereg;
8272 Elf64_Internal_RegInfo reginfo;
8273
8274 ereg = (Elf64_External_RegInfo *) (option + 1);
8275 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
8276 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8277 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8278 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8279 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8280 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
8281
8282 printf ("GPR %08lx GP 0x",
8283 reginfo.ri_gprmask);
8284 printf_vma (reginfo.ri_gp_value);
8285 printf ("\n");
8286
8287 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8288 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8289 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8290 }
8291 ++option;
8292 continue;
8293 case ODK_EXCEPTIONS:
8294 fputs (" EXCEPTIONS fpe_min(", stdout);
8295 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
8296 fputs (") fpe_max(", stdout);
8297 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
8298 fputs (")", stdout);
8299
8300 if (option->info & OEX_PAGE0)
8301 fputs (" PAGE0", stdout);
8302 if (option->info & OEX_SMM)
8303 fputs (" SMM", stdout);
8304 if (option->info & OEX_FPDBUG)
8305 fputs (" FPDBUG", stdout);
8306 if (option->info & OEX_DISMISS)
8307 fputs (" DISMISS", stdout);
8308 break;
8309 case ODK_PAD:
8310 fputs (" PAD ", stdout);
8311 if (option->info & OPAD_PREFIX)
8312 fputs (" PREFIX", stdout);
8313 if (option->info & OPAD_POSTFIX)
8314 fputs (" POSTFIX", stdout);
8315 if (option->info & OPAD_SYMBOL)
8316 fputs (" SYMBOL", stdout);
8317 break;
8318 case ODK_HWPATCH:
8319 fputs (" HWPATCH ", stdout);
8320 if (option->info & OHW_R4KEOP)
8321 fputs (" R4KEOP", stdout);
8322 if (option->info & OHW_R8KPFETCH)
8323 fputs (" R8KPFETCH", stdout);
8324 if (option->info & OHW_R5KEOP)
8325 fputs (" R5KEOP", stdout);
8326 if (option->info & OHW_R5KCVTL)
8327 fputs (" R5KCVTL", stdout);
8328 break;
8329 case ODK_FILL:
8330 fputs (" FILL ", stdout);
8331 /* XXX Print content of info word? */
8332 break;
8333 case ODK_TAGS:
8334 fputs (" TAGS ", stdout);
8335 /* XXX Print content of info word? */
8336 break;
8337 case ODK_HWAND:
8338 fputs (" HWAND ", stdout);
8339 if (option->info & OHWA0_R4KEOP_CHECKED)
8340 fputs (" R4KEOP_CHECKED", stdout);
8341 if (option->info & OHWA0_R4KEOP_CLEAN)
8342 fputs (" R4KEOP_CLEAN", stdout);
8343 break;
8344 case ODK_HWOR:
8345 fputs (" HWOR ", stdout);
8346 if (option->info & OHWA0_R4KEOP_CHECKED)
8347 fputs (" R4KEOP_CHECKED", stdout);
8348 if (option->info & OHWA0_R4KEOP_CLEAN)
8349 fputs (" R4KEOP_CLEAN", stdout);
8350 break;
8351 case ODK_GP_GROUP:
8352 printf (" GP_GROUP %#06lx self-contained %#06lx",
8353 option->info & OGP_GROUP,
8354 (option->info & OGP_SELF) >> 16);
8355 break;
8356 case ODK_IDENT:
8357 printf (" IDENT %#06lx self-contained %#06lx",
8358 option->info & OGP_GROUP,
8359 (option->info & OGP_SELF) >> 16);
8360 break;
8361 default:
8362 /* This shouldn't happen. */
8363 printf (" %3d ??? %d %lx",
8364 option->kind, option->section, option->info);
8365 break;
8366 }
8367
8368 len = sizeof (*eopt);
8369 while (len < option->size)
8370 if (((char *) option)[len] >= ' '
8371 && ((char *) option)[len] < 0x7f)
8372 printf ("%c", ((char *) option)[len++]);
8373 else
8374 printf ("\\%03o", ((char *) option)[len++]);
8375
8376 fputs ("\n", stdout);
8377 ++option;
8378 }
8379
8380 free (eopt);
8381 }
8382 }
8383
8384 if (conflicts_offset != 0 && conflictsno != 0)
8385 {
8386 Elf32_Conflict *iconf;
8387 size_t cnt;
8388
8389 if (dynamic_symbols == NULL)
8390 {
8391 error (_("conflict list found without a dynamic symbol table"));
8392 return 0;
8393 }
8394
8395 iconf = cmalloc (conflictsno, sizeof (*iconf));
8396 if (iconf == NULL)
8397 {
8398 error (_("Out of memory"));
8399 return 0;
8400 }
8401
8402 if (is_32bit_elf)
8403 {
8404 Elf32_External_Conflict *econf32;
8405
8406 econf32 = get_data (NULL, file, conflicts_offset,
8407 conflictsno, sizeof (*econf32), _("conflict"));
8408 if (!econf32)
8409 return 0;
8410
8411 for (cnt = 0; cnt < conflictsno; ++cnt)
8412 iconf[cnt] = BYTE_GET (econf32[cnt]);
8413
8414 free (econf32);
8415 }
8416 else
8417 {
8418 Elf64_External_Conflict *econf64;
8419
8420 econf64 = get_data (NULL, file, conflicts_offset,
8421 conflictsno, sizeof (*econf64), _("conflict"));
8422 if (!econf64)
8423 return 0;
8424
8425 for (cnt = 0; cnt < conflictsno; ++cnt)
8426 iconf[cnt] = BYTE_GET (econf64[cnt]);
8427
8428 free (econf64);
8429 }
8430
8431 printf (_("\nSection '.conflict' contains %lu entries:\n"),
8432 (unsigned long) conflictsno);
8433 puts (_(" Num: Index Value Name"));
8434
8435 for (cnt = 0; cnt < conflictsno; ++cnt)
8436 {
8437 Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
8438
8439 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
8440 print_vma (psym->st_value, FULL_HEX);
8441 putchar (' ');
8442 if (VALID_DYNAMIC_NAME (psym->st_name))
8443 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8444 else
8445 printf ("<corrupt: %14ld>", psym->st_name);
8446 putchar ('\n');
8447 }
8448
8449 free (iconf);
8450 }
8451
8452 return 1;
8453 }
8454
8455 static int
8456 process_gnu_liblist (FILE *file)
8457 {
8458 Elf_Internal_Shdr *section, *string_sec;
8459 Elf32_External_Lib *elib;
8460 char *strtab;
8461 size_t strtab_size;
8462 size_t cnt;
8463 unsigned i;
8464
8465 if (! do_arch)
8466 return 0;
8467
8468 for (i = 0, section = section_headers;
8469 i < elf_header.e_shnum;
8470 i++, section++)
8471 {
8472 switch (section->sh_type)
8473 {
8474 case SHT_GNU_LIBLIST:
8475 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum)
8476 break;
8477
8478 elib = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
8479 _("liblist"));
8480
8481 if (elib == NULL)
8482 break;
8483 string_sec = SECTION_HEADER (section->sh_link);
8484
8485 strtab = get_data (NULL, file, string_sec->sh_offset, 1,
8486 string_sec->sh_size, _("liblist string table"));
8487 strtab_size = string_sec->sh_size;
8488
8489 if (strtab == NULL
8490 || section->sh_entsize != sizeof (Elf32_External_Lib))
8491 {
8492 free (elib);
8493 break;
8494 }
8495
8496 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
8497 SECTION_NAME (section),
8498 (long) (section->sh_size / sizeof (Elf32_External_Lib)));
8499
8500 puts (" Library Time Stamp Checksum Version Flags");
8501
8502 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
8503 ++cnt)
8504 {
8505 Elf32_Lib liblist;
8506 time_t time;
8507 char timebuf[20];
8508 struct tm *tmp;
8509
8510 liblist.l_name = BYTE_GET (elib[cnt].l_name);
8511 time = BYTE_GET (elib[cnt].l_time_stamp);
8512 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
8513 liblist.l_version = BYTE_GET (elib[cnt].l_version);
8514 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
8515
8516 tmp = gmtime (&time);
8517 snprintf (timebuf, sizeof (timebuf),
8518 "%04u-%02u-%02uT%02u:%02u:%02u",
8519 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8520 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8521
8522 printf ("%3lu: ", (unsigned long) cnt);
8523 if (do_wide)
8524 printf ("%-20s", liblist.l_name < strtab_size
8525 ? strtab + liblist.l_name : "<corrupt>");
8526 else
8527 printf ("%-20.20s", liblist.l_name < strtab_size
8528 ? strtab + liblist.l_name : "<corrupt>");
8529 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
8530 liblist.l_version, liblist.l_flags);
8531 }
8532
8533 free (elib);
8534 }
8535 }
8536
8537 return 1;
8538 }
8539
8540 static const char *
8541 get_note_type (unsigned e_type)
8542 {
8543 static char buff[64];
8544
8545 if (elf_header.e_type == ET_CORE)
8546 switch (e_type)
8547 {
8548 case NT_AUXV:
8549 return _("NT_AUXV (auxiliary vector)");
8550 case NT_PRSTATUS:
8551 return _("NT_PRSTATUS (prstatus structure)");
8552 case NT_FPREGSET:
8553 return _("NT_FPREGSET (floating point registers)");
8554 case NT_PRPSINFO:
8555 return _("NT_PRPSINFO (prpsinfo structure)");
8556 case NT_TASKSTRUCT:
8557 return _("NT_TASKSTRUCT (task structure)");
8558 case NT_PRXFPREG:
8559 return _("NT_PRXFPREG (user_xfpregs structure)");
8560 case NT_PSTATUS:
8561 return _("NT_PSTATUS (pstatus structure)");
8562 case NT_FPREGS:
8563 return _("NT_FPREGS (floating point registers)");
8564 case NT_PSINFO:
8565 return _("NT_PSINFO (psinfo structure)");
8566 case NT_LWPSTATUS:
8567 return _("NT_LWPSTATUS (lwpstatus_t structure)");
8568 case NT_LWPSINFO:
8569 return _("NT_LWPSINFO (lwpsinfo_t structure)");
8570 case NT_WIN32PSTATUS:
8571 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
8572 default:
8573 break;
8574 }
8575 else
8576 switch (e_type)
8577 {
8578 case NT_VERSION:
8579 return _("NT_VERSION (version)");
8580 case NT_ARCH:
8581 return _("NT_ARCH (architecture)");
8582 default:
8583 break;
8584 }
8585
8586 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
8587 return buff;
8588 }
8589
8590 static const char *
8591 get_netbsd_elfcore_note_type (unsigned e_type)
8592 {
8593 static char buff[64];
8594
8595 if (e_type == NT_NETBSDCORE_PROCINFO)
8596 {
8597 /* NetBSD core "procinfo" structure. */
8598 return _("NetBSD procinfo structure");
8599 }
8600
8601 /* As of Jan 2002 there are no other machine-independent notes
8602 defined for NetBSD core files. If the note type is less
8603 than the start of the machine-dependent note types, we don't
8604 understand it. */
8605
8606 if (e_type < NT_NETBSDCORE_FIRSTMACH)
8607 {
8608 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
8609 return buff;
8610 }
8611
8612 switch (elf_header.e_machine)
8613 {
8614 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
8615 and PT_GETFPREGS == mach+2. */
8616
8617 case EM_OLD_ALPHA:
8618 case EM_ALPHA:
8619 case EM_SPARC:
8620 case EM_SPARC32PLUS:
8621 case EM_SPARCV9:
8622 switch (e_type)
8623 {
8624 case NT_NETBSDCORE_FIRSTMACH+0:
8625 return _("PT_GETREGS (reg structure)");
8626 case NT_NETBSDCORE_FIRSTMACH+2:
8627 return _("PT_GETFPREGS (fpreg structure)");
8628 default:
8629 break;
8630 }
8631 break;
8632
8633 /* On all other arch's, PT_GETREGS == mach+1 and
8634 PT_GETFPREGS == mach+3. */
8635 default:
8636 switch (e_type)
8637 {
8638 case NT_NETBSDCORE_FIRSTMACH+1:
8639 return _("PT_GETREGS (reg structure)");
8640 case NT_NETBSDCORE_FIRSTMACH+3:
8641 return _("PT_GETFPREGS (fpreg structure)");
8642 default:
8643 break;
8644 }
8645 }
8646
8647 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
8648 e_type - NT_NETBSDCORE_FIRSTMACH);
8649 return buff;
8650 }
8651
8652 /* Note that by the ELF standard, the name field is already null byte
8653 terminated, and namesz includes the terminating null byte.
8654 I.E. the value of namesz for the name "FSF" is 4.
8655
8656 If the value of namesz is zero, there is no name present. */
8657 static int
8658 process_note (Elf_Internal_Note *pnote)
8659 {
8660 const char *nt;
8661
8662 if (pnote->namesz == 0)
8663 /* If there is no note name, then use the default set of
8664 note type strings. */
8665 nt = get_note_type (pnote->type);
8666
8667 else if (strneq (pnote->namedata, "NetBSD-CORE", 11))
8668 /* NetBSD-specific core file notes. */
8669 nt = get_netbsd_elfcore_note_type (pnote->type);
8670
8671 else
8672 /* Don't recognize this note name; just use the default set of
8673 note type strings. */
8674 nt = get_note_type (pnote->type);
8675
8676 printf (" %s\t\t0x%08lx\t%s\n",
8677 pnote->namesz ? pnote->namedata : "(NONE)",
8678 pnote->descsz, nt);
8679 return 1;
8680 }
8681
8682
8683 static int
8684 process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length)
8685 {
8686 Elf_External_Note *pnotes;
8687 Elf_External_Note *external;
8688 int res = 1;
8689
8690 if (length <= 0)
8691 return 0;
8692
8693 pnotes = get_data (NULL, file, offset, 1, length, _("notes"));
8694 if (!pnotes)
8695 return 0;
8696
8697 external = pnotes;
8698
8699 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8700 (unsigned long) offset, (unsigned long) length);
8701 printf (_(" Owner\t\tData size\tDescription\n"));
8702
8703 while (external < (Elf_External_Note *)((char *) pnotes + length))
8704 {
8705 Elf_External_Note *next;
8706 Elf_Internal_Note inote;
8707 char *temp = NULL;
8708
8709 inote.type = BYTE_GET (external->type);
8710 inote.namesz = BYTE_GET (external->namesz);
8711 inote.namedata = external->name;
8712 inote.descsz = BYTE_GET (external->descsz);
8713 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
8714 inote.descpos = offset + (inote.descdata - (char *) pnotes);
8715
8716 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
8717
8718 if (((char *) next) > (((char *) pnotes) + length))
8719 {
8720 warn (_("corrupt note found at offset %lx into core notes\n"),
8721 (long)((char *)external - (char *)pnotes));
8722 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
8723 inote.type, inote.namesz, inote.descsz);
8724 break;
8725 }
8726
8727 external = next;
8728
8729 /* Verify that name is null terminated. It appears that at least
8730 one version of Linux (RedHat 6.0) generates corefiles that don't
8731 comply with the ELF spec by failing to include the null byte in
8732 namesz. */
8733 if (inote.namedata[inote.namesz] != '\0')
8734 {
8735 temp = malloc (inote.namesz + 1);
8736
8737 if (temp == NULL)
8738 {
8739 error (_("Out of memory\n"));
8740 res = 0;
8741 break;
8742 }
8743
8744 strncpy (temp, inote.namedata, inote.namesz);
8745 temp[inote.namesz] = 0;
8746
8747 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8748 inote.namedata = temp;
8749 }
8750
8751 res &= process_note (& inote);
8752
8753 if (temp != NULL)
8754 {
8755 free (temp);
8756 temp = NULL;
8757 }
8758 }
8759
8760 free (pnotes);
8761
8762 return res;
8763 }
8764
8765 static int
8766 process_corefile_note_segments (FILE *file)
8767 {
8768 Elf_Internal_Phdr *segment;
8769 unsigned int i;
8770 int res = 1;
8771
8772 if (! get_program_headers (file))
8773 return 0;
8774
8775 for (i = 0, segment = program_headers;
8776 i < elf_header.e_phnum;
8777 i++, segment++)
8778 {
8779 if (segment->p_type == PT_NOTE)
8780 res &= process_corefile_note_segment (file,
8781 (bfd_vma) segment->p_offset,
8782 (bfd_vma) segment->p_filesz);
8783 }
8784
8785 return res;
8786 }
8787
8788 static int
8789 process_note_sections (FILE *file)
8790 {
8791 Elf_Internal_Shdr *section;
8792 unsigned long i;
8793 int res = 1;
8794
8795 for (i = 0, section = section_headers;
8796 i < elf_header.e_shnum;
8797 i++, section++)
8798 if (section->sh_type == SHT_NOTE)
8799 res &= process_corefile_note_segment (file,
8800 (bfd_vma) section->sh_offset,
8801 (bfd_vma) section->sh_size);
8802
8803 return res;
8804 }
8805
8806 static int
8807 process_notes (FILE *file)
8808 {
8809 /* If we have not been asked to display the notes then do nothing. */
8810 if (! do_notes)
8811 return 1;
8812
8813 if (elf_header.e_type != ET_CORE)
8814 return process_note_sections (file);
8815
8816 /* No program headers means no NOTE segment. */
8817 if (elf_header.e_phnum > 0)
8818 return process_corefile_note_segments (file);
8819
8820 printf (_("No note segments present in the core file.\n"));
8821 return 1;
8822 }
8823
8824 static int
8825 process_arch_specific (FILE *file)
8826 {
8827 if (! do_arch)
8828 return 1;
8829
8830 switch (elf_header.e_machine)
8831 {
8832 case EM_ARM:
8833 return process_arm_specific (file);
8834 case EM_MIPS:
8835 case EM_MIPS_RS3_LE:
8836 return process_mips_specific (file);
8837 break;
8838 default:
8839 break;
8840 }
8841 return 1;
8842 }
8843
8844 static int
8845 get_file_header (FILE *file)
8846 {
8847 /* Read in the identity array. */
8848 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
8849 return 0;
8850
8851 /* Determine how to read the rest of the header. */
8852 switch (elf_header.e_ident[EI_DATA])
8853 {
8854 default: /* fall through */
8855 case ELFDATANONE: /* fall through */
8856 case ELFDATA2LSB:
8857 byte_get = byte_get_little_endian;
8858 byte_put = byte_put_little_endian;
8859 break;
8860 case ELFDATA2MSB:
8861 byte_get = byte_get_big_endian;
8862 byte_put = byte_put_big_endian;
8863 break;
8864 }
8865
8866 /* For now we only support 32 bit and 64 bit ELF files. */
8867 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
8868
8869 /* Read in the rest of the header. */
8870 if (is_32bit_elf)
8871 {
8872 Elf32_External_Ehdr ehdr32;
8873
8874 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
8875 return 0;
8876
8877 elf_header.e_type = BYTE_GET (ehdr32.e_type);
8878 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
8879 elf_header.e_version = BYTE_GET (ehdr32.e_version);
8880 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
8881 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
8882 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
8883 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
8884 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
8885 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
8886 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
8887 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
8888 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
8889 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
8890 }
8891 else
8892 {
8893 Elf64_External_Ehdr ehdr64;
8894
8895 /* If we have been compiled with sizeof (bfd_vma) == 4, then
8896 we will not be able to cope with the 64bit data found in
8897 64 ELF files. Detect this now and abort before we start
8898 overwriting things. */
8899 if (sizeof (bfd_vma) < 8)
8900 {
8901 error (_("This instance of readelf has been built without support for a\n\
8902 64 bit data type and so it cannot read 64 bit ELF files.\n"));
8903 return 0;
8904 }
8905
8906 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
8907 return 0;
8908
8909 elf_header.e_type = BYTE_GET (ehdr64.e_type);
8910 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
8911 elf_header.e_version = BYTE_GET (ehdr64.e_version);
8912 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
8913 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
8914 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
8915 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
8916 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
8917 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
8918 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
8919 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
8920 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
8921 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
8922 }
8923
8924 if (elf_header.e_shoff)
8925 {
8926 /* There may be some extensions in the first section header. Don't
8927 bomb if we can't read it. */
8928 if (is_32bit_elf)
8929 get_32bit_section_headers (file, 1);
8930 else
8931 get_64bit_section_headers (file, 1);
8932 }
8933
8934 is_relocatable = elf_header.e_type == ET_REL;
8935
8936 return 1;
8937 }
8938
8939 /* Process one ELF object file according to the command line options.
8940 This file may actually be stored in an archive. The file is
8941 positioned at the start of the ELF object. */
8942
8943 static int
8944 process_object (char *file_name, FILE *file)
8945 {
8946 unsigned int i;
8947
8948 if (! get_file_header (file))
8949 {
8950 error (_("%s: Failed to read file header\n"), file_name);
8951 return 1;
8952 }
8953
8954 /* Initialise per file variables. */
8955 for (i = NUM_ELEM (version_info); i--;)
8956 version_info[i] = 0;
8957
8958 for (i = NUM_ELEM (dynamic_info); i--;)
8959 dynamic_info[i] = 0;
8960
8961 /* Process the file. */
8962 if (show_name)
8963 printf (_("\nFile: %s\n"), file_name);
8964
8965 /* Initialise the dump_sects array from the cmdline_dump_sects array.
8966 Note we do this even if cmdline_dump_sects is empty because we
8967 must make sure that the dump_sets array is zeroed out before each
8968 object file is processed. */
8969 if (num_dump_sects > num_cmdline_dump_sects)
8970 memset (dump_sects, 0, num_dump_sects);
8971
8972 if (num_cmdline_dump_sects > 0)
8973 {
8974 if (num_dump_sects == 0)
8975 /* A sneaky way of allocating the dump_sects array. */
8976 request_dump (num_cmdline_dump_sects, 0);
8977
8978 assert (num_dump_sects >= num_cmdline_dump_sects);
8979 memcpy (dump_sects, cmdline_dump_sects, num_cmdline_dump_sects);
8980 }
8981
8982 if (! process_file_header ())
8983 return 1;
8984
8985 if (! process_section_headers (file))
8986 {
8987 /* Without loaded section headers we cannot process lots of
8988 things. */
8989 do_unwind = do_version = do_dump = do_arch = 0;
8990
8991 if (! do_using_dynamic)
8992 do_syms = do_reloc = 0;
8993 }
8994
8995 if (! process_section_groups (file))
8996 {
8997 /* Without loaded section groups we cannot process unwind. */
8998 do_unwind = 0;
8999 }
9000
9001 if (process_program_headers (file))
9002 process_dynamic_section (file);
9003
9004 process_relocs (file);
9005
9006 process_unwind (file);
9007
9008 process_symbol_table (file);
9009
9010 process_syminfo (file);
9011
9012 process_version_sections (file);
9013
9014 process_section_contents (file);
9015
9016 process_notes (file);
9017
9018 process_gnu_liblist (file);
9019
9020 process_arch_specific (file);
9021
9022 if (program_headers)
9023 {
9024 free (program_headers);
9025 program_headers = NULL;
9026 }
9027
9028 if (section_headers)
9029 {
9030 free (section_headers);
9031 section_headers = NULL;
9032 }
9033
9034 if (string_table)
9035 {
9036 free (string_table);
9037 string_table = NULL;
9038 string_table_length = 0;
9039 }
9040
9041 if (dynamic_strings)
9042 {
9043 free (dynamic_strings);
9044 dynamic_strings = NULL;
9045 dynamic_strings_length = 0;
9046 }
9047
9048 if (dynamic_symbols)
9049 {
9050 free (dynamic_symbols);
9051 dynamic_symbols = NULL;
9052 num_dynamic_syms = 0;
9053 }
9054
9055 if (dynamic_syminfo)
9056 {
9057 free (dynamic_syminfo);
9058 dynamic_syminfo = NULL;
9059 }
9060
9061 if (section_headers_groups)
9062 {
9063 free (section_headers_groups);
9064 section_headers_groups = NULL;
9065 }
9066
9067 if (section_groups)
9068 {
9069 struct group_list *g, *next;
9070
9071 for (i = 0; i < group_count; i++)
9072 {
9073 for (g = section_groups [i].root; g != NULL; g = next)
9074 {
9075 next = g->next;
9076 free (g);
9077 }
9078 }
9079
9080 free (section_groups);
9081 section_groups = NULL;
9082 }
9083
9084 free_debug_memory ();
9085
9086 return 0;
9087 }
9088
9089 /* Process an ELF archive. The file is positioned just after the
9090 ARMAG string. */
9091
9092 static int
9093 process_archive (char *file_name, FILE *file)
9094 {
9095 struct ar_hdr arhdr;
9096 size_t got;
9097 unsigned long size;
9098 char *longnames = NULL;
9099 unsigned long longnames_size = 0;
9100 size_t file_name_size;
9101 int ret;
9102
9103 show_name = 1;
9104
9105 got = fread (&arhdr, 1, sizeof arhdr, file);
9106 if (got != sizeof arhdr)
9107 {
9108 if (got == 0)
9109 return 0;
9110
9111 error (_("%s: failed to read archive header\n"), file_name);
9112 return 1;
9113 }
9114
9115 if (memcmp (arhdr.ar_name, "/ ", 16) == 0)
9116 {
9117 /* This is the archive symbol table. Skip it.
9118 FIXME: We should have an option to dump it. */
9119 size = strtoul (arhdr.ar_size, NULL, 10);
9120 if (fseek (file, size + (size & 1), SEEK_CUR) != 0)
9121 {
9122 error (_("%s: failed to skip archive symbol table\n"), file_name);
9123 return 1;
9124 }
9125
9126 got = fread (&arhdr, 1, sizeof arhdr, file);
9127 if (got != sizeof arhdr)
9128 {
9129 if (got == 0)
9130 return 0;
9131
9132 error (_("%s: failed to read archive header\n"), file_name);
9133 return 1;
9134 }
9135 }
9136
9137 if (memcmp (arhdr.ar_name, "// ", 16) == 0)
9138 {
9139 /* This is the archive string table holding long member
9140 names. */
9141
9142 longnames_size = strtoul (arhdr.ar_size, NULL, 10);
9143
9144 longnames = malloc (longnames_size);
9145 if (longnames == NULL)
9146 {
9147 error (_("Out of memory\n"));
9148 return 1;
9149 }
9150
9151 if (fread (longnames, longnames_size, 1, file) != 1)
9152 {
9153 free (longnames);
9154 error (_("%s: failed to read string table\n"), file_name);
9155 return 1;
9156 }
9157
9158 if ((longnames_size & 1) != 0)
9159 getc (file);
9160
9161 got = fread (&arhdr, 1, sizeof arhdr, file);
9162 if (got != sizeof arhdr)
9163 {
9164 free (longnames);
9165
9166 if (got == 0)
9167 return 0;
9168
9169 error (_("%s: failed to read archive header\n"), file_name);
9170 return 1;
9171 }
9172 }
9173
9174 file_name_size = strlen (file_name);
9175 ret = 0;
9176
9177 while (1)
9178 {
9179 char *name;
9180 char *nameend;
9181 char *namealc;
9182
9183 if (arhdr.ar_name[0] == '/')
9184 {
9185 unsigned long off;
9186
9187 off = strtoul (arhdr.ar_name + 1, NULL, 10);
9188 if (off >= longnames_size)
9189 {
9190 error (_("%s: invalid archive string table offset %lu\n"), file_name, off);
9191 ret = 1;
9192 break;
9193 }
9194
9195 name = longnames + off;
9196 nameend = memchr (name, '/', longnames_size - off);
9197 }
9198 else
9199 {
9200 name = arhdr.ar_name;
9201 nameend = memchr (name, '/', 16);
9202 }
9203
9204 if (nameend == NULL)
9205 {
9206 error (_("%s: bad archive file name\n"), file_name);
9207 ret = 1;
9208 break;
9209 }
9210
9211 namealc = malloc (file_name_size + (nameend - name) + 3);
9212 if (namealc == NULL)
9213 {
9214 error (_("Out of memory\n"));
9215 ret = 1;
9216 break;
9217 }
9218
9219 memcpy (namealc, file_name, file_name_size);
9220 namealc[file_name_size] = '(';
9221 memcpy (namealc + file_name_size + 1, name, nameend - name);
9222 namealc[file_name_size + 1 + (nameend - name)] = ')';
9223 namealc[file_name_size + 2 + (nameend - name)] = '\0';
9224
9225 archive_file_offset = ftell (file);
9226 archive_file_size = strtoul (arhdr.ar_size, NULL, 10);
9227
9228 ret |= process_object (namealc, file);
9229
9230 free (namealc);
9231
9232 if (fseek (file,
9233 (archive_file_offset
9234 + archive_file_size
9235 + (archive_file_size & 1)),
9236 SEEK_SET) != 0)
9237 {
9238 error (_("%s: failed to seek to next archive header\n"), file_name);
9239 ret = 1;
9240 break;
9241 }
9242
9243 got = fread (&arhdr, 1, sizeof arhdr, file);
9244 if (got != sizeof arhdr)
9245 {
9246 if (got == 0)
9247 break;
9248
9249 error (_("%s: failed to read archive header\n"), file_name);
9250 ret = 1;
9251 break;
9252 }
9253 }
9254
9255 if (longnames != 0)
9256 free (longnames);
9257
9258 return ret;
9259 }
9260
9261 static int
9262 process_file (char *file_name)
9263 {
9264 FILE *file;
9265 struct stat statbuf;
9266 char armag[SARMAG];
9267 int ret;
9268
9269 if (stat (file_name, &statbuf) < 0)
9270 {
9271 if (errno == ENOENT)
9272 error (_("'%s': No such file\n"), file_name);
9273 else
9274 error (_("Could not locate '%s'. System error message: %s\n"),
9275 file_name, strerror (errno));
9276 return 1;
9277 }
9278
9279 if (! S_ISREG (statbuf.st_mode))
9280 {
9281 error (_("'%s' is not an ordinary file\n"), file_name);
9282 return 1;
9283 }
9284
9285 file = fopen (file_name, "rb");
9286 if (file == NULL)
9287 {
9288 error (_("Input file '%s' is not readable.\n"), file_name);
9289 return 1;
9290 }
9291
9292 if (fread (armag, SARMAG, 1, file) != 1)
9293 {
9294 error (_("%s: Failed to read file header\n"), file_name);
9295 fclose (file);
9296 return 1;
9297 }
9298
9299 if (memcmp (armag, ARMAG, SARMAG) == 0)
9300 ret = process_archive (file_name, file);
9301 else
9302 {
9303 rewind (file);
9304 archive_file_size = archive_file_offset = 0;
9305 ret = process_object (file_name, file);
9306 }
9307
9308 fclose (file);
9309
9310 return ret;
9311 }
9312
9313 #ifdef SUPPORT_DISASSEMBLY
9314 /* Needed by the i386 disassembler. For extra credit, someone could
9315 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9316 symbols. */
9317
9318 void
9319 print_address (unsigned int addr, FILE *outfile)
9320 {
9321 fprintf (outfile,"0x%8.8x", addr);
9322 }
9323
9324 /* Needed by the i386 disassembler. */
9325 void
9326 db_task_printsym (unsigned int addr)
9327 {
9328 print_address (addr, stderr);
9329 }
9330 #endif
9331
9332 int
9333 main (int argc, char **argv)
9334 {
9335 int err;
9336
9337 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9338 setlocale (LC_MESSAGES, "");
9339 #endif
9340 #if defined (HAVE_SETLOCALE)
9341 setlocale (LC_CTYPE, "");
9342 #endif
9343 bindtextdomain (PACKAGE, LOCALEDIR);
9344 textdomain (PACKAGE);
9345
9346 expandargv (&argc, &argv);
9347
9348 parse_args (argc, argv);
9349
9350 if (num_dump_sects > 0)
9351 {
9352 /* Make a copy of the dump_sects array. */
9353 cmdline_dump_sects = malloc (num_dump_sects);
9354 if (cmdline_dump_sects == NULL)
9355 error (_("Out of memory allocating dump request table."));
9356 else
9357 {
9358 memcpy (cmdline_dump_sects, dump_sects, num_dump_sects);
9359 num_cmdline_dump_sects = num_dump_sects;
9360 }
9361 }
9362
9363 if (optind < (argc - 1))
9364 show_name = 1;
9365
9366 err = 0;
9367 while (optind < argc)
9368 err |= process_file (argv[optind++]);
9369
9370 if (dump_sects != NULL)
9371 free (dump_sects);
9372 if (cmdline_dump_sects != NULL)
9373 free (cmdline_dump_sects);
9374
9375 return err;
9376 }
git-cvsimport of binutils cvsroot