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