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