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