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