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