projects / binutils-gdb.git / blob
? search:


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