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