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