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