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