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