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