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