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