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