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