projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* elf32-ppc.c (ppc_elf_merge_obj_attributes): Add support for
[deliverable/binutils-gdb.git] / binutils / readelf.c
1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 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 /* By default, assume that the .dynamic section is the first
3534 section in the DYNAMIC segment. */
3535 dynamic_addr = segment->p_offset;
3536 dynamic_size = segment->p_filesz;
3537
3538 /* Try to locate the .dynamic section. If there is
3539 a section header table, we can easily locate it. */
3540 if (section_headers != NULL)
3541 {
3542 Elf_Internal_Shdr *sec;
3543
3544 sec = find_section (".dynamic");
3545 if (sec == NULL || sec->sh_size == 0)
3546 {
3547 error (_("no .dynamic section in the dynamic segment\n"));
3548 break;
3549 }
3550
3551 if (sec->sh_type == SHT_NOBITS)
3552 {
3553 dynamic_size = 0;
3554 break;
3555 }
3556
3557 dynamic_addr = sec->sh_offset;
3558 dynamic_size = sec->sh_size;
3559
3560 if (dynamic_addr < segment->p_offset
3561 || dynamic_addr > segment->p_offset + segment->p_filesz)
3562 warn (_("the .dynamic section is not contained"
3563 " within the dynamic segment\n"));
3564 else if (dynamic_addr > segment->p_offset)
3565 warn (_("the .dynamic section is not the first section"
3566 " in the dynamic segment.\n"));
3567 }
3568 break;
3569
3570 case PT_INTERP:
3571 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3572 SEEK_SET))
3573 error (_("Unable to find program interpreter name\n"));
3574 else
3575 {
3576 char fmt [32];
3577 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3578
3579 if (ret >= (int) sizeof (fmt) || ret < 0)
3580 error (_("Internal error: failed to create format string to display program interpreter\n"));
3581
3582 program_interpreter[0] = 0;
3583 if (fscanf (file, fmt, program_interpreter) <= 0)
3584 error (_("Unable to read program interpreter name\n"));
3585
3586 if (do_segments)
3587 printf (_("\n [Requesting program interpreter: %s]"),
3588 program_interpreter);
3589 }
3590 break;
3591 }
3592
3593 if (do_segments)
3594 putc ('\n', stdout);
3595 }
3596
3597 if (do_segments && section_headers != NULL && string_table != NULL)
3598 {
3599 printf (_("\n Section to Segment mapping:\n"));
3600 printf (_(" Segment Sections...\n"));
3601
3602 for (i = 0; i < elf_header.e_phnum; i++)
3603 {
3604 unsigned int j;
3605 Elf_Internal_Shdr *section;
3606
3607 segment = program_headers + i;
3608 section = section_headers;
3609
3610 printf (" %2.2d ", i);
3611
3612 for (j = 1; j < elf_header.e_shnum; j++, section++)
3613 {
3614 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section, segment))
3615 printf ("%s ", SECTION_NAME (section));
3616 }
3617
3618 putc ('\n',stdout);
3619 }
3620 }
3621
3622 return 1;
3623 }
3624
3625
3626 /* Find the file offset corresponding to VMA by using the program headers. */
3627
3628 static long
3629 offset_from_vma (FILE *file, bfd_vma vma, bfd_size_type size)
3630 {
3631 Elf_Internal_Phdr *seg;
3632
3633 if (! get_program_headers (file))
3634 {
3635 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3636 return (long) vma;
3637 }
3638
3639 for (seg = program_headers;
3640 seg < program_headers + elf_header.e_phnum;
3641 ++seg)
3642 {
3643 if (seg->p_type != PT_LOAD)
3644 continue;
3645
3646 if (vma >= (seg->p_vaddr & -seg->p_align)
3647 && vma + size <= seg->p_vaddr + seg->p_filesz)
3648 return vma - seg->p_vaddr + seg->p_offset;
3649 }
3650
3651 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3652 (long) vma);
3653 return (long) vma;
3654 }
3655
3656
3657 static int
3658 get_32bit_section_headers (FILE *file, unsigned int num)
3659 {
3660 Elf32_External_Shdr *shdrs;
3661 Elf_Internal_Shdr *internal;
3662 unsigned int i;
3663
3664 shdrs = get_data (NULL, file, elf_header.e_shoff,
3665 elf_header.e_shentsize, num, _("section headers"));
3666 if (!shdrs)
3667 return 0;
3668
3669 section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3670
3671 if (section_headers == NULL)
3672 {
3673 error (_("Out of memory\n"));
3674 return 0;
3675 }
3676
3677 for (i = 0, internal = section_headers;
3678 i < num;
3679 i++, internal++)
3680 {
3681 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3682 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3683 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3684 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3685 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3686 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3687 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3688 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3689 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3690 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3691 }
3692
3693 free (shdrs);
3694
3695 return 1;
3696 }
3697
3698 static int
3699 get_64bit_section_headers (FILE *file, unsigned int num)
3700 {
3701 Elf64_External_Shdr *shdrs;
3702 Elf_Internal_Shdr *internal;
3703 unsigned int i;
3704
3705 shdrs = get_data (NULL, file, elf_header.e_shoff,
3706 elf_header.e_shentsize, num, _("section headers"));
3707 if (!shdrs)
3708 return 0;
3709
3710 section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3711
3712 if (section_headers == NULL)
3713 {
3714 error (_("Out of memory\n"));
3715 return 0;
3716 }
3717
3718 for (i = 0, internal = section_headers;
3719 i < num;
3720 i++, internal++)
3721 {
3722 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3723 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3724 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3725 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3726 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3727 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3728 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3729 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3730 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3731 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3732 }
3733
3734 free (shdrs);
3735
3736 return 1;
3737 }
3738
3739 static Elf_Internal_Sym *
3740 get_32bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3741 {
3742 unsigned long number;
3743 Elf32_External_Sym *esyms;
3744 Elf_External_Sym_Shndx *shndx;
3745 Elf_Internal_Sym *isyms;
3746 Elf_Internal_Sym *psym;
3747 unsigned int j;
3748
3749 esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3750 _("symbols"));
3751 if (!esyms)
3752 return NULL;
3753
3754 shndx = NULL;
3755 if (symtab_shndx_hdr != NULL
3756 && (symtab_shndx_hdr->sh_link
3757 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3758 {
3759 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3760 1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3761 if (!shndx)
3762 {
3763 free (esyms);
3764 return NULL;
3765 }
3766 }
3767
3768 number = section->sh_size / section->sh_entsize;
3769 isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3770
3771 if (isyms == NULL)
3772 {
3773 error (_("Out of memory\n"));
3774 if (shndx)
3775 free (shndx);
3776 free (esyms);
3777 return NULL;
3778 }
3779
3780 for (j = 0, psym = isyms;
3781 j < number;
3782 j++, psym++)
3783 {
3784 psym->st_name = BYTE_GET (esyms[j].st_name);
3785 psym->st_value = BYTE_GET (esyms[j].st_value);
3786 psym->st_size = BYTE_GET (esyms[j].st_size);
3787 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3788 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3789 psym->st_shndx
3790 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3791 psym->st_info = BYTE_GET (esyms[j].st_info);
3792 psym->st_other = BYTE_GET (esyms[j].st_other);
3793 }
3794
3795 if (shndx)
3796 free (shndx);
3797 free (esyms);
3798
3799 return isyms;
3800 }
3801
3802 static Elf_Internal_Sym *
3803 get_64bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3804 {
3805 unsigned long number;
3806 Elf64_External_Sym *esyms;
3807 Elf_External_Sym_Shndx *shndx;
3808 Elf_Internal_Sym *isyms;
3809 Elf_Internal_Sym *psym;
3810 unsigned int j;
3811
3812 esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3813 _("symbols"));
3814 if (!esyms)
3815 return NULL;
3816
3817 shndx = NULL;
3818 if (symtab_shndx_hdr != NULL
3819 && (symtab_shndx_hdr->sh_link
3820 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3821 {
3822 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3823 1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3824 if (!shndx)
3825 {
3826 free (esyms);
3827 return NULL;
3828 }
3829 }
3830
3831 number = section->sh_size / section->sh_entsize;
3832 isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3833
3834 if (isyms == NULL)
3835 {
3836 error (_("Out of memory\n"));
3837 if (shndx)
3838 free (shndx);
3839 free (esyms);
3840 return NULL;
3841 }
3842
3843 for (j = 0, psym = isyms;
3844 j < number;
3845 j++, psym++)
3846 {
3847 psym->st_name = BYTE_GET (esyms[j].st_name);
3848 psym->st_info = BYTE_GET (esyms[j].st_info);
3849 psym->st_other = BYTE_GET (esyms[j].st_other);
3850 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3851 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3852 psym->st_shndx
3853 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3854 psym->st_value = BYTE_GET (esyms[j].st_value);
3855 psym->st_size = BYTE_GET (esyms[j].st_size);
3856 }
3857
3858 if (shndx)
3859 free (shndx);
3860 free (esyms);
3861
3862 return isyms;
3863 }
3864
3865 static const char *
3866 get_elf_section_flags (bfd_vma sh_flags)
3867 {
3868 static char buff[1024];
3869 char *p = buff;
3870 int field_size = is_32bit_elf ? 8 : 16;
3871 int index, size = sizeof (buff) - (field_size + 4 + 1);
3872 bfd_vma os_flags = 0;
3873 bfd_vma proc_flags = 0;
3874 bfd_vma unknown_flags = 0;
3875 const struct
3876 {
3877 const char *str;
3878 int len;
3879 }
3880 flags [] =
3881 {
3882 { "WRITE", 5 },
3883 { "ALLOC", 5 },
3884 { "EXEC", 4 },
3885 { "MERGE", 5 },
3886 { "STRINGS", 7 },
3887 { "INFO LINK", 9 },
3888 { "LINK ORDER", 10 },
3889 { "OS NONCONF", 10 },
3890 { "GROUP", 5 },
3891 { "TLS", 3 }
3892 };
3893
3894 if (do_section_details)
3895 {
3896 sprintf (buff, "[%*.*lx]: ",
3897 field_size, field_size, (unsigned long) sh_flags);
3898 p += field_size + 4;
3899 }
3900
3901 while (sh_flags)
3902 {
3903 bfd_vma flag;
3904
3905 flag = sh_flags & - sh_flags;
3906 sh_flags &= ~ flag;
3907
3908 if (do_section_details)
3909 {
3910 switch (flag)
3911 {
3912 case SHF_WRITE: index = 0; break;
3913 case SHF_ALLOC: index = 1; break;
3914 case SHF_EXECINSTR: index = 2; break;
3915 case SHF_MERGE: index = 3; break;
3916 case SHF_STRINGS: index = 4; break;
3917 case SHF_INFO_LINK: index = 5; break;
3918 case SHF_LINK_ORDER: index = 6; break;
3919 case SHF_OS_NONCONFORMING: index = 7; break;
3920 case SHF_GROUP: index = 8; break;
3921 case SHF_TLS: index = 9; break;
3922
3923 default:
3924 index = -1;
3925 break;
3926 }
3927
3928 if (index != -1)
3929 {
3930 if (p != buff + field_size + 4)
3931 {
3932 if (size < (10 + 2))
3933 abort ();
3934 size -= 2;
3935 *p++ = ',';
3936 *p++ = ' ';
3937 }
3938
3939 size -= flags [index].len;
3940 p = stpcpy (p, flags [index].str);
3941 }
3942 else if (flag & SHF_MASKOS)
3943 os_flags |= flag;
3944 else if (flag & SHF_MASKPROC)
3945 proc_flags |= flag;
3946 else
3947 unknown_flags |= flag;
3948 }
3949 else
3950 {
3951 switch (flag)
3952 {
3953 case SHF_WRITE: *p = 'W'; break;
3954 case SHF_ALLOC: *p = 'A'; break;
3955 case SHF_EXECINSTR: *p = 'X'; break;
3956 case SHF_MERGE: *p = 'M'; break;
3957 case SHF_STRINGS: *p = 'S'; break;
3958 case SHF_INFO_LINK: *p = 'I'; break;
3959 case SHF_LINK_ORDER: *p = 'L'; break;
3960 case SHF_OS_NONCONFORMING: *p = 'O'; break;
3961 case SHF_GROUP: *p = 'G'; break;
3962 case SHF_TLS: *p = 'T'; break;
3963
3964 default:
3965 if (elf_header.e_machine == EM_X86_64
3966 && flag == SHF_X86_64_LARGE)
3967 *p = 'l';
3968 else if (flag & SHF_MASKOS)
3969 {
3970 *p = 'o';
3971 sh_flags &= ~ SHF_MASKOS;
3972 }
3973 else if (flag & SHF_MASKPROC)
3974 {
3975 *p = 'p';
3976 sh_flags &= ~ SHF_MASKPROC;
3977 }
3978 else
3979 *p = 'x';
3980 break;
3981 }
3982 p++;
3983 }
3984 }
3985
3986 if (do_section_details)
3987 {
3988 if (os_flags)
3989 {
3990 size -= 5 + field_size;
3991 if (p != buff + field_size + 4)
3992 {
3993 if (size < (2 + 1))
3994 abort ();
3995 size -= 2;
3996 *p++ = ',';
3997 *p++ = ' ';
3998 }
3999 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4000 (unsigned long) os_flags);
4001 p += 5 + field_size;
4002 }
4003 if (proc_flags)
4004 {
4005 size -= 7 + field_size;
4006 if (p != buff + field_size + 4)
4007 {
4008 if (size < (2 + 1))
4009 abort ();
4010 size -= 2;
4011 *p++ = ',';
4012 *p++ = ' ';
4013 }
4014 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4015 (unsigned long) proc_flags);
4016 p += 7 + field_size;
4017 }
4018 if (unknown_flags)
4019 {
4020 size -= 10 + field_size;
4021 if (p != buff + field_size + 4)
4022 {
4023 if (size < (2 + 1))
4024 abort ();
4025 size -= 2;
4026 *p++ = ',';
4027 *p++ = ' ';
4028 }
4029 sprintf (p, "UNKNOWN (%*.*lx)", field_size, field_size,
4030 (unsigned long) unknown_flags);
4031 p += 10 + field_size;
4032 }
4033 }
4034
4035 *p = '\0';
4036 return buff;
4037 }
4038
4039 static int
4040 process_section_headers (FILE *file)
4041 {
4042 Elf_Internal_Shdr *section;
4043 unsigned int i;
4044
4045 section_headers = NULL;
4046
4047 if (elf_header.e_shnum == 0)
4048 {
4049 if (do_sections)
4050 printf (_("\nThere are no sections in this file.\n"));
4051
4052 return 1;
4053 }
4054
4055 if (do_sections && !do_header)
4056 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4057 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4058
4059 if (is_32bit_elf)
4060 {
4061 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4062 return 0;
4063 }
4064 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4065 return 0;
4066
4067 /* Read in the string table, so that we have names to display. */
4068 if (elf_header.e_shstrndx != SHN_UNDEF
4069 && SECTION_HEADER_INDEX (elf_header.e_shstrndx) < elf_header.e_shnum)
4070 {
4071 section = SECTION_HEADER (elf_header.e_shstrndx);
4072
4073 if (section->sh_size != 0)
4074 {
4075 string_table = get_data (NULL, file, section->sh_offset,
4076 1, section->sh_size, _("string table"));
4077
4078 string_table_length = string_table != NULL ? section->sh_size : 0;
4079 }
4080 }
4081
4082 /* Scan the sections for the dynamic symbol table
4083 and dynamic string table and debug sections. */
4084 dynamic_symbols = NULL;
4085 dynamic_strings = NULL;
4086 dynamic_syminfo = NULL;
4087 symtab_shndx_hdr = NULL;
4088
4089 eh_addr_size = is_32bit_elf ? 4 : 8;
4090 switch (elf_header.e_machine)
4091 {
4092 case EM_MIPS:
4093 case EM_MIPS_RS3_LE:
4094 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4095 FDE addresses. However, the ABI also has a semi-official ILP32
4096 variant for which the normal FDE address size rules apply.
4097
4098 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4099 section, where XX is the size of longs in bits. Unfortunately,
4100 earlier compilers provided no way of distinguishing ILP32 objects
4101 from LP64 objects, so if there's any doubt, we should assume that
4102 the official LP64 form is being used. */
4103 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4104 && find_section (".gcc_compiled_long32") == NULL)
4105 eh_addr_size = 8;
4106 break;
4107
4108 case EM_H8_300:
4109 case EM_H8_300H:
4110 switch (elf_header.e_flags & EF_H8_MACH)
4111 {
4112 case E_H8_MACH_H8300:
4113 case E_H8_MACH_H8300HN:
4114 case E_H8_MACH_H8300SN:
4115 case E_H8_MACH_H8300SXN:
4116 eh_addr_size = 2;
4117 break;
4118 case E_H8_MACH_H8300H:
4119 case E_H8_MACH_H8300S:
4120 case E_H8_MACH_H8300SX:
4121 eh_addr_size = 4;
4122 break;
4123 }
4124 }
4125
4126 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4127 do \
4128 { \
4129 size_t expected_entsize \
4130 = is_32bit_elf ? size32 : size64; \
4131 if (section->sh_entsize != expected_entsize) \
4132 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4133 i, (unsigned long int) section->sh_entsize, \
4134 (unsigned long int) expected_entsize); \
4135 section->sh_entsize = expected_entsize; \
4136 } \
4137 while (0)
4138 #define CHECK_ENTSIZE(section, i, type) \
4139 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4140 sizeof (Elf64_External_##type))
4141
4142 for (i = 0, section = section_headers;
4143 i < elf_header.e_shnum;
4144 i++, section++)
4145 {
4146 char *name = SECTION_NAME (section);
4147
4148 if (section->sh_type == SHT_DYNSYM)
4149 {
4150 if (dynamic_symbols != NULL)
4151 {
4152 error (_("File contains multiple dynamic symbol tables\n"));
4153 continue;
4154 }
4155
4156 CHECK_ENTSIZE (section, i, Sym);
4157 num_dynamic_syms = section->sh_size / section->sh_entsize;
4158 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4159 }
4160 else if (section->sh_type == SHT_STRTAB
4161 && streq (name, ".dynstr"))
4162 {
4163 if (dynamic_strings != NULL)
4164 {
4165 error (_("File contains multiple dynamic string tables\n"));
4166 continue;
4167 }
4168
4169 dynamic_strings = get_data (NULL, file, section->sh_offset,
4170 1, section->sh_size, _("dynamic strings"));
4171 dynamic_strings_length = section->sh_size;
4172 }
4173 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4174 {
4175 if (symtab_shndx_hdr != NULL)
4176 {
4177 error (_("File contains multiple symtab shndx tables\n"));
4178 continue;
4179 }
4180 symtab_shndx_hdr = section;
4181 }
4182 else if (section->sh_type == SHT_SYMTAB)
4183 CHECK_ENTSIZE (section, i, Sym);
4184 else if (section->sh_type == SHT_GROUP)
4185 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4186 else if (section->sh_type == SHT_REL)
4187 CHECK_ENTSIZE (section, i, Rel);
4188 else if (section->sh_type == SHT_RELA)
4189 CHECK_ENTSIZE (section, i, Rela);
4190 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4191 || do_debug_lines || do_debug_pubnames || do_debug_aranges
4192 || do_debug_frames || do_debug_macinfo || do_debug_str
4193 || do_debug_loc || do_debug_ranges)
4194 && const_strneq (name, ".debug_"))
4195 {
4196 name += 7;
4197
4198 if (do_debugging
4199 || (do_debug_info && streq (name, "info"))
4200 || (do_debug_abbrevs && streq (name, "abbrev"))
4201 || (do_debug_lines && streq (name, "line"))
4202 || (do_debug_pubnames && streq (name, "pubnames"))
4203 || (do_debug_aranges && streq (name, "aranges"))
4204 || (do_debug_ranges && streq (name, "ranges"))
4205 || (do_debug_frames && streq (name, "frame"))
4206 || (do_debug_macinfo && streq (name, "macinfo"))
4207 || (do_debug_str && streq (name, "str"))
4208 || (do_debug_loc && streq (name, "loc"))
4209 )
4210 request_dump_bynumber (i, DEBUG_DUMP);
4211 }
4212 /* linkonce section to be combined with .debug_info at link time. */
4213 else if ((do_debugging || do_debug_info)
4214 && const_strneq (name, ".gnu.linkonce.wi."))
4215 request_dump_bynumber (i, DEBUG_DUMP);
4216 else if (do_debug_frames && streq (name, ".eh_frame"))
4217 request_dump_bynumber (i, DEBUG_DUMP);
4218 }
4219
4220 if (! do_sections)
4221 return 1;
4222
4223 if (elf_header.e_shnum > 1)
4224 printf (_("\nSection Headers:\n"));
4225 else
4226 printf (_("\nSection Header:\n"));
4227
4228 if (is_32bit_elf)
4229 {
4230 if (do_section_details)
4231 {
4232 printf (_(" [Nr] Name\n"));
4233 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4234 }
4235 else
4236 printf
4237 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4238 }
4239 else if (do_wide)
4240 {
4241 if (do_section_details)
4242 {
4243 printf (_(" [Nr] Name\n"));
4244 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4245 }
4246 else
4247 printf
4248 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4249 }
4250 else
4251 {
4252 if (do_section_details)
4253 {
4254 printf (_(" [Nr] Name\n"));
4255 printf (_(" Type Address Offset Link\n"));
4256 printf (_(" Size EntSize Info Align\n"));
4257 }
4258 else
4259 {
4260 printf (_(" [Nr] Name Type Address Offset\n"));
4261 printf (_(" Size EntSize Flags Link Info Align\n"));
4262 }
4263 }
4264
4265 if (do_section_details)
4266 printf (_(" Flags\n"));
4267
4268 for (i = 0, section = section_headers;
4269 i < elf_header.e_shnum;
4270 i++, section++)
4271 {
4272 if (do_section_details)
4273 {
4274 printf (" [%2u] %s\n",
4275 SECTION_HEADER_NUM (i),
4276 SECTION_NAME (section));
4277 if (is_32bit_elf || do_wide)
4278 printf (" %-15.15s ",
4279 get_section_type_name (section->sh_type));
4280 }
4281 else
4282 printf (" [%2u] %-17.17s %-15.15s ",
4283 SECTION_HEADER_NUM (i),
4284 SECTION_NAME (section),
4285 get_section_type_name (section->sh_type));
4286
4287 if (is_32bit_elf)
4288 {
4289 print_vma (section->sh_addr, LONG_HEX);
4290
4291 printf ( " %6.6lx %6.6lx %2.2lx",
4292 (unsigned long) section->sh_offset,
4293 (unsigned long) section->sh_size,
4294 (unsigned long) section->sh_entsize);
4295
4296 if (do_section_details)
4297 fputs (" ", stdout);
4298 else
4299 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4300
4301 printf ("%2ld %3lu %2ld\n",
4302 (unsigned long) section->sh_link,
4303 (unsigned long) section->sh_info,
4304 (unsigned long) section->sh_addralign);
4305 }
4306 else if (do_wide)
4307 {
4308 print_vma (section->sh_addr, LONG_HEX);
4309
4310 if ((long) section->sh_offset == section->sh_offset)
4311 printf (" %6.6lx", (unsigned long) section->sh_offset);
4312 else
4313 {
4314 putchar (' ');
4315 print_vma (section->sh_offset, LONG_HEX);
4316 }
4317
4318 if ((unsigned long) section->sh_size == section->sh_size)
4319 printf (" %6.6lx", (unsigned long) section->sh_size);
4320 else
4321 {
4322 putchar (' ');
4323 print_vma (section->sh_size, LONG_HEX);
4324 }
4325
4326 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4327 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4328 else
4329 {
4330 putchar (' ');
4331 print_vma (section->sh_entsize, LONG_HEX);
4332 }
4333
4334 if (do_section_details)
4335 fputs (" ", stdout);
4336 else
4337 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4338
4339 printf ("%2ld %3lu ",
4340 (unsigned long) section->sh_link,
4341 (unsigned long) section->sh_info);
4342
4343 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4344 printf ("%2ld\n", (unsigned long) section->sh_addralign);
4345 else
4346 {
4347 print_vma (section->sh_addralign, DEC);
4348 putchar ('\n');
4349 }
4350 }
4351 else if (do_section_details)
4352 {
4353 printf (" %-15.15s ",
4354 get_section_type_name (section->sh_type));
4355 print_vma (section->sh_addr, LONG_HEX);
4356 if ((long) section->sh_offset == section->sh_offset)
4357 printf (" %16.16lx", (unsigned long) section->sh_offset);
4358 else
4359 {
4360 printf (" ");
4361 print_vma (section->sh_offset, LONG_HEX);
4362 }
4363 printf (" %ld\n ", (unsigned long) section->sh_link);
4364 print_vma (section->sh_size, LONG_HEX);
4365 putchar (' ');
4366 print_vma (section->sh_entsize, LONG_HEX);
4367
4368 printf (" %-16lu %ld\n",
4369 (unsigned long) section->sh_info,
4370 (unsigned long) section->sh_addralign);
4371 }
4372 else
4373 {
4374 putchar (' ');
4375 print_vma (section->sh_addr, LONG_HEX);
4376 if ((long) section->sh_offset == section->sh_offset)
4377 printf (" %8.8lx", (unsigned long) section->sh_offset);
4378 else
4379 {
4380 printf (" ");
4381 print_vma (section->sh_offset, LONG_HEX);
4382 }
4383 printf ("\n ");
4384 print_vma (section->sh_size, LONG_HEX);
4385 printf (" ");
4386 print_vma (section->sh_entsize, LONG_HEX);
4387
4388 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4389
4390 printf (" %2ld %3lu %ld\n",
4391 (unsigned long) section->sh_link,
4392 (unsigned long) section->sh_info,
4393 (unsigned long) section->sh_addralign);
4394 }
4395
4396 if (do_section_details)
4397 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4398 }
4399
4400 if (!do_section_details)
4401 printf (_("Key to Flags:\n\
4402 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4403 I (info), L (link order), G (group), x (unknown)\n\
4404 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4405
4406 return 1;
4407 }
4408
4409 static const char *
4410 get_group_flags (unsigned int flags)
4411 {
4412 static char buff[32];
4413 switch (flags)
4414 {
4415 case GRP_COMDAT:
4416 return "COMDAT";
4417
4418 default:
4419 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags);
4420 break;
4421 }
4422 return buff;
4423 }
4424
4425 static int
4426 process_section_groups (FILE *file)
4427 {
4428 Elf_Internal_Shdr *section;
4429 unsigned int i;
4430 struct group *group;
4431 Elf_Internal_Shdr *symtab_sec, *strtab_sec;
4432 Elf_Internal_Sym *symtab;
4433 char *strtab;
4434 size_t strtab_size;
4435
4436 /* Don't process section groups unless needed. */
4437 if (!do_unwind && !do_section_groups)
4438 return 1;
4439
4440 if (elf_header.e_shnum == 0)
4441 {
4442 if (do_section_groups)
4443 printf (_("\nThere are no sections in this file.\n"));
4444
4445 return 1;
4446 }
4447
4448 if (section_headers == NULL)
4449 {
4450 error (_("Section headers are not available!\n"));
4451 abort ();
4452 }
4453
4454 section_headers_groups = calloc (elf_header.e_shnum,
4455 sizeof (struct group *));
4456
4457 if (section_headers_groups == NULL)
4458 {
4459 error (_("Out of memory\n"));
4460 return 0;
4461 }
4462
4463 /* Scan the sections for the group section. */
4464 group_count = 0;
4465 for (i = 0, section = section_headers;
4466 i < elf_header.e_shnum;
4467 i++, section++)
4468 if (section->sh_type == SHT_GROUP)
4469 group_count++;
4470
4471 if (group_count == 0)
4472 {
4473 if (do_section_groups)
4474 printf (_("\nThere are no section groups in this file.\n"));
4475
4476 return 1;
4477 }
4478
4479 section_groups = calloc (group_count, sizeof (struct group));
4480
4481 if (section_groups == NULL)
4482 {
4483 error (_("Out of memory\n"));
4484 return 0;
4485 }
4486
4487 symtab_sec = NULL;
4488 strtab_sec = NULL;
4489 symtab = NULL;
4490 strtab = NULL;
4491 strtab_size = 0;
4492 for (i = 0, section = section_headers, group = section_groups;
4493 i < elf_header.e_shnum;
4494 i++, section++)
4495 {
4496 if (section->sh_type == SHT_GROUP)
4497 {
4498 char *name = SECTION_NAME (section);
4499 char *group_name;
4500 unsigned char *start, *indices;
4501 unsigned int entry, j, size;
4502 Elf_Internal_Shdr *sec;
4503 Elf_Internal_Sym *sym;
4504
4505 /* Get the symbol table. */
4506 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum
4507 || ((sec = SECTION_HEADER (section->sh_link))->sh_type
4508 != SHT_SYMTAB))
4509 {
4510 error (_("Bad sh_link in group section `%s'\n"), name);
4511 continue;
4512 }
4513
4514 if (symtab_sec != sec)
4515 {
4516 symtab_sec = sec;
4517 if (symtab)
4518 free (symtab);
4519 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4520 }
4521
4522 sym = symtab + section->sh_info;
4523
4524 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4525 {
4526 bfd_vma sec_index = SECTION_HEADER_INDEX (sym->st_shndx);
4527 if (sec_index == 0)
4528 {
4529 error (_("Bad sh_info in group section `%s'\n"), name);
4530 continue;
4531 }
4532
4533 group_name = SECTION_NAME (section_headers + sec_index);
4534 strtab_sec = NULL;
4535 if (strtab)
4536 free (strtab);
4537 strtab = NULL;
4538 strtab_size = 0;
4539 }
4540 else
4541 {
4542 /* Get the string table. */
4543 if (SECTION_HEADER_INDEX (symtab_sec->sh_link)
4544 >= elf_header.e_shnum)
4545 {
4546 strtab_sec = NULL;
4547 if (strtab)
4548 free (strtab);
4549 strtab = NULL;
4550 strtab_size = 0;
4551 }
4552 else if (strtab_sec
4553 != (sec = SECTION_HEADER (symtab_sec->sh_link)))
4554 {
4555 strtab_sec = sec;
4556 if (strtab)
4557 free (strtab);
4558 strtab = get_data (NULL, file, strtab_sec->sh_offset,
4559 1, strtab_sec->sh_size,
4560 _("string table"));
4561 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
4562 }
4563 group_name = sym->st_name < strtab_size
4564 ? strtab + sym->st_name : "<corrupt>";
4565 }
4566
4567 start = get_data (NULL, file, section->sh_offset,
4568 1, section->sh_size, _("section data"));
4569
4570 indices = start;
4571 size = (section->sh_size / section->sh_entsize) - 1;
4572 entry = byte_get (indices, 4);
4573 indices += 4;
4574
4575 if (do_section_groups)
4576 {
4577 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4578 get_group_flags (entry), i, name, group_name, size);
4579
4580 printf (_(" [Index] Name\n"));
4581 }
4582
4583 group->group_index = i;
4584
4585 for (j = 0; j < size; j++)
4586 {
4587 struct group_list *g;
4588
4589 entry = byte_get (indices, 4);
4590 indices += 4;
4591
4592 if (SECTION_HEADER_INDEX (entry) >= elf_header.e_shnum)
4593 {
4594 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4595 entry, i, elf_header.e_shnum - 1);
4596 continue;
4597 }
4598 else if (entry >= SHN_LORESERVE && entry <= SHN_HIRESERVE)
4599 {
4600 error (_("invalid section [%5u] in group section [%5u]\n"),
4601 entry, i);
4602 continue;
4603 }
4604
4605 if (section_headers_groups [SECTION_HEADER_INDEX (entry)]
4606 != NULL)
4607 {
4608 if (entry)
4609 {
4610 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4611 entry, i,
4612 section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index);
4613 continue;
4614 }
4615 else
4616 {
4617 /* Intel C/C++ compiler may put section 0 in a
4618 section group. We just warn it the first time
4619 and ignore it afterwards. */
4620 static int warned = 0;
4621 if (!warned)
4622 {
4623 error (_("section 0 in group section [%5u]\n"),
4624 section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index);
4625 warned++;
4626 }
4627 }
4628 }
4629
4630 section_headers_groups [SECTION_HEADER_INDEX (entry)]
4631 = group;
4632
4633 if (do_section_groups)
4634 {
4635 sec = SECTION_HEADER (entry);
4636 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
4637 }
4638
4639 g = xmalloc (sizeof (struct group_list));
4640 g->section_index = entry;
4641 g->next = group->root;
4642 group->root = g;
4643 }
4644
4645 if (start)
4646 free (start);
4647
4648 group++;
4649 }
4650 }
4651
4652 if (symtab)
4653 free (symtab);
4654 if (strtab)
4655 free (strtab);
4656 return 1;
4657 }
4658
4659 static struct
4660 {
4661 const char *name;
4662 int reloc;
4663 int size;
4664 int rela;
4665 } dynamic_relocations [] =
4666 {
4667 { "REL", DT_REL, DT_RELSZ, FALSE },
4668 { "RELA", DT_RELA, DT_RELASZ, TRUE },
4669 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
4670 };
4671
4672 /* Process the reloc section. */
4673
4674 static int
4675 process_relocs (FILE *file)
4676 {
4677 unsigned long rel_size;
4678 unsigned long rel_offset;
4679
4680
4681 if (!do_reloc)
4682 return 1;
4683
4684 if (do_using_dynamic)
4685 {
4686 int is_rela;
4687 const char *name;
4688 int has_dynamic_reloc;
4689 unsigned int i;
4690
4691 has_dynamic_reloc = 0;
4692
4693 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
4694 {
4695 is_rela = dynamic_relocations [i].rela;
4696 name = dynamic_relocations [i].name;
4697 rel_size = dynamic_info [dynamic_relocations [i].size];
4698 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
4699
4700 has_dynamic_reloc |= rel_size;
4701
4702 if (is_rela == UNKNOWN)
4703 {
4704 if (dynamic_relocations [i].reloc == DT_JMPREL)
4705 switch (dynamic_info[DT_PLTREL])
4706 {
4707 case DT_REL:
4708 is_rela = FALSE;
4709 break;
4710 case DT_RELA:
4711 is_rela = TRUE;
4712 break;
4713 }
4714 }
4715
4716 if (rel_size)
4717 {
4718 printf
4719 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4720 name, rel_offset, rel_size);
4721
4722 dump_relocations (file,
4723 offset_from_vma (file, rel_offset, rel_size),
4724 rel_size,
4725 dynamic_symbols, num_dynamic_syms,
4726 dynamic_strings, dynamic_strings_length, is_rela);
4727 }
4728 }
4729
4730 if (! has_dynamic_reloc)
4731 printf (_("\nThere are no dynamic relocations in this file.\n"));
4732 }
4733 else
4734 {
4735 Elf_Internal_Shdr *section;
4736 unsigned long i;
4737 int found = 0;
4738
4739 for (i = 0, section = section_headers;
4740 i < elf_header.e_shnum;
4741 i++, section++)
4742 {
4743 if ( section->sh_type != SHT_RELA
4744 && section->sh_type != SHT_REL)
4745 continue;
4746
4747 rel_offset = section->sh_offset;
4748 rel_size = section->sh_size;
4749
4750 if (rel_size)
4751 {
4752 Elf_Internal_Shdr *strsec;
4753 int is_rela;
4754
4755 printf (_("\nRelocation section "));
4756
4757 if (string_table == NULL)
4758 printf ("%d", section->sh_name);
4759 else
4760 printf (_("'%s'"), SECTION_NAME (section));
4761
4762 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4763 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
4764
4765 is_rela = section->sh_type == SHT_RELA;
4766
4767 if (section->sh_link
4768 && SECTION_HEADER_INDEX (section->sh_link)
4769 < elf_header.e_shnum)
4770 {
4771 Elf_Internal_Shdr *symsec;
4772 Elf_Internal_Sym *symtab;
4773 unsigned long nsyms;
4774 unsigned long strtablen = 0;
4775 char *strtab = NULL;
4776
4777 symsec = SECTION_HEADER (section->sh_link);
4778 if (symsec->sh_type != SHT_SYMTAB
4779 && symsec->sh_type != SHT_DYNSYM)
4780 continue;
4781
4782 nsyms = symsec->sh_size / symsec->sh_entsize;
4783 symtab = GET_ELF_SYMBOLS (file, symsec);
4784
4785 if (symtab == NULL)
4786 continue;
4787
4788 if (SECTION_HEADER_INDEX (symsec->sh_link)
4789 < elf_header.e_shnum)
4790 {
4791 strsec = SECTION_HEADER (symsec->sh_link);
4792
4793 strtab = get_data (NULL, file, strsec->sh_offset,
4794 1, strsec->sh_size,
4795 _("string table"));
4796 strtablen = strtab == NULL ? 0 : strsec->sh_size;
4797 }
4798
4799 dump_relocations (file, rel_offset, rel_size,
4800 symtab, nsyms, strtab, strtablen, is_rela);
4801 if (strtab)
4802 free (strtab);
4803 free (symtab);
4804 }
4805 else
4806 dump_relocations (file, rel_offset, rel_size,
4807 NULL, 0, NULL, 0, is_rela);
4808
4809 found = 1;
4810 }
4811 }
4812
4813 if (! found)
4814 printf (_("\nThere are no relocations in this file.\n"));
4815 }
4816
4817 return 1;
4818 }
4819
4820 /* Process the unwind section. */
4821
4822 #include "unwind-ia64.h"
4823
4824 /* An absolute address consists of a section and an offset. If the
4825 section is NULL, the offset itself is the address, otherwise, the
4826 address equals to LOAD_ADDRESS(section) + offset. */
4827
4828 struct absaddr
4829 {
4830 unsigned short section;
4831 bfd_vma offset;
4832 };
4833
4834 #define ABSADDR(a) \
4835 ((a).section \
4836 ? section_headers [(a).section].sh_addr + (a).offset \
4837 : (a).offset)
4838
4839 struct ia64_unw_aux_info
4840 {
4841 struct ia64_unw_table_entry
4842 {
4843 struct absaddr start;
4844 struct absaddr end;
4845 struct absaddr info;
4846 }
4847 *table; /* Unwind table. */
4848 unsigned long table_len; /* Length of unwind table. */
4849 unsigned char *info; /* Unwind info. */
4850 unsigned long info_size; /* Size of unwind info. */
4851 bfd_vma info_addr; /* starting address of unwind info. */
4852 bfd_vma seg_base; /* Starting address of segment. */
4853 Elf_Internal_Sym *symtab; /* The symbol table. */
4854 unsigned long nsyms; /* Number of symbols. */
4855 char *strtab; /* The string table. */
4856 unsigned long strtab_size; /* Size of string table. */
4857 };
4858
4859 static void
4860 find_symbol_for_address (Elf_Internal_Sym *symtab,
4861 unsigned long nsyms,
4862 const char *strtab,
4863 unsigned long strtab_size,
4864 struct absaddr addr,
4865 const char **symname,
4866 bfd_vma *offset)
4867 {
4868 bfd_vma dist = 0x100000;
4869 Elf_Internal_Sym *sym, *best = NULL;
4870 unsigned long i;
4871
4872 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4873 {
4874 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
4875 && sym->st_name != 0
4876 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
4877 && addr.offset >= sym->st_value
4878 && addr.offset - sym->st_value < dist)
4879 {
4880 best = sym;
4881 dist = addr.offset - sym->st_value;
4882 if (!dist)
4883 break;
4884 }
4885 }
4886 if (best)
4887 {
4888 *symname = (best->st_name >= strtab_size
4889 ? "<corrupt>" : strtab + best->st_name);
4890 *offset = dist;
4891 return;
4892 }
4893 *symname = NULL;
4894 *offset = addr.offset;
4895 }
4896
4897 static void
4898 dump_ia64_unwind (struct ia64_unw_aux_info *aux)
4899 {
4900 struct ia64_unw_table_entry *tp;
4901 int in_body;
4902
4903 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
4904 {
4905 bfd_vma stamp;
4906 bfd_vma offset;
4907 const unsigned char *dp;
4908 const unsigned char *head;
4909 const char *procname;
4910
4911 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
4912 aux->strtab_size, tp->start, &procname, &offset);
4913
4914 fputs ("\n<", stdout);
4915
4916 if (procname)
4917 {
4918 fputs (procname, stdout);
4919
4920 if (offset)
4921 printf ("+%lx", (unsigned long) offset);
4922 }
4923
4924 fputs (">: [", stdout);
4925 print_vma (tp->start.offset, PREFIX_HEX);
4926 fputc ('-', stdout);
4927 print_vma (tp->end.offset, PREFIX_HEX);
4928 printf ("], info at +0x%lx\n",
4929 (unsigned long) (tp->info.offset - aux->seg_base));
4930
4931 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
4932 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4933
4934 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4935 (unsigned) UNW_VER (stamp),
4936 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
4937 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
4938 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
4939 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4940
4941 if (UNW_VER (stamp) != 1)
4942 {
4943 printf ("\tUnknown version.\n");
4944 continue;
4945 }
4946
4947 in_body = 0;
4948 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4949 dp = unw_decode (dp, in_body, & in_body);
4950 }
4951 }
4952
4953 static int
4954 slurp_ia64_unwind_table (FILE *file,
4955 struct ia64_unw_aux_info *aux,
4956 Elf_Internal_Shdr *sec)
4957 {
4958 unsigned long size, nrelas, i;
4959 Elf_Internal_Phdr *seg;
4960 struct ia64_unw_table_entry *tep;
4961 Elf_Internal_Shdr *relsec;
4962 Elf_Internal_Rela *rela, *rp;
4963 unsigned char *table, *tp;
4964 Elf_Internal_Sym *sym;
4965 const char *relname;
4966
4967 /* First, find the starting address of the segment that includes
4968 this section: */
4969
4970 if (elf_header.e_phnum)
4971 {
4972 if (! get_program_headers (file))
4973 return 0;
4974
4975 for (seg = program_headers;
4976 seg < program_headers + elf_header.e_phnum;
4977 ++seg)
4978 {
4979 if (seg->p_type != PT_LOAD)
4980 continue;
4981
4982 if (sec->sh_addr >= seg->p_vaddr
4983 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
4984 {
4985 aux->seg_base = seg->p_vaddr;
4986 break;
4987 }
4988 }
4989 }
4990
4991 /* Second, build the unwind table from the contents of the unwind section: */
4992 size = sec->sh_size;
4993 table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
4994 if (!table)
4995 return 0;
4996
4997 aux->table = xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
4998 tep = aux->table;
4999 for (tp = table; tp < table + size; tp += 3 * eh_addr_size, ++tep)
5000 {
5001 tep->start.section = SHN_UNDEF;
5002 tep->end.section = SHN_UNDEF;
5003 tep->info.section = SHN_UNDEF;
5004 if (is_32bit_elf)
5005 {
5006 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5007 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5008 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
5009 }
5010 else
5011 {
5012 tep->start.offset = BYTE_GET ((unsigned char *) tp + 0);
5013 tep->end.offset = BYTE_GET ((unsigned char *) tp + 8);
5014 tep->info.offset = BYTE_GET ((unsigned char *) tp + 16);
5015 }
5016 tep->start.offset += aux->seg_base;
5017 tep->end.offset += aux->seg_base;
5018 tep->info.offset += aux->seg_base;
5019 }
5020 free (table);
5021
5022 /* Third, apply any relocations to the unwind table: */
5023
5024 for (relsec = section_headers;
5025 relsec < section_headers + elf_header.e_shnum;
5026 ++relsec)
5027 {
5028 if (relsec->sh_type != SHT_RELA
5029 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
5030 || SECTION_HEADER (relsec->sh_info) != sec)
5031 continue;
5032
5033 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5034 & rela, & nrelas))
5035 return 0;
5036
5037 for (rp = rela; rp < rela + nrelas; ++rp)
5038 {
5039 if (is_32bit_elf)
5040 {
5041 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
5042 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
5043 }
5044 else
5045 {
5046 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
5047 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
5048 }
5049
5050 if (! const_strneq (relname, "R_IA64_SEGREL"))
5051 {
5052 warn (_("Skipping unexpected relocation type %s\n"), relname);
5053 continue;
5054 }
5055
5056 i = rp->r_offset / (3 * eh_addr_size);
5057
5058 switch (rp->r_offset/eh_addr_size % 3)
5059 {
5060 case 0:
5061 aux->table[i].start.section = sym->st_shndx;
5062 aux->table[i].start.offset += rp->r_addend + sym->st_value;
5063 break;
5064 case 1:
5065 aux->table[i].end.section = sym->st_shndx;
5066 aux->table[i].end.offset += rp->r_addend + sym->st_value;
5067 break;
5068 case 2:
5069 aux->table[i].info.section = sym->st_shndx;
5070 aux->table[i].info.offset += rp->r_addend + sym->st_value;
5071 break;
5072 default:
5073 break;
5074 }
5075 }
5076
5077 free (rela);
5078 }
5079
5080 aux->table_len = size / (3 * eh_addr_size);
5081 return 1;
5082 }
5083
5084 static int
5085 ia64_process_unwind (FILE *file)
5086 {
5087 Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
5088 unsigned long i, unwcount = 0, unwstart = 0;
5089 struct ia64_unw_aux_info aux;
5090
5091 memset (& aux, 0, sizeof (aux));
5092
5093 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5094 {
5095 if (sec->sh_type == SHT_SYMTAB
5096 && SECTION_HEADER_INDEX (sec->sh_link) < elf_header.e_shnum)
5097 {
5098 aux.nsyms = sec->sh_size / sec->sh_entsize;
5099 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5100
5101 strsec = SECTION_HEADER (sec->sh_link);
5102 aux.strtab = get_data (NULL, file, strsec->sh_offset,
5103 1, strsec->sh_size, _("string table"));
5104 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5105 }
5106 else if (sec->sh_type == SHT_IA_64_UNWIND)
5107 unwcount++;
5108 }
5109
5110 if (!unwcount)
5111 printf (_("\nThere are no unwind sections in this file.\n"));
5112
5113 while (unwcount-- > 0)
5114 {
5115 char *suffix;
5116 size_t len, len2;
5117
5118 for (i = unwstart, sec = section_headers + unwstart;
5119 i < elf_header.e_shnum; ++i, ++sec)
5120 if (sec->sh_type == SHT_IA_64_UNWIND)
5121 {
5122 unwsec = sec;
5123 break;
5124 }
5125
5126 unwstart = i + 1;
5127 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5128
5129 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5130 {
5131 /* We need to find which section group it is in. */
5132 struct group_list *g = section_headers_groups [i]->root;
5133
5134 for (; g != NULL; g = g->next)
5135 {
5136 sec = SECTION_HEADER (g->section_index);
5137
5138 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5139 break;
5140 }
5141
5142 if (g == NULL)
5143 i = elf_header.e_shnum;
5144 }
5145 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5146 {
5147 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5148 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5149 suffix = SECTION_NAME (unwsec) + len;
5150 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5151 ++i, ++sec)
5152 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5153 && streq (SECTION_NAME (sec) + len2, suffix))
5154 break;
5155 }
5156 else
5157 {
5158 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5159 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5160 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5161 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5162 suffix = "";
5163 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5164 suffix = SECTION_NAME (unwsec) + len;
5165 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5166 ++i, ++sec)
5167 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5168 && streq (SECTION_NAME (sec) + len2, suffix))
5169 break;
5170 }
5171
5172 if (i == elf_header.e_shnum)
5173 {
5174 printf (_("\nCould not find unwind info section for "));
5175
5176 if (string_table == NULL)
5177 printf ("%d", unwsec->sh_name);
5178 else
5179 printf (_("'%s'"), SECTION_NAME (unwsec));
5180 }
5181 else
5182 {
5183 aux.info_size = sec->sh_size;
5184 aux.info_addr = sec->sh_addr;
5185 aux.info = get_data (NULL, file, sec->sh_offset, 1, aux.info_size,
5186 _("unwind info"));
5187
5188 printf (_("\nUnwind section "));
5189
5190 if (string_table == NULL)
5191 printf ("%d", unwsec->sh_name);
5192 else
5193 printf (_("'%s'"), SECTION_NAME (unwsec));
5194
5195 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5196 (unsigned long) unwsec->sh_offset,
5197 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5198
5199 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5200
5201 if (aux.table_len > 0)
5202 dump_ia64_unwind (& aux);
5203
5204 if (aux.table)
5205 free ((char *) aux.table);
5206 if (aux.info)
5207 free ((char *) aux.info);
5208 aux.table = NULL;
5209 aux.info = NULL;
5210 }
5211 }
5212
5213 if (aux.symtab)
5214 free (aux.symtab);
5215 if (aux.strtab)
5216 free ((char *) aux.strtab);
5217
5218 return 1;
5219 }
5220
5221 struct hppa_unw_aux_info
5222 {
5223 struct hppa_unw_table_entry
5224 {
5225 struct absaddr start;
5226 struct absaddr end;
5227 unsigned int Cannot_unwind:1; /* 0 */
5228 unsigned int Millicode:1; /* 1 */
5229 unsigned int Millicode_save_sr0:1; /* 2 */
5230 unsigned int Region_description:2; /* 3..4 */
5231 unsigned int reserved1:1; /* 5 */
5232 unsigned int Entry_SR:1; /* 6 */
5233 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5234 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5235 unsigned int Args_stored:1; /* 16 */
5236 unsigned int Variable_Frame:1; /* 17 */
5237 unsigned int Separate_Package_Body:1; /* 18 */
5238 unsigned int Frame_Extension_Millicode:1; /* 19 */
5239 unsigned int Stack_Overflow_Check:1; /* 20 */
5240 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5241 unsigned int Ada_Region:1; /* 22 */
5242 unsigned int cxx_info:1; /* 23 */
5243 unsigned int cxx_try_catch:1; /* 24 */
5244 unsigned int sched_entry_seq:1; /* 25 */
5245 unsigned int reserved2:1; /* 26 */
5246 unsigned int Save_SP:1; /* 27 */
5247 unsigned int Save_RP:1; /* 28 */
5248 unsigned int Save_MRP_in_frame:1; /* 29 */
5249 unsigned int extn_ptr_defined:1; /* 30 */
5250 unsigned int Cleanup_defined:1; /* 31 */
5251
5252 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5253 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5254 unsigned int Large_frame:1; /* 2 */
5255 unsigned int Pseudo_SP_Set:1; /* 3 */
5256 unsigned int reserved4:1; /* 4 */
5257 unsigned int Total_frame_size:27; /* 5..31 */
5258 }
5259 *table; /* Unwind table. */
5260 unsigned long table_len; /* Length of unwind table. */
5261 bfd_vma seg_base; /* Starting address of segment. */
5262 Elf_Internal_Sym *symtab; /* The symbol table. */
5263 unsigned long nsyms; /* Number of symbols. */
5264 char *strtab; /* The string table. */
5265 unsigned long strtab_size; /* Size of string table. */
5266 };
5267
5268 static void
5269 dump_hppa_unwind (struct hppa_unw_aux_info *aux)
5270 {
5271 struct hppa_unw_table_entry *tp;
5272
5273 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5274 {
5275 bfd_vma offset;
5276 const char *procname;
5277
5278 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5279 aux->strtab_size, tp->start, &procname,
5280 &offset);
5281
5282 fputs ("\n<", stdout);
5283
5284 if (procname)
5285 {
5286 fputs (procname, stdout);
5287
5288 if (offset)
5289 printf ("+%lx", (unsigned long) offset);
5290 }
5291
5292 fputs (">: [", stdout);
5293 print_vma (tp->start.offset, PREFIX_HEX);
5294 fputc ('-', stdout);
5295 print_vma (tp->end.offset, PREFIX_HEX);
5296 printf ("]\n\t");
5297
5298 #define PF(_m) if (tp->_m) printf (#_m " ");
5299 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5300 PF(Cannot_unwind);
5301 PF(Millicode);
5302 PF(Millicode_save_sr0);
5303 /* PV(Region_description); */
5304 PF(Entry_SR);
5305 PV(Entry_FR);
5306 PV(Entry_GR);
5307 PF(Args_stored);
5308 PF(Variable_Frame);
5309 PF(Separate_Package_Body);
5310 PF(Frame_Extension_Millicode);
5311 PF(Stack_Overflow_Check);
5312 PF(Two_Instruction_SP_Increment);
5313 PF(Ada_Region);
5314 PF(cxx_info);
5315 PF(cxx_try_catch);
5316 PF(sched_entry_seq);
5317 PF(Save_SP);
5318 PF(Save_RP);
5319 PF(Save_MRP_in_frame);
5320 PF(extn_ptr_defined);
5321 PF(Cleanup_defined);
5322 PF(MPE_XL_interrupt_marker);
5323 PF(HP_UX_interrupt_marker);
5324 PF(Large_frame);
5325 PF(Pseudo_SP_Set);
5326 PV(Total_frame_size);
5327 #undef PF
5328 #undef PV
5329 }
5330
5331 printf ("\n");
5332 }
5333
5334 static int
5335 slurp_hppa_unwind_table (FILE *file,
5336 struct hppa_unw_aux_info *aux,
5337 Elf_Internal_Shdr *sec)
5338 {
5339 unsigned long size, unw_ent_size, nentries, nrelas, i;
5340 Elf_Internal_Phdr *seg;
5341 struct hppa_unw_table_entry *tep;
5342 Elf_Internal_Shdr *relsec;
5343 Elf_Internal_Rela *rela, *rp;
5344 unsigned char *table, *tp;
5345 Elf_Internal_Sym *sym;
5346 const char *relname;
5347
5348 /* First, find the starting address of the segment that includes
5349 this section. */
5350
5351 if (elf_header.e_phnum)
5352 {
5353 if (! get_program_headers (file))
5354 return 0;
5355
5356 for (seg = program_headers;
5357 seg < program_headers + elf_header.e_phnum;
5358 ++seg)
5359 {
5360 if (seg->p_type != PT_LOAD)
5361 continue;
5362
5363 if (sec->sh_addr >= seg->p_vaddr
5364 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5365 {
5366 aux->seg_base = seg->p_vaddr;
5367 break;
5368 }
5369 }
5370 }
5371
5372 /* Second, build the unwind table from the contents of the unwind
5373 section. */
5374 size = sec->sh_size;
5375 table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
5376 if (!table)
5377 return 0;
5378
5379 unw_ent_size = 16;
5380 nentries = size / unw_ent_size;
5381 size = unw_ent_size * nentries;
5382
5383 tep = aux->table = xcmalloc (nentries, sizeof (aux->table[0]));
5384
5385 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
5386 {
5387 unsigned int tmp1, tmp2;
5388
5389 tep->start.section = SHN_UNDEF;
5390 tep->end.section = SHN_UNDEF;
5391
5392 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5393 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5394 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5395 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5396
5397 tep->start.offset += aux->seg_base;
5398 tep->end.offset += aux->seg_base;
5399
5400 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5401 tep->Millicode = (tmp1 >> 30) & 0x1;
5402 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5403 tep->Region_description = (tmp1 >> 27) & 0x3;
5404 tep->reserved1 = (tmp1 >> 26) & 0x1;
5405 tep->Entry_SR = (tmp1 >> 25) & 0x1;
5406 tep->Entry_FR = (tmp1 >> 21) & 0xf;
5407 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5408 tep->Args_stored = (tmp1 >> 15) & 0x1;
5409 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5410 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5411 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5412 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5413 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5414 tep->Ada_Region = (tmp1 >> 9) & 0x1;
5415 tep->cxx_info = (tmp1 >> 8) & 0x1;
5416 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5417 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5418 tep->reserved2 = (tmp1 >> 5) & 0x1;
5419 tep->Save_SP = (tmp1 >> 4) & 0x1;
5420 tep->Save_RP = (tmp1 >> 3) & 0x1;
5421 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5422 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5423 tep->Cleanup_defined = tmp1 & 0x1;
5424
5425 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5426 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5427 tep->Large_frame = (tmp2 >> 29) & 0x1;
5428 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5429 tep->reserved4 = (tmp2 >> 27) & 0x1;
5430 tep->Total_frame_size = tmp2 & 0x7ffffff;
5431 }
5432 free (table);
5433
5434 /* Third, apply any relocations to the unwind table. */
5435
5436 for (relsec = section_headers;
5437 relsec < section_headers + elf_header.e_shnum;
5438 ++relsec)
5439 {
5440 if (relsec->sh_type != SHT_RELA
5441 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
5442 || SECTION_HEADER (relsec->sh_info) != sec)
5443 continue;
5444
5445 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5446 & rela, & nrelas))
5447 return 0;
5448
5449 for (rp = rela; rp < rela + nrelas; ++rp)
5450 {
5451 if (is_32bit_elf)
5452 {
5453 relname = elf_hppa_reloc_type (ELF32_R_TYPE (rp->r_info));
5454 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
5455 }
5456 else
5457 {
5458 relname = elf_hppa_reloc_type (ELF64_R_TYPE (rp->r_info));
5459 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
5460 }
5461
5462 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5463 if (! const_strneq (relname, "R_PARISC_SEGREL"))
5464 {
5465 warn (_("Skipping unexpected relocation type %s\n"), relname);
5466 continue;
5467 }
5468
5469 i = rp->r_offset / unw_ent_size;
5470
5471 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
5472 {
5473 case 0:
5474 aux->table[i].start.section = sym->st_shndx;
5475 aux->table[i].start.offset += sym->st_value + rp->r_addend;
5476 break;
5477 case 1:
5478 aux->table[i].end.section = sym->st_shndx;
5479 aux->table[i].end.offset += sym->st_value + rp->r_addend;
5480 break;
5481 default:
5482 break;
5483 }
5484 }
5485
5486 free (rela);
5487 }
5488
5489 aux->table_len = nentries;
5490
5491 return 1;
5492 }
5493
5494 static int
5495 hppa_process_unwind (FILE *file)
5496 {
5497 struct hppa_unw_aux_info aux;
5498 Elf_Internal_Shdr *unwsec = NULL;
5499 Elf_Internal_Shdr *strsec;
5500 Elf_Internal_Shdr *sec;
5501 unsigned long i;
5502
5503 memset (& aux, 0, sizeof (aux));
5504
5505 if (string_table == NULL)
5506 return 1;
5507
5508 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5509 {
5510 if (sec->sh_type == SHT_SYMTAB
5511 && SECTION_HEADER_INDEX (sec->sh_link) < elf_header.e_shnum)
5512 {
5513 aux.nsyms = sec->sh_size / sec->sh_entsize;
5514 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5515
5516 strsec = SECTION_HEADER (sec->sh_link);
5517 aux.strtab = get_data (NULL, file, strsec->sh_offset,
5518 1, strsec->sh_size, _("string table"));
5519 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5520 }
5521 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5522 unwsec = sec;
5523 }
5524
5525 if (!unwsec)
5526 printf (_("\nThere are no unwind sections in this file.\n"));
5527
5528 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5529 {
5530 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5531 {
5532 printf (_("\nUnwind section "));
5533 printf (_("'%s'"), SECTION_NAME (sec));
5534
5535 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5536 (unsigned long) sec->sh_offset,
5537 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
5538
5539 slurp_hppa_unwind_table (file, &aux, sec);
5540 if (aux.table_len > 0)
5541 dump_hppa_unwind (&aux);
5542
5543 if (aux.table)
5544 free ((char *) aux.table);
5545 aux.table = NULL;
5546 }
5547 }
5548
5549 if (aux.symtab)
5550 free (aux.symtab);
5551 if (aux.strtab)
5552 free ((char *) aux.strtab);
5553
5554 return 1;
5555 }
5556
5557 static int
5558 process_unwind (FILE *file)
5559 {
5560 struct unwind_handler {
5561 int machtype;
5562 int (*handler)(FILE *file);
5563 } handlers[] = {
5564 { EM_IA_64, ia64_process_unwind },
5565 { EM_PARISC, hppa_process_unwind },
5566 { 0, 0 }
5567 };
5568 int i;
5569
5570 if (!do_unwind)
5571 return 1;
5572
5573 for (i = 0; handlers[i].handler != NULL; i++)
5574 if (elf_header.e_machine == handlers[i].machtype)
5575 return handlers[i].handler (file);
5576
5577 printf (_("\nThere are no unwind sections in this file.\n"));
5578 return 1;
5579 }
5580
5581 static void
5582 dynamic_section_mips_val (Elf_Internal_Dyn *entry)
5583 {
5584 switch (entry->d_tag)
5585 {
5586 case DT_MIPS_FLAGS:
5587 if (entry->d_un.d_val == 0)
5588 printf ("NONE\n");
5589 else
5590 {
5591 static const char * opts[] =
5592 {
5593 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5594 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5595 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5596 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5597 "RLD_ORDER_SAFE"
5598 };
5599 unsigned int cnt;
5600 int first = 1;
5601 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
5602 if (entry->d_un.d_val & (1 << cnt))
5603 {
5604 printf ("%s%s", first ? "" : " ", opts[cnt]);
5605 first = 0;
5606 }
5607 puts ("");
5608 }
5609 break;
5610
5611 case DT_MIPS_IVERSION:
5612 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5613 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5614 else
5615 printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
5616 break;
5617
5618 case DT_MIPS_TIME_STAMP:
5619 {
5620 char timebuf[20];
5621 struct tm *tmp;
5622
5623 time_t time = entry->d_un.d_val;
5624 tmp = gmtime (&time);
5625 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
5626 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5627 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5628 printf ("Time Stamp: %s\n", timebuf);
5629 }
5630 break;
5631
5632 case DT_MIPS_RLD_VERSION:
5633 case DT_MIPS_LOCAL_GOTNO:
5634 case DT_MIPS_CONFLICTNO:
5635 case DT_MIPS_LIBLISTNO:
5636 case DT_MIPS_SYMTABNO:
5637 case DT_MIPS_UNREFEXTNO:
5638 case DT_MIPS_HIPAGENO:
5639 case DT_MIPS_DELTA_CLASS_NO:
5640 case DT_MIPS_DELTA_INSTANCE_NO:
5641 case DT_MIPS_DELTA_RELOC_NO:
5642 case DT_MIPS_DELTA_SYM_NO:
5643 case DT_MIPS_DELTA_CLASSSYM_NO:
5644 case DT_MIPS_COMPACT_SIZE:
5645 printf ("%ld\n", (long) entry->d_un.d_ptr);
5646 break;
5647
5648 default:
5649 printf ("%#lx\n", (long) entry->d_un.d_ptr);
5650 }
5651 }
5652
5653
5654 static void
5655 dynamic_section_parisc_val (Elf_Internal_Dyn *entry)
5656 {
5657 switch (entry->d_tag)
5658 {
5659 case DT_HP_DLD_FLAGS:
5660 {
5661 static struct
5662 {
5663 long int bit;
5664 const char *str;
5665 }
5666 flags[] =
5667 {
5668 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
5669 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
5670 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
5671 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
5672 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
5673 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
5674 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
5675 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
5676 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
5677 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
5678 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
5679 { DT_HP_GST, "HP_GST" },
5680 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
5681 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
5682 { DT_HP_NODELETE, "HP_NODELETE" },
5683 { DT_HP_GROUP, "HP_GROUP" },
5684 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5685 };
5686 int first = 1;
5687 size_t cnt;
5688 bfd_vma val = entry->d_un.d_val;
5689
5690 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
5691 if (val & flags[cnt].bit)
5692 {
5693 if (! first)
5694 putchar (' ');
5695 fputs (flags[cnt].str, stdout);
5696 first = 0;
5697 val ^= flags[cnt].bit;
5698 }
5699
5700 if (val != 0 || first)
5701 {
5702 if (! first)
5703 putchar (' ');
5704 print_vma (val, HEX);
5705 }
5706 }
5707 break;
5708
5709 default:
5710 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5711 break;
5712 }
5713 putchar ('\n');
5714 }
5715
5716 static void
5717 dynamic_section_ia64_val (Elf_Internal_Dyn *entry)
5718 {
5719 switch (entry->d_tag)
5720 {
5721 case DT_IA_64_PLT_RESERVE:
5722 /* First 3 slots reserved. */
5723 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5724 printf (" -- ");
5725 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
5726 break;
5727
5728 default:
5729 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5730 break;
5731 }
5732 putchar ('\n');
5733 }
5734
5735 static int
5736 get_32bit_dynamic_section (FILE *file)
5737 {
5738 Elf32_External_Dyn *edyn, *ext;
5739 Elf_Internal_Dyn *entry;
5740
5741 edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5742 _("dynamic section"));
5743 if (!edyn)
5744 return 0;
5745
5746 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5747 might not have the luxury of section headers. Look for the DT_NULL
5748 terminator to determine the number of entries. */
5749 for (ext = edyn, dynamic_nent = 0;
5750 (char *) ext < (char *) edyn + dynamic_size;
5751 ext++)
5752 {
5753 dynamic_nent++;
5754 if (BYTE_GET (ext->d_tag) == DT_NULL)
5755 break;
5756 }
5757
5758 dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5759 if (dynamic_section == NULL)
5760 {
5761 error (_("Out of memory\n"));
5762 free (edyn);
5763 return 0;
5764 }
5765
5766 for (ext = edyn, entry = dynamic_section;
5767 entry < dynamic_section + dynamic_nent;
5768 ext++, entry++)
5769 {
5770 entry->d_tag = BYTE_GET (ext->d_tag);
5771 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5772 }
5773
5774 free (edyn);
5775
5776 return 1;
5777 }
5778
5779 static int
5780 get_64bit_dynamic_section (FILE *file)
5781 {
5782 Elf64_External_Dyn *edyn, *ext;
5783 Elf_Internal_Dyn *entry;
5784
5785 edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5786 _("dynamic section"));
5787 if (!edyn)
5788 return 0;
5789
5790 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5791 might not have the luxury of section headers. Look for the DT_NULL
5792 terminator to determine the number of entries. */
5793 for (ext = edyn, dynamic_nent = 0;
5794 (char *) ext < (char *) edyn + dynamic_size;
5795 ext++)
5796 {
5797 dynamic_nent++;
5798 if (BYTE_GET (ext->d_tag) == DT_NULL)
5799 break;
5800 }
5801
5802 dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5803 if (dynamic_section == NULL)
5804 {
5805 error (_("Out of memory\n"));
5806 free (edyn);
5807 return 0;
5808 }
5809
5810 for (ext = edyn, entry = dynamic_section;
5811 entry < dynamic_section + dynamic_nent;
5812 ext++, entry++)
5813 {
5814 entry->d_tag = BYTE_GET (ext->d_tag);
5815 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5816 }
5817
5818 free (edyn);
5819
5820 return 1;
5821 }
5822
5823 static void
5824 print_dynamic_flags (bfd_vma flags)
5825 {
5826 int first = 1;
5827
5828 while (flags)
5829 {
5830 bfd_vma flag;
5831
5832 flag = flags & - flags;
5833 flags &= ~ flag;
5834
5835 if (first)
5836 first = 0;
5837 else
5838 putc (' ', stdout);
5839
5840 switch (flag)
5841 {
5842 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
5843 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
5844 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
5845 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
5846 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
5847 default: fputs ("unknown", stdout); break;
5848 }
5849 }
5850 puts ("");
5851 }
5852
5853 /* Parse and display the contents of the dynamic section. */
5854
5855 static int
5856 process_dynamic_section (FILE *file)
5857 {
5858 Elf_Internal_Dyn *entry;
5859
5860 if (dynamic_size == 0)
5861 {
5862 if (do_dynamic)
5863 printf (_("\nThere is no dynamic section in this file.\n"));
5864
5865 return 1;
5866 }
5867
5868 if (is_32bit_elf)
5869 {
5870 if (! get_32bit_dynamic_section (file))
5871 return 0;
5872 }
5873 else if (! get_64bit_dynamic_section (file))
5874 return 0;
5875
5876 /* Find the appropriate symbol table. */
5877 if (dynamic_symbols == NULL)
5878 {
5879 for (entry = dynamic_section;
5880 entry < dynamic_section + dynamic_nent;
5881 ++entry)
5882 {
5883 Elf_Internal_Shdr section;
5884
5885 if (entry->d_tag != DT_SYMTAB)
5886 continue;
5887
5888 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
5889
5890 /* Since we do not know how big the symbol table is,
5891 we default to reading in the entire file (!) and
5892 processing that. This is overkill, I know, but it
5893 should work. */
5894 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
5895
5896 if (archive_file_offset != 0)
5897 section.sh_size = archive_file_size - section.sh_offset;
5898 else
5899 {
5900 if (fseek (file, 0, SEEK_END))
5901 error (_("Unable to seek to end of file!\n"));
5902
5903 section.sh_size = ftell (file) - section.sh_offset;
5904 }
5905
5906 if (is_32bit_elf)
5907 section.sh_entsize = sizeof (Elf32_External_Sym);
5908 else
5909 section.sh_entsize = sizeof (Elf64_External_Sym);
5910
5911 num_dynamic_syms = section.sh_size / section.sh_entsize;
5912 if (num_dynamic_syms < 1)
5913 {
5914 error (_("Unable to determine the number of symbols to load\n"));
5915 continue;
5916 }
5917
5918 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
5919 }
5920 }
5921
5922 /* Similarly find a string table. */
5923 if (dynamic_strings == NULL)
5924 {
5925 for (entry = dynamic_section;
5926 entry < dynamic_section + dynamic_nent;
5927 ++entry)
5928 {
5929 unsigned long offset;
5930 long str_tab_len;
5931
5932 if (entry->d_tag != DT_STRTAB)
5933 continue;
5934
5935 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
5936
5937 /* Since we do not know how big the string table is,
5938 we default to reading in the entire file (!) and
5939 processing that. This is overkill, I know, but it
5940 should work. */
5941
5942 offset = offset_from_vma (file, entry->d_un.d_val, 0);
5943
5944 if (archive_file_offset != 0)
5945 str_tab_len = archive_file_size - offset;
5946 else
5947 {
5948 if (fseek (file, 0, SEEK_END))
5949 error (_("Unable to seek to end of file\n"));
5950 str_tab_len = ftell (file) - offset;
5951 }
5952
5953 if (str_tab_len < 1)
5954 {
5955 error
5956 (_("Unable to determine the length of the dynamic string table\n"));
5957 continue;
5958 }
5959
5960 dynamic_strings = get_data (NULL, file, offset, 1, str_tab_len,
5961 _("dynamic string table"));
5962 dynamic_strings_length = str_tab_len;
5963 break;
5964 }
5965 }
5966
5967 /* And find the syminfo section if available. */
5968 if (dynamic_syminfo == NULL)
5969 {
5970 unsigned long syminsz = 0;
5971
5972 for (entry = dynamic_section;
5973 entry < dynamic_section + dynamic_nent;
5974 ++entry)
5975 {
5976 if (entry->d_tag == DT_SYMINENT)
5977 {
5978 /* Note: these braces are necessary to avoid a syntax
5979 error from the SunOS4 C compiler. */
5980 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
5981 }
5982 else if (entry->d_tag == DT_SYMINSZ)
5983 syminsz = entry->d_un.d_val;
5984 else if (entry->d_tag == DT_SYMINFO)
5985 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
5986 syminsz);
5987 }
5988
5989 if (dynamic_syminfo_offset != 0 && syminsz != 0)
5990 {
5991 Elf_External_Syminfo *extsyminfo, *extsym;
5992 Elf_Internal_Syminfo *syminfo;
5993
5994 /* There is a syminfo section. Read the data. */
5995 extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, 1,
5996 syminsz, _("symbol information"));
5997 if (!extsyminfo)
5998 return 0;
5999
6000 dynamic_syminfo = malloc (syminsz);
6001 if (dynamic_syminfo == NULL)
6002 {
6003 error (_("Out of memory\n"));
6004 return 0;
6005 }
6006
6007 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
6008 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
6009 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
6010 ++syminfo, ++extsym)
6011 {
6012 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
6013 syminfo->si_flags = BYTE_GET (extsym->si_flags);
6014 }
6015
6016 free (extsyminfo);
6017 }
6018 }
6019
6020 if (do_dynamic && dynamic_addr)
6021 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6022 dynamic_addr, dynamic_nent);
6023 if (do_dynamic)
6024 printf (_(" Tag Type Name/Value\n"));
6025
6026 for (entry = dynamic_section;
6027 entry < dynamic_section + dynamic_nent;
6028 entry++)
6029 {
6030 if (do_dynamic)
6031 {
6032 const char *dtype;
6033
6034 putchar (' ');
6035 print_vma (entry->d_tag, FULL_HEX);
6036 dtype = get_dynamic_type (entry->d_tag);
6037 printf (" (%s)%*s", dtype,
6038 ((is_32bit_elf ? 27 : 19)
6039 - (int) strlen (dtype)),
6040 " ");
6041 }
6042
6043 switch (entry->d_tag)
6044 {
6045 case DT_FLAGS:
6046 if (do_dynamic)
6047 print_dynamic_flags (entry->d_un.d_val);
6048 break;
6049
6050 case DT_AUXILIARY:
6051 case DT_FILTER:
6052 case DT_CONFIG:
6053 case DT_DEPAUDIT:
6054 case DT_AUDIT:
6055 if (do_dynamic)
6056 {
6057 switch (entry->d_tag)
6058 {
6059 case DT_AUXILIARY:
6060 printf (_("Auxiliary library"));
6061 break;
6062
6063 case DT_FILTER:
6064 printf (_("Filter library"));
6065 break;
6066
6067 case DT_CONFIG:
6068 printf (_("Configuration file"));
6069 break;
6070
6071 case DT_DEPAUDIT:
6072 printf (_("Dependency audit library"));
6073 break;
6074
6075 case DT_AUDIT:
6076 printf (_("Audit library"));
6077 break;
6078 }
6079
6080 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6081 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
6082 else
6083 {
6084 printf (": ");
6085 print_vma (entry->d_un.d_val, PREFIX_HEX);
6086 putchar ('\n');
6087 }
6088 }
6089 break;
6090
6091 case DT_FEATURE:
6092 if (do_dynamic)
6093 {
6094 printf (_("Flags:"));
6095
6096 if (entry->d_un.d_val == 0)
6097 printf (_(" None\n"));
6098 else
6099 {
6100 unsigned long int val = entry->d_un.d_val;
6101
6102 if (val & DTF_1_PARINIT)
6103 {
6104 printf (" PARINIT");
6105 val ^= DTF_1_PARINIT;
6106 }
6107 if (val & DTF_1_CONFEXP)
6108 {
6109 printf (" CONFEXP");
6110 val ^= DTF_1_CONFEXP;
6111 }
6112 if (val != 0)
6113 printf (" %lx", val);
6114 puts ("");
6115 }
6116 }
6117 break;
6118
6119 case DT_POSFLAG_1:
6120 if (do_dynamic)
6121 {
6122 printf (_("Flags:"));
6123
6124 if (entry->d_un.d_val == 0)
6125 printf (_(" None\n"));
6126 else
6127 {
6128 unsigned long int val = entry->d_un.d_val;
6129
6130 if (val & DF_P1_LAZYLOAD)
6131 {
6132 printf (" LAZYLOAD");
6133 val ^= DF_P1_LAZYLOAD;
6134 }
6135 if (val & DF_P1_GROUPPERM)
6136 {
6137 printf (" GROUPPERM");
6138 val ^= DF_P1_GROUPPERM;
6139 }
6140 if (val != 0)
6141 printf (" %lx", val);
6142 puts ("");
6143 }
6144 }
6145 break;
6146
6147 case DT_FLAGS_1:
6148 if (do_dynamic)
6149 {
6150 printf (_("Flags:"));
6151 if (entry->d_un.d_val == 0)
6152 printf (_(" None\n"));
6153 else
6154 {
6155 unsigned long int val = entry->d_un.d_val;
6156
6157 if (val & DF_1_NOW)
6158 {
6159 printf (" NOW");
6160 val ^= DF_1_NOW;
6161 }
6162 if (val & DF_1_GLOBAL)
6163 {
6164 printf (" GLOBAL");
6165 val ^= DF_1_GLOBAL;
6166 }
6167 if (val & DF_1_GROUP)
6168 {
6169 printf (" GROUP");
6170 val ^= DF_1_GROUP;
6171 }
6172 if (val & DF_1_NODELETE)
6173 {
6174 printf (" NODELETE");
6175 val ^= DF_1_NODELETE;
6176 }
6177 if (val & DF_1_LOADFLTR)
6178 {
6179 printf (" LOADFLTR");
6180 val ^= DF_1_LOADFLTR;
6181 }
6182 if (val & DF_1_INITFIRST)
6183 {
6184 printf (" INITFIRST");
6185 val ^= DF_1_INITFIRST;
6186 }
6187 if (val & DF_1_NOOPEN)
6188 {
6189 printf (" NOOPEN");
6190 val ^= DF_1_NOOPEN;
6191 }
6192 if (val & DF_1_ORIGIN)
6193 {
6194 printf (" ORIGIN");
6195 val ^= DF_1_ORIGIN;
6196 }
6197 if (val & DF_1_DIRECT)
6198 {
6199 printf (" DIRECT");
6200 val ^= DF_1_DIRECT;
6201 }
6202 if (val & DF_1_TRANS)
6203 {
6204 printf (" TRANS");
6205 val ^= DF_1_TRANS;
6206 }
6207 if (val & DF_1_INTERPOSE)
6208 {
6209 printf (" INTERPOSE");
6210 val ^= DF_1_INTERPOSE;
6211 }
6212 if (val & DF_1_NODEFLIB)
6213 {
6214 printf (" NODEFLIB");
6215 val ^= DF_1_NODEFLIB;
6216 }
6217 if (val & DF_1_NODUMP)
6218 {
6219 printf (" NODUMP");
6220 val ^= DF_1_NODUMP;
6221 }
6222 if (val & DF_1_CONLFAT)
6223 {
6224 printf (" CONLFAT");
6225 val ^= DF_1_CONLFAT;
6226 }
6227 if (val != 0)
6228 printf (" %lx", val);
6229 puts ("");
6230 }
6231 }
6232 break;
6233
6234 case DT_PLTREL:
6235 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6236 if (do_dynamic)
6237 puts (get_dynamic_type (entry->d_un.d_val));
6238 break;
6239
6240 case DT_NULL :
6241 case DT_NEEDED :
6242 case DT_PLTGOT :
6243 case DT_HASH :
6244 case DT_STRTAB :
6245 case DT_SYMTAB :
6246 case DT_RELA :
6247 case DT_INIT :
6248 case DT_FINI :
6249 case DT_SONAME :
6250 case DT_RPATH :
6251 case DT_SYMBOLIC:
6252 case DT_REL :
6253 case DT_DEBUG :
6254 case DT_TEXTREL :
6255 case DT_JMPREL :
6256 case DT_RUNPATH :
6257 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6258
6259 if (do_dynamic)
6260 {
6261 char *name;
6262
6263 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6264 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6265 else
6266 name = NULL;
6267
6268 if (name)
6269 {
6270 switch (entry->d_tag)
6271 {
6272 case DT_NEEDED:
6273 printf (_("Shared library: [%s]"), name);
6274
6275 if (streq (name, program_interpreter))
6276 printf (_(" program interpreter"));
6277 break;
6278
6279 case DT_SONAME:
6280 printf (_("Library soname: [%s]"), name);
6281 break;
6282
6283 case DT_RPATH:
6284 printf (_("Library rpath: [%s]"), name);
6285 break;
6286
6287 case DT_RUNPATH:
6288 printf (_("Library runpath: [%s]"), name);
6289 break;
6290
6291 default:
6292 print_vma (entry->d_un.d_val, PREFIX_HEX);
6293 break;
6294 }
6295 }
6296 else
6297 print_vma (entry->d_un.d_val, PREFIX_HEX);
6298
6299 putchar ('\n');
6300 }
6301 break;
6302
6303 case DT_PLTRELSZ:
6304 case DT_RELASZ :
6305 case DT_STRSZ :
6306 case DT_RELSZ :
6307 case DT_RELAENT :
6308 case DT_SYMENT :
6309 case DT_RELENT :
6310 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6311 case DT_PLTPADSZ:
6312 case DT_MOVEENT :
6313 case DT_MOVESZ :
6314 case DT_INIT_ARRAYSZ:
6315 case DT_FINI_ARRAYSZ:
6316 case DT_GNU_CONFLICTSZ:
6317 case DT_GNU_LIBLISTSZ:
6318 if (do_dynamic)
6319 {
6320 print_vma (entry->d_un.d_val, UNSIGNED);
6321 printf (" (bytes)\n");
6322 }
6323 break;
6324
6325 case DT_VERDEFNUM:
6326 case DT_VERNEEDNUM:
6327 case DT_RELACOUNT:
6328 case DT_RELCOUNT:
6329 if (do_dynamic)
6330 {
6331 print_vma (entry->d_un.d_val, UNSIGNED);
6332 putchar ('\n');
6333 }
6334 break;
6335
6336 case DT_SYMINSZ:
6337 case DT_SYMINENT:
6338 case DT_SYMINFO:
6339 case DT_USED:
6340 case DT_INIT_ARRAY:
6341 case DT_FINI_ARRAY:
6342 if (do_dynamic)
6343 {
6344 if (entry->d_tag == DT_USED
6345 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
6346 {
6347 char *name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6348
6349 if (*name)
6350 {
6351 printf (_("Not needed object: [%s]\n"), name);
6352 break;
6353 }
6354 }
6355
6356 print_vma (entry->d_un.d_val, PREFIX_HEX);
6357 putchar ('\n');
6358 }
6359 break;
6360
6361 case DT_BIND_NOW:
6362 /* The value of this entry is ignored. */
6363 if (do_dynamic)
6364 putchar ('\n');
6365 break;
6366
6367 case DT_GNU_PRELINKED:
6368 if (do_dynamic)
6369 {
6370 struct tm *tmp;
6371 time_t time = entry->d_un.d_val;
6372
6373 tmp = gmtime (&time);
6374 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6375 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6376 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6377
6378 }
6379 break;
6380
6381 case DT_GNU_HASH:
6382 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
6383 if (do_dynamic)
6384 {
6385 print_vma (entry->d_un.d_val, PREFIX_HEX);
6386 putchar ('\n');
6387 }
6388 break;
6389
6390 default:
6391 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
6392 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
6393 entry->d_un.d_val;
6394
6395 if (do_dynamic)
6396 {
6397 switch (elf_header.e_machine)
6398 {
6399 case EM_MIPS:
6400 case EM_MIPS_RS3_LE:
6401 dynamic_section_mips_val (entry);
6402 break;
6403 case EM_PARISC:
6404 dynamic_section_parisc_val (entry);
6405 break;
6406 case EM_IA_64:
6407 dynamic_section_ia64_val (entry);
6408 break;
6409 default:
6410 print_vma (entry->d_un.d_val, PREFIX_HEX);
6411 putchar ('\n');
6412 }
6413 }
6414 break;
6415 }
6416 }
6417
6418 return 1;
6419 }
6420
6421 static char *
6422 get_ver_flags (unsigned int flags)
6423 {
6424 static char buff[32];
6425
6426 buff[0] = 0;
6427
6428 if (flags == 0)
6429 return _("none");
6430
6431 if (flags & VER_FLG_BASE)
6432 strcat (buff, "BASE ");
6433
6434 if (flags & VER_FLG_WEAK)
6435 {
6436 if (flags & VER_FLG_BASE)
6437 strcat (buff, "| ");
6438
6439 strcat (buff, "WEAK ");
6440 }
6441
6442 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
6443 strcat (buff, "| <unknown>");
6444
6445 return buff;
6446 }
6447
6448 /* Display the contents of the version sections. */
6449 static int
6450 process_version_sections (FILE *file)
6451 {
6452 Elf_Internal_Shdr *section;
6453 unsigned i;
6454 int found = 0;
6455
6456 if (! do_version)
6457 return 1;
6458
6459 for (i = 0, section = section_headers;
6460 i < elf_header.e_shnum;
6461 i++, section++)
6462 {
6463 switch (section->sh_type)
6464 {
6465 case SHT_GNU_verdef:
6466 {
6467 Elf_External_Verdef *edefs;
6468 unsigned int idx;
6469 unsigned int cnt;
6470 char *endbuf;
6471
6472 found = 1;
6473
6474 printf
6475 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6476 SECTION_NAME (section), section->sh_info);
6477
6478 printf (_(" Addr: 0x"));
6479 printf_vma (section->sh_addr);
6480 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6481 (unsigned long) section->sh_offset, section->sh_link,
6482 SECTION_HEADER_INDEX (section->sh_link)
6483 < elf_header.e_shnum
6484 ? SECTION_NAME (SECTION_HEADER (section->sh_link))
6485 : "<corrupt>");
6486
6487 edefs = get_data (NULL, file, section->sh_offset, 1,
6488 section->sh_size,
6489 _("version definition section"));
6490 endbuf = (char *) edefs + section->sh_size;
6491 if (!edefs)
6492 break;
6493
6494 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6495 {
6496 char *vstart;
6497 Elf_External_Verdef *edef;
6498 Elf_Internal_Verdef ent;
6499 Elf_External_Verdaux *eaux;
6500 Elf_Internal_Verdaux aux;
6501 int j;
6502 int isum;
6503
6504 vstart = ((char *) edefs) + idx;
6505 if (vstart + sizeof (*edef) > endbuf)
6506 break;
6507
6508 edef = (Elf_External_Verdef *) vstart;
6509
6510 ent.vd_version = BYTE_GET (edef->vd_version);
6511 ent.vd_flags = BYTE_GET (edef->vd_flags);
6512 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
6513 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
6514 ent.vd_hash = BYTE_GET (edef->vd_hash);
6515 ent.vd_aux = BYTE_GET (edef->vd_aux);
6516 ent.vd_next = BYTE_GET (edef->vd_next);
6517
6518 printf (_(" %#06x: Rev: %d Flags: %s"),
6519 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
6520
6521 printf (_(" Index: %d Cnt: %d "),
6522 ent.vd_ndx, ent.vd_cnt);
6523
6524 vstart += ent.vd_aux;
6525
6526 eaux = (Elf_External_Verdaux *) vstart;
6527
6528 aux.vda_name = BYTE_GET (eaux->vda_name);
6529 aux.vda_next = BYTE_GET (eaux->vda_next);
6530
6531 if (VALID_DYNAMIC_NAME (aux.vda_name))
6532 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
6533 else
6534 printf (_("Name index: %ld\n"), aux.vda_name);
6535
6536 isum = idx + ent.vd_aux;
6537
6538 for (j = 1; j < ent.vd_cnt; j++)
6539 {
6540 isum += aux.vda_next;
6541 vstart += aux.vda_next;
6542
6543 eaux = (Elf_External_Verdaux *) vstart;
6544 if (vstart + sizeof (*eaux) > endbuf)
6545 break;
6546
6547 aux.vda_name = BYTE_GET (eaux->vda_name);
6548 aux.vda_next = BYTE_GET (eaux->vda_next);
6549
6550 if (VALID_DYNAMIC_NAME (aux.vda_name))
6551 printf (_(" %#06x: Parent %d: %s\n"),
6552 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
6553 else
6554 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6555 isum, j, aux.vda_name);
6556 }
6557 if (j < ent.vd_cnt)
6558 printf (_(" Version def aux past end of section\n"));
6559
6560 idx += ent.vd_next;
6561 }
6562 if (cnt < section->sh_info)
6563 printf (_(" Version definition past end of section\n"));
6564
6565 free (edefs);
6566 }
6567 break;
6568
6569 case SHT_GNU_verneed:
6570 {
6571 Elf_External_Verneed *eneed;
6572 unsigned int idx;
6573 unsigned int cnt;
6574 char *endbuf;
6575
6576 found = 1;
6577
6578 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6579 SECTION_NAME (section), section->sh_info);
6580
6581 printf (_(" Addr: 0x"));
6582 printf_vma (section->sh_addr);
6583 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6584 (unsigned long) section->sh_offset, section->sh_link,
6585 SECTION_HEADER_INDEX (section->sh_link)
6586 < elf_header.e_shnum
6587 ? SECTION_NAME (SECTION_HEADER (section->sh_link))
6588 : "<corrupt>");
6589
6590 eneed = get_data (NULL, file, section->sh_offset, 1,
6591 section->sh_size,
6592 _("version need section"));
6593 endbuf = (char *) eneed + section->sh_size;
6594 if (!eneed)
6595 break;
6596
6597 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6598 {
6599 Elf_External_Verneed *entry;
6600 Elf_Internal_Verneed ent;
6601 int j;
6602 int isum;
6603 char *vstart;
6604
6605 vstart = ((char *) eneed) + idx;
6606 if (vstart + sizeof (*entry) > endbuf)
6607 break;
6608
6609 entry = (Elf_External_Verneed *) vstart;
6610
6611 ent.vn_version = BYTE_GET (entry->vn_version);
6612 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
6613 ent.vn_file = BYTE_GET (entry->vn_file);
6614 ent.vn_aux = BYTE_GET (entry->vn_aux);
6615 ent.vn_next = BYTE_GET (entry->vn_next);
6616
6617 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
6618
6619 if (VALID_DYNAMIC_NAME (ent.vn_file))
6620 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
6621 else
6622 printf (_(" File: %lx"), ent.vn_file);
6623
6624 printf (_(" Cnt: %d\n"), ent.vn_cnt);
6625
6626 vstart += ent.vn_aux;
6627
6628 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
6629 {
6630 Elf_External_Vernaux *eaux;
6631 Elf_Internal_Vernaux aux;
6632
6633 if (vstart + sizeof (*eaux) > endbuf)
6634 break;
6635 eaux = (Elf_External_Vernaux *) vstart;
6636
6637 aux.vna_hash = BYTE_GET (eaux->vna_hash);
6638 aux.vna_flags = BYTE_GET (eaux->vna_flags);
6639 aux.vna_other = BYTE_GET (eaux->vna_other);
6640 aux.vna_name = BYTE_GET (eaux->vna_name);
6641 aux.vna_next = BYTE_GET (eaux->vna_next);
6642
6643 if (VALID_DYNAMIC_NAME (aux.vna_name))
6644 printf (_(" %#06x: Name: %s"),
6645 isum, GET_DYNAMIC_NAME (aux.vna_name));
6646 else
6647 printf (_(" %#06x: Name index: %lx"),
6648 isum, aux.vna_name);
6649
6650 printf (_(" Flags: %s Version: %d\n"),
6651 get_ver_flags (aux.vna_flags), aux.vna_other);
6652
6653 isum += aux.vna_next;
6654 vstart += aux.vna_next;
6655 }
6656 if (j < ent.vn_cnt)
6657 printf (_(" Version need aux past end of section\n"));
6658
6659 idx += ent.vn_next;
6660 }
6661 if (cnt < section->sh_info)
6662 printf (_(" Version need past end of section\n"));
6663
6664 free (eneed);
6665 }
6666 break;
6667
6668 case SHT_GNU_versym:
6669 {
6670 Elf_Internal_Shdr *link_section;
6671 int total;
6672 int cnt;
6673 unsigned char *edata;
6674 unsigned short *data;
6675 char *strtab;
6676 Elf_Internal_Sym *symbols;
6677 Elf_Internal_Shdr *string_sec;
6678 long off;
6679
6680 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum)
6681 break;
6682
6683 link_section = SECTION_HEADER (section->sh_link);
6684 total = section->sh_size / sizeof (Elf_External_Versym);
6685
6686 if (SECTION_HEADER_INDEX (link_section->sh_link)
6687 >= elf_header.e_shnum)
6688 break;
6689
6690 found = 1;
6691
6692 symbols = GET_ELF_SYMBOLS (file, link_section);
6693
6694 string_sec = SECTION_HEADER (link_section->sh_link);
6695
6696 strtab = get_data (NULL, file, string_sec->sh_offset, 1,
6697 string_sec->sh_size, _("version string table"));
6698 if (!strtab)
6699 break;
6700
6701 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6702 SECTION_NAME (section), total);
6703
6704 printf (_(" Addr: "));
6705 printf_vma (section->sh_addr);
6706 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6707 (unsigned long) section->sh_offset, section->sh_link,
6708 SECTION_NAME (link_section));
6709
6710 off = offset_from_vma (file,
6711 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6712 total * sizeof (short));
6713 edata = get_data (NULL, file, off, total, sizeof (short),
6714 _("version symbol data"));
6715 if (!edata)
6716 {
6717 free (strtab);
6718 break;
6719 }
6720
6721 data = cmalloc (total, sizeof (short));
6722
6723 for (cnt = total; cnt --;)
6724 data[cnt] = byte_get (edata + cnt * sizeof (short),
6725 sizeof (short));
6726
6727 free (edata);
6728
6729 for (cnt = 0; cnt < total; cnt += 4)
6730 {
6731 int j, nn;
6732 int check_def, check_need;
6733 char *name;
6734
6735 printf (" %03x:", cnt);
6736
6737 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
6738 switch (data[cnt + j])
6739 {
6740 case 0:
6741 fputs (_(" 0 (*local*) "), stdout);
6742 break;
6743
6744 case 1:
6745 fputs (_(" 1 (*global*) "), stdout);
6746 break;
6747
6748 default:
6749 nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
6750 data[cnt + j] & 0x8000 ? 'h' : ' ');
6751
6752 check_def = 1;
6753 check_need = 1;
6754 if (SECTION_HEADER_INDEX (symbols[cnt + j].st_shndx)
6755 >= elf_header.e_shnum
6756 || SECTION_HEADER (symbols[cnt + j].st_shndx)->sh_type
6757 != SHT_NOBITS)
6758 {
6759 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
6760 check_def = 0;
6761 else
6762 check_need = 0;
6763 }
6764
6765 if (check_need
6766 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
6767 {
6768 Elf_Internal_Verneed ivn;
6769 unsigned long offset;
6770
6771 offset = offset_from_vma
6772 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6773 sizeof (Elf_External_Verneed));
6774
6775 do
6776 {
6777 Elf_Internal_Vernaux ivna;
6778 Elf_External_Verneed evn;
6779 Elf_External_Vernaux evna;
6780 unsigned long a_off;
6781
6782 get_data (&evn, file, offset, sizeof (evn), 1,
6783 _("version need"));
6784
6785 ivn.vn_aux = BYTE_GET (evn.vn_aux);
6786 ivn.vn_next = BYTE_GET (evn.vn_next);
6787
6788 a_off = offset + ivn.vn_aux;
6789
6790 do
6791 {
6792 get_data (&evna, file, a_off, sizeof (evna),
6793 1, _("version need aux (2)"));
6794
6795 ivna.vna_next = BYTE_GET (evna.vna_next);
6796 ivna.vna_other = BYTE_GET (evna.vna_other);
6797
6798 a_off += ivna.vna_next;
6799 }
6800 while (ivna.vna_other != data[cnt + j]
6801 && ivna.vna_next != 0);
6802
6803 if (ivna.vna_other == data[cnt + j])
6804 {
6805 ivna.vna_name = BYTE_GET (evna.vna_name);
6806
6807 if (ivna.vna_name >= string_sec->sh_size)
6808 name = _("*invalid*");
6809 else
6810 name = strtab + ivna.vna_name;
6811 nn += printf ("(%s%-*s",
6812 name,
6813 12 - (int) strlen (name),
6814 ")");
6815 check_def = 0;
6816 break;
6817 }
6818
6819 offset += ivn.vn_next;
6820 }
6821 while (ivn.vn_next);
6822 }
6823
6824 if (check_def && data[cnt + j] != 0x8001
6825 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
6826 {
6827 Elf_Internal_Verdef ivd;
6828 Elf_External_Verdef evd;
6829 unsigned long offset;
6830
6831 offset = offset_from_vma
6832 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
6833 sizeof evd);
6834
6835 do
6836 {
6837 get_data (&evd, file, offset, sizeof (evd), 1,
6838 _("version def"));
6839
6840 ivd.vd_next = BYTE_GET (evd.vd_next);
6841 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
6842
6843 offset += ivd.vd_next;
6844 }
6845 while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
6846 && ivd.vd_next != 0);
6847
6848 if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
6849 {
6850 Elf_External_Verdaux evda;
6851 Elf_Internal_Verdaux ivda;
6852
6853 ivd.vd_aux = BYTE_GET (evd.vd_aux);
6854
6855 get_data (&evda, file,
6856 offset - ivd.vd_next + ivd.vd_aux,
6857 sizeof (evda), 1,
6858 _("version def aux"));
6859
6860 ivda.vda_name = BYTE_GET (evda.vda_name);
6861
6862 if (ivda.vda_name >= string_sec->sh_size)
6863 name = _("*invalid*");
6864 else
6865 name = strtab + ivda.vda_name;
6866 nn += printf ("(%s%-*s",
6867 name,
6868 12 - (int) strlen (name),
6869 ")");
6870 }
6871 }
6872
6873 if (nn < 18)
6874 printf ("%*c", 18 - nn, ' ');
6875 }
6876
6877 putchar ('\n');
6878 }
6879
6880 free (data);
6881 free (strtab);
6882 free (symbols);
6883 }
6884 break;
6885
6886 default:
6887 break;
6888 }
6889 }
6890
6891 if (! found)
6892 printf (_("\nNo version information found in this file.\n"));
6893
6894 return 1;
6895 }
6896
6897 static const char *
6898 get_symbol_binding (unsigned int binding)
6899 {
6900 static char buff[32];
6901
6902 switch (binding)
6903 {
6904 case STB_LOCAL: return "LOCAL";
6905 case STB_GLOBAL: return "GLOBAL";
6906 case STB_WEAK: return "WEAK";
6907 default:
6908 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
6909 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
6910 binding);
6911 else if (binding >= STB_LOOS && binding <= STB_HIOS)
6912 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
6913 else
6914 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
6915 return buff;
6916 }
6917 }
6918
6919 static const char *
6920 get_symbol_type (unsigned int type)
6921 {
6922 static char buff[32];
6923
6924 switch (type)
6925 {
6926 case STT_NOTYPE: return "NOTYPE";
6927 case STT_OBJECT: return "OBJECT";
6928 case STT_FUNC: return "FUNC";
6929 case STT_SECTION: return "SECTION";
6930 case STT_FILE: return "FILE";
6931 case STT_COMMON: return "COMMON";
6932 case STT_TLS: return "TLS";
6933 case STT_RELC: return "RELC";
6934 case STT_SRELC: return "SRELC";
6935 default:
6936 if (type >= STT_LOPROC && type <= STT_HIPROC)
6937 {
6938 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
6939 return "THUMB_FUNC";
6940
6941 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
6942 return "REGISTER";
6943
6944 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
6945 return "PARISC_MILLI";
6946
6947 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
6948 }
6949 else if (type >= STT_LOOS && type <= STT_HIOS)
6950 {
6951 if (elf_header.e_machine == EM_PARISC)
6952 {
6953 if (type == STT_HP_OPAQUE)
6954 return "HP_OPAQUE";
6955 if (type == STT_HP_STUB)
6956 return "HP_STUB";
6957 }
6958
6959 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
6960 }
6961 else
6962 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
6963 return buff;
6964 }
6965 }
6966
6967 static const char *
6968 get_symbol_visibility (unsigned int visibility)
6969 {
6970 switch (visibility)
6971 {
6972 case STV_DEFAULT: return "DEFAULT";
6973 case STV_INTERNAL: return "INTERNAL";
6974 case STV_HIDDEN: return "HIDDEN";
6975 case STV_PROTECTED: return "PROTECTED";
6976 default: abort ();
6977 }
6978 }
6979
6980 static const char *
6981 get_mips_symbol_other (unsigned int other)
6982 {
6983 switch (other)
6984 {
6985 case STO_OPTIONAL: return "OPTIONAL";
6986 case STO_MIPS16: return "MIPS16";
6987 default: return NULL;
6988 }
6989 }
6990
6991 static const char *
6992 get_symbol_other (unsigned int other)
6993 {
6994 const char * result = NULL;
6995 static char buff [32];
6996
6997 if (other == 0)
6998 return "";
6999
7000 switch (elf_header.e_machine)
7001 {
7002 case EM_MIPS:
7003 result = get_mips_symbol_other (other);
7004 default:
7005 break;
7006 }
7007
7008 if (result)
7009 return result;
7010
7011 snprintf (buff, sizeof buff, _("<other>: %x"), other);
7012 return buff;
7013 }
7014
7015 static const char *
7016 get_symbol_index_type (unsigned int type)
7017 {
7018 static char buff[32];
7019
7020 switch (type)
7021 {
7022 case SHN_UNDEF: return "UND";
7023 case SHN_ABS: return "ABS";
7024 case SHN_COMMON: return "COM";
7025 default:
7026 if (type == SHN_IA_64_ANSI_COMMON
7027 && elf_header.e_machine == EM_IA_64
7028 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
7029 return "ANSI_COM";
7030 else if (elf_header.e_machine == EM_X86_64
7031 && type == SHN_X86_64_LCOMMON)
7032 return "LARGE_COM";
7033 else if (type == SHN_MIPS_SCOMMON
7034 && elf_header.e_machine == EM_MIPS)
7035 return "SCOM";
7036 else if (type == SHN_MIPS_SUNDEFINED
7037 && elf_header.e_machine == EM_MIPS)
7038 return "SUND";
7039 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
7040 sprintf (buff, "PRC[0x%04x]", type);
7041 else if (type >= SHN_LOOS && type <= SHN_HIOS)
7042 sprintf (buff, "OS [0x%04x]", type);
7043 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
7044 sprintf (buff, "RSV[0x%04x]", type);
7045 else
7046 sprintf (buff, "%3d", type);
7047 break;
7048 }
7049
7050 return buff;
7051 }
7052
7053 static bfd_vma *
7054 get_dynamic_data (FILE *file, unsigned int number, unsigned int ent_size)
7055 {
7056 unsigned char *e_data;
7057 bfd_vma *i_data;
7058
7059 e_data = cmalloc (number, ent_size);
7060
7061 if (e_data == NULL)
7062 {
7063 error (_("Out of memory\n"));
7064 return NULL;
7065 }
7066
7067 if (fread (e_data, ent_size, number, file) != number)
7068 {
7069 error (_("Unable to read in dynamic data\n"));
7070 return NULL;
7071 }
7072
7073 i_data = cmalloc (number, sizeof (*i_data));
7074
7075 if (i_data == NULL)
7076 {
7077 error (_("Out of memory\n"));
7078 free (e_data);
7079 return NULL;
7080 }
7081
7082 while (number--)
7083 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
7084
7085 free (e_data);
7086
7087 return i_data;
7088 }
7089
7090 static void
7091 print_dynamic_symbol (bfd_vma si, unsigned long hn)
7092 {
7093 Elf_Internal_Sym *psym;
7094 int n;
7095
7096 psym = dynamic_symbols + si;
7097
7098 n = print_vma (si, DEC_5);
7099 if (n < 5)
7100 fputs (" " + n, stdout);
7101 printf (" %3lu: ", hn);
7102 print_vma (psym->st_value, LONG_HEX);
7103 putchar (' ');
7104 print_vma (psym->st_size, DEC_5);
7105
7106 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7107 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7108 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7109 /* Check to see if any other bits in the st_other field are set.
7110 Note - displaying this information disrupts the layout of the
7111 table being generated, but for the moment this case is very
7112 rare. */
7113 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7114 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7115 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
7116 if (VALID_DYNAMIC_NAME (psym->st_name))
7117 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
7118 else
7119 printf (" <corrupt: %14ld>", psym->st_name);
7120 putchar ('\n');
7121 }
7122
7123 /* Dump the symbol table. */
7124 static int
7125 process_symbol_table (FILE *file)
7126 {
7127 Elf_Internal_Shdr *section;
7128 bfd_vma nbuckets = 0;
7129 bfd_vma nchains = 0;
7130 bfd_vma *buckets = NULL;
7131 bfd_vma *chains = NULL;
7132 bfd_vma ngnubuckets = 0;
7133 bfd_vma *gnubuckets = NULL;
7134 bfd_vma *gnuchains = NULL;
7135 bfd_vma gnusymidx = 0;
7136
7137 if (! do_syms && !do_histogram)
7138 return 1;
7139
7140 if (dynamic_info[DT_HASH]
7141 && (do_histogram
7142 || (do_using_dynamic && dynamic_strings != NULL)))
7143 {
7144 unsigned char nb[8];
7145 unsigned char nc[8];
7146 int hash_ent_size = 4;
7147
7148 if ((elf_header.e_machine == EM_ALPHA
7149 || elf_header.e_machine == EM_S390
7150 || elf_header.e_machine == EM_S390_OLD)
7151 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
7152 hash_ent_size = 8;
7153
7154 if (fseek (file,
7155 (archive_file_offset
7156 + offset_from_vma (file, dynamic_info[DT_HASH],
7157 sizeof nb + sizeof nc)),
7158 SEEK_SET))
7159 {
7160 error (_("Unable to seek to start of dynamic information\n"));
7161 return 0;
7162 }
7163
7164 if (fread (nb, hash_ent_size, 1, file) != 1)
7165 {
7166 error (_("Failed to read in number of buckets\n"));
7167 return 0;
7168 }
7169
7170 if (fread (nc, hash_ent_size, 1, file) != 1)
7171 {
7172 error (_("Failed to read in number of chains\n"));
7173 return 0;
7174 }
7175
7176 nbuckets = byte_get (nb, hash_ent_size);
7177 nchains = byte_get (nc, hash_ent_size);
7178
7179 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
7180 chains = get_dynamic_data (file, nchains, hash_ent_size);
7181
7182 if (buckets == NULL || chains == NULL)
7183 return 0;
7184 }
7185
7186 if (dynamic_info_DT_GNU_HASH
7187 && (do_histogram
7188 || (do_using_dynamic && dynamic_strings != NULL)))
7189 {
7190 unsigned char nb[16];
7191 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
7192 bfd_vma buckets_vma;
7193
7194 if (fseek (file,
7195 (archive_file_offset
7196 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
7197 sizeof nb)),
7198 SEEK_SET))
7199 {
7200 error (_("Unable to seek to start of dynamic information\n"));
7201 return 0;
7202 }
7203
7204 if (fread (nb, 16, 1, file) != 1)
7205 {
7206 error (_("Failed to read in number of buckets\n"));
7207 return 0;
7208 }
7209
7210 ngnubuckets = byte_get (nb, 4);
7211 gnusymidx = byte_get (nb + 4, 4);
7212 bitmaskwords = byte_get (nb + 8, 4);
7213 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
7214 if (is_32bit_elf)
7215 buckets_vma += bitmaskwords * 4;
7216 else
7217 buckets_vma += bitmaskwords * 8;
7218
7219 if (fseek (file,
7220 (archive_file_offset
7221 + offset_from_vma (file, buckets_vma, 4)),
7222 SEEK_SET))
7223 {
7224 error (_("Unable to seek to start of dynamic information\n"));
7225 return 0;
7226 }
7227
7228 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
7229
7230 if (gnubuckets == NULL)
7231 return 0;
7232
7233 for (i = 0; i < ngnubuckets; i++)
7234 if (gnubuckets[i] != 0)
7235 {
7236 if (gnubuckets[i] < gnusymidx)
7237 return 0;
7238
7239 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
7240 maxchain = gnubuckets[i];
7241 }
7242
7243 if (maxchain == 0xffffffff)
7244 return 0;
7245
7246 maxchain -= gnusymidx;
7247
7248 if (fseek (file,
7249 (archive_file_offset
7250 + offset_from_vma (file, buckets_vma
7251 + 4 * (ngnubuckets + maxchain), 4)),
7252 SEEK_SET))
7253 {
7254 error (_("Unable to seek to start of dynamic information\n"));
7255 return 0;
7256 }
7257
7258 do
7259 {
7260 if (fread (nb, 4, 1, file) != 1)
7261 {
7262 error (_("Failed to determine last chain length\n"));
7263 return 0;
7264 }
7265
7266 if (maxchain + 1 == 0)
7267 return 0;
7268
7269 ++maxchain;
7270 }
7271 while ((byte_get (nb, 4) & 1) == 0);
7272
7273 if (fseek (file,
7274 (archive_file_offset
7275 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
7276 SEEK_SET))
7277 {
7278 error (_("Unable to seek to start of dynamic information\n"));
7279 return 0;
7280 }
7281
7282 gnuchains = get_dynamic_data (file, maxchain, 4);
7283
7284 if (gnuchains == NULL)
7285 return 0;
7286 }
7287
7288 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
7289 && do_syms
7290 && do_using_dynamic
7291 && dynamic_strings != NULL)
7292 {
7293 unsigned long hn;
7294
7295 if (dynamic_info[DT_HASH])
7296 {
7297 bfd_vma si;
7298
7299 printf (_("\nSymbol table for image:\n"));
7300 if (is_32bit_elf)
7301 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7302 else
7303 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7304
7305 for (hn = 0; hn < nbuckets; hn++)
7306 {
7307 if (! buckets[hn])
7308 continue;
7309
7310 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
7311 print_dynamic_symbol (si, hn);
7312 }
7313 }
7314
7315 if (dynamic_info_DT_GNU_HASH)
7316 {
7317 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7318 if (is_32bit_elf)
7319 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7320 else
7321 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7322
7323 for (hn = 0; hn < ngnubuckets; ++hn)
7324 if (gnubuckets[hn] != 0)
7325 {
7326 bfd_vma si = gnubuckets[hn];
7327 bfd_vma off = si - gnusymidx;
7328
7329 do
7330 {
7331 print_dynamic_symbol (si, hn);
7332 si++;
7333 }
7334 while ((gnuchains[off++] & 1) == 0);
7335 }
7336 }
7337 }
7338 else if (do_syms && !do_using_dynamic)
7339 {
7340 unsigned int i;
7341
7342 for (i = 0, section = section_headers;
7343 i < elf_header.e_shnum;
7344 i++, section++)
7345 {
7346 unsigned int si;
7347 char *strtab = NULL;
7348 unsigned long int strtab_size = 0;
7349 Elf_Internal_Sym *symtab;
7350 Elf_Internal_Sym *psym;
7351
7352
7353 if ( section->sh_type != SHT_SYMTAB
7354 && section->sh_type != SHT_DYNSYM)
7355 continue;
7356
7357 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7358 SECTION_NAME (section),
7359 (unsigned long) (section->sh_size / section->sh_entsize));
7360 if (is_32bit_elf)
7361 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7362 else
7363 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7364
7365 symtab = GET_ELF_SYMBOLS (file, section);
7366 if (symtab == NULL)
7367 continue;
7368
7369 if (section->sh_link == elf_header.e_shstrndx)
7370 {
7371 strtab = string_table;
7372 strtab_size = string_table_length;
7373 }
7374 else if (SECTION_HEADER_INDEX (section->sh_link) < elf_header.e_shnum)
7375 {
7376 Elf_Internal_Shdr *string_sec;
7377
7378 string_sec = SECTION_HEADER (section->sh_link);
7379
7380 strtab = get_data (NULL, file, string_sec->sh_offset,
7381 1, string_sec->sh_size, _("string table"));
7382 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
7383 }
7384
7385 for (si = 0, psym = symtab;
7386 si < section->sh_size / section->sh_entsize;
7387 si++, psym++)
7388 {
7389 printf ("%6d: ", si);
7390 print_vma (psym->st_value, LONG_HEX);
7391 putchar (' ');
7392 print_vma (psym->st_size, DEC_5);
7393 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7394 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7395 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7396 /* Check to see if any other bits in the st_other field are set.
7397 Note - displaying this information disrupts the layout of the
7398 table being generated, but for the moment this case is very rare. */
7399 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7400 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7401 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
7402 print_symbol (25, psym->st_name < strtab_size
7403 ? strtab + psym->st_name : "<corrupt>");
7404
7405 if (section->sh_type == SHT_DYNSYM &&
7406 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
7407 {
7408 unsigned char data[2];
7409 unsigned short vers_data;
7410 unsigned long offset;
7411 int is_nobits;
7412 int check_def;
7413
7414 offset = offset_from_vma
7415 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7416 sizeof data + si * sizeof (vers_data));
7417
7418 get_data (&data, file, offset + si * sizeof (vers_data),
7419 sizeof (data), 1, _("version data"));
7420
7421 vers_data = byte_get (data, 2);
7422
7423 is_nobits = (SECTION_HEADER_INDEX (psym->st_shndx)
7424 < elf_header.e_shnum
7425 && SECTION_HEADER (psym->st_shndx)->sh_type
7426 == SHT_NOBITS);
7427
7428 check_def = (psym->st_shndx != SHN_UNDEF);
7429
7430 if ((vers_data & 0x8000) || vers_data > 1)
7431 {
7432 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
7433 && (is_nobits || ! check_def))
7434 {
7435 Elf_External_Verneed evn;
7436 Elf_Internal_Verneed ivn;
7437 Elf_Internal_Vernaux ivna;
7438
7439 /* We must test both. */
7440 offset = offset_from_vma
7441 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7442 sizeof evn);
7443
7444 do
7445 {
7446 unsigned long vna_off;
7447
7448 get_data (&evn, file, offset, sizeof (evn), 1,
7449 _("version need"));
7450
7451 ivn.vn_aux = BYTE_GET (evn.vn_aux);
7452 ivn.vn_next = BYTE_GET (evn.vn_next);
7453
7454 vna_off = offset + ivn.vn_aux;
7455
7456 do
7457 {
7458 Elf_External_Vernaux evna;
7459
7460 get_data (&evna, file, vna_off,
7461 sizeof (evna), 1,
7462 _("version need aux (3)"));
7463
7464 ivna.vna_other = BYTE_GET (evna.vna_other);
7465 ivna.vna_next = BYTE_GET (evna.vna_next);
7466 ivna.vna_name = BYTE_GET (evna.vna_name);
7467
7468 vna_off += ivna.vna_next;
7469 }
7470 while (ivna.vna_other != vers_data
7471 && ivna.vna_next != 0);
7472
7473 if (ivna.vna_other == vers_data)
7474 break;
7475
7476 offset += ivn.vn_next;
7477 }
7478 while (ivn.vn_next != 0);
7479
7480 if (ivna.vna_other == vers_data)
7481 {
7482 printf ("@%s (%d)",
7483 ivna.vna_name < strtab_size
7484 ? strtab + ivna.vna_name : "<corrupt>",
7485 ivna.vna_other);
7486 check_def = 0;
7487 }
7488 else if (! is_nobits)
7489 error (_("bad dynamic symbol\n"));
7490 else
7491 check_def = 1;
7492 }
7493
7494 if (check_def)
7495 {
7496 if (vers_data != 0x8001
7497 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7498 {
7499 Elf_Internal_Verdef ivd;
7500 Elf_Internal_Verdaux ivda;
7501 Elf_External_Verdaux evda;
7502 unsigned long offset;
7503
7504 offset = offset_from_vma
7505 (file,
7506 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7507 sizeof (Elf_External_Verdef));
7508
7509 do
7510 {
7511 Elf_External_Verdef evd;
7512
7513 get_data (&evd, file, offset, sizeof (evd),
7514 1, _("version def"));
7515
7516 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7517 ivd.vd_aux = BYTE_GET (evd.vd_aux);
7518 ivd.vd_next = BYTE_GET (evd.vd_next);
7519
7520 offset += ivd.vd_next;
7521 }
7522 while (ivd.vd_ndx != (vers_data & 0x7fff)
7523 && ivd.vd_next != 0);
7524
7525 offset -= ivd.vd_next;
7526 offset += ivd.vd_aux;
7527
7528 get_data (&evda, file, offset, sizeof (evda),
7529 1, _("version def aux"));
7530
7531 ivda.vda_name = BYTE_GET (evda.vda_name);
7532
7533 if (psym->st_name != ivda.vda_name)
7534 printf ((vers_data & 0x8000)
7535 ? "@%s" : "@@%s",
7536 ivda.vda_name < strtab_size
7537 ? strtab + ivda.vda_name : "<corrupt>");
7538 }
7539 }
7540 }
7541 }
7542
7543 putchar ('\n');
7544 }
7545
7546 free (symtab);
7547 if (strtab != string_table)
7548 free (strtab);
7549 }
7550 }
7551 else if (do_syms)
7552 printf
7553 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7554
7555 if (do_histogram && buckets != NULL)
7556 {
7557 unsigned long *lengths;
7558 unsigned long *counts;
7559 unsigned long hn;
7560 bfd_vma si;
7561 unsigned long maxlength = 0;
7562 unsigned long nzero_counts = 0;
7563 unsigned long nsyms = 0;
7564
7565 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7566 (unsigned long) nbuckets);
7567 printf (_(" Length Number %% of total Coverage\n"));
7568
7569 lengths = calloc (nbuckets, sizeof (*lengths));
7570 if (lengths == NULL)
7571 {
7572 error (_("Out of memory\n"));
7573 return 0;
7574 }
7575 for (hn = 0; hn < nbuckets; ++hn)
7576 {
7577 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
7578 {
7579 ++nsyms;
7580 if (maxlength < ++lengths[hn])
7581 ++maxlength;
7582 }
7583 }
7584
7585 counts = calloc (maxlength + 1, sizeof (*counts));
7586 if (counts == NULL)
7587 {
7588 error (_("Out of memory\n"));
7589 return 0;
7590 }
7591
7592 for (hn = 0; hn < nbuckets; ++hn)
7593 ++counts[lengths[hn]];
7594
7595 if (nbuckets > 0)
7596 {
7597 unsigned long i;
7598 printf (" 0 %-10lu (%5.1f%%)\n",
7599 counts[0], (counts[0] * 100.0) / nbuckets);
7600 for (i = 1; i <= maxlength; ++i)
7601 {
7602 nzero_counts += counts[i] * i;
7603 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7604 i, counts[i], (counts[i] * 100.0) / nbuckets,
7605 (nzero_counts * 100.0) / nsyms);
7606 }
7607 }
7608
7609 free (counts);
7610 free (lengths);
7611 }
7612
7613 if (buckets != NULL)
7614 {
7615 free (buckets);
7616 free (chains);
7617 }
7618
7619 if (do_histogram && dynamic_info_DT_GNU_HASH)
7620 {
7621 unsigned long *lengths;
7622 unsigned long *counts;
7623 unsigned long hn;
7624 unsigned long maxlength = 0;
7625 unsigned long nzero_counts = 0;
7626 unsigned long nsyms = 0;
7627
7628 lengths = calloc (ngnubuckets, sizeof (*lengths));
7629 if (lengths == NULL)
7630 {
7631 error (_("Out of memory\n"));
7632 return 0;
7633 }
7634
7635 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7636 (unsigned long) ngnubuckets);
7637 printf (_(" Length Number %% of total Coverage\n"));
7638
7639 for (hn = 0; hn < ngnubuckets; ++hn)
7640 if (gnubuckets[hn] != 0)
7641 {
7642 bfd_vma off, length = 1;
7643
7644 for (off = gnubuckets[hn] - gnusymidx;
7645 (gnuchains[off] & 1) == 0; ++off)
7646 ++length;
7647 lengths[hn] = length;
7648 if (length > maxlength)
7649 maxlength = length;
7650 nsyms += length;
7651 }
7652
7653 counts = calloc (maxlength + 1, sizeof (*counts));
7654 if (counts == NULL)
7655 {
7656 error (_("Out of memory\n"));
7657 return 0;
7658 }
7659
7660 for (hn = 0; hn < ngnubuckets; ++hn)
7661 ++counts[lengths[hn]];
7662
7663 if (ngnubuckets > 0)
7664 {
7665 unsigned long j;
7666 printf (" 0 %-10lu (%5.1f%%)\n",
7667 counts[0], (counts[0] * 100.0) / ngnubuckets);
7668 for (j = 1; j <= maxlength; ++j)
7669 {
7670 nzero_counts += counts[j] * j;
7671 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7672 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
7673 (nzero_counts * 100.0) / nsyms);
7674 }
7675 }
7676
7677 free (counts);
7678 free (lengths);
7679 free (gnubuckets);
7680 free (gnuchains);
7681 }
7682
7683 return 1;
7684 }
7685
7686 static int
7687 process_syminfo (FILE *file ATTRIBUTE_UNUSED)
7688 {
7689 unsigned int i;
7690
7691 if (dynamic_syminfo == NULL
7692 || !do_dynamic)
7693 /* No syminfo, this is ok. */
7694 return 1;
7695
7696 /* There better should be a dynamic symbol section. */
7697 if (dynamic_symbols == NULL || dynamic_strings == NULL)
7698 return 0;
7699
7700 if (dynamic_addr)
7701 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7702 dynamic_syminfo_offset, dynamic_syminfo_nent);
7703
7704 printf (_(" Num: Name BoundTo Flags\n"));
7705 for (i = 0; i < dynamic_syminfo_nent; ++i)
7706 {
7707 unsigned short int flags = dynamic_syminfo[i].si_flags;
7708
7709 printf ("%4d: ", i);
7710 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
7711 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
7712 else
7713 printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
7714 putchar (' ');
7715
7716 switch (dynamic_syminfo[i].si_boundto)
7717 {
7718 case SYMINFO_BT_SELF:
7719 fputs ("SELF ", stdout);
7720 break;
7721 case SYMINFO_BT_PARENT:
7722 fputs ("PARENT ", stdout);
7723 break;
7724 default:
7725 if (dynamic_syminfo[i].si_boundto > 0
7726 && dynamic_syminfo[i].si_boundto < dynamic_nent
7727 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
7728 {
7729 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
7730 putchar (' ' );
7731 }
7732 else
7733 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
7734 break;
7735 }
7736
7737 if (flags & SYMINFO_FLG_DIRECT)
7738 printf (" DIRECT");
7739 if (flags & SYMINFO_FLG_PASSTHRU)
7740 printf (" PASSTHRU");
7741 if (flags & SYMINFO_FLG_COPY)
7742 printf (" COPY");
7743 if (flags & SYMINFO_FLG_LAZYLOAD)
7744 printf (" LAZYLOAD");
7745
7746 puts ("");
7747 }
7748
7749 return 1;
7750 }
7751
7752 #ifdef SUPPORT_DISASSEMBLY
7753 static int
7754 disassemble_section (Elf_Internal_Shdr *section, FILE *file)
7755 {
7756 printf (_("\nAssembly dump of section %s\n"),
7757 SECTION_NAME (section));
7758
7759 /* XXX -- to be done --- XXX */
7760
7761 return 1;
7762 }
7763 #endif
7764
7765 static int
7766 dump_section_as_strings (Elf_Internal_Shdr *section, FILE *file)
7767 {
7768 Elf_Internal_Shdr *relsec;
7769 bfd_size_type num_bytes;
7770 bfd_vma addr;
7771 char *data;
7772 char *end;
7773 char *start;
7774 char *name = SECTION_NAME (section);
7775 bfd_boolean some_strings_shown;
7776
7777 num_bytes = section->sh_size;
7778
7779 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
7780 {
7781 printf (_("\nSection '%s' has no data to dump.\n"), name);
7782 return 0;
7783 }
7784
7785 addr = section->sh_addr;
7786
7787 start = get_data (NULL, file, section->sh_offset, 1, num_bytes,
7788 _("section data"));
7789 if (!start)
7790 return 0;
7791
7792 printf (_("\nString dump of section '%s':\n"), name);
7793
7794 /* If the section being dumped has relocations against it the user might
7795 be expecting these relocations to have been applied. Check for this
7796 case and issue a warning message in order to avoid confusion.
7797 FIXME: Maybe we ought to have an option that dumps a section with
7798 relocs applied ? */
7799 for (relsec = section_headers;
7800 relsec < section_headers + elf_header.e_shnum;
7801 ++relsec)
7802 {
7803 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
7804 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
7805 || SECTION_HEADER (relsec->sh_info) != section
7806 || relsec->sh_size == 0
7807 || SECTION_HEADER_INDEX (relsec->sh_link) >= elf_header.e_shnum)
7808 continue;
7809
7810 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7811 break;
7812 }
7813
7814 data = start;
7815 end = start + num_bytes;
7816 some_strings_shown = FALSE;
7817
7818 while (data < end)
7819 {
7820 while (!ISPRINT (* data))
7821 if (++ data >= end)
7822 break;
7823
7824 if (data < end)
7825 {
7826 printf (" [%6tx] %s\n", data - start, data);
7827 data += strlen (data);
7828 some_strings_shown = TRUE;
7829 }
7830 }
7831
7832 if (! some_strings_shown)
7833 printf (_(" No strings found in this section."));
7834
7835 free (start);
7836
7837 putchar ('\n');
7838 return 1;
7839 }
7840
7841
7842 static int
7843 dump_section_as_bytes (Elf_Internal_Shdr *section, FILE *file)
7844 {
7845 Elf_Internal_Shdr *relsec;
7846 bfd_size_type bytes;
7847 bfd_vma addr;
7848 unsigned char *data;
7849 unsigned char *start;
7850
7851 bytes = section->sh_size;
7852
7853 if (bytes == 0 || section->sh_type == SHT_NOBITS)
7854 {
7855 printf (_("\nSection '%s' has no data to dump.\n"),
7856 SECTION_NAME (section));
7857 return 0;
7858 }
7859 else
7860 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
7861
7862 addr = section->sh_addr;
7863
7864 start = get_data (NULL, file, section->sh_offset, 1, bytes,
7865 _("section data"));
7866 if (!start)
7867 return 0;
7868
7869 /* If the section being dumped has relocations against it the user might
7870 be expecting these relocations to have been applied. Check for this
7871 case and issue a warning message in order to avoid confusion.
7872 FIXME: Maybe we ought to have an option that dumps a section with
7873 relocs applied ? */
7874 for (relsec = section_headers;
7875 relsec < section_headers + elf_header.e_shnum;
7876 ++relsec)
7877 {
7878 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
7879 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
7880 || SECTION_HEADER (relsec->sh_info) != section
7881 || relsec->sh_size == 0
7882 || SECTION_HEADER_INDEX (relsec->sh_link) >= elf_header.e_shnum)
7883 continue;
7884
7885 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7886 break;
7887 }
7888
7889 data = start;
7890
7891 while (bytes)
7892 {
7893 int j;
7894 int k;
7895 int lbytes;
7896
7897 lbytes = (bytes > 16 ? 16 : bytes);
7898
7899 printf (" 0x%8.8lx ", (unsigned long) addr);
7900
7901 for (j = 0; j < 16; j++)
7902 {
7903 if (j < lbytes)
7904 printf ("%2.2x", data[j]);
7905 else
7906 printf (" ");
7907
7908 if ((j & 3) == 3)
7909 printf (" ");
7910 }
7911
7912 for (j = 0; j < lbytes; j++)
7913 {
7914 k = data[j];
7915 if (k >= ' ' && k < 0x7f)
7916 printf ("%c", k);
7917 else
7918 printf (".");
7919 }
7920
7921 putchar ('\n');
7922
7923 data += lbytes;
7924 addr += lbytes;
7925 bytes -= lbytes;
7926 }
7927
7928 free (start);
7929
7930 putchar ('\n');
7931 return 1;
7932 }
7933
7934 /* Return the number of bytes affected by a given reloc.
7935 This information is architecture and reloc dependent.
7936 Returns 4 by default, although this is not always correct.
7937 It should return 0 if a decision cannot be made.
7938 FIXME: This is not the correct way to solve this problem.
7939 The proper way is to have target specific reloc sizing functions
7940 created by the reloc-macros.h header, in the same way that it
7941 already creates the reloc naming functions. */
7942
7943 static unsigned int
7944 get_reloc_size (Elf_Internal_Rela * reloc)
7945 {
7946 switch (elf_header.e_machine)
7947 {
7948 case EM_H8S:
7949 case EM_H8_300:
7950 case EM_H8_300H:
7951 case EM_H8_500:
7952 switch (ELF32_R_TYPE (reloc->r_info))
7953 {
7954 /* PR gas/3800 - without this information we do not correctly
7955 decode the debug information generated by the h8300 assembler. */
7956 case R_H8_DIR16:
7957 return 2;
7958 default:
7959 return 4;
7960 }
7961 default:
7962 /* FIXME: We need to extend this switch statement to cope with other
7963 architecture's relocs. (When those relocs are used against debug
7964 sections, and when their size is not 4). But see the multiple
7965 inclusions of <elf/h8.h> for an example of the hoops that we need
7966 to jump through in order to obtain the reloc numbers. */
7967 return 4;
7968 }
7969 }
7970
7971 /* Apply addends of RELA relocations. */
7972
7973 static int
7974 debug_apply_rela_addends (void *file,
7975 Elf_Internal_Shdr *section,
7976 unsigned char *start)
7977 {
7978 Elf_Internal_Shdr *relsec;
7979 unsigned char *end = start + section->sh_size;
7980
7981 if (!is_relocatable)
7982 return 1;
7983
7984 /* SH uses RELA but uses in place value instead of the addend field. */
7985 if (elf_header.e_machine == EM_SH)
7986 return 0;
7987
7988 for (relsec = section_headers;
7989 relsec < section_headers + elf_header.e_shnum;
7990 ++relsec)
7991 {
7992 unsigned long nrelas;
7993 Elf_Internal_Rela *rela, *rp;
7994 Elf_Internal_Shdr *symsec;
7995 Elf_Internal_Sym *symtab;
7996 Elf_Internal_Sym *sym;
7997
7998 if (relsec->sh_type != SHT_RELA
7999 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
8000 || SECTION_HEADER (relsec->sh_info) != section
8001 || relsec->sh_size == 0
8002 || SECTION_HEADER_INDEX (relsec->sh_link) >= elf_header.e_shnum)
8003 continue;
8004
8005 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
8006 &rela, &nrelas))
8007 return 0;
8008
8009 symsec = SECTION_HEADER (relsec->sh_link);
8010 symtab = GET_ELF_SYMBOLS (file, symsec);
8011
8012 for (rp = rela; rp < rela + nrelas; ++rp)
8013 {
8014 unsigned char *loc;
8015 unsigned int reloc_size;
8016
8017 reloc_size = get_reloc_size (rp);
8018 if (reloc_size == 0)
8019 {
8020 warn (_("skipping relocation of unknown size against offset 0x%lx in section %s\n"),
8021 (unsigned long) rp->r_offset,
8022 SECTION_NAME (section));
8023 continue;
8024 }
8025
8026 loc = start + rp->r_offset;
8027 if ((loc + reloc_size) > end)
8028 {
8029 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8030 (unsigned long) rp->r_offset,
8031 SECTION_NAME (section));
8032 continue;
8033 }
8034
8035 if (is_32bit_elf)
8036 {
8037 sym = symtab + ELF32_R_SYM (rp->r_info);
8038
8039 if (ELF32_R_SYM (rp->r_info) != 0
8040 && ELF32_ST_TYPE (sym->st_info) != STT_SECTION
8041 /* Relocations against symbols without type can happen.
8042 Gcc -feliminate-dwarf2-dups may generate symbols
8043 without type for debug info. */
8044 && ELF32_ST_TYPE (sym->st_info) != STT_NOTYPE
8045 /* Relocations against object symbols can happen,
8046 eg when referencing a global array. For an
8047 example of this see the _clz.o binary in libgcc.a. */
8048 && ELF32_ST_TYPE (sym->st_info) != STT_OBJECT)
8049 {
8050 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
8051 get_symbol_type (ELF32_ST_TYPE (sym->st_info)),
8052 SECTION_NAME (section));
8053 continue;
8054 }
8055 }
8056 else
8057 {
8058 /* In MIPS little-endian objects, r_info isn't really a
8059 64-bit little-endian value: it has a 32-bit little-endian
8060 symbol index followed by four individual byte fields.
8061 Reorder INFO accordingly. */
8062 if (elf_header.e_machine == EM_MIPS
8063 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
8064 rp->r_info = (((rp->r_info & 0xffffffff) << 32)
8065 | ((rp->r_info >> 56) & 0xff)
8066 | ((rp->r_info >> 40) & 0xff00)
8067 | ((rp->r_info >> 24) & 0xff0000)
8068 | ((rp->r_info >> 8) & 0xff000000));
8069
8070 sym = symtab + ELF64_R_SYM (rp->r_info);
8071
8072 if (ELF64_R_SYM (rp->r_info) != 0
8073 && ELF64_ST_TYPE (sym->st_info) != STT_SECTION
8074 && ELF64_ST_TYPE (sym->st_info) != STT_NOTYPE
8075 && ELF64_ST_TYPE (sym->st_info) != STT_OBJECT)
8076 {
8077 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
8078 get_symbol_type (ELF64_ST_TYPE (sym->st_info)),
8079 SECTION_NAME (section));
8080 continue;
8081 }
8082 }
8083
8084 byte_put (loc, rp->r_addend, reloc_size);
8085 }
8086
8087 free (symtab);
8088 free (rela);
8089 break;
8090 }
8091 return 1;
8092 }
8093
8094 int
8095 load_debug_section (enum dwarf_section_display_enum debug, void *file)
8096 {
8097 struct dwarf_section *section = &debug_displays [debug].section;
8098 Elf_Internal_Shdr *sec;
8099 char buf [64];
8100
8101 /* If it is already loaded, do nothing. */
8102 if (section->start != NULL)
8103 return 1;
8104
8105 /* Locate the debug section. */
8106 sec = find_section (section->name);
8107 if (sec == NULL)
8108 return 0;
8109
8110 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
8111 section->address = sec->sh_addr;
8112 section->size = sec->sh_size;
8113 section->start = get_data (NULL, file, sec->sh_offset, 1,
8114 sec->sh_size, buf);
8115
8116 if (debug_displays [debug].relocate)
8117 debug_apply_rela_addends (file, sec, section->start);
8118
8119 return section->start != NULL;
8120 }
8121
8122 void
8123 free_debug_section (enum dwarf_section_display_enum debug)
8124 {
8125 struct dwarf_section *section = &debug_displays [debug].section;
8126
8127 if (section->start == NULL)
8128 return;
8129
8130 free ((char *) section->start);
8131 section->start = NULL;
8132 section->address = 0;
8133 section->size = 0;
8134 }
8135
8136 static int
8137 display_debug_section (Elf_Internal_Shdr *section, FILE *file)
8138 {
8139 char *name = SECTION_NAME (section);
8140 bfd_size_type length;
8141 int result = 1;
8142 enum dwarf_section_display_enum i;
8143
8144 length = section->sh_size;
8145 if (length == 0)
8146 {
8147 printf (_("\nSection '%s' has no debugging data.\n"), name);
8148 return 0;
8149 }
8150
8151 if (const_strneq (name, ".gnu.linkonce.wi."))
8152 name = ".debug_info";
8153
8154 /* See if we know how to display the contents of this section. */
8155 for (i = 0; i < max; i++)
8156 if (streq (debug_displays[i].section.name, name))
8157 {
8158 struct dwarf_section *sec = &debug_displays [i].section;
8159
8160 if (load_debug_section (i, file))
8161 {
8162 result &= debug_displays[i].display (sec, file);
8163
8164 if (i != info && i != abbrev)
8165 free_debug_section (i);
8166 }
8167
8168 break;
8169 }
8170
8171 if (i == max)
8172 {
8173 printf (_("Unrecognized debug section: %s\n"), name);
8174 result = 0;
8175 }
8176
8177 return result;
8178 }
8179
8180 /* Set DUMP_SECTS for all sections where dumps were requested
8181 based on section name. */
8182
8183 static void
8184 initialise_dumps_byname (void)
8185 {
8186 struct dump_list_entry *cur;
8187
8188 for (cur = dump_sects_byname; cur; cur = cur->next)
8189 {
8190 unsigned int i;
8191 int any;
8192
8193 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
8194 if (streq (SECTION_NAME (section_headers + i), cur->name))
8195 {
8196 request_dump_bynumber (i, cur->type);
8197 any = 1;
8198 }
8199
8200 if (!any)
8201 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8202 cur->name);
8203 }
8204 }
8205
8206 static void
8207 process_section_contents (FILE *file)
8208 {
8209 Elf_Internal_Shdr *section;
8210 unsigned int i;
8211
8212 if (! do_dump)
8213 return;
8214
8215 initialise_dumps_byname ();
8216
8217 for (i = 0, section = section_headers;
8218 i < elf_header.e_shnum && i < num_dump_sects;
8219 i++, section++)
8220 {
8221 #ifdef SUPPORT_DISASSEMBLY
8222 if (dump_sects[i] & DISASS_DUMP)
8223 disassemble_section (section, file);
8224 #endif
8225 if (dump_sects[i] & HEX_DUMP)
8226 dump_section_as_bytes (section, file);
8227
8228 if (dump_sects[i] & DEBUG_DUMP)
8229 display_debug_section (section, file);
8230
8231 if (dump_sects[i] & STRING_DUMP)
8232 dump_section_as_strings (section, file);
8233 }
8234
8235 /* Check to see if the user requested a
8236 dump of a section that does not exist. */
8237 while (i++ < num_dump_sects)
8238 if (dump_sects[i])
8239 warn (_("Section %d was not dumped because it does not exist!\n"), i);
8240 }
8241
8242 static void
8243 process_mips_fpe_exception (int mask)
8244 {
8245 if (mask)
8246 {
8247 int first = 1;
8248 if (mask & OEX_FPU_INEX)
8249 fputs ("INEX", stdout), first = 0;
8250 if (mask & OEX_FPU_UFLO)
8251 printf ("%sUFLO", first ? "" : "|"), first = 0;
8252 if (mask & OEX_FPU_OFLO)
8253 printf ("%sOFLO", first ? "" : "|"), first = 0;
8254 if (mask & OEX_FPU_DIV0)
8255 printf ("%sDIV0", first ? "" : "|"), first = 0;
8256 if (mask & OEX_FPU_INVAL)
8257 printf ("%sINVAL", first ? "" : "|");
8258 }
8259 else
8260 fputs ("0", stdout);
8261 }
8262
8263 /* ARM EABI attributes section. */
8264 typedef struct
8265 {
8266 int tag;
8267 const char *name;
8268 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8269 int type;
8270 const char **table;
8271 } arm_attr_public_tag;
8272
8273 static const char *arm_attr_tag_CPU_arch[] =
8274 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8275 "v6K", "v7"};
8276 static const char *arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
8277 static const char *arm_attr_tag_THUMB_ISA_use[] =
8278 {"No", "Thumb-1", "Thumb-2"};
8279 /* FIXME: VFPv3 encoding was extrapolated! */
8280 static const char *arm_attr_tag_VFP_arch[] = {"No", "VFPv1", "VFPv2", "VFPv3"};
8281 static const char *arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1"};
8282 static const char *arm_attr_tag_NEON_arch[] = {"No", "NEONv1"};
8283 static const char *arm_attr_tag_ABI_PCS_config[] =
8284 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8285 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8286 static const char *arm_attr_tag_ABI_PCS_R9_use[] =
8287 {"V6", "SB", "TLS", "Unused"};
8288 static const char *arm_attr_tag_ABI_PCS_RW_data[] =
8289 {"Absolute", "PC-relative", "SB-relative", "None"};
8290 static const char *arm_attr_tag_ABI_PCS_RO_DATA[] =
8291 {"Absolute", "PC-relative", "None"};
8292 static const char *arm_attr_tag_ABI_PCS_GOT_use[] =
8293 {"None", "direct", "GOT-indirect"};
8294 static const char *arm_attr_tag_ABI_PCS_wchar_t[] =
8295 {"None", "??? 1", "2", "??? 3", "4"};
8296 static const char *arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
8297 static const char *arm_attr_tag_ABI_FP_denormal[] = {"Unused", "Needed"};
8298 static const char *arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
8299 static const char *arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
8300 static const char *arm_attr_tag_ABI_FP_number_model[] =
8301 {"Unused", "Finite", "RTABI", "IEEE 754"};
8302 static const char *arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
8303 static const char *arm_attr_tag_ABI_align8_preserved[] =
8304 {"No", "Yes, except leaf SP", "Yes"};
8305 static const char *arm_attr_tag_ABI_enum_size[] =
8306 {"Unused", "small", "int", "forced to int"};
8307 static const char *arm_attr_tag_ABI_HardFP_use[] =
8308 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8309 static const char *arm_attr_tag_ABI_VFP_args[] =
8310 {"AAPCS", "VFP registers", "custom"};
8311 static const char *arm_attr_tag_ABI_WMMX_args[] =
8312 {"AAPCS", "WMMX registers", "custom"};
8313 static const char *arm_attr_tag_ABI_optimization_goals[] =
8314 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8315 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8316 static const char *arm_attr_tag_ABI_FP_optimization_goals[] =
8317 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8318 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8319
8320 #define LOOKUP(id, name) \
8321 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8322 static arm_attr_public_tag arm_attr_public_tags[] =
8323 {
8324 {4, "CPU_raw_name", 1, NULL},
8325 {5, "CPU_name", 1, NULL},
8326 LOOKUP(6, CPU_arch),
8327 {7, "CPU_arch_profile", 0, NULL},
8328 LOOKUP(8, ARM_ISA_use),
8329 LOOKUP(9, THUMB_ISA_use),
8330 LOOKUP(10, VFP_arch),
8331 LOOKUP(11, WMMX_arch),
8332 LOOKUP(12, NEON_arch),
8333 LOOKUP(13, ABI_PCS_config),
8334 LOOKUP(14, ABI_PCS_R9_use),
8335 LOOKUP(15, ABI_PCS_RW_data),
8336 LOOKUP(16, ABI_PCS_RO_DATA),
8337 LOOKUP(17, ABI_PCS_GOT_use),
8338 LOOKUP(18, ABI_PCS_wchar_t),
8339 LOOKUP(19, ABI_FP_rounding),
8340 LOOKUP(20, ABI_FP_denormal),
8341 LOOKUP(21, ABI_FP_exceptions),
8342 LOOKUP(22, ABI_FP_user_exceptions),
8343 LOOKUP(23, ABI_FP_number_model),
8344 LOOKUP(24, ABI_align8_needed),
8345 LOOKUP(25, ABI_align8_preserved),
8346 LOOKUP(26, ABI_enum_size),
8347 LOOKUP(27, ABI_HardFP_use),
8348 LOOKUP(28, ABI_VFP_args),
8349 LOOKUP(29, ABI_WMMX_args),
8350 LOOKUP(30, ABI_optimization_goals),
8351 LOOKUP(31, ABI_FP_optimization_goals),
8352 {32, "compatibility", 0, NULL}
8353 };
8354 #undef LOOKUP
8355
8356 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8357 bytes read. */
8358 static unsigned int
8359 read_uleb128 (unsigned char *p, unsigned int *plen)
8360 {
8361 unsigned char c;
8362 unsigned int val;
8363 int shift;
8364 int len;
8365
8366 val = 0;
8367 shift = 0;
8368 len = 0;
8369 do
8370 {
8371 c = *(p++);
8372 len++;
8373 val |= ((unsigned int)c & 0x7f) << shift;
8374 shift += 7;
8375 }
8376 while (c & 0x80);
8377
8378 *plen = len;
8379 return val;
8380 }
8381
8382 static unsigned char *
8383 display_arm_attribute (unsigned char *p)
8384 {
8385 int tag;
8386 unsigned int len;
8387 int val;
8388 arm_attr_public_tag *attr;
8389 unsigned i;
8390 int type;
8391
8392 tag = read_uleb128 (p, &len);
8393 p += len;
8394 attr = NULL;
8395 for (i = 0; i < ARRAY_SIZE(arm_attr_public_tags); i++)
8396 {
8397 if (arm_attr_public_tags[i].tag == tag)
8398 {
8399 attr = &arm_attr_public_tags[i];
8400 break;
8401 }
8402 }
8403
8404 if (attr)
8405 {
8406 printf (" Tag_%s: ", attr->name);
8407 switch (attr->type)
8408 {
8409 case 0:
8410 switch (tag)
8411 {
8412 case 7: /* Tag_CPU_arch_profile. */
8413 val = read_uleb128 (p, &len);
8414 p += len;
8415 switch (val)
8416 {
8417 case 0: printf ("None\n"); break;
8418 case 'A': printf ("Application\n"); break;
8419 case 'R': printf ("Realtime\n"); break;
8420 case 'M': printf ("Microcontroller\n"); break;
8421 default: printf ("??? (%d)\n", val); break;
8422 }
8423 break;
8424
8425 case 32: /* Tag_compatibility. */
8426 val = read_uleb128 (p, &len);
8427 p += len;
8428 printf ("flag = %d, vendor = %s\n", val, p);
8429 p += strlen((char *)p) + 1;
8430 break;
8431
8432 default:
8433 abort();
8434 }
8435 return p;
8436
8437 case 1:
8438 case 2:
8439 type = attr->type;
8440 break;
8441
8442 default:
8443 assert (attr->type & 0x80);
8444 val = read_uleb128 (p, &len);
8445 p += len;
8446 type = attr->type & 0x7f;
8447 if (val >= type)
8448 printf ("??? (%d)\n", val);
8449 else
8450 printf ("%s\n", attr->table[val]);
8451 return p;
8452 }
8453 }
8454 else
8455 {
8456 if (tag & 1)
8457 type = 1; /* String. */
8458 else
8459 type = 2; /* uleb128. */
8460 printf (" Tag_unknown_%d: ", tag);
8461 }
8462
8463 if (type == 1)
8464 {
8465 printf ("\"%s\"\n", p);
8466 p += strlen((char *)p) + 1;
8467 }
8468 else
8469 {
8470 val = read_uleb128 (p, &len);
8471 p += len;
8472 printf ("%d (0x%x)\n", val, val);
8473 }
8474
8475 return p;
8476 }
8477
8478 static unsigned char *
8479 display_gnu_attribute (unsigned char * p,
8480 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
8481 {
8482 int tag;
8483 unsigned int len;
8484 int val;
8485 int type;
8486
8487 tag = read_uleb128 (p, &len);
8488 p += len;
8489
8490 /* Tag_compatibility is the only generic GNU attribute defined at
8491 present. */
8492 if (tag == 32)
8493 {
8494 val = read_uleb128 (p, &len);
8495 p += len;
8496 printf ("flag = %d, vendor = %s\n", val, p);
8497 p += strlen ((char *) p) + 1;
8498 return p;
8499 }
8500
8501 if ((tag & 2) == 0 && display_proc_gnu_attribute)
8502 return display_proc_gnu_attribute (p, tag);
8503
8504 if (tag & 1)
8505 type = 1; /* String. */
8506 else
8507 type = 2; /* uleb128. */
8508 printf (" Tag_unknown_%d: ", tag);
8509
8510 if (type == 1)
8511 {
8512 printf ("\"%s\"\n", p);
8513 p += strlen ((char *) p) + 1;
8514 }
8515 else
8516 {
8517 val = read_uleb128 (p, &len);
8518 p += len;
8519 printf ("%d (0x%x)\n", val, val);
8520 }
8521
8522 return p;
8523 }
8524
8525 static unsigned char *
8526 display_power_gnu_attribute (unsigned char *p, int tag)
8527 {
8528 int type;
8529 unsigned int len;
8530 int val;
8531
8532 if (tag == Tag_GNU_Power_ABI_FP)
8533 {
8534 val = read_uleb128 (p, &len);
8535 p += len;
8536 printf (" Tag_GNU_Power_ABI_FP: ");
8537
8538 switch (val)
8539 {
8540 case 0:
8541 printf ("Hard or soft float\n");
8542 break;
8543 case 1:
8544 printf ("Hard float\n");
8545 break;
8546 case 2:
8547 printf ("Soft float\n");
8548 break;
8549 default:
8550 printf ("??? (%d)\n", val);
8551 break;
8552 }
8553 return p;
8554 }
8555
8556 if (tag == Tag_GNU_Power_ABI_Vector)
8557 {
8558 val = read_uleb128 (p, &len);
8559 p += len;
8560 printf (" Tag_GNU_Power_ABI_Vector: ");
8561 switch (val)
8562 {
8563 case 0:
8564 printf ("Any\n");
8565 break;
8566 case 1:
8567 printf ("Generic\n");
8568 break;
8569 case 2:
8570 printf ("AltiVec\n");
8571 break;
8572 case 3:
8573 printf ("SPE\n");
8574 break;
8575 default:
8576 printf ("??? (%d)\n", val);
8577 break;
8578 }
8579 return p;
8580 }
8581
8582 if (tag & 1)
8583 type = 1; /* String. */
8584 else
8585 type = 2; /* uleb128. */
8586 printf (" Tag_unknown_%d: ", tag);
8587
8588 if (type == 1)
8589 {
8590 printf ("\"%s\"\n", p);
8591 p += strlen ((char *) p) + 1;
8592 }
8593 else
8594 {
8595 val = read_uleb128 (p, &len);
8596 p += len;
8597 printf ("%d (0x%x)\n", val, val);
8598 }
8599
8600 return p;
8601 }
8602
8603 static unsigned char *
8604 display_mips_gnu_attribute (unsigned char *p, int tag)
8605 {
8606 int type;
8607 unsigned int len;
8608 int val;
8609
8610 if (tag == Tag_GNU_MIPS_ABI_FP)
8611 {
8612 val = read_uleb128 (p, &len);
8613 p += len;
8614 printf (" Tag_GNU_MIPS_ABI_FP: ");
8615
8616 switch (val)
8617 {
8618 case 0:
8619 printf ("Hard or soft float\n");
8620 break;
8621 case 1:
8622 printf ("Hard float (-mdouble-float)\n");
8623 break;
8624 case 2:
8625 printf ("Hard float (-msingle-float)\n");
8626 break;
8627 case 3:
8628 printf ("Soft float\n");
8629 break;
8630 default:
8631 printf ("??? (%d)\n", val);
8632 break;
8633 }
8634 return p;
8635 }
8636
8637 if (tag & 1)
8638 type = 1; /* String. */
8639 else
8640 type = 2; /* uleb128. */
8641 printf (" Tag_unknown_%d: ", tag);
8642
8643 if (type == 1)
8644 {
8645 printf ("\"%s\"\n", p);
8646 p += strlen ((char *) p) + 1;
8647 }
8648 else
8649 {
8650 val = read_uleb128 (p, &len);
8651 p += len;
8652 printf ("%d (0x%x)\n", val, val);
8653 }
8654
8655 return p;
8656 }
8657
8658 static int
8659 process_attributes (FILE * file,
8660 const char * public_name,
8661 unsigned int proc_type,
8662 unsigned char * (* display_pub_attribute) (unsigned char *),
8663 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
8664 {
8665 Elf_Internal_Shdr *sect;
8666 unsigned char *contents;
8667 unsigned char *p;
8668 unsigned char *end;
8669 bfd_vma section_len;
8670 bfd_vma len;
8671 unsigned i;
8672
8673 /* Find the section header so that we get the size. */
8674 for (i = 0, sect = section_headers;
8675 i < elf_header.e_shnum;
8676 i++, sect++)
8677 {
8678 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
8679 continue;
8680
8681 contents = get_data (NULL, file, sect->sh_offset, 1, sect->sh_size,
8682 _("attributes"));
8683 if (contents == NULL)
8684 continue;
8685
8686 p = contents;
8687 if (*p == 'A')
8688 {
8689 len = sect->sh_size - 1;
8690 p++;
8691
8692 while (len > 0)
8693 {
8694 int namelen;
8695 bfd_boolean public_section;
8696 bfd_boolean gnu_section;
8697
8698 section_len = byte_get (p, 4);
8699 p += 4;
8700
8701 if (section_len > len)
8702 {
8703 printf (_("ERROR: Bad section length (%d > %d)\n"),
8704 (int) section_len, (int) len);
8705 section_len = len;
8706 }
8707
8708 len -= section_len;
8709 printf ("Attribute Section: %s\n", p);
8710
8711 if (public_name && streq ((char *) p, public_name))
8712 public_section = TRUE;
8713 else
8714 public_section = FALSE;
8715
8716 if (streq ((char *) p, "gnu"))
8717 gnu_section = TRUE;
8718 else
8719 gnu_section = FALSE;
8720
8721 namelen = strlen ((char *) p) + 1;
8722 p += namelen;
8723 section_len -= namelen + 4;
8724
8725 while (section_len > 0)
8726 {
8727 int tag = *(p++);
8728 int val;
8729 bfd_vma size;
8730
8731 size = byte_get (p, 4);
8732 if (size > section_len)
8733 {
8734 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
8735 (int) size, (int) section_len);
8736 size = section_len;
8737 }
8738
8739 section_len -= size;
8740 end = p + size - 1;
8741 p += 4;
8742
8743 switch (tag)
8744 {
8745 case 1:
8746 printf ("File Attributes\n");
8747 break;
8748 case 2:
8749 printf ("Section Attributes:");
8750 goto do_numlist;
8751 case 3:
8752 printf ("Symbol Attributes:");
8753 do_numlist:
8754 for (;;)
8755 {
8756 unsigned int i;
8757
8758 val = read_uleb128 (p, &i);
8759 p += i;
8760 if (val == 0)
8761 break;
8762 printf (" %d", val);
8763 }
8764 printf ("\n");
8765 break;
8766 default:
8767 printf ("Unknown tag: %d\n", tag);
8768 public_section = FALSE;
8769 break;
8770 }
8771
8772 if (public_section)
8773 {
8774 while (p < end)
8775 p = display_pub_attribute (p);
8776 }
8777 else if (gnu_section)
8778 {
8779 while (p < end)
8780 p = display_gnu_attribute (p,
8781 display_proc_gnu_attribute);
8782 }
8783 else
8784 {
8785 /* ??? Do something sensible, like dump hex. */
8786 printf (" Unknown section contexts\n");
8787 p = end;
8788 }
8789 }
8790 }
8791 }
8792 else
8793 printf (_("Unknown format '%c'\n"), *p);
8794
8795 free (contents);
8796 }
8797 return 1;
8798 }
8799
8800 static int
8801 process_arm_specific (FILE *file)
8802 {
8803 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
8804 display_arm_attribute, NULL);
8805 }
8806
8807 static int
8808 process_power_specific (FILE *file)
8809 {
8810 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
8811 display_power_gnu_attribute);
8812 }
8813
8814 static int
8815 process_mips_specific (FILE *file)
8816 {
8817 Elf_Internal_Dyn *entry;
8818 size_t liblist_offset = 0;
8819 size_t liblistno = 0;
8820 size_t conflictsno = 0;
8821 size_t options_offset = 0;
8822 size_t conflicts_offset = 0;
8823
8824 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
8825 display_mips_gnu_attribute);
8826
8827 /* We have a lot of special sections. Thanks SGI! */
8828 if (dynamic_section == NULL)
8829 /* No information available. */
8830 return 0;
8831
8832 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
8833 switch (entry->d_tag)
8834 {
8835 case DT_MIPS_LIBLIST:
8836 liblist_offset
8837 = offset_from_vma (file, entry->d_un.d_val,
8838 liblistno * sizeof (Elf32_External_Lib));
8839 break;
8840 case DT_MIPS_LIBLISTNO:
8841 liblistno = entry->d_un.d_val;
8842 break;
8843 case DT_MIPS_OPTIONS:
8844 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8845 break;
8846 case DT_MIPS_CONFLICT:
8847 conflicts_offset
8848 = offset_from_vma (file, entry->d_un.d_val,
8849 conflictsno * sizeof (Elf32_External_Conflict));
8850 break;
8851 case DT_MIPS_CONFLICTNO:
8852 conflictsno = entry->d_un.d_val;
8853 break;
8854 default:
8855 break;
8856 }
8857
8858 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
8859 {
8860 Elf32_External_Lib *elib;
8861 size_t cnt;
8862
8863 elib = get_data (NULL, file, liblist_offset,
8864 liblistno, sizeof (Elf32_External_Lib),
8865 _("liblist"));
8866 if (elib)
8867 {
8868 printf ("\nSection '.liblist' contains %lu entries:\n",
8869 (unsigned long) liblistno);
8870 fputs (" Library Time Stamp Checksum Version Flags\n",
8871 stdout);
8872
8873 for (cnt = 0; cnt < liblistno; ++cnt)
8874 {
8875 Elf32_Lib liblist;
8876 time_t time;
8877 char timebuf[20];
8878 struct tm *tmp;
8879
8880 liblist.l_name = BYTE_GET (elib[cnt].l_name);
8881 time = BYTE_GET (elib[cnt].l_time_stamp);
8882 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
8883 liblist.l_version = BYTE_GET (elib[cnt].l_version);
8884 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
8885
8886 tmp = gmtime (&time);
8887 snprintf (timebuf, sizeof (timebuf),
8888 "%04u-%02u-%02uT%02u:%02u:%02u",
8889 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8890 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8891
8892 printf ("%3lu: ", (unsigned long) cnt);
8893 if (VALID_DYNAMIC_NAME (liblist.l_name))
8894 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
8895 else
8896 printf ("<corrupt: %9ld>", liblist.l_name);
8897 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
8898 liblist.l_version);
8899
8900 if (liblist.l_flags == 0)
8901 puts (" NONE");
8902 else
8903 {
8904 static const struct
8905 {
8906 const char *name;
8907 int bit;
8908 }
8909 l_flags_vals[] =
8910 {
8911 { " EXACT_MATCH", LL_EXACT_MATCH },
8912 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
8913 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
8914 { " EXPORTS", LL_EXPORTS },
8915 { " DELAY_LOAD", LL_DELAY_LOAD },
8916 { " DELTA", LL_DELTA }
8917 };
8918 int flags = liblist.l_flags;
8919 size_t fcnt;
8920
8921 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
8922 if ((flags & l_flags_vals[fcnt].bit) != 0)
8923 {
8924 fputs (l_flags_vals[fcnt].name, stdout);
8925 flags ^= l_flags_vals[fcnt].bit;
8926 }
8927 if (flags != 0)
8928 printf (" %#x", (unsigned int) flags);
8929
8930 puts ("");
8931 }
8932 }
8933
8934 free (elib);
8935 }
8936 }
8937
8938 if (options_offset != 0)
8939 {
8940 Elf_External_Options *eopt;
8941 Elf_Internal_Shdr *sect = section_headers;
8942 Elf_Internal_Options *iopt;
8943 Elf_Internal_Options *option;
8944 size_t offset;
8945 int cnt;
8946
8947 /* Find the section header so that we get the size. */
8948 while (sect->sh_type != SHT_MIPS_OPTIONS)
8949 ++sect;
8950
8951 eopt = get_data (NULL, file, options_offset, 1, sect->sh_size,
8952 _("options"));
8953 if (eopt)
8954 {
8955 iopt = cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (*iopt));
8956 if (iopt == NULL)
8957 {
8958 error (_("Out of memory\n"));
8959 return 0;
8960 }
8961
8962 offset = cnt = 0;
8963 option = iopt;
8964
8965 while (offset < sect->sh_size)
8966 {
8967 Elf_External_Options *eoption;
8968
8969 eoption = (Elf_External_Options *) ((char *) eopt + offset);
8970
8971 option->kind = BYTE_GET (eoption->kind);
8972 option->size = BYTE_GET (eoption->size);
8973 option->section = BYTE_GET (eoption->section);
8974 option->info = BYTE_GET (eoption->info);
8975
8976 offset += option->size;
8977
8978 ++option;
8979 ++cnt;
8980 }
8981
8982 printf (_("\nSection '%s' contains %d entries:\n"),
8983 SECTION_NAME (sect), cnt);
8984
8985 option = iopt;
8986
8987 while (cnt-- > 0)
8988 {
8989 size_t len;
8990
8991 switch (option->kind)
8992 {
8993 case ODK_NULL:
8994 /* This shouldn't happen. */
8995 printf (" NULL %d %lx", option->section, option->info);
8996 break;
8997 case ODK_REGINFO:
8998 printf (" REGINFO ");
8999 if (elf_header.e_machine == EM_MIPS)
9000 {
9001 /* 32bit form. */
9002 Elf32_External_RegInfo *ereg;
9003 Elf32_RegInfo reginfo;
9004
9005 ereg = (Elf32_External_RegInfo *) (option + 1);
9006 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9007 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9008 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9009 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9010 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9011 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9012
9013 printf ("GPR %08lx GP 0x%lx\n",
9014 reginfo.ri_gprmask,
9015 (unsigned long) reginfo.ri_gp_value);
9016 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9017 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9018 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9019 }
9020 else
9021 {
9022 /* 64 bit form. */
9023 Elf64_External_RegInfo *ereg;
9024 Elf64_Internal_RegInfo reginfo;
9025
9026 ereg = (Elf64_External_RegInfo *) (option + 1);
9027 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9028 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9029 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9030 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9031 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9032 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9033
9034 printf ("GPR %08lx GP 0x",
9035 reginfo.ri_gprmask);
9036 printf_vma (reginfo.ri_gp_value);
9037 printf ("\n");
9038
9039 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9040 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9041 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9042 }
9043 ++option;
9044 continue;
9045 case ODK_EXCEPTIONS:
9046 fputs (" EXCEPTIONS fpe_min(", stdout);
9047 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9048 fputs (") fpe_max(", stdout);
9049 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9050 fputs (")", stdout);
9051
9052 if (option->info & OEX_PAGE0)
9053 fputs (" PAGE0", stdout);
9054 if (option->info & OEX_SMM)
9055 fputs (" SMM", stdout);
9056 if (option->info & OEX_FPDBUG)
9057 fputs (" FPDBUG", stdout);
9058 if (option->info & OEX_DISMISS)
9059 fputs (" DISMISS", stdout);
9060 break;
9061 case ODK_PAD:
9062 fputs (" PAD ", stdout);
9063 if (option->info & OPAD_PREFIX)
9064 fputs (" PREFIX", stdout);
9065 if (option->info & OPAD_POSTFIX)
9066 fputs (" POSTFIX", stdout);
9067 if (option->info & OPAD_SYMBOL)
9068 fputs (" SYMBOL", stdout);
9069 break;
9070 case ODK_HWPATCH:
9071 fputs (" HWPATCH ", stdout);
9072 if (option->info & OHW_R4KEOP)
9073 fputs (" R4KEOP", stdout);
9074 if (option->info & OHW_R8KPFETCH)
9075 fputs (" R8KPFETCH", stdout);
9076 if (option->info & OHW_R5KEOP)
9077 fputs (" R5KEOP", stdout);
9078 if (option->info & OHW_R5KCVTL)
9079 fputs (" R5KCVTL", stdout);
9080 break;
9081 case ODK_FILL:
9082 fputs (" FILL ", stdout);
9083 /* XXX Print content of info word? */
9084 break;
9085 case ODK_TAGS:
9086 fputs (" TAGS ", stdout);
9087 /* XXX Print content of info word? */
9088 break;
9089 case ODK_HWAND:
9090 fputs (" HWAND ", stdout);
9091 if (option->info & OHWA0_R4KEOP_CHECKED)
9092 fputs (" R4KEOP_CHECKED", stdout);
9093 if (option->info & OHWA0_R4KEOP_CLEAN)
9094 fputs (" R4KEOP_CLEAN", stdout);
9095 break;
9096 case ODK_HWOR:
9097 fputs (" HWOR ", stdout);
9098 if (option->info & OHWA0_R4KEOP_CHECKED)
9099 fputs (" R4KEOP_CHECKED", stdout);
9100 if (option->info & OHWA0_R4KEOP_CLEAN)
9101 fputs (" R4KEOP_CLEAN", stdout);
9102 break;
9103 case ODK_GP_GROUP:
9104 printf (" GP_GROUP %#06lx self-contained %#06lx",
9105 option->info & OGP_GROUP,
9106 (option->info & OGP_SELF) >> 16);
9107 break;
9108 case ODK_IDENT:
9109 printf (" IDENT %#06lx self-contained %#06lx",
9110 option->info & OGP_GROUP,
9111 (option->info & OGP_SELF) >> 16);
9112 break;
9113 default:
9114 /* This shouldn't happen. */
9115 printf (" %3d ??? %d %lx",
9116 option->kind, option->section, option->info);
9117 break;
9118 }
9119
9120 len = sizeof (*eopt);
9121 while (len < option->size)
9122 if (((char *) option)[len] >= ' '
9123 && ((char *) option)[len] < 0x7f)
9124 printf ("%c", ((char *) option)[len++]);
9125 else
9126 printf ("\\%03o", ((char *) option)[len++]);
9127
9128 fputs ("\n", stdout);
9129 ++option;
9130 }
9131
9132 free (eopt);
9133 }
9134 }
9135
9136 if (conflicts_offset != 0 && conflictsno != 0)
9137 {
9138 Elf32_Conflict *iconf;
9139 size_t cnt;
9140
9141 if (dynamic_symbols == NULL)
9142 {
9143 error (_("conflict list found without a dynamic symbol table\n"));
9144 return 0;
9145 }
9146
9147 iconf = cmalloc (conflictsno, sizeof (*iconf));
9148 if (iconf == NULL)
9149 {
9150 error (_("Out of memory\n"));
9151 return 0;
9152 }
9153
9154 if (is_32bit_elf)
9155 {
9156 Elf32_External_Conflict *econf32;
9157
9158 econf32 = get_data (NULL, file, conflicts_offset,
9159 conflictsno, sizeof (*econf32), _("conflict"));
9160 if (!econf32)
9161 return 0;
9162
9163 for (cnt = 0; cnt < conflictsno; ++cnt)
9164 iconf[cnt] = BYTE_GET (econf32[cnt]);
9165
9166 free (econf32);
9167 }
9168 else
9169 {
9170 Elf64_External_Conflict *econf64;
9171
9172 econf64 = get_data (NULL, file, conflicts_offset,
9173 conflictsno, sizeof (*econf64), _("conflict"));
9174 if (!econf64)
9175 return 0;
9176
9177 for (cnt = 0; cnt < conflictsno; ++cnt)
9178 iconf[cnt] = BYTE_GET (econf64[cnt]);
9179
9180 free (econf64);
9181 }
9182
9183 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9184 (unsigned long) conflictsno);
9185 puts (_(" Num: Index Value Name"));
9186
9187 for (cnt = 0; cnt < conflictsno; ++cnt)
9188 {
9189 Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
9190
9191 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
9192 print_vma (psym->st_value, FULL_HEX);
9193 putchar (' ');
9194 if (VALID_DYNAMIC_NAME (psym->st_name))
9195 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9196 else
9197 printf ("<corrupt: %14ld>", psym->st_name);
9198 putchar ('\n');
9199 }
9200
9201 free (iconf);
9202 }
9203
9204 return 1;
9205 }
9206
9207 static int
9208 process_gnu_liblist (FILE *file)
9209 {
9210 Elf_Internal_Shdr *section, *string_sec;
9211 Elf32_External_Lib *elib;
9212 char *strtab;
9213 size_t strtab_size;
9214 size_t cnt;
9215 unsigned i;
9216
9217 if (! do_arch)
9218 return 0;
9219
9220 for (i = 0, section = section_headers;
9221 i < elf_header.e_shnum;
9222 i++, section++)
9223 {
9224 switch (section->sh_type)
9225 {
9226 case SHT_GNU_LIBLIST:
9227 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum)
9228 break;
9229
9230 elib = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9231 _("liblist"));
9232
9233 if (elib == NULL)
9234 break;
9235 string_sec = SECTION_HEADER (section->sh_link);
9236
9237 strtab = get_data (NULL, file, string_sec->sh_offset, 1,
9238 string_sec->sh_size, _("liblist string table"));
9239 strtab_size = string_sec->sh_size;
9240
9241 if (strtab == NULL
9242 || section->sh_entsize != sizeof (Elf32_External_Lib))
9243 {
9244 free (elib);
9245 break;
9246 }
9247
9248 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9249 SECTION_NAME (section),
9250 (long) (section->sh_size / sizeof (Elf32_External_Lib)));
9251
9252 puts (" Library Time Stamp Checksum Version Flags");
9253
9254 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
9255 ++cnt)
9256 {
9257 Elf32_Lib liblist;
9258 time_t time;
9259 char timebuf[20];
9260 struct tm *tmp;
9261
9262 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9263 time = BYTE_GET (elib[cnt].l_time_stamp);
9264 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9265 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9266 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9267
9268 tmp = gmtime (&time);
9269 snprintf (timebuf, sizeof (timebuf),
9270 "%04u-%02u-%02uT%02u:%02u:%02u",
9271 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9272 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9273
9274 printf ("%3lu: ", (unsigned long) cnt);
9275 if (do_wide)
9276 printf ("%-20s", liblist.l_name < strtab_size
9277 ? strtab + liblist.l_name : "<corrupt>");
9278 else
9279 printf ("%-20.20s", liblist.l_name < strtab_size
9280 ? strtab + liblist.l_name : "<corrupt>");
9281 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
9282 liblist.l_version, liblist.l_flags);
9283 }
9284
9285 free (elib);
9286 }
9287 }
9288
9289 return 1;
9290 }
9291
9292 static const char *
9293 get_note_type (unsigned e_type)
9294 {
9295 static char buff[64];
9296
9297 if (elf_header.e_type == ET_CORE)
9298 switch (e_type)
9299 {
9300 case NT_AUXV:
9301 return _("NT_AUXV (auxiliary vector)");
9302 case NT_PRSTATUS:
9303 return _("NT_PRSTATUS (prstatus structure)");
9304 case NT_FPREGSET:
9305 return _("NT_FPREGSET (floating point registers)");
9306 case NT_PRPSINFO:
9307 return _("NT_PRPSINFO (prpsinfo structure)");
9308 case NT_TASKSTRUCT:
9309 return _("NT_TASKSTRUCT (task structure)");
9310 case NT_PRXFPREG:
9311 return _("NT_PRXFPREG (user_xfpregs structure)");
9312 case NT_PPC_VMX:
9313 return _("NT_PPC_VMX (ppc Altivec registers)");
9314 case NT_PSTATUS:
9315 return _("NT_PSTATUS (pstatus structure)");
9316 case NT_FPREGS:
9317 return _("NT_FPREGS (floating point registers)");
9318 case NT_PSINFO:
9319 return _("NT_PSINFO (psinfo structure)");
9320 case NT_LWPSTATUS:
9321 return _("NT_LWPSTATUS (lwpstatus_t structure)");
9322 case NT_LWPSINFO:
9323 return _("NT_LWPSINFO (lwpsinfo_t structure)");
9324 case NT_WIN32PSTATUS:
9325 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9326 default:
9327 break;
9328 }
9329 else
9330 switch (e_type)
9331 {
9332 case NT_VERSION:
9333 return _("NT_VERSION (version)");
9334 case NT_ARCH:
9335 return _("NT_ARCH (architecture)");
9336 default:
9337 break;
9338 }
9339
9340 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9341 return buff;
9342 }
9343
9344 static const char *
9345 get_gnu_elf_note_type (unsigned e_type)
9346 {
9347 static char buff[64];
9348
9349 switch (e_type)
9350 {
9351 case NT_GNU_ABI_TAG:
9352 return _("NT_GNU_ABI_TAG (ABI version tag)");
9353 case NT_GNU_HWCAP:
9354 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
9355 case NT_GNU_BUILD_ID:
9356 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
9357 default:
9358 break;
9359 }
9360
9361 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9362 return buff;
9363 }
9364
9365 static const char *
9366 get_netbsd_elfcore_note_type (unsigned e_type)
9367 {
9368 static char buff[64];
9369
9370 if (e_type == NT_NETBSDCORE_PROCINFO)
9371 {
9372 /* NetBSD core "procinfo" structure. */
9373 return _("NetBSD procinfo structure");
9374 }
9375
9376 /* As of Jan 2002 there are no other machine-independent notes
9377 defined for NetBSD core files. If the note type is less
9378 than the start of the machine-dependent note types, we don't
9379 understand it. */
9380
9381 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9382 {
9383 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9384 return buff;
9385 }
9386
9387 switch (elf_header.e_machine)
9388 {
9389 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9390 and PT_GETFPREGS == mach+2. */
9391
9392 case EM_OLD_ALPHA:
9393 case EM_ALPHA:
9394 case EM_SPARC:
9395 case EM_SPARC32PLUS:
9396 case EM_SPARCV9:
9397 switch (e_type)
9398 {
9399 case NT_NETBSDCORE_FIRSTMACH+0:
9400 return _("PT_GETREGS (reg structure)");
9401 case NT_NETBSDCORE_FIRSTMACH+2:
9402 return _("PT_GETFPREGS (fpreg structure)");
9403 default:
9404 break;
9405 }
9406 break;
9407
9408 /* On all other arch's, PT_GETREGS == mach+1 and
9409 PT_GETFPREGS == mach+3. */
9410 default:
9411 switch (e_type)
9412 {
9413 case NT_NETBSDCORE_FIRSTMACH+1:
9414 return _("PT_GETREGS (reg structure)");
9415 case NT_NETBSDCORE_FIRSTMACH+3:
9416 return _("PT_GETFPREGS (fpreg structure)");
9417 default:
9418 break;
9419 }
9420 }
9421
9422 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
9423 e_type - NT_NETBSDCORE_FIRSTMACH);
9424 return buff;
9425 }
9426
9427 /* Note that by the ELF standard, the name field is already null byte
9428 terminated, and namesz includes the terminating null byte.
9429 I.E. the value of namesz for the name "FSF" is 4.
9430
9431 If the value of namesz is zero, there is no name present. */
9432 static int
9433 process_note (Elf_Internal_Note *pnote)
9434 {
9435 const char *name = pnote->namesz ? pnote->namedata : "(NONE)";
9436 const char *nt;
9437
9438 if (pnote->namesz == 0)
9439 /* If there is no note name, then use the default set of
9440 note type strings. */
9441 nt = get_note_type (pnote->type);
9442
9443 else if (const_strneq (pnote->namedata, "GNU"))
9444 /* GNU-specific object file notes. */
9445 nt = get_gnu_elf_note_type (pnote->type);
9446
9447 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
9448 /* NetBSD-specific core file notes. */
9449 nt = get_netbsd_elfcore_note_type (pnote->type);
9450
9451 else if (strneq (pnote->namedata, "SPU/", 4))
9452 {
9453 /* SPU-specific core file notes. */
9454 nt = pnote->namedata + 4;
9455 name = "SPU";
9456 }
9457
9458 else
9459 /* Don't recognize this note name; just use the default set of
9460 note type strings. */
9461 nt = get_note_type (pnote->type);
9462
9463 printf (" %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
9464 return 1;
9465 }
9466
9467
9468 static int
9469 process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length)
9470 {
9471 Elf_External_Note *pnotes;
9472 Elf_External_Note *external;
9473 int res = 1;
9474
9475 if (length <= 0)
9476 return 0;
9477
9478 pnotes = get_data (NULL, file, offset, 1, length, _("notes"));
9479 if (!pnotes)
9480 return 0;
9481
9482 external = pnotes;
9483
9484 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9485 (unsigned long) offset, (unsigned long) length);
9486 printf (_(" Owner\t\tData size\tDescription\n"));
9487
9488 while (external < (Elf_External_Note *)((char *) pnotes + length))
9489 {
9490 Elf_External_Note *next;
9491 Elf_Internal_Note inote;
9492 char *temp = NULL;
9493
9494 inote.type = BYTE_GET (external->type);
9495 inote.namesz = BYTE_GET (external->namesz);
9496 inote.namedata = external->name;
9497 inote.descsz = BYTE_GET (external->descsz);
9498 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
9499 inote.descpos = offset + (inote.descdata - (char *) pnotes);
9500
9501 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
9502
9503 if (((char *) next) > (((char *) pnotes) + length))
9504 {
9505 warn (_("corrupt note found at offset %lx into core notes\n"),
9506 (long)((char *)external - (char *)pnotes));
9507 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
9508 inote.type, inote.namesz, inote.descsz);
9509 break;
9510 }
9511
9512 external = next;
9513
9514 /* Verify that name is null terminated. It appears that at least
9515 one version of Linux (RedHat 6.0) generates corefiles that don't
9516 comply with the ELF spec by failing to include the null byte in
9517 namesz. */
9518 if (inote.namedata[inote.namesz] != '\0')
9519 {
9520 temp = malloc (inote.namesz + 1);
9521
9522 if (temp == NULL)
9523 {
9524 error (_("Out of memory\n"));
9525 res = 0;
9526 break;
9527 }
9528
9529 strncpy (temp, inote.namedata, inote.namesz);
9530 temp[inote.namesz] = 0;
9531
9532 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9533 inote.namedata = temp;
9534 }
9535
9536 res &= process_note (& inote);
9537
9538 if (temp != NULL)
9539 {
9540 free (temp);
9541 temp = NULL;
9542 }
9543 }
9544
9545 free (pnotes);
9546
9547 return res;
9548 }
9549
9550 static int
9551 process_corefile_note_segments (FILE *file)
9552 {
9553 Elf_Internal_Phdr *segment;
9554 unsigned int i;
9555 int res = 1;
9556
9557 if (! get_program_headers (file))
9558 return 0;
9559
9560 for (i = 0, segment = program_headers;
9561 i < elf_header.e_phnum;
9562 i++, segment++)
9563 {
9564 if (segment->p_type == PT_NOTE)
9565 res &= process_corefile_note_segment (file,
9566 (bfd_vma) segment->p_offset,
9567 (bfd_vma) segment->p_filesz);
9568 }
9569
9570 return res;
9571 }
9572
9573 static int
9574 process_note_sections (FILE *file)
9575 {
9576 Elf_Internal_Shdr *section;
9577 unsigned long i;
9578 int res = 1;
9579
9580 for (i = 0, section = section_headers;
9581 i < elf_header.e_shnum;
9582 i++, section++)
9583 if (section->sh_type == SHT_NOTE)
9584 res &= process_corefile_note_segment (file,
9585 (bfd_vma) section->sh_offset,
9586 (bfd_vma) section->sh_size);
9587
9588 return res;
9589 }
9590
9591 static int
9592 process_notes (FILE *file)
9593 {
9594 /* If we have not been asked to display the notes then do nothing. */
9595 if (! do_notes)
9596 return 1;
9597
9598 if (elf_header.e_type != ET_CORE)
9599 return process_note_sections (file);
9600
9601 /* No program headers means no NOTE segment. */
9602 if (elf_header.e_phnum > 0)
9603 return process_corefile_note_segments (file);
9604
9605 printf (_("No note segments present in the core file.\n"));
9606 return 1;
9607 }
9608
9609 static int
9610 process_arch_specific (FILE *file)
9611 {
9612 if (! do_arch)
9613 return 1;
9614
9615 switch (elf_header.e_machine)
9616 {
9617 case EM_ARM:
9618 return process_arm_specific (file);
9619 case EM_MIPS:
9620 case EM_MIPS_RS3_LE:
9621 return process_mips_specific (file);
9622 break;
9623 case EM_PPC:
9624 return process_power_specific (file);
9625 break;
9626 default:
9627 break;
9628 }
9629 return 1;
9630 }
9631
9632 static int
9633 get_file_header (FILE *file)
9634 {
9635 /* Read in the identity array. */
9636 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
9637 return 0;
9638
9639 /* Determine how to read the rest of the header. */
9640 switch (elf_header.e_ident[EI_DATA])
9641 {
9642 default: /* fall through */
9643 case ELFDATANONE: /* fall through */
9644 case ELFDATA2LSB:
9645 byte_get = byte_get_little_endian;
9646 byte_put = byte_put_little_endian;
9647 break;
9648 case ELFDATA2MSB:
9649 byte_get = byte_get_big_endian;
9650 byte_put = byte_put_big_endian;
9651 break;
9652 }
9653
9654 /* For now we only support 32 bit and 64 bit ELF files. */
9655 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9656
9657 /* Read in the rest of the header. */
9658 if (is_32bit_elf)
9659 {
9660 Elf32_External_Ehdr ehdr32;
9661
9662 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
9663 return 0;
9664
9665 elf_header.e_type = BYTE_GET (ehdr32.e_type);
9666 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
9667 elf_header.e_version = BYTE_GET (ehdr32.e_version);
9668 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
9669 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
9670 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
9671 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
9672 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
9673 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
9674 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
9675 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
9676 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
9677 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
9678 }
9679 else
9680 {
9681 Elf64_External_Ehdr ehdr64;
9682
9683 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9684 we will not be able to cope with the 64bit data found in
9685 64 ELF files. Detect this now and abort before we start
9686 overwriting things. */
9687 if (sizeof (bfd_vma) < 8)
9688 {
9689 error (_("This instance of readelf has been built without support for a\n\
9690 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9691 return 0;
9692 }
9693
9694 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
9695 return 0;
9696
9697 elf_header.e_type = BYTE_GET (ehdr64.e_type);
9698 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
9699 elf_header.e_version = BYTE_GET (ehdr64.e_version);
9700 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
9701 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
9702 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9703 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
9704 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
9705 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
9706 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
9707 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
9708 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
9709 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
9710 }
9711
9712 if (elf_header.e_shoff)
9713 {
9714 /* There may be some extensions in the first section header. Don't
9715 bomb if we can't read it. */
9716 if (is_32bit_elf)
9717 get_32bit_section_headers (file, 1);
9718 else
9719 get_64bit_section_headers (file, 1);
9720 }
9721
9722 is_relocatable = elf_header.e_type == ET_REL;
9723
9724 return 1;
9725 }
9726
9727 /* Process one ELF object file according to the command line options.
9728 This file may actually be stored in an archive. The file is
9729 positioned at the start of the ELF object. */
9730
9731 static int
9732 process_object (char *file_name, FILE *file)
9733 {
9734 unsigned int i;
9735
9736 if (! get_file_header (file))
9737 {
9738 error (_("%s: Failed to read file header\n"), file_name);
9739 return 1;
9740 }
9741
9742 /* Initialise per file variables. */
9743 for (i = ARRAY_SIZE (version_info); i--;)
9744 version_info[i] = 0;
9745
9746 for (i = ARRAY_SIZE (dynamic_info); i--;)
9747 dynamic_info[i] = 0;
9748
9749 /* Process the file. */
9750 if (show_name)
9751 printf (_("\nFile: %s\n"), file_name);
9752
9753 /* Initialise the dump_sects array from the cmdline_dump_sects array.
9754 Note we do this even if cmdline_dump_sects is empty because we
9755 must make sure that the dump_sets array is zeroed out before each
9756 object file is processed. */
9757 if (num_dump_sects > num_cmdline_dump_sects)
9758 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
9759
9760 if (num_cmdline_dump_sects > 0)
9761 {
9762 if (num_dump_sects == 0)
9763 /* A sneaky way of allocating the dump_sects array. */
9764 request_dump_bynumber (num_cmdline_dump_sects, 0);
9765
9766 assert (num_dump_sects >= num_cmdline_dump_sects);
9767 memcpy (dump_sects, cmdline_dump_sects,
9768 num_cmdline_dump_sects * sizeof (* dump_sects));
9769 }
9770
9771 if (! process_file_header ())
9772 return 1;
9773
9774 if (! process_section_headers (file))
9775 {
9776 /* Without loaded section headers we cannot process lots of
9777 things. */
9778 do_unwind = do_version = do_dump = do_arch = 0;
9779
9780 if (! do_using_dynamic)
9781 do_syms = do_reloc = 0;
9782 }
9783
9784 if (! process_section_groups (file))
9785 {
9786 /* Without loaded section groups we cannot process unwind. */
9787 do_unwind = 0;
9788 }
9789
9790 if (process_program_headers (file))
9791 process_dynamic_section (file);
9792
9793 process_relocs (file);
9794
9795 process_unwind (file);
9796
9797 process_symbol_table (file);
9798
9799 process_syminfo (file);
9800
9801 process_version_sections (file);
9802
9803 process_section_contents (file);
9804
9805 process_notes (file);
9806
9807 process_gnu_liblist (file);
9808
9809 process_arch_specific (file);
9810
9811 if (program_headers)
9812 {
9813 free (program_headers);
9814 program_headers = NULL;
9815 }
9816
9817 if (section_headers)
9818 {
9819 free (section_headers);
9820 section_headers = NULL;
9821 }
9822
9823 if (string_table)
9824 {
9825 free (string_table);
9826 string_table = NULL;
9827 string_table_length = 0;
9828 }
9829
9830 if (dynamic_strings)
9831 {
9832 free (dynamic_strings);
9833 dynamic_strings = NULL;
9834 dynamic_strings_length = 0;
9835 }
9836
9837 if (dynamic_symbols)
9838 {
9839 free (dynamic_symbols);
9840 dynamic_symbols = NULL;
9841 num_dynamic_syms = 0;
9842 }
9843
9844 if (dynamic_syminfo)
9845 {
9846 free (dynamic_syminfo);
9847 dynamic_syminfo = NULL;
9848 }
9849
9850 if (section_headers_groups)
9851 {
9852 free (section_headers_groups);
9853 section_headers_groups = NULL;
9854 }
9855
9856 if (section_groups)
9857 {
9858 struct group_list *g, *next;
9859
9860 for (i = 0; i < group_count; i++)
9861 {
9862 for (g = section_groups [i].root; g != NULL; g = next)
9863 {
9864 next = g->next;
9865 free (g);
9866 }
9867 }
9868
9869 free (section_groups);
9870 section_groups = NULL;
9871 }
9872
9873 free_debug_memory ();
9874
9875 return 0;
9876 }
9877
9878 /* Process an ELF archive.
9879 On entry the file is positioned just after the ARMAG string. */
9880
9881 static int
9882 process_archive (char *file_name, FILE *file)
9883 {
9884 struct ar_hdr arhdr;
9885 size_t got;
9886 unsigned long size;
9887 unsigned long index_num = 0;
9888 unsigned long *index_array = NULL;
9889 char *sym_table = NULL;
9890 unsigned long sym_size = 0;
9891 char *longnames = NULL;
9892 unsigned long longnames_size = 0;
9893 size_t file_name_size;
9894 int ret;
9895
9896 show_name = 1;
9897
9898 got = fread (&arhdr, 1, sizeof arhdr, file);
9899 if (got != sizeof arhdr)
9900 {
9901 if (got == 0)
9902 return 0;
9903
9904 error (_("%s: failed to read archive header\n"), file_name);
9905 return 1;
9906 }
9907
9908 /* See if this is the archive symbol table. */
9909 if (const_strneq (arhdr.ar_name, "/ ")
9910 || const_strneq (arhdr.ar_name, "/SYM64/ "))
9911 {
9912 size = strtoul (arhdr.ar_size, NULL, 10);
9913 size = size + (size & 1);
9914
9915 if (do_archive_index)
9916 {
9917 unsigned long i;
9918 /* A buffer used to hold numbers read in from an archive index.
9919 These are always 4 bytes long and stored in big-endian format. */
9920 #define SIZEOF_AR_INDEX_NUMBERS 4
9921 unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
9922 unsigned char * index_buffer;
9923
9924 /* Check the size of the archive index. */
9925 if (size < SIZEOF_AR_INDEX_NUMBERS)
9926 {
9927 error (_("%s: the archive index is empty\n"), file_name);
9928 return 1;
9929 }
9930
9931 /* Read the numer of entries in the archive index. */
9932 got = fread (integer_buffer, 1, sizeof integer_buffer, file);
9933 if (got != sizeof (integer_buffer))
9934 {
9935 error (_("%s: failed to read archive index\n"), file_name);
9936 return 1;
9937 }
9938 index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
9939 size -= SIZEOF_AR_INDEX_NUMBERS;
9940
9941 /* Read in the archive index. */
9942 if (size < index_num * SIZEOF_AR_INDEX_NUMBERS)
9943 {
9944 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
9945 file_name, index_num);
9946 return 1;
9947 }
9948 index_buffer = malloc (index_num * SIZEOF_AR_INDEX_NUMBERS);
9949 if (index_buffer == NULL)
9950 {
9951 error (_("Out of memory whilst trying to read archive symbol index\n"));
9952 return 1;
9953 }
9954 got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, index_num, file);
9955 if (got != index_num)
9956 {
9957 free (index_buffer);
9958 error (_("%s: failed to read archive index\n"), file_name);
9959 ret = 1;
9960 goto out;
9961 }
9962 size -= index_num * SIZEOF_AR_INDEX_NUMBERS;
9963
9964 /* Convert the index numbers into the host's numeric format. */
9965 index_array = malloc (index_num * sizeof (* index_array));
9966 if (index_array == NULL)
9967 {
9968 free (index_buffer);
9969 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
9970 return 1;
9971 }
9972
9973 for (i = 0; i < index_num; i++)
9974 index_array[i] = byte_get_big_endian ((unsigned char *)(index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
9975 SIZEOF_AR_INDEX_NUMBERS);
9976 free (index_buffer);
9977
9978 /* The remaining space in the header is taken up by the symbol table. */
9979 if (size < 1)
9980 {
9981 error (_("%s: the archive has an index but no symbols\n"), file_name);
9982 ret = 1;
9983 goto out;
9984 }
9985 sym_table = malloc (size);
9986 sym_size = size;
9987 if (sym_table == NULL)
9988 {
9989 error (_("Out of memory whilst trying to read archive index symbol table\n"));
9990 ret = 1;
9991 goto out;
9992 }
9993 got = fread (sym_table, 1, size, file);
9994 if (got != size)
9995 {
9996 error (_("%s: failed to read archive index symbol table\n"), file_name);
9997 ret = 1;
9998 goto out;
9999 }
10000 }
10001 else
10002 {
10003 if (fseek (file, size, SEEK_CUR) != 0)
10004 {
10005 error (_("%s: failed to skip archive symbol table\n"), file_name);
10006 return 1;
10007 }
10008 }
10009
10010 got = fread (& arhdr, 1, sizeof arhdr, file);
10011 if (got != sizeof arhdr)
10012 {
10013 if (got == 0)
10014 {
10015 ret = 0;
10016 goto out;
10017 }
10018
10019 error (_("%s: failed to read archive header following archive index\n"), file_name);
10020 ret = 1;
10021 goto out;
10022 }
10023 }
10024 else if (do_archive_index)
10025 printf (_("%s has no archive index\n"), file_name);
10026
10027 if (const_strneq (arhdr.ar_name, "// "))
10028 {
10029 /* This is the archive string table holding long member
10030 names. */
10031
10032 longnames_size = strtoul (arhdr.ar_size, NULL, 10);
10033 longnames = malloc (longnames_size);
10034 if (longnames == NULL)
10035 {
10036 error (_("Out of memory reading long symbol names in archive\n"));
10037 ret = 1;
10038 goto out;
10039 }
10040
10041 if (fread (longnames, longnames_size, 1, file) != 1)
10042 {
10043 free (longnames);
10044 error (_("%s: failed to read long symbol name string table\n"), file_name);
10045 ret = 1;
10046 goto out;
10047 }
10048
10049 if ((longnames_size & 1) != 0)
10050 getc (file);
10051
10052 got = fread (& arhdr, 1, sizeof arhdr, file);
10053 if (got != sizeof arhdr)
10054 {
10055 if (got == 0)
10056 ret = 0;
10057 else
10058 {
10059 error (_("%s: failed to read archive header following long symbol names\n"), file_name);
10060 ret = 1;
10061 }
10062 goto out;
10063 }
10064 }
10065
10066 if (do_archive_index)
10067 {
10068 if (sym_table == NULL)
10069 error (_("%s: unable to dump the index as none was found\n"), file_name);
10070 else
10071 {
10072 unsigned int i, j, k, l;
10073 char elf_name[16];
10074 unsigned long current_pos;
10075
10076 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10077 file_name, index_num, sym_size);
10078 current_pos = ftell (file);
10079
10080 for (i = l = 0; i < index_num; i++)
10081 {
10082 if ((i == 0) || ((i > 0) && (index_array[i] != index_array[i - 1])))
10083 {
10084 if (fseek (file, index_array[i], SEEK_SET) != 0)
10085 {
10086 error (_("%s: failed to seek to next file name\n"), file_name);
10087 ret = 1;
10088 goto out;
10089 }
10090 got = fread (elf_name, 1, 16, file);
10091 if (got != 16)
10092 {
10093 error (_("%s: failed to read file name\n"), file_name);
10094 ret = 1;
10095 goto out;
10096 }
10097
10098 if (elf_name[0] == '/')
10099 {
10100 /* We have a long name. */
10101 k = j = strtoul (elf_name + 1, NULL, 10);
10102 while ((j < longnames_size) && (longnames[j] != '/'))
10103 j++;
10104 longnames[j] = '\0';
10105 printf (_("Binary %s contains:\n"), longnames + k);
10106 longnames[j] = '/';
10107 }
10108 else
10109 {
10110 j = 0;
10111 while ((elf_name[j] != '/') && (j < 16))
10112 j++;
10113 elf_name[j] = '\0';
10114 printf(_("Binary %s contains:\n"), elf_name);
10115 }
10116 }
10117 if (l >= sym_size)
10118 {
10119 error (_("%s: end of the symbol table reached before the end of the index\n"),
10120 file_name);
10121 break;
10122 }
10123 printf ("\t%s\n", sym_table + l);
10124 l += strlen (sym_table + l) + 1;
10125 }
10126
10127 if (l < sym_size)
10128 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10129 file_name);
10130
10131 free (index_array);
10132 index_array = NULL;
10133 free (sym_table);
10134 sym_table = NULL;
10135 if (fseek (file, current_pos, SEEK_SET) != 0)
10136 {
10137 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
10138 return 1;
10139 }
10140 }
10141
10142 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
10143 && !do_segments && !do_header && !do_dump && !do_version
10144 && !do_histogram && !do_debugging && !do_arch && !do_notes
10145 && !do_section_groups)
10146 return 0; /* Archive index only. */
10147 }
10148
10149 file_name_size = strlen (file_name);
10150 ret = 0;
10151
10152 while (1)
10153 {
10154 char *name;
10155 char *nameend;
10156 char *namealc;
10157
10158 if (arhdr.ar_name[0] == '/')
10159 {
10160 unsigned long off;
10161
10162 off = strtoul (arhdr.ar_name + 1, NULL, 10);
10163 if (off >= longnames_size)
10164 {
10165 error (_("%s: invalid archive string table offset %lu\n"), file_name, off);
10166 ret = 1;
10167 break;
10168 }
10169
10170 name = longnames + off;
10171 nameend = memchr (name, '/', longnames_size - off);
10172 }
10173 else
10174 {
10175 name = arhdr.ar_name;
10176 nameend = memchr (name, '/', 16);
10177 }
10178
10179 if (nameend == NULL)
10180 {
10181 error (_("%s: bad archive file name\n"), file_name);
10182 ret = 1;
10183 break;
10184 }
10185
10186 namealc = malloc (file_name_size + (nameend - name) + 3);
10187 if (namealc == NULL)
10188 {
10189 error (_("Out of memory\n"));
10190 ret = 1;
10191 break;
10192 }
10193
10194 memcpy (namealc, file_name, file_name_size);
10195 namealc[file_name_size] = '(';
10196 memcpy (namealc + file_name_size + 1, name, nameend - name);
10197 namealc[file_name_size + 1 + (nameend - name)] = ')';
10198 namealc[file_name_size + 2 + (nameend - name)] = '\0';
10199
10200 archive_file_offset = ftell (file);
10201 archive_file_size = strtoul (arhdr.ar_size, NULL, 10);
10202
10203 ret |= process_object (namealc, file);
10204
10205 free (namealc);
10206
10207 if (fseek (file,
10208 (archive_file_offset
10209 + archive_file_size
10210 + (archive_file_size & 1)),
10211 SEEK_SET) != 0)
10212 {
10213 error (_("%s: failed to seek to next archive header\n"), file_name);
10214 ret = 1;
10215 break;
10216 }
10217
10218 got = fread (&arhdr, 1, sizeof arhdr, file);
10219 if (got != sizeof arhdr)
10220 {
10221 if (got == 0)
10222 break;
10223
10224 error (_("%s: failed to read archive header\n"), file_name);
10225 ret = 1;
10226 break;
10227 }
10228 }
10229
10230 out:
10231 if (index_array != NULL)
10232 free (index_array);
10233 if (sym_table != NULL)
10234 free (sym_table);
10235 if (longnames != NULL)
10236 free (longnames);
10237
10238 return ret;
10239 }
10240
10241 static int
10242 process_file (char *file_name)
10243 {
10244 FILE *file;
10245 struct stat statbuf;
10246 char armag[SARMAG];
10247 int ret;
10248
10249 if (stat (file_name, &statbuf) < 0)
10250 {
10251 if (errno == ENOENT)
10252 error (_("'%s': No such file\n"), file_name);
10253 else
10254 error (_("Could not locate '%s'. System error message: %s\n"),
10255 file_name, strerror (errno));
10256 return 1;
10257 }
10258
10259 if (! S_ISREG (statbuf.st_mode))
10260 {
10261 error (_("'%s' is not an ordinary file\n"), file_name);
10262 return 1;
10263 }
10264
10265 file = fopen (file_name, "rb");
10266 if (file == NULL)
10267 {
10268 error (_("Input file '%s' is not readable.\n"), file_name);
10269 return 1;
10270 }
10271
10272 if (fread (armag, SARMAG, 1, file) != 1)
10273 {
10274 error (_("%s: Failed to read file's magic number\n"), file_name);
10275 fclose (file);
10276 return 1;
10277 }
10278
10279 if (memcmp (armag, ARMAG, SARMAG) == 0)
10280 ret = process_archive (file_name, file);
10281 else
10282 {
10283 if (do_archive_index)
10284 error (_("File %s is not an archive so its index cannot be displayed.\n"),
10285 file_name);
10286
10287 rewind (file);
10288 archive_file_size = archive_file_offset = 0;
10289 ret = process_object (file_name, file);
10290 }
10291
10292 fclose (file);
10293
10294 return ret;
10295 }
10296
10297 #ifdef SUPPORT_DISASSEMBLY
10298 /* Needed by the i386 disassembler. For extra credit, someone could
10299 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10300 symbols. */
10301
10302 void
10303 print_address (unsigned int addr, FILE *outfile)
10304 {
10305 fprintf (outfile,"0x%8.8x", addr);
10306 }
10307
10308 /* Needed by the i386 disassembler. */
10309 void
10310 db_task_printsym (unsigned int addr)
10311 {
10312 print_address (addr, stderr);
10313 }
10314 #endif
10315
10316 int
10317 main (int argc, char **argv)
10318 {
10319 int err;
10320
10321 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10322 setlocale (LC_MESSAGES, "");
10323 #endif
10324 #if defined (HAVE_SETLOCALE)
10325 setlocale (LC_CTYPE, "");
10326 #endif
10327 bindtextdomain (PACKAGE, LOCALEDIR);
10328 textdomain (PACKAGE);
10329
10330 expandargv (&argc, &argv);
10331
10332 parse_args (argc, argv);
10333
10334 if (num_dump_sects > 0)
10335 {
10336 /* Make a copy of the dump_sects array. */
10337 cmdline_dump_sects = malloc (num_dump_sects * sizeof (* dump_sects));
10338 if (cmdline_dump_sects == NULL)
10339 error (_("Out of memory allocating dump request table.\n"));
10340 else
10341 {
10342 memcpy (cmdline_dump_sects, dump_sects,
10343 num_dump_sects * sizeof (* dump_sects));
10344 num_cmdline_dump_sects = num_dump_sects;
10345 }
10346 }
10347
10348 if (optind < (argc - 1))
10349 show_name = 1;
10350
10351 err = 0;
10352 while (optind < argc)
10353 err |= process_file (argv[optind++]);
10354
10355 if (dump_sects != NULL)
10356 free (dump_sects);
10357 if (cmdline_dump_sects != NULL)
10358 free (cmdline_dump_sects);
10359
10360 return err;
10361 }
GDB Binutils - Deliverables
This page took 0.276408 seconds and 5 git commands to generate.