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