projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
2010-05-24 Tristan Gingold <gingold@adacore.com>
[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 =trace_info,=trace_abbrev,=trace_aranges]\n\
3146 Display the contents of DWARF2 debug sections\n"));
3147 #ifdef SUPPORT_DISASSEMBLY
3148 fprintf (stream, _("\
3149 -i --instruction-dump=<number|name>\n\
3150 Disassemble the contents of section <number|name>\n"));
3151 #endif
3152 fprintf (stream, _("\
3153 -I --histogram Display histogram of bucket list lengths\n\
3154 -W --wide Allow output width to exceed 80 characters\n\
3155 @<file> Read options from <file>\n\
3156 -H --help Display this information\n\
3157 -v --version Display the version number of readelf\n"));
3158
3159 if (REPORT_BUGS_TO[0] && stream == stdout)
3160 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3161
3162 exit (stream == stdout ? 0 : 1);
3163 }
3164
3165 /* Record the fact that the user wants the contents of section number
3166 SECTION to be displayed using the method(s) encoded as flags bits
3167 in TYPE. Note, TYPE can be zero if we are creating the array for
3168 the first time. */
3169
3170 static void
3171 request_dump_bynumber (unsigned int section, dump_type type)
3172 {
3173 if (section >= num_dump_sects)
3174 {
3175 dump_type * new_dump_sects;
3176
3177 new_dump_sects = (dump_type *) calloc (section + 1,
3178 sizeof (* dump_sects));
3179
3180 if (new_dump_sects == NULL)
3181 error (_("Out of memory allocating dump request table.\n"));
3182 else
3183 {
3184 /* Copy current flag settings. */
3185 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3186
3187 free (dump_sects);
3188
3189 dump_sects = new_dump_sects;
3190 num_dump_sects = section + 1;
3191 }
3192 }
3193
3194 if (dump_sects)
3195 dump_sects[section] |= type;
3196
3197 return;
3198 }
3199
3200 /* Request a dump by section name. */
3201
3202 static void
3203 request_dump_byname (const char * section, dump_type type)
3204 {
3205 struct dump_list_entry * new_request;
3206
3207 new_request = (struct dump_list_entry *)
3208 malloc (sizeof (struct dump_list_entry));
3209 if (!new_request)
3210 error (_("Out of memory allocating dump request table.\n"));
3211
3212 new_request->name = strdup (section);
3213 if (!new_request->name)
3214 error (_("Out of memory allocating dump request table.\n"));
3215
3216 new_request->type = type;
3217
3218 new_request->next = dump_sects_byname;
3219 dump_sects_byname = new_request;
3220 }
3221
3222 static inline void
3223 request_dump (dump_type type)
3224 {
3225 int section;
3226 char * cp;
3227
3228 do_dump++;
3229 section = strtoul (optarg, & cp, 0);
3230
3231 if (! *cp && section >= 0)
3232 request_dump_bynumber (section, type);
3233 else
3234 request_dump_byname (optarg, type);
3235 }
3236
3237
3238 static void
3239 parse_args (int argc, char ** argv)
3240 {
3241 int c;
3242
3243 if (argc < 2)
3244 usage (stderr);
3245
3246 while ((c = getopt_long
3247 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3248 {
3249 switch (c)
3250 {
3251 case 0:
3252 /* Long options. */
3253 break;
3254 case 'H':
3255 usage (stdout);
3256 break;
3257
3258 case 'a':
3259 do_syms++;
3260 do_reloc++;
3261 do_unwind++;
3262 do_dynamic++;
3263 do_header++;
3264 do_sections++;
3265 do_section_groups++;
3266 do_segments++;
3267 do_version++;
3268 do_histogram++;
3269 do_arch++;
3270 do_notes++;
3271 break;
3272 case 'g':
3273 do_section_groups++;
3274 break;
3275 case 't':
3276 case 'N':
3277 do_sections++;
3278 do_section_details++;
3279 break;
3280 case 'e':
3281 do_header++;
3282 do_sections++;
3283 do_segments++;
3284 break;
3285 case 'A':
3286 do_arch++;
3287 break;
3288 case 'D':
3289 do_using_dynamic++;
3290 break;
3291 case 'r':
3292 do_reloc++;
3293 break;
3294 case 'u':
3295 do_unwind++;
3296 break;
3297 case 'h':
3298 do_header++;
3299 break;
3300 case 'l':
3301 do_segments++;
3302 break;
3303 case 's':
3304 do_syms++;
3305 break;
3306 case 'S':
3307 do_sections++;
3308 break;
3309 case 'd':
3310 do_dynamic++;
3311 break;
3312 case 'I':
3313 do_histogram++;
3314 break;
3315 case 'n':
3316 do_notes++;
3317 break;
3318 case 'c':
3319 do_archive_index++;
3320 break;
3321 case 'x':
3322 request_dump (HEX_DUMP);
3323 break;
3324 case 'p':
3325 request_dump (STRING_DUMP);
3326 break;
3327 case 'R':
3328 request_dump (RELOC_DUMP);
3329 break;
3330 case 'w':
3331 do_dump++;
3332 if (optarg == 0)
3333 {
3334 do_debugging = 1;
3335 dwarf_select_sections_all ();
3336 }
3337 else
3338 {
3339 do_debugging = 0;
3340 dwarf_select_sections_by_letters (optarg);
3341 }
3342 break;
3343 case OPTION_DEBUG_DUMP:
3344 do_dump++;
3345 if (optarg == 0)
3346 do_debugging = 1;
3347 else
3348 {
3349 do_debugging = 0;
3350 dwarf_select_sections_by_names (optarg);
3351 }
3352 break;
3353 case OPTION_DYN_SYMS:
3354 do_dyn_syms++;
3355 break;
3356 #ifdef SUPPORT_DISASSEMBLY
3357 case 'i':
3358 request_dump (DISASS_DUMP);
3359 break;
3360 #endif
3361 case 'v':
3362 print_version (program_name);
3363 break;
3364 case 'V':
3365 do_version++;
3366 break;
3367 case 'W':
3368 do_wide++;
3369 break;
3370 default:
3371 /* xgettext:c-format */
3372 error (_("Invalid option '-%c'\n"), c);
3373 /* Drop through. */
3374 case '?':
3375 usage (stderr);
3376 }
3377 }
3378
3379 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3380 && !do_segments && !do_header && !do_dump && !do_version
3381 && !do_histogram && !do_debugging && !do_arch && !do_notes
3382 && !do_section_groups && !do_archive_index
3383 && !do_dyn_syms)
3384 usage (stderr);
3385 else if (argc < 3)
3386 {
3387 warn (_("Nothing to do.\n"));
3388 usage (stderr);
3389 }
3390 }
3391
3392 static const char *
3393 get_elf_class (unsigned int elf_class)
3394 {
3395 static char buff[32];
3396
3397 switch (elf_class)
3398 {
3399 case ELFCLASSNONE: return _("none");
3400 case ELFCLASS32: return "ELF32";
3401 case ELFCLASS64: return "ELF64";
3402 default:
3403 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3404 return buff;
3405 }
3406 }
3407
3408 static const char *
3409 get_data_encoding (unsigned int encoding)
3410 {
3411 static char buff[32];
3412
3413 switch (encoding)
3414 {
3415 case ELFDATANONE: return _("none");
3416 case ELFDATA2LSB: return _("2's complement, little endian");
3417 case ELFDATA2MSB: return _("2's complement, big endian");
3418 default:
3419 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3420 return buff;
3421 }
3422 }
3423
3424 /* Decode the data held in 'elf_header'. */
3425
3426 static int
3427 process_file_header (void)
3428 {
3429 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3430 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3431 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3432 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3433 {
3434 error
3435 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3436 return 0;
3437 }
3438
3439 init_dwarf_regnames (elf_header.e_machine);
3440
3441 if (do_header)
3442 {
3443 int i;
3444
3445 printf (_("ELF Header:\n"));
3446 printf (_(" Magic: "));
3447 for (i = 0; i < EI_NIDENT; i++)
3448 printf ("%2.2x ", elf_header.e_ident[i]);
3449 printf ("\n");
3450 printf (_(" Class: %s\n"),
3451 get_elf_class (elf_header.e_ident[EI_CLASS]));
3452 printf (_(" Data: %s\n"),
3453 get_data_encoding (elf_header.e_ident[EI_DATA]));
3454 printf (_(" Version: %d %s\n"),
3455 elf_header.e_ident[EI_VERSION],
3456 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3457 ? "(current)"
3458 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3459 ? _("<unknown: %lx>")
3460 : "")));
3461 printf (_(" OS/ABI: %s\n"),
3462 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3463 printf (_(" ABI Version: %d\n"),
3464 elf_header.e_ident[EI_ABIVERSION]);
3465 printf (_(" Type: %s\n"),
3466 get_file_type (elf_header.e_type));
3467 printf (_(" Machine: %s\n"),
3468 get_machine_name (elf_header.e_machine));
3469 printf (_(" Version: 0x%lx\n"),
3470 (unsigned long) elf_header.e_version);
3471
3472 printf (_(" Entry point address: "));
3473 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3474 printf (_("\n Start of program headers: "));
3475 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3476 printf (_(" (bytes into file)\n Start of section headers: "));
3477 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3478 printf (_(" (bytes into file)\n"));
3479
3480 printf (_(" Flags: 0x%lx%s\n"),
3481 (unsigned long) elf_header.e_flags,
3482 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3483 printf (_(" Size of this header: %ld (bytes)\n"),
3484 (long) elf_header.e_ehsize);
3485 printf (_(" Size of program headers: %ld (bytes)\n"),
3486 (long) elf_header.e_phentsize);
3487 printf (_(" Number of program headers: %ld"),
3488 (long) elf_header.e_phnum);
3489 if (section_headers != NULL
3490 && elf_header.e_phnum == PN_XNUM
3491 && section_headers[0].sh_info != 0)
3492 printf (_(" (%ld)"), (long) section_headers[0].sh_info);
3493 putc ('\n', stdout);
3494 printf (_(" Size of section headers: %ld (bytes)\n"),
3495 (long) elf_header.e_shentsize);
3496 printf (_(" Number of section headers: %ld"),
3497 (long) elf_header.e_shnum);
3498 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3499 printf (" (%ld)", (long) section_headers[0].sh_size);
3500 putc ('\n', stdout);
3501 printf (_(" Section header string table index: %ld"),
3502 (long) elf_header.e_shstrndx);
3503 if (section_headers != NULL
3504 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3505 printf (" (%u)", section_headers[0].sh_link);
3506 else if (elf_header.e_shstrndx != SHN_UNDEF
3507 && elf_header.e_shstrndx >= elf_header.e_shnum)
3508 printf (_(" <corrupt: out of range>"));
3509 putc ('\n', stdout);
3510 }
3511
3512 if (section_headers != NULL)
3513 {
3514 if (elf_header.e_phnum == PN_XNUM
3515 && section_headers[0].sh_info != 0)
3516 elf_header.e_phnum = section_headers[0].sh_info;
3517 if (elf_header.e_shnum == SHN_UNDEF)
3518 elf_header.e_shnum = section_headers[0].sh_size;
3519 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3520 elf_header.e_shstrndx = section_headers[0].sh_link;
3521 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3522 elf_header.e_shstrndx = SHN_UNDEF;
3523 free (section_headers);
3524 section_headers = NULL;
3525 }
3526
3527 return 1;
3528 }
3529
3530
3531 static int
3532 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3533 {
3534 Elf32_External_Phdr * phdrs;
3535 Elf32_External_Phdr * external;
3536 Elf_Internal_Phdr * internal;
3537 unsigned int i;
3538
3539 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3540 elf_header.e_phentsize,
3541 elf_header.e_phnum,
3542 _("program headers"));
3543 if (!phdrs)
3544 return 0;
3545
3546 for (i = 0, internal = pheaders, external = phdrs;
3547 i < elf_header.e_phnum;
3548 i++, internal++, external++)
3549 {
3550 internal->p_type = BYTE_GET (external->p_type);
3551 internal->p_offset = BYTE_GET (external->p_offset);
3552 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3553 internal->p_paddr = BYTE_GET (external->p_paddr);
3554 internal->p_filesz = BYTE_GET (external->p_filesz);
3555 internal->p_memsz = BYTE_GET (external->p_memsz);
3556 internal->p_flags = BYTE_GET (external->p_flags);
3557 internal->p_align = BYTE_GET (external->p_align);
3558 }
3559
3560 free (phdrs);
3561
3562 return 1;
3563 }
3564
3565 static int
3566 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3567 {
3568 Elf64_External_Phdr * phdrs;
3569 Elf64_External_Phdr * external;
3570 Elf_Internal_Phdr * internal;
3571 unsigned int i;
3572
3573 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3574 elf_header.e_phentsize,
3575 elf_header.e_phnum,
3576 _("program headers"));
3577 if (!phdrs)
3578 return 0;
3579
3580 for (i = 0, internal = pheaders, external = phdrs;
3581 i < elf_header.e_phnum;
3582 i++, internal++, external++)
3583 {
3584 internal->p_type = BYTE_GET (external->p_type);
3585 internal->p_flags = BYTE_GET (external->p_flags);
3586 internal->p_offset = BYTE_GET (external->p_offset);
3587 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3588 internal->p_paddr = BYTE_GET (external->p_paddr);
3589 internal->p_filesz = BYTE_GET (external->p_filesz);
3590 internal->p_memsz = BYTE_GET (external->p_memsz);
3591 internal->p_align = BYTE_GET (external->p_align);
3592 }
3593
3594 free (phdrs);
3595
3596 return 1;
3597 }
3598
3599 /* Returns 1 if the program headers were read into `program_headers'. */
3600
3601 static int
3602 get_program_headers (FILE * file)
3603 {
3604 Elf_Internal_Phdr * phdrs;
3605
3606 /* Check cache of prior read. */
3607 if (program_headers != NULL)
3608 return 1;
3609
3610 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3611 sizeof (Elf_Internal_Phdr));
3612
3613 if (phdrs == NULL)
3614 {
3615 error (_("Out of memory\n"));
3616 return 0;
3617 }
3618
3619 if (is_32bit_elf
3620 ? get_32bit_program_headers (file, phdrs)
3621 : get_64bit_program_headers (file, phdrs))
3622 {
3623 program_headers = phdrs;
3624 return 1;
3625 }
3626
3627 free (phdrs);
3628 return 0;
3629 }
3630
3631 /* Returns 1 if the program headers were loaded. */
3632
3633 static int
3634 process_program_headers (FILE * file)
3635 {
3636 Elf_Internal_Phdr * segment;
3637 unsigned int i;
3638
3639 if (elf_header.e_phnum == 0)
3640 {
3641 if (do_segments)
3642 printf (_("\nThere are no program headers in this file.\n"));
3643 return 0;
3644 }
3645
3646 if (do_segments && !do_header)
3647 {
3648 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3649 printf (_("Entry point "));
3650 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3651 printf (_("\nThere are %d program headers, starting at offset "),
3652 elf_header.e_phnum);
3653 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3654 printf ("\n");
3655 }
3656
3657 if (! get_program_headers (file))
3658 return 0;
3659
3660 if (do_segments)
3661 {
3662 if (elf_header.e_phnum > 1)
3663 printf (_("\nProgram Headers:\n"));
3664 else
3665 printf (_("\nProgram Headers:\n"));
3666
3667 if (is_32bit_elf)
3668 printf
3669 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3670 else if (do_wide)
3671 printf
3672 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3673 else
3674 {
3675 printf
3676 (_(" Type Offset VirtAddr PhysAddr\n"));
3677 printf
3678 (_(" FileSiz MemSiz Flags Align\n"));
3679 }
3680 }
3681
3682 dynamic_addr = 0;
3683 dynamic_size = 0;
3684
3685 for (i = 0, segment = program_headers;
3686 i < elf_header.e_phnum;
3687 i++, segment++)
3688 {
3689 if (do_segments)
3690 {
3691 printf (" %-14.14s ", get_segment_type (segment->p_type));
3692
3693 if (is_32bit_elf)
3694 {
3695 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3696 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3697 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3698 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3699 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3700 printf ("%c%c%c ",
3701 (segment->p_flags & PF_R ? 'R' : ' '),
3702 (segment->p_flags & PF_W ? 'W' : ' '),
3703 (segment->p_flags & PF_X ? 'E' : ' '));
3704 printf ("%#lx", (unsigned long) segment->p_align);
3705 }
3706 else if (do_wide)
3707 {
3708 if ((unsigned long) segment->p_offset == segment->p_offset)
3709 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3710 else
3711 {
3712 print_vma (segment->p_offset, FULL_HEX);
3713 putchar (' ');
3714 }
3715
3716 print_vma (segment->p_vaddr, FULL_HEX);
3717 putchar (' ');
3718 print_vma (segment->p_paddr, FULL_HEX);
3719 putchar (' ');
3720
3721 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3722 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3723 else
3724 {
3725 print_vma (segment->p_filesz, FULL_HEX);
3726 putchar (' ');
3727 }
3728
3729 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3730 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3731 else
3732 {
3733 print_vma (segment->p_offset, FULL_HEX);
3734 }
3735
3736 printf (" %c%c%c ",
3737 (segment->p_flags & PF_R ? 'R' : ' '),
3738 (segment->p_flags & PF_W ? 'W' : ' '),
3739 (segment->p_flags & PF_X ? 'E' : ' '));
3740
3741 if ((unsigned long) segment->p_align == segment->p_align)
3742 printf ("%#lx", (unsigned long) segment->p_align);
3743 else
3744 {
3745 print_vma (segment->p_align, PREFIX_HEX);
3746 }
3747 }
3748 else
3749 {
3750 print_vma (segment->p_offset, FULL_HEX);
3751 putchar (' ');
3752 print_vma (segment->p_vaddr, FULL_HEX);
3753 putchar (' ');
3754 print_vma (segment->p_paddr, FULL_HEX);
3755 printf ("\n ");
3756 print_vma (segment->p_filesz, FULL_HEX);
3757 putchar (' ');
3758 print_vma (segment->p_memsz, FULL_HEX);
3759 printf (" %c%c%c ",
3760 (segment->p_flags & PF_R ? 'R' : ' '),
3761 (segment->p_flags & PF_W ? 'W' : ' '),
3762 (segment->p_flags & PF_X ? 'E' : ' '));
3763 print_vma (segment->p_align, HEX);
3764 }
3765 }
3766
3767 switch (segment->p_type)
3768 {
3769 case PT_DYNAMIC:
3770 if (dynamic_addr)
3771 error (_("more than one dynamic segment\n"));
3772
3773 /* By default, assume that the .dynamic section is the first
3774 section in the DYNAMIC segment. */
3775 dynamic_addr = segment->p_offset;
3776 dynamic_size = segment->p_filesz;
3777
3778 /* Try to locate the .dynamic section. If there is
3779 a section header table, we can easily locate it. */
3780 if (section_headers != NULL)
3781 {
3782 Elf_Internal_Shdr * sec;
3783
3784 sec = find_section (".dynamic");
3785 if (sec == NULL || sec->sh_size == 0)
3786 {
3787 error (_("no .dynamic section in the dynamic segment\n"));
3788 break;
3789 }
3790
3791 if (sec->sh_type == SHT_NOBITS)
3792 {
3793 dynamic_size = 0;
3794 break;
3795 }
3796
3797 dynamic_addr = sec->sh_offset;
3798 dynamic_size = sec->sh_size;
3799
3800 if (dynamic_addr < segment->p_offset
3801 || dynamic_addr > segment->p_offset + segment->p_filesz)
3802 warn (_("the .dynamic section is not contained"
3803 " within the dynamic segment\n"));
3804 else if (dynamic_addr > segment->p_offset)
3805 warn (_("the .dynamic section is not the first section"
3806 " in the dynamic segment.\n"));
3807 }
3808 break;
3809
3810 case PT_INTERP:
3811 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3812 SEEK_SET))
3813 error (_("Unable to find program interpreter name\n"));
3814 else
3815 {
3816 char fmt [32];
3817 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3818
3819 if (ret >= (int) sizeof (fmt) || ret < 0)
3820 error (_("Internal error: failed to create format string to display program interpreter\n"));
3821
3822 program_interpreter[0] = 0;
3823 if (fscanf (file, fmt, program_interpreter) <= 0)
3824 error (_("Unable to read program interpreter name\n"));
3825
3826 if (do_segments)
3827 printf (_("\n [Requesting program interpreter: %s]"),
3828 program_interpreter);
3829 }
3830 break;
3831 }
3832
3833 if (do_segments)
3834 putc ('\n', stdout);
3835 }
3836
3837 if (do_segments && section_headers != NULL && string_table != NULL)
3838 {
3839 printf (_("\n Section to Segment mapping:\n"));
3840 printf (_(" Segment Sections...\n"));
3841
3842 for (i = 0; i < elf_header.e_phnum; i++)
3843 {
3844 unsigned int j;
3845 Elf_Internal_Shdr * section;
3846
3847 segment = program_headers + i;
3848 section = section_headers + 1;
3849
3850 printf (" %2.2d ", i);
3851
3852 for (j = 1; j < elf_header.e_shnum; j++, section++)
3853 {
3854 if (ELF_SECTION_SIZE (section, segment) != 0
3855 && ELF_SECTION_IN_SEGMENT (section, segment))
3856 printf ("%s ", SECTION_NAME (section));
3857 }
3858
3859 putc ('\n',stdout);
3860 }
3861 }
3862
3863 return 1;
3864 }
3865
3866
3867 /* Find the file offset corresponding to VMA by using the program headers. */
3868
3869 static long
3870 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
3871 {
3872 Elf_Internal_Phdr * seg;
3873
3874 if (! get_program_headers (file))
3875 {
3876 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3877 return (long) vma;
3878 }
3879
3880 for (seg = program_headers;
3881 seg < program_headers + elf_header.e_phnum;
3882 ++seg)
3883 {
3884 if (seg->p_type != PT_LOAD)
3885 continue;
3886
3887 if (vma >= (seg->p_vaddr & -seg->p_align)
3888 && vma + size <= seg->p_vaddr + seg->p_filesz)
3889 return vma - seg->p_vaddr + seg->p_offset;
3890 }
3891
3892 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3893 (unsigned long) vma);
3894 return (long) vma;
3895 }
3896
3897
3898 static int
3899 get_32bit_section_headers (FILE * file, unsigned int num)
3900 {
3901 Elf32_External_Shdr * shdrs;
3902 Elf_Internal_Shdr * internal;
3903 unsigned int i;
3904
3905 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3906 elf_header.e_shentsize, num,
3907 _("section headers"));
3908 if (!shdrs)
3909 return 0;
3910
3911 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3912 sizeof (Elf_Internal_Shdr));
3913
3914 if (section_headers == NULL)
3915 {
3916 error (_("Out of memory\n"));
3917 return 0;
3918 }
3919
3920 for (i = 0, internal = section_headers;
3921 i < num;
3922 i++, internal++)
3923 {
3924 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3925 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3926 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3927 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3928 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3929 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3930 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3931 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3932 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3933 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3934 }
3935
3936 free (shdrs);
3937
3938 return 1;
3939 }
3940
3941 static int
3942 get_64bit_section_headers (FILE * file, unsigned int num)
3943 {
3944 Elf64_External_Shdr * shdrs;
3945 Elf_Internal_Shdr * internal;
3946 unsigned int i;
3947
3948 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3949 elf_header.e_shentsize, num,
3950 _("section headers"));
3951 if (!shdrs)
3952 return 0;
3953
3954 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3955 sizeof (Elf_Internal_Shdr));
3956
3957 if (section_headers == NULL)
3958 {
3959 error (_("Out of memory\n"));
3960 return 0;
3961 }
3962
3963 for (i = 0, internal = section_headers;
3964 i < num;
3965 i++, internal++)
3966 {
3967 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3968 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3969 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3970 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3971 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3972 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3973 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3974 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3975 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3976 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3977 }
3978
3979 free (shdrs);
3980
3981 return 1;
3982 }
3983
3984 static Elf_Internal_Sym *
3985 get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
3986 {
3987 unsigned long number;
3988 Elf32_External_Sym * esyms;
3989 Elf_External_Sym_Shndx * shndx;
3990 Elf_Internal_Sym * isyms;
3991 Elf_Internal_Sym * psym;
3992 unsigned int j;
3993
3994 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
3995 section->sh_size, _("symbols"));
3996 if (!esyms)
3997 return NULL;
3998
3999 shndx = NULL;
4000 if (symtab_shndx_hdr != NULL
4001 && (symtab_shndx_hdr->sh_link
4002 == (unsigned long) (section - section_headers)))
4003 {
4004 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4005 symtab_shndx_hdr->sh_offset,
4006 1, symtab_shndx_hdr->sh_size,
4007 _("symtab shndx"));
4008 if (!shndx)
4009 {
4010 free (esyms);
4011 return NULL;
4012 }
4013 }
4014
4015 number = section->sh_size / section->sh_entsize;
4016 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4017
4018 if (isyms == NULL)
4019 {
4020 error (_("Out of memory\n"));
4021 if (shndx)
4022 free (shndx);
4023 free (esyms);
4024 return NULL;
4025 }
4026
4027 for (j = 0, psym = isyms;
4028 j < number;
4029 j++, psym++)
4030 {
4031 psym->st_name = BYTE_GET (esyms[j].st_name);
4032 psym->st_value = BYTE_GET (esyms[j].st_value);
4033 psym->st_size = BYTE_GET (esyms[j].st_size);
4034 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4035 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4036 psym->st_shndx
4037 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4038 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4039 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4040 psym->st_info = BYTE_GET (esyms[j].st_info);
4041 psym->st_other = BYTE_GET (esyms[j].st_other);
4042 }
4043
4044 if (shndx)
4045 free (shndx);
4046 free (esyms);
4047
4048 return isyms;
4049 }
4050
4051 static Elf_Internal_Sym *
4052 get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
4053 {
4054 unsigned long number;
4055 Elf64_External_Sym * esyms;
4056 Elf_External_Sym_Shndx * shndx;
4057 Elf_Internal_Sym * isyms;
4058 Elf_Internal_Sym * psym;
4059 unsigned int j;
4060
4061 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4062 section->sh_size, _("symbols"));
4063 if (!esyms)
4064 return NULL;
4065
4066 shndx = NULL;
4067 if (symtab_shndx_hdr != NULL
4068 && (symtab_shndx_hdr->sh_link
4069 == (unsigned long) (section - section_headers)))
4070 {
4071 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4072 symtab_shndx_hdr->sh_offset,
4073 1, symtab_shndx_hdr->sh_size,
4074 _("symtab shndx"));
4075 if (!shndx)
4076 {
4077 free (esyms);
4078 return NULL;
4079 }
4080 }
4081
4082 number = section->sh_size / section->sh_entsize;
4083 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4084
4085 if (isyms == NULL)
4086 {
4087 error (_("Out of memory\n"));
4088 if (shndx)
4089 free (shndx);
4090 free (esyms);
4091 return NULL;
4092 }
4093
4094 for (j = 0, psym = isyms;
4095 j < number;
4096 j++, psym++)
4097 {
4098 psym->st_name = BYTE_GET (esyms[j].st_name);
4099 psym->st_info = BYTE_GET (esyms[j].st_info);
4100 psym->st_other = BYTE_GET (esyms[j].st_other);
4101 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4102 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4103 psym->st_shndx
4104 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4105 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4106 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4107 psym->st_value = BYTE_GET (esyms[j].st_value);
4108 psym->st_size = BYTE_GET (esyms[j].st_size);
4109 }
4110
4111 if (shndx)
4112 free (shndx);
4113 free (esyms);
4114
4115 return isyms;
4116 }
4117
4118 static const char *
4119 get_elf_section_flags (bfd_vma sh_flags)
4120 {
4121 static char buff[1024];
4122 char * p = buff;
4123 int field_size = is_32bit_elf ? 8 : 16;
4124 int sindex;
4125 int size = sizeof (buff) - (field_size + 4 + 1);
4126 bfd_vma os_flags = 0;
4127 bfd_vma proc_flags = 0;
4128 bfd_vma unknown_flags = 0;
4129 static const struct
4130 {
4131 const char * str;
4132 int len;
4133 }
4134 flags [] =
4135 {
4136 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4137 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4138 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4139 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4140 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4141 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4142 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4143 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4144 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4145 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4146 /* IA-64 specific. */
4147 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4148 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4149 /* IA-64 OpenVMS specific. */
4150 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4151 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4152 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4153 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4154 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4155 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4156 /* Generic. */
4157 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4158 /* SPARC specific. */
4159 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4160 };
4161
4162 if (do_section_details)
4163 {
4164 sprintf (buff, "[%*.*lx]: ",
4165 field_size, field_size, (unsigned long) sh_flags);
4166 p += field_size + 4;
4167 }
4168
4169 while (sh_flags)
4170 {
4171 bfd_vma flag;
4172
4173 flag = sh_flags & - sh_flags;
4174 sh_flags &= ~ flag;
4175
4176 if (do_section_details)
4177 {
4178 switch (flag)
4179 {
4180 case SHF_WRITE: sindex = 0; break;
4181 case SHF_ALLOC: sindex = 1; break;
4182 case SHF_EXECINSTR: sindex = 2; break;
4183 case SHF_MERGE: sindex = 3; break;
4184 case SHF_STRINGS: sindex = 4; break;
4185 case SHF_INFO_LINK: sindex = 5; break;
4186 case SHF_LINK_ORDER: sindex = 6; break;
4187 case SHF_OS_NONCONFORMING: sindex = 7; break;
4188 case SHF_GROUP: sindex = 8; break;
4189 case SHF_TLS: sindex = 9; break;
4190 case SHF_EXCLUDE: sindex = 18; break;
4191
4192 default:
4193 sindex = -1;
4194 switch (elf_header.e_machine)
4195 {
4196 case EM_IA_64:
4197 if (flag == SHF_IA_64_SHORT)
4198 sindex = 10;
4199 else if (flag == SHF_IA_64_NORECOV)
4200 sindex = 11;
4201 #ifdef BFD64
4202 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4203 switch (flag)
4204 {
4205 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4206 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4207 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4208 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4209 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4210 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4211 default: break;
4212 }
4213 #endif
4214 break;
4215
4216 case EM_386:
4217 case EM_486:
4218 case EM_X86_64:
4219 case EM_L1OM:
4220 case EM_OLD_SPARCV9:
4221 case EM_SPARC32PLUS:
4222 case EM_SPARCV9:
4223 case EM_SPARC:
4224 if (flag == SHF_ORDERED)
4225 sindex = 19;
4226 break;
4227 default:
4228 break;
4229 }
4230 }
4231
4232 if (sindex != -1)
4233 {
4234 if (p != buff + field_size + 4)
4235 {
4236 if (size < (10 + 2))
4237 abort ();
4238 size -= 2;
4239 *p++ = ',';
4240 *p++ = ' ';
4241 }
4242
4243 size -= flags [sindex].len;
4244 p = stpcpy (p, flags [sindex].str);
4245 }
4246 else if (flag & SHF_MASKOS)
4247 os_flags |= flag;
4248 else if (flag & SHF_MASKPROC)
4249 proc_flags |= flag;
4250 else
4251 unknown_flags |= flag;
4252 }
4253 else
4254 {
4255 switch (flag)
4256 {
4257 case SHF_WRITE: *p = 'W'; break;
4258 case SHF_ALLOC: *p = 'A'; break;
4259 case SHF_EXECINSTR: *p = 'X'; break;
4260 case SHF_MERGE: *p = 'M'; break;
4261 case SHF_STRINGS: *p = 'S'; break;
4262 case SHF_INFO_LINK: *p = 'I'; break;
4263 case SHF_LINK_ORDER: *p = 'L'; break;
4264 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4265 case SHF_GROUP: *p = 'G'; break;
4266 case SHF_TLS: *p = 'T'; break;
4267 case SHF_EXCLUDE: *p = 'E'; break;
4268
4269 default:
4270 if ((elf_header.e_machine == EM_X86_64
4271 || elf_header.e_machine == EM_L1OM)
4272 && flag == SHF_X86_64_LARGE)
4273 *p = 'l';
4274 else if (flag & SHF_MASKOS)
4275 {
4276 *p = 'o';
4277 sh_flags &= ~ SHF_MASKOS;
4278 }
4279 else if (flag & SHF_MASKPROC)
4280 {
4281 *p = 'p';
4282 sh_flags &= ~ SHF_MASKPROC;
4283 }
4284 else
4285 *p = 'x';
4286 break;
4287 }
4288 p++;
4289 }
4290 }
4291
4292 if (do_section_details)
4293 {
4294 if (os_flags)
4295 {
4296 size -= 5 + field_size;
4297 if (p != buff + field_size + 4)
4298 {
4299 if (size < (2 + 1))
4300 abort ();
4301 size -= 2;
4302 *p++ = ',';
4303 *p++ = ' ';
4304 }
4305 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4306 (unsigned long) os_flags);
4307 p += 5 + field_size;
4308 }
4309 if (proc_flags)
4310 {
4311 size -= 7 + field_size;
4312 if (p != buff + field_size + 4)
4313 {
4314 if (size < (2 + 1))
4315 abort ();
4316 size -= 2;
4317 *p++ = ',';
4318 *p++ = ' ';
4319 }
4320 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4321 (unsigned long) proc_flags);
4322 p += 7 + field_size;
4323 }
4324 if (unknown_flags)
4325 {
4326 size -= 10 + field_size;
4327 if (p != buff + field_size + 4)
4328 {
4329 if (size < (2 + 1))
4330 abort ();
4331 size -= 2;
4332 *p++ = ',';
4333 *p++ = ' ';
4334 }
4335 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4336 (unsigned long) unknown_flags);
4337 p += 10 + field_size;
4338 }
4339 }
4340
4341 *p = '\0';
4342 return buff;
4343 }
4344
4345 static int
4346 process_section_headers (FILE * file)
4347 {
4348 Elf_Internal_Shdr * section;
4349 unsigned int i;
4350
4351 section_headers = NULL;
4352
4353 if (elf_header.e_shnum == 0)
4354 {
4355 if (do_sections)
4356 printf (_("\nThere are no sections in this file.\n"));
4357
4358 return 1;
4359 }
4360
4361 if (do_sections && !do_header)
4362 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4363 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4364
4365 if (is_32bit_elf)
4366 {
4367 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4368 return 0;
4369 }
4370 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4371 return 0;
4372
4373 /* Read in the string table, so that we have names to display. */
4374 if (elf_header.e_shstrndx != SHN_UNDEF
4375 && elf_header.e_shstrndx < elf_header.e_shnum)
4376 {
4377 section = section_headers + elf_header.e_shstrndx;
4378
4379 if (section->sh_size != 0)
4380 {
4381 string_table = (char *) get_data (NULL, file, section->sh_offset,
4382 1, section->sh_size,
4383 _("string table"));
4384
4385 string_table_length = string_table != NULL ? section->sh_size : 0;
4386 }
4387 }
4388
4389 /* Scan the sections for the dynamic symbol table
4390 and dynamic string table and debug sections. */
4391 dynamic_symbols = NULL;
4392 dynamic_strings = NULL;
4393 dynamic_syminfo = NULL;
4394 symtab_shndx_hdr = NULL;
4395
4396 eh_addr_size = is_32bit_elf ? 4 : 8;
4397 switch (elf_header.e_machine)
4398 {
4399 case EM_MIPS:
4400 case EM_MIPS_RS3_LE:
4401 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4402 FDE addresses. However, the ABI also has a semi-official ILP32
4403 variant for which the normal FDE address size rules apply.
4404
4405 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4406 section, where XX is the size of longs in bits. Unfortunately,
4407 earlier compilers provided no way of distinguishing ILP32 objects
4408 from LP64 objects, so if there's any doubt, we should assume that
4409 the official LP64 form is being used. */
4410 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4411 && find_section (".gcc_compiled_long32") == NULL)
4412 eh_addr_size = 8;
4413 break;
4414
4415 case EM_H8_300:
4416 case EM_H8_300H:
4417 switch (elf_header.e_flags & EF_H8_MACH)
4418 {
4419 case E_H8_MACH_H8300:
4420 case E_H8_MACH_H8300HN:
4421 case E_H8_MACH_H8300SN:
4422 case E_H8_MACH_H8300SXN:
4423 eh_addr_size = 2;
4424 break;
4425 case E_H8_MACH_H8300H:
4426 case E_H8_MACH_H8300S:
4427 case E_H8_MACH_H8300SX:
4428 eh_addr_size = 4;
4429 break;
4430 }
4431 break;
4432
4433 case EM_M32C_OLD:
4434 case EM_M32C:
4435 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4436 {
4437 case EF_M32C_CPU_M16C:
4438 eh_addr_size = 2;
4439 break;
4440 }
4441 break;
4442 }
4443
4444 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4445 do \
4446 { \
4447 size_t expected_entsize \
4448 = is_32bit_elf ? size32 : size64; \
4449 if (section->sh_entsize != expected_entsize) \
4450 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4451 i, (unsigned long int) section->sh_entsize, \
4452 (unsigned long int) expected_entsize); \
4453 section->sh_entsize = expected_entsize; \
4454 } \
4455 while (0)
4456 #define CHECK_ENTSIZE(section, i, type) \
4457 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4458 sizeof (Elf64_External_##type))
4459
4460 for (i = 0, section = section_headers;
4461 i < elf_header.e_shnum;
4462 i++, section++)
4463 {
4464 char * name = SECTION_NAME (section);
4465
4466 if (section->sh_type == SHT_DYNSYM)
4467 {
4468 if (dynamic_symbols != NULL)
4469 {
4470 error (_("File contains multiple dynamic symbol tables\n"));
4471 continue;
4472 }
4473
4474 CHECK_ENTSIZE (section, i, Sym);
4475 num_dynamic_syms = section->sh_size / section->sh_entsize;
4476 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4477 }
4478 else if (section->sh_type == SHT_STRTAB
4479 && streq (name, ".dynstr"))
4480 {
4481 if (dynamic_strings != NULL)
4482 {
4483 error (_("File contains multiple dynamic string tables\n"));
4484 continue;
4485 }
4486
4487 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4488 1, section->sh_size,
4489 _("dynamic strings"));
4490 dynamic_strings_length = section->sh_size;
4491 }
4492 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4493 {
4494 if (symtab_shndx_hdr != NULL)
4495 {
4496 error (_("File contains multiple symtab shndx tables\n"));
4497 continue;
4498 }
4499 symtab_shndx_hdr = section;
4500 }
4501 else if (section->sh_type == SHT_SYMTAB)
4502 CHECK_ENTSIZE (section, i, Sym);
4503 else if (section->sh_type == SHT_GROUP)
4504 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4505 else if (section->sh_type == SHT_REL)
4506 CHECK_ENTSIZE (section, i, Rel);
4507 else if (section->sh_type == SHT_RELA)
4508 CHECK_ENTSIZE (section, i, Rela);
4509 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4510 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4511 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4512 || do_debug_str || do_debug_loc || do_debug_ranges)
4513 && (const_strneq (name, ".debug_")
4514 || const_strneq (name, ".zdebug_")))
4515 {
4516 if (name[1] == 'z')
4517 name += sizeof (".zdebug_") - 1;
4518 else
4519 name += sizeof (".debug_") - 1;
4520
4521 if (do_debugging
4522 || (do_debug_info && streq (name, "info"))
4523 || (do_debug_info && streq (name, "types"))
4524 || (do_debug_abbrevs && streq (name, "abbrev"))
4525 || (do_debug_lines && streq (name, "line"))
4526 || (do_debug_pubnames && streq (name, "pubnames"))
4527 || (do_debug_pubtypes && streq (name, "pubtypes"))
4528 || (do_debug_aranges && streq (name, "aranges"))
4529 || (do_debug_ranges && streq (name, "ranges"))
4530 || (do_debug_frames && streq (name, "frame"))
4531 || (do_debug_macinfo && streq (name, "macinfo"))
4532 || (do_debug_str && streq (name, "str"))
4533 || (do_debug_loc && streq (name, "loc"))
4534 )
4535 request_dump_bynumber (i, DEBUG_DUMP);
4536 }
4537 /* Linkonce section to be combined with .debug_info at link time. */
4538 else if ((do_debugging || do_debug_info)
4539 && const_strneq (name, ".gnu.linkonce.wi."))
4540 request_dump_bynumber (i, DEBUG_DUMP);
4541 else if (do_debug_frames && streq (name, ".eh_frame"))
4542 request_dump_bynumber (i, DEBUG_DUMP);
4543 /* Trace sections for Itanium VMS. */
4544 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4545 || do_trace_aranges)
4546 && const_strneq (name, ".trace_"))
4547 {
4548 name += sizeof (".trace_") - 1;
4549
4550 if (do_debugging
4551 || (do_trace_info && streq (name, "info"))
4552 || (do_trace_abbrevs && streq (name, "abbrev"))
4553 || (do_trace_aranges && streq (name, "aranges"))
4554 )
4555 request_dump_bynumber (i, DEBUG_DUMP);
4556 }
4557
4558 }
4559
4560 if (! do_sections)
4561 return 1;
4562
4563 if (elf_header.e_shnum > 1)
4564 printf (_("\nSection Headers:\n"));
4565 else
4566 printf (_("\nSection Header:\n"));
4567
4568 if (is_32bit_elf)
4569 {
4570 if (do_section_details)
4571 {
4572 printf (_(" [Nr] Name\n"));
4573 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4574 }
4575 else
4576 printf
4577 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4578 }
4579 else if (do_wide)
4580 {
4581 if (do_section_details)
4582 {
4583 printf (_(" [Nr] Name\n"));
4584 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4585 }
4586 else
4587 printf
4588 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4589 }
4590 else
4591 {
4592 if (do_section_details)
4593 {
4594 printf (_(" [Nr] Name\n"));
4595 printf (_(" Type Address Offset Link\n"));
4596 printf (_(" Size EntSize Info Align\n"));
4597 }
4598 else
4599 {
4600 printf (_(" [Nr] Name Type Address Offset\n"));
4601 printf (_(" Size EntSize Flags Link Info Align\n"));
4602 }
4603 }
4604
4605 if (do_section_details)
4606 printf (_(" Flags\n"));
4607
4608 for (i = 0, section = section_headers;
4609 i < elf_header.e_shnum;
4610 i++, section++)
4611 {
4612 if (do_section_details)
4613 {
4614 printf (" [%2u] %s\n",
4615 i,
4616 SECTION_NAME (section));
4617 if (is_32bit_elf || do_wide)
4618 printf (" %-15.15s ",
4619 get_section_type_name (section->sh_type));
4620 }
4621 else
4622 printf ((do_wide ? " [%2u] %-17s %-15s "
4623 : " [%2u] %-17.17s %-15.15s "),
4624 i,
4625 SECTION_NAME (section),
4626 get_section_type_name (section->sh_type));
4627
4628 if (is_32bit_elf)
4629 {
4630 const char * link_too_big = NULL;
4631
4632 print_vma (section->sh_addr, LONG_HEX);
4633
4634 printf ( " %6.6lx %6.6lx %2.2lx",
4635 (unsigned long) section->sh_offset,
4636 (unsigned long) section->sh_size,
4637 (unsigned long) section->sh_entsize);
4638
4639 if (do_section_details)
4640 fputs (" ", stdout);
4641 else
4642 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4643
4644 if (section->sh_link >= elf_header.e_shnum)
4645 {
4646 link_too_big = "";
4647 /* The sh_link value is out of range. Normally this indicates
4648 an error but it can have special values in Solaris binaries. */
4649 switch (elf_header.e_machine)
4650 {
4651 case EM_386:
4652 case EM_486:
4653 case EM_X86_64:
4654 case EM_L1OM:
4655 case EM_OLD_SPARCV9:
4656 case EM_SPARC32PLUS:
4657 case EM_SPARCV9:
4658 case EM_SPARC:
4659 if (section->sh_link == (SHN_BEFORE & 0xffff))
4660 link_too_big = "BEFORE";
4661 else if (section->sh_link == (SHN_AFTER & 0xffff))
4662 link_too_big = "AFTER";
4663 break;
4664 default:
4665 break;
4666 }
4667 }
4668
4669 if (do_section_details)
4670 {
4671 if (link_too_big != NULL && * link_too_big)
4672 printf ("<%s> ", link_too_big);
4673 else
4674 printf ("%2u ", section->sh_link);
4675 printf ("%3u %2lu\n", section->sh_info,
4676 (unsigned long) section->sh_addralign);
4677 }
4678 else
4679 printf ("%2u %3u %2lu\n",
4680 section->sh_link,
4681 section->sh_info,
4682 (unsigned long) section->sh_addralign);
4683
4684 if (link_too_big && ! * link_too_big)
4685 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4686 i, section->sh_link);
4687 }
4688 else if (do_wide)
4689 {
4690 print_vma (section->sh_addr, LONG_HEX);
4691
4692 if ((long) section->sh_offset == section->sh_offset)
4693 printf (" %6.6lx", (unsigned long) section->sh_offset);
4694 else
4695 {
4696 putchar (' ');
4697 print_vma (section->sh_offset, LONG_HEX);
4698 }
4699
4700 if ((unsigned long) section->sh_size == section->sh_size)
4701 printf (" %6.6lx", (unsigned long) section->sh_size);
4702 else
4703 {
4704 putchar (' ');
4705 print_vma (section->sh_size, LONG_HEX);
4706 }
4707
4708 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4709 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4710 else
4711 {
4712 putchar (' ');
4713 print_vma (section->sh_entsize, LONG_HEX);
4714 }
4715
4716 if (do_section_details)
4717 fputs (" ", stdout);
4718 else
4719 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4720
4721 printf ("%2u %3u ", section->sh_link, section->sh_info);
4722
4723 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4724 printf ("%2lu\n", (unsigned long) section->sh_addralign);
4725 else
4726 {
4727 print_vma (section->sh_addralign, DEC);
4728 putchar ('\n');
4729 }
4730 }
4731 else if (do_section_details)
4732 {
4733 printf (" %-15.15s ",
4734 get_section_type_name (section->sh_type));
4735 print_vma (section->sh_addr, LONG_HEX);
4736 if ((long) section->sh_offset == section->sh_offset)
4737 printf (" %16.16lx", (unsigned long) section->sh_offset);
4738 else
4739 {
4740 printf (" ");
4741 print_vma (section->sh_offset, LONG_HEX);
4742 }
4743 printf (" %u\n ", section->sh_link);
4744 print_vma (section->sh_size, LONG_HEX);
4745 putchar (' ');
4746 print_vma (section->sh_entsize, LONG_HEX);
4747
4748 printf (" %-16u %lu\n",
4749 section->sh_info,
4750 (unsigned long) section->sh_addralign);
4751 }
4752 else
4753 {
4754 putchar (' ');
4755 print_vma (section->sh_addr, LONG_HEX);
4756 if ((long) section->sh_offset == section->sh_offset)
4757 printf (" %8.8lx", (unsigned long) section->sh_offset);
4758 else
4759 {
4760 printf (" ");
4761 print_vma (section->sh_offset, LONG_HEX);
4762 }
4763 printf ("\n ");
4764 print_vma (section->sh_size, LONG_HEX);
4765 printf (" ");
4766 print_vma (section->sh_entsize, LONG_HEX);
4767
4768 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4769
4770 printf (" %2u %3u %lu\n",
4771 section->sh_link,
4772 section->sh_info,
4773 (unsigned long) section->sh_addralign);
4774 }
4775
4776 if (do_section_details)
4777 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4778 }
4779
4780 if (!do_section_details)
4781 printf (_("Key to Flags:\n\
4782 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4783 I (info), L (link order), G (group), x (unknown)\n\
4784 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4785
4786 return 1;
4787 }
4788
4789 static const char *
4790 get_group_flags (unsigned int flags)
4791 {
4792 static char buff[32];
4793 switch (flags)
4794 {
4795 case 0:
4796 return "";
4797
4798 case GRP_COMDAT:
4799 return "COMDAT ";
4800
4801 default:
4802 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
4803 break;
4804 }
4805 return buff;
4806 }
4807
4808 static int
4809 process_section_groups (FILE * file)
4810 {
4811 Elf_Internal_Shdr * section;
4812 unsigned int i;
4813 struct group * group;
4814 Elf_Internal_Shdr * symtab_sec;
4815 Elf_Internal_Shdr * strtab_sec;
4816 Elf_Internal_Sym * symtab;
4817 char * strtab;
4818 size_t strtab_size;
4819
4820 /* Don't process section groups unless needed. */
4821 if (!do_unwind && !do_section_groups)
4822 return 1;
4823
4824 if (elf_header.e_shnum == 0)
4825 {
4826 if (do_section_groups)
4827 printf (_("\nThere are no sections in this file.\n"));
4828
4829 return 1;
4830 }
4831
4832 if (section_headers == NULL)
4833 {
4834 error (_("Section headers are not available!\n"));
4835 abort ();
4836 }
4837
4838 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4839 sizeof (struct group *));
4840
4841 if (section_headers_groups == NULL)
4842 {
4843 error (_("Out of memory\n"));
4844 return 0;
4845 }
4846
4847 /* Scan the sections for the group section. */
4848 group_count = 0;
4849 for (i = 0, section = section_headers;
4850 i < elf_header.e_shnum;
4851 i++, section++)
4852 if (section->sh_type == SHT_GROUP)
4853 group_count++;
4854
4855 if (group_count == 0)
4856 {
4857 if (do_section_groups)
4858 printf (_("\nThere are no section groups in this file.\n"));
4859
4860 return 1;
4861 }
4862
4863 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
4864
4865 if (section_groups == NULL)
4866 {
4867 error (_("Out of memory\n"));
4868 return 0;
4869 }
4870
4871 symtab_sec = NULL;
4872 strtab_sec = NULL;
4873 symtab = NULL;
4874 strtab = NULL;
4875 strtab_size = 0;
4876 for (i = 0, section = section_headers, group = section_groups;
4877 i < elf_header.e_shnum;
4878 i++, section++)
4879 {
4880 if (section->sh_type == SHT_GROUP)
4881 {
4882 char * name = SECTION_NAME (section);
4883 char * group_name;
4884 unsigned char * start;
4885 unsigned char * indices;
4886 unsigned int entry, j, size;
4887 Elf_Internal_Shdr * sec;
4888 Elf_Internal_Sym * sym;
4889
4890 /* Get the symbol table. */
4891 if (section->sh_link >= elf_header.e_shnum
4892 || ((sec = section_headers + section->sh_link)->sh_type
4893 != SHT_SYMTAB))
4894 {
4895 error (_("Bad sh_link in group section `%s'\n"), name);
4896 continue;
4897 }
4898
4899 if (symtab_sec != sec)
4900 {
4901 symtab_sec = sec;
4902 if (symtab)
4903 free (symtab);
4904 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4905 }
4906
4907 sym = symtab + section->sh_info;
4908
4909 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4910 {
4911 if (sym->st_shndx == 0
4912 || sym->st_shndx >= elf_header.e_shnum)
4913 {
4914 error (_("Bad sh_info in group section `%s'\n"), name);
4915 continue;
4916 }
4917
4918 group_name = SECTION_NAME (section_headers + sym->st_shndx);
4919 strtab_sec = NULL;
4920 if (strtab)
4921 free (strtab);
4922 strtab = NULL;
4923 strtab_size = 0;
4924 }
4925 else
4926 {
4927 /* Get the string table. */
4928 if (symtab_sec->sh_link >= elf_header.e_shnum)
4929 {
4930 strtab_sec = NULL;
4931 if (strtab)
4932 free (strtab);
4933 strtab = NULL;
4934 strtab_size = 0;
4935 }
4936 else if (strtab_sec
4937 != (sec = section_headers + symtab_sec->sh_link))
4938 {
4939 strtab_sec = sec;
4940 if (strtab)
4941 free (strtab);
4942 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
4943 1, strtab_sec->sh_size,
4944 _("string table"));
4945 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
4946 }
4947 group_name = sym->st_name < strtab_size
4948 ? strtab + sym->st_name : _("<corrupt>");
4949 }
4950
4951 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
4952 1, section->sh_size,
4953 _("section data"));
4954
4955 indices = start;
4956 size = (section->sh_size / section->sh_entsize) - 1;
4957 entry = byte_get (indices, 4);
4958 indices += 4;
4959
4960 if (do_section_groups)
4961 {
4962 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
4963 get_group_flags (entry), i, name, group_name, size);
4964
4965 printf (_(" [Index] Name\n"));
4966 }
4967
4968 group->group_index = i;
4969
4970 for (j = 0; j < size; j++)
4971 {
4972 struct group_list * g;
4973
4974 entry = byte_get (indices, 4);
4975 indices += 4;
4976
4977 if (entry >= elf_header.e_shnum)
4978 {
4979 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4980 entry, i, elf_header.e_shnum - 1);
4981 continue;
4982 }
4983
4984 if (section_headers_groups [entry] != NULL)
4985 {
4986 if (entry)
4987 {
4988 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4989 entry, i,
4990 section_headers_groups [entry]->group_index);
4991 continue;
4992 }
4993 else
4994 {
4995 /* Intel C/C++ compiler may put section 0 in a
4996 section group. We just warn it the first time
4997 and ignore it afterwards. */
4998 static int warned = 0;
4999 if (!warned)
5000 {
5001 error (_("section 0 in group section [%5u]\n"),
5002 section_headers_groups [entry]->group_index);
5003 warned++;
5004 }
5005 }
5006 }
5007
5008 section_headers_groups [entry] = group;
5009
5010 if (do_section_groups)
5011 {
5012 sec = section_headers + entry;
5013 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
5014 }
5015
5016 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5017 g->section_index = entry;
5018 g->next = group->root;
5019 group->root = g;
5020 }
5021
5022 if (start)
5023 free (start);
5024
5025 group++;
5026 }
5027 }
5028
5029 if (symtab)
5030 free (symtab);
5031 if (strtab)
5032 free (strtab);
5033 return 1;
5034 }
5035
5036 static struct
5037 {
5038 const char * name;
5039 int reloc;
5040 int size;
5041 int rela;
5042 } dynamic_relocations [] =
5043 {
5044 { "REL", DT_REL, DT_RELSZ, FALSE },
5045 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5046 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5047 };
5048
5049 /* Process the reloc section. */
5050
5051 static int
5052 process_relocs (FILE * file)
5053 {
5054 unsigned long rel_size;
5055 unsigned long rel_offset;
5056
5057
5058 if (!do_reloc)
5059 return 1;
5060
5061 if (do_using_dynamic)
5062 {
5063 int is_rela;
5064 const char * name;
5065 int has_dynamic_reloc;
5066 unsigned int i;
5067
5068 has_dynamic_reloc = 0;
5069
5070 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5071 {
5072 is_rela = dynamic_relocations [i].rela;
5073 name = dynamic_relocations [i].name;
5074 rel_size = dynamic_info [dynamic_relocations [i].size];
5075 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5076
5077 has_dynamic_reloc |= rel_size;
5078
5079 if (is_rela == UNKNOWN)
5080 {
5081 if (dynamic_relocations [i].reloc == DT_JMPREL)
5082 switch (dynamic_info[DT_PLTREL])
5083 {
5084 case DT_REL:
5085 is_rela = FALSE;
5086 break;
5087 case DT_RELA:
5088 is_rela = TRUE;
5089 break;
5090 }
5091 }
5092
5093 if (rel_size)
5094 {
5095 printf
5096 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5097 name, rel_offset, rel_size);
5098
5099 dump_relocations (file,
5100 offset_from_vma (file, rel_offset, rel_size),
5101 rel_size,
5102 dynamic_symbols, num_dynamic_syms,
5103 dynamic_strings, dynamic_strings_length, is_rela);
5104 }
5105 }
5106
5107 if (! has_dynamic_reloc)
5108 printf (_("\nThere are no dynamic relocations in this file.\n"));
5109 }
5110 else
5111 {
5112 Elf_Internal_Shdr * section;
5113 unsigned long i;
5114 int found = 0;
5115
5116 for (i = 0, section = section_headers;
5117 i < elf_header.e_shnum;
5118 i++, section++)
5119 {
5120 if ( section->sh_type != SHT_RELA
5121 && section->sh_type != SHT_REL)
5122 continue;
5123
5124 rel_offset = section->sh_offset;
5125 rel_size = section->sh_size;
5126
5127 if (rel_size)
5128 {
5129 Elf_Internal_Shdr * strsec;
5130 int is_rela;
5131
5132 printf (_("\nRelocation section "));
5133
5134 if (string_table == NULL)
5135 printf ("%d", section->sh_name);
5136 else
5137 printf (_("'%s'"), SECTION_NAME (section));
5138
5139 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5140 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5141
5142 is_rela = section->sh_type == SHT_RELA;
5143
5144 if (section->sh_link != 0
5145 && section->sh_link < elf_header.e_shnum)
5146 {
5147 Elf_Internal_Shdr * symsec;
5148 Elf_Internal_Sym * symtab;
5149 unsigned long nsyms;
5150 unsigned long strtablen = 0;
5151 char * strtab = NULL;
5152
5153 symsec = section_headers + section->sh_link;
5154 if (symsec->sh_type != SHT_SYMTAB
5155 && symsec->sh_type != SHT_DYNSYM)
5156 continue;
5157
5158 nsyms = symsec->sh_size / symsec->sh_entsize;
5159 symtab = GET_ELF_SYMBOLS (file, symsec);
5160
5161 if (symtab == NULL)
5162 continue;
5163
5164 if (symsec->sh_link != 0
5165 && symsec->sh_link < elf_header.e_shnum)
5166 {
5167 strsec = section_headers + symsec->sh_link;
5168
5169 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5170 1, strsec->sh_size,
5171 _("string table"));
5172 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5173 }
5174
5175 dump_relocations (file, rel_offset, rel_size,
5176 symtab, nsyms, strtab, strtablen, is_rela);
5177 if (strtab)
5178 free (strtab);
5179 free (symtab);
5180 }
5181 else
5182 dump_relocations (file, rel_offset, rel_size,
5183 NULL, 0, NULL, 0, is_rela);
5184
5185 found = 1;
5186 }
5187 }
5188
5189 if (! found)
5190 printf (_("\nThere are no relocations in this file.\n"));
5191 }
5192
5193 return 1;
5194 }
5195
5196 /* Process the unwind section. */
5197
5198 #include "unwind-ia64.h"
5199
5200 /* An absolute address consists of a section and an offset. If the
5201 section is NULL, the offset itself is the address, otherwise, the
5202 address equals to LOAD_ADDRESS(section) + offset. */
5203
5204 struct absaddr
5205 {
5206 unsigned short section;
5207 bfd_vma offset;
5208 };
5209
5210 #define ABSADDR(a) \
5211 ((a).section \
5212 ? section_headers [(a).section].sh_addr + (a).offset \
5213 : (a).offset)
5214
5215 struct ia64_unw_table_entry
5216 {
5217 struct absaddr start;
5218 struct absaddr end;
5219 struct absaddr info;
5220 };
5221
5222 struct ia64_unw_aux_info
5223 {
5224
5225 struct ia64_unw_table_entry *table; /* Unwind table. */
5226 unsigned long table_len; /* Length of unwind table. */
5227 unsigned char * info; /* Unwind info. */
5228 unsigned long info_size; /* Size of unwind info. */
5229 bfd_vma info_addr; /* starting address of unwind info. */
5230 bfd_vma seg_base; /* Starting address of segment. */
5231 Elf_Internal_Sym * symtab; /* The symbol table. */
5232 unsigned long nsyms; /* Number of symbols. */
5233 char * strtab; /* The string table. */
5234 unsigned long strtab_size; /* Size of string table. */
5235 };
5236
5237 static void
5238 find_symbol_for_address (Elf_Internal_Sym * symtab,
5239 unsigned long nsyms,
5240 const char * strtab,
5241 unsigned long strtab_size,
5242 struct absaddr addr,
5243 const char ** symname,
5244 bfd_vma * offset)
5245 {
5246 bfd_vma dist = 0x100000;
5247 Elf_Internal_Sym * sym;
5248 Elf_Internal_Sym * best = NULL;
5249 unsigned long i;
5250
5251 REMOVE_ARCH_BITS (addr.offset);
5252
5253 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5254 {
5255 bfd_vma value = sym->st_value;
5256
5257 REMOVE_ARCH_BITS (value);
5258
5259 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5260 && sym->st_name != 0
5261 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5262 && addr.offset >= value
5263 && addr.offset - value < dist)
5264 {
5265 best = sym;
5266 dist = addr.offset - value;
5267 if (!dist)
5268 break;
5269 }
5270 }
5271 if (best)
5272 {
5273 *symname = (best->st_name >= strtab_size
5274 ? _("<corrupt>") : strtab + best->st_name);
5275 *offset = dist;
5276 return;
5277 }
5278 *symname = NULL;
5279 *offset = addr.offset;
5280 }
5281
5282 static void
5283 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5284 {
5285 struct ia64_unw_table_entry * tp;
5286 int in_body;
5287
5288 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5289 {
5290 bfd_vma stamp;
5291 bfd_vma offset;
5292 const unsigned char * dp;
5293 const unsigned char * head;
5294 const char * procname;
5295
5296 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5297 aux->strtab_size, tp->start, &procname, &offset);
5298
5299 fputs ("\n<", stdout);
5300
5301 if (procname)
5302 {
5303 fputs (procname, stdout);
5304
5305 if (offset)
5306 printf ("+%lx", (unsigned long) offset);
5307 }
5308
5309 fputs (">: [", stdout);
5310 print_vma (tp->start.offset, PREFIX_HEX);
5311 fputc ('-', stdout);
5312 print_vma (tp->end.offset, PREFIX_HEX);
5313 printf ("], info at +0x%lx\n",
5314 (unsigned long) (tp->info.offset - aux->seg_base));
5315
5316 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5317 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5318
5319 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5320 (unsigned) UNW_VER (stamp),
5321 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5322 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5323 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5324 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5325
5326 if (UNW_VER (stamp) != 1)
5327 {
5328 printf (_("\tUnknown version.\n"));
5329 continue;
5330 }
5331
5332 in_body = 0;
5333 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5334 dp = unw_decode (dp, in_body, & in_body);
5335 }
5336 }
5337
5338 static int
5339 slurp_ia64_unwind_table (FILE * file,
5340 struct ia64_unw_aux_info * aux,
5341 Elf_Internal_Shdr * sec)
5342 {
5343 unsigned long size, nrelas, i;
5344 Elf_Internal_Phdr * seg;
5345 struct ia64_unw_table_entry * tep;
5346 Elf_Internal_Shdr * relsec;
5347 Elf_Internal_Rela * rela;
5348 Elf_Internal_Rela * rp;
5349 unsigned char * table;
5350 unsigned char * tp;
5351 Elf_Internal_Sym * sym;
5352 const char * relname;
5353
5354 /* First, find the starting address of the segment that includes
5355 this section: */
5356
5357 if (elf_header.e_phnum)
5358 {
5359 if (! get_program_headers (file))
5360 return 0;
5361
5362 for (seg = program_headers;
5363 seg < program_headers + elf_header.e_phnum;
5364 ++seg)
5365 {
5366 if (seg->p_type != PT_LOAD)
5367 continue;
5368
5369 if (sec->sh_addr >= seg->p_vaddr
5370 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5371 {
5372 aux->seg_base = seg->p_vaddr;
5373 break;
5374 }
5375 }
5376 }
5377
5378 /* Second, build the unwind table from the contents of the unwind section: */
5379 size = sec->sh_size;
5380 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5381 _("unwind table"));
5382 if (!table)
5383 return 0;
5384
5385 aux->table = (struct ia64_unw_table_entry *)
5386 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5387 tep = aux->table;
5388 for (tp = table; tp < table + size; ++tep)
5389 {
5390 tep->start.section = SHN_UNDEF;
5391 tep->end.section = SHN_UNDEF;
5392 tep->info.section = SHN_UNDEF;
5393 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5394 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5395 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5396 tep->start.offset += aux->seg_base;
5397 tep->end.offset += aux->seg_base;
5398 tep->info.offset += aux->seg_base;
5399 }
5400 free (table);
5401
5402 /* Third, apply any relocations to the unwind table: */
5403 for (relsec = section_headers;
5404 relsec < section_headers + elf_header.e_shnum;
5405 ++relsec)
5406 {
5407 if (relsec->sh_type != SHT_RELA
5408 || relsec->sh_info >= elf_header.e_shnum
5409 || section_headers + relsec->sh_info != sec)
5410 continue;
5411
5412 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5413 & rela, & nrelas))
5414 return 0;
5415
5416 for (rp = rela; rp < rela + nrelas; ++rp)
5417 {
5418 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5419 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5420
5421 if (! const_strneq (relname, "R_IA64_SEGREL"))
5422 {
5423 warn (_("Skipping unexpected relocation type %s\n"), relname);
5424 continue;
5425 }
5426
5427 i = rp->r_offset / (3 * eh_addr_size);
5428
5429 switch (rp->r_offset/eh_addr_size % 3)
5430 {
5431 case 0:
5432 aux->table[i].start.section = sym->st_shndx;
5433 aux->table[i].start.offset += rp->r_addend + sym->st_value;
5434 break;
5435 case 1:
5436 aux->table[i].end.section = sym->st_shndx;
5437 aux->table[i].end.offset += rp->r_addend + sym->st_value;
5438 break;
5439 case 2:
5440 aux->table[i].info.section = sym->st_shndx;
5441 aux->table[i].info.offset += rp->r_addend + sym->st_value;
5442 break;
5443 default:
5444 break;
5445 }
5446 }
5447
5448 free (rela);
5449 }
5450
5451 aux->table_len = size / (3 * eh_addr_size);
5452 return 1;
5453 }
5454
5455 static int
5456 ia64_process_unwind (FILE * file)
5457 {
5458 Elf_Internal_Shdr * sec;
5459 Elf_Internal_Shdr * unwsec = NULL;
5460 Elf_Internal_Shdr * strsec;
5461 unsigned long i, unwcount = 0, unwstart = 0;
5462 struct ia64_unw_aux_info aux;
5463
5464 memset (& aux, 0, sizeof (aux));
5465
5466 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5467 {
5468 if (sec->sh_type == SHT_SYMTAB
5469 && sec->sh_link < elf_header.e_shnum)
5470 {
5471 aux.nsyms = sec->sh_size / sec->sh_entsize;
5472 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5473
5474 strsec = section_headers + sec->sh_link;
5475 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5476 1, strsec->sh_size,
5477 _("string table"));
5478 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5479 }
5480 else if (sec->sh_type == SHT_IA_64_UNWIND)
5481 unwcount++;
5482 }
5483
5484 if (!unwcount)
5485 printf (_("\nThere are no unwind sections in this file.\n"));
5486
5487 while (unwcount-- > 0)
5488 {
5489 char * suffix;
5490 size_t len, len2;
5491
5492 for (i = unwstart, sec = section_headers + unwstart;
5493 i < elf_header.e_shnum; ++i, ++sec)
5494 if (sec->sh_type == SHT_IA_64_UNWIND)
5495 {
5496 unwsec = sec;
5497 break;
5498 }
5499
5500 unwstart = i + 1;
5501 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5502
5503 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5504 {
5505 /* We need to find which section group it is in. */
5506 struct group_list * g = section_headers_groups [i]->root;
5507
5508 for (; g != NULL; g = g->next)
5509 {
5510 sec = section_headers + g->section_index;
5511
5512 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5513 break;
5514 }
5515
5516 if (g == NULL)
5517 i = elf_header.e_shnum;
5518 }
5519 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5520 {
5521 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5522 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5523 suffix = SECTION_NAME (unwsec) + len;
5524 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5525 ++i, ++sec)
5526 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5527 && streq (SECTION_NAME (sec) + len2, suffix))
5528 break;
5529 }
5530 else
5531 {
5532 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5533 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5534 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5535 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5536 suffix = "";
5537 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5538 suffix = SECTION_NAME (unwsec) + len;
5539 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5540 ++i, ++sec)
5541 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5542 && streq (SECTION_NAME (sec) + len2, suffix))
5543 break;
5544 }
5545
5546 if (i == elf_header.e_shnum)
5547 {
5548 printf (_("\nCould not find unwind info section for "));
5549
5550 if (string_table == NULL)
5551 printf ("%d", unwsec->sh_name);
5552 else
5553 printf (_("'%s'"), SECTION_NAME (unwsec));
5554 }
5555 else
5556 {
5557 aux.info_size = sec->sh_size;
5558 aux.info_addr = sec->sh_addr;
5559 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5560 aux.info_size,
5561 _("unwind info"));
5562
5563 printf (_("\nUnwind section "));
5564
5565 if (string_table == NULL)
5566 printf ("%d", unwsec->sh_name);
5567 else
5568 printf (_("'%s'"), SECTION_NAME (unwsec));
5569
5570 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5571 (unsigned long) unwsec->sh_offset,
5572 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5573
5574 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5575
5576 if (aux.table_len > 0)
5577 dump_ia64_unwind (& aux);
5578
5579 if (aux.table)
5580 free ((char *) aux.table);
5581 if (aux.info)
5582 free ((char *) aux.info);
5583 aux.table = NULL;
5584 aux.info = NULL;
5585 }
5586 }
5587
5588 if (aux.symtab)
5589 free (aux.symtab);
5590 if (aux.strtab)
5591 free ((char *) aux.strtab);
5592
5593 return 1;
5594 }
5595
5596 struct hppa_unw_table_entry
5597 {
5598 struct absaddr start;
5599 struct absaddr end;
5600 unsigned int Cannot_unwind:1; /* 0 */
5601 unsigned int Millicode:1; /* 1 */
5602 unsigned int Millicode_save_sr0:1; /* 2 */
5603 unsigned int Region_description:2; /* 3..4 */
5604 unsigned int reserved1:1; /* 5 */
5605 unsigned int Entry_SR:1; /* 6 */
5606 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5607 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5608 unsigned int Args_stored:1; /* 16 */
5609 unsigned int Variable_Frame:1; /* 17 */
5610 unsigned int Separate_Package_Body:1; /* 18 */
5611 unsigned int Frame_Extension_Millicode:1; /* 19 */
5612 unsigned int Stack_Overflow_Check:1; /* 20 */
5613 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5614 unsigned int Ada_Region:1; /* 22 */
5615 unsigned int cxx_info:1; /* 23 */
5616 unsigned int cxx_try_catch:1; /* 24 */
5617 unsigned int sched_entry_seq:1; /* 25 */
5618 unsigned int reserved2:1; /* 26 */
5619 unsigned int Save_SP:1; /* 27 */
5620 unsigned int Save_RP:1; /* 28 */
5621 unsigned int Save_MRP_in_frame:1; /* 29 */
5622 unsigned int extn_ptr_defined:1; /* 30 */
5623 unsigned int Cleanup_defined:1; /* 31 */
5624
5625 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5626 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5627 unsigned int Large_frame:1; /* 2 */
5628 unsigned int Pseudo_SP_Set:1; /* 3 */
5629 unsigned int reserved4:1; /* 4 */
5630 unsigned int Total_frame_size:27; /* 5..31 */
5631 };
5632
5633 struct hppa_unw_aux_info
5634 {
5635 struct hppa_unw_table_entry *table; /* Unwind table. */
5636 unsigned long table_len; /* Length of unwind table. */
5637 bfd_vma seg_base; /* Starting address of segment. */
5638 Elf_Internal_Sym * symtab; /* The symbol table. */
5639 unsigned long nsyms; /* Number of symbols. */
5640 char * strtab; /* The string table. */
5641 unsigned long strtab_size; /* Size of string table. */
5642 };
5643
5644 static void
5645 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5646 {
5647 struct hppa_unw_table_entry * tp;
5648
5649 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5650 {
5651 bfd_vma offset;
5652 const char * procname;
5653
5654 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5655 aux->strtab_size, tp->start, &procname,
5656 &offset);
5657
5658 fputs ("\n<", stdout);
5659
5660 if (procname)
5661 {
5662 fputs (procname, stdout);
5663
5664 if (offset)
5665 printf ("+%lx", (unsigned long) offset);
5666 }
5667
5668 fputs (">: [", stdout);
5669 print_vma (tp->start.offset, PREFIX_HEX);
5670 fputc ('-', stdout);
5671 print_vma (tp->end.offset, PREFIX_HEX);
5672 printf ("]\n\t");
5673
5674 #define PF(_m) if (tp->_m) printf (#_m " ");
5675 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5676 PF(Cannot_unwind);
5677 PF(Millicode);
5678 PF(Millicode_save_sr0);
5679 /* PV(Region_description); */
5680 PF(Entry_SR);
5681 PV(Entry_FR);
5682 PV(Entry_GR);
5683 PF(Args_stored);
5684 PF(Variable_Frame);
5685 PF(Separate_Package_Body);
5686 PF(Frame_Extension_Millicode);
5687 PF(Stack_Overflow_Check);
5688 PF(Two_Instruction_SP_Increment);
5689 PF(Ada_Region);
5690 PF(cxx_info);
5691 PF(cxx_try_catch);
5692 PF(sched_entry_seq);
5693 PF(Save_SP);
5694 PF(Save_RP);
5695 PF(Save_MRP_in_frame);
5696 PF(extn_ptr_defined);
5697 PF(Cleanup_defined);
5698 PF(MPE_XL_interrupt_marker);
5699 PF(HP_UX_interrupt_marker);
5700 PF(Large_frame);
5701 PF(Pseudo_SP_Set);
5702 PV(Total_frame_size);
5703 #undef PF
5704 #undef PV
5705 }
5706
5707 printf ("\n");
5708 }
5709
5710 static int
5711 slurp_hppa_unwind_table (FILE * file,
5712 struct hppa_unw_aux_info * aux,
5713 Elf_Internal_Shdr * sec)
5714 {
5715 unsigned long size, unw_ent_size, nentries, nrelas, i;
5716 Elf_Internal_Phdr * seg;
5717 struct hppa_unw_table_entry * tep;
5718 Elf_Internal_Shdr * relsec;
5719 Elf_Internal_Rela * rela;
5720 Elf_Internal_Rela * rp;
5721 unsigned char * table;
5722 unsigned char * tp;
5723 Elf_Internal_Sym * sym;
5724 const char * relname;
5725
5726 /* First, find the starting address of the segment that includes
5727 this section. */
5728
5729 if (elf_header.e_phnum)
5730 {
5731 if (! get_program_headers (file))
5732 return 0;
5733
5734 for (seg = program_headers;
5735 seg < program_headers + elf_header.e_phnum;
5736 ++seg)
5737 {
5738 if (seg->p_type != PT_LOAD)
5739 continue;
5740
5741 if (sec->sh_addr >= seg->p_vaddr
5742 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5743 {
5744 aux->seg_base = seg->p_vaddr;
5745 break;
5746 }
5747 }
5748 }
5749
5750 /* Second, build the unwind table from the contents of the unwind
5751 section. */
5752 size = sec->sh_size;
5753 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5754 _("unwind table"));
5755 if (!table)
5756 return 0;
5757
5758 unw_ent_size = 16;
5759 nentries = size / unw_ent_size;
5760 size = unw_ent_size * nentries;
5761
5762 tep = aux->table = (struct hppa_unw_table_entry *)
5763 xcmalloc (nentries, sizeof (aux->table[0]));
5764
5765 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
5766 {
5767 unsigned int tmp1, tmp2;
5768
5769 tep->start.section = SHN_UNDEF;
5770 tep->end.section = SHN_UNDEF;
5771
5772 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5773 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5774 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5775 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5776
5777 tep->start.offset += aux->seg_base;
5778 tep->end.offset += aux->seg_base;
5779
5780 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5781 tep->Millicode = (tmp1 >> 30) & 0x1;
5782 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5783 tep->Region_description = (tmp1 >> 27) & 0x3;
5784 tep->reserved1 = (tmp1 >> 26) & 0x1;
5785 tep->Entry_SR = (tmp1 >> 25) & 0x1;
5786 tep->Entry_FR = (tmp1 >> 21) & 0xf;
5787 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5788 tep->Args_stored = (tmp1 >> 15) & 0x1;
5789 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5790 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5791 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5792 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5793 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5794 tep->Ada_Region = (tmp1 >> 9) & 0x1;
5795 tep->cxx_info = (tmp1 >> 8) & 0x1;
5796 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5797 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5798 tep->reserved2 = (tmp1 >> 5) & 0x1;
5799 tep->Save_SP = (tmp1 >> 4) & 0x1;
5800 tep->Save_RP = (tmp1 >> 3) & 0x1;
5801 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5802 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5803 tep->Cleanup_defined = tmp1 & 0x1;
5804
5805 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5806 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5807 tep->Large_frame = (tmp2 >> 29) & 0x1;
5808 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5809 tep->reserved4 = (tmp2 >> 27) & 0x1;
5810 tep->Total_frame_size = tmp2 & 0x7ffffff;
5811 }
5812 free (table);
5813
5814 /* Third, apply any relocations to the unwind table. */
5815 for (relsec = section_headers;
5816 relsec < section_headers + elf_header.e_shnum;
5817 ++relsec)
5818 {
5819 if (relsec->sh_type != SHT_RELA
5820 || relsec->sh_info >= elf_header.e_shnum
5821 || section_headers + relsec->sh_info != sec)
5822 continue;
5823
5824 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5825 & rela, & nrelas))
5826 return 0;
5827
5828 for (rp = rela; rp < rela + nrelas; ++rp)
5829 {
5830 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
5831 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5832
5833 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5834 if (! const_strneq (relname, "R_PARISC_SEGREL"))
5835 {
5836 warn (_("Skipping unexpected relocation type %s\n"), relname);
5837 continue;
5838 }
5839
5840 i = rp->r_offset / unw_ent_size;
5841
5842 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
5843 {
5844 case 0:
5845 aux->table[i].start.section = sym->st_shndx;
5846 aux->table[i].start.offset = sym->st_value + rp->r_addend;
5847 break;
5848 case 1:
5849 aux->table[i].end.section = sym->st_shndx;
5850 aux->table[i].end.offset = sym->st_value + rp->r_addend;
5851 break;
5852 default:
5853 break;
5854 }
5855 }
5856
5857 free (rela);
5858 }
5859
5860 aux->table_len = nentries;
5861
5862 return 1;
5863 }
5864
5865 static int
5866 hppa_process_unwind (FILE * file)
5867 {
5868 struct hppa_unw_aux_info aux;
5869 Elf_Internal_Shdr * unwsec = NULL;
5870 Elf_Internal_Shdr * strsec;
5871 Elf_Internal_Shdr * sec;
5872 unsigned long i;
5873
5874 memset (& aux, 0, sizeof (aux));
5875
5876 if (string_table == NULL)
5877 return 1;
5878
5879 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5880 {
5881 if (sec->sh_type == SHT_SYMTAB
5882 && sec->sh_link < elf_header.e_shnum)
5883 {
5884 aux.nsyms = sec->sh_size / sec->sh_entsize;
5885 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5886
5887 strsec = section_headers + sec->sh_link;
5888 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5889 1, strsec->sh_size,
5890 _("string table"));
5891 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5892 }
5893 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5894 unwsec = sec;
5895 }
5896
5897 if (!unwsec)
5898 printf (_("\nThere are no unwind sections in this file.\n"));
5899
5900 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5901 {
5902 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5903 {
5904 printf (_("\nUnwind section "));
5905 printf (_("'%s'"), SECTION_NAME (sec));
5906
5907 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5908 (unsigned long) sec->sh_offset,
5909 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
5910
5911 slurp_hppa_unwind_table (file, &aux, sec);
5912 if (aux.table_len > 0)
5913 dump_hppa_unwind (&aux);
5914
5915 if (aux.table)
5916 free ((char *) aux.table);
5917 aux.table = NULL;
5918 }
5919 }
5920
5921 if (aux.symtab)
5922 free (aux.symtab);
5923 if (aux.strtab)
5924 free ((char *) aux.strtab);
5925
5926 return 1;
5927 }
5928
5929 struct arm_section
5930 {
5931 unsigned char *data;
5932
5933 Elf_Internal_Shdr *sec;
5934 Elf_Internal_Rela *rela;
5935 unsigned long nrelas;
5936 unsigned int rel_type;
5937
5938 Elf_Internal_Rela *next_rela;
5939 };
5940
5941 struct arm_unw_aux_info
5942 {
5943 FILE *file;
5944
5945 Elf_Internal_Sym *symtab; /* The symbol table. */
5946 unsigned long nsyms; /* Number of symbols. */
5947 char *strtab; /* The string table. */
5948 unsigned long strtab_size; /* Size of string table. */
5949 };
5950
5951 static const char *
5952 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
5953 bfd_vma fn, struct absaddr addr)
5954 {
5955 const char *procname;
5956 bfd_vma sym_offset;
5957
5958 if (addr.section == SHN_UNDEF)
5959 addr.offset = fn;
5960
5961 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5962 aux->strtab_size, addr, &procname,
5963 &sym_offset);
5964
5965 print_vma (fn, PREFIX_HEX);
5966
5967 if (procname)
5968 {
5969 fputs (" <", stdout);
5970 fputs (procname, stdout);
5971
5972 if (sym_offset)
5973 printf ("+0x%lx", (unsigned long) sym_offset);
5974 fputc ('>', stdout);
5975 }
5976
5977 return procname;
5978 }
5979
5980 static void
5981 arm_free_section (struct arm_section *arm_sec)
5982 {
5983 if (arm_sec->data != NULL)
5984 free (arm_sec->data);
5985
5986 if (arm_sec->rela != NULL)
5987 free (arm_sec->rela);
5988 }
5989
5990 static int
5991 arm_section_get_word (struct arm_unw_aux_info *aux,
5992 struct arm_section *arm_sec,
5993 Elf_Internal_Shdr *sec, bfd_vma word_offset,
5994 unsigned int *wordp, struct absaddr *addr)
5995 {
5996 Elf_Internal_Rela *rp;
5997 Elf_Internal_Sym *sym;
5998 const char * relname;
5999 unsigned int word;
6000 bfd_boolean wrapped;
6001
6002 addr->section = SHN_UNDEF;
6003 addr->offset = 0;
6004
6005 if (sec != arm_sec->sec)
6006 {
6007 Elf_Internal_Shdr *relsec;
6008
6009 arm_free_section (arm_sec);
6010
6011 arm_sec->sec = sec;
6012 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6013 sec->sh_size, _("unwind data"));
6014
6015 arm_sec->rela = NULL;
6016 arm_sec->nrelas = 0;
6017
6018 for (relsec = section_headers;
6019 relsec < section_headers + elf_header.e_shnum;
6020 ++relsec)
6021 {
6022 if (relsec->sh_info >= elf_header.e_shnum
6023 || section_headers + relsec->sh_info != sec)
6024 continue;
6025
6026 if (relsec->sh_type == SHT_REL)
6027 {
6028 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6029 relsec->sh_size,
6030 & arm_sec->rela, & arm_sec->nrelas))
6031 return 0;
6032 break;
6033 }
6034 else if (relsec->sh_type == SHT_RELA)
6035 {
6036 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6037 relsec->sh_size,
6038 & arm_sec->rela, & arm_sec->nrelas))
6039 return 0;
6040 break;
6041 }
6042 }
6043
6044 arm_sec->next_rela = arm_sec->rela;
6045 }
6046
6047 if (arm_sec->data == NULL)
6048 return 0;
6049
6050 word = byte_get (arm_sec->data + word_offset, 4);
6051
6052 wrapped = FALSE;
6053 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6054 {
6055 bfd_vma prelval, offset;
6056
6057 if (rp->r_offset > word_offset && !wrapped)
6058 {
6059 rp = arm_sec->rela;
6060 wrapped = TRUE;
6061 }
6062 if (rp->r_offset > word_offset)
6063 break;
6064
6065 if (rp->r_offset & 3)
6066 {
6067 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6068 (unsigned long) rp->r_offset);
6069 continue;
6070 }
6071
6072 if (rp->r_offset < word_offset)
6073 continue;
6074
6075 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6076
6077 if (streq (relname, "R_ARM_NONE"))
6078 continue;
6079
6080 if (! streq (relname, "R_ARM_PREL31"))
6081 {
6082 warn (_("Skipping unexpected relocation type %s\n"), relname);
6083 continue;
6084 }
6085
6086 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6087
6088 if (arm_sec->rel_type == SHT_REL)
6089 {
6090 offset = word & 0x7fffffff;
6091 if (offset & 0x40000000)
6092 offset |= ~ (bfd_vma) 0x7fffffff;
6093 }
6094 else
6095 offset = rp->r_addend;
6096
6097 offset += sym->st_value;
6098 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6099
6100 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6101 addr->section = sym->st_shndx;
6102 addr->offset = offset;
6103 break;
6104 }
6105
6106 *wordp = word;
6107 arm_sec->next_rela = rp;
6108
6109 return 1;
6110 }
6111
6112 static void
6113 decode_arm_unwind (struct arm_unw_aux_info *aux,
6114 unsigned int word, unsigned int remaining,
6115 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6116 struct arm_section *data_arm_sec)
6117 {
6118 int per_index;
6119 unsigned int more_words;
6120 struct absaddr addr;
6121
6122 #define ADVANCE \
6123 if (remaining == 0 && more_words) \
6124 { \
6125 data_offset += 4; \
6126 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6127 data_offset, &word, &addr)) \
6128 return; \
6129 remaining = 4; \
6130 more_words--; \
6131 } \
6132
6133 #define GET_OP(OP) \
6134 ADVANCE; \
6135 if (remaining) \
6136 { \
6137 remaining--; \
6138 (OP) = word >> 24; \
6139 word <<= 8; \
6140 } \
6141 else \
6142 { \
6143 printf (_("[Truncated opcode]\n")); \
6144 return; \
6145 } \
6146 printf (_("0x%02x "), OP)
6147
6148 if (remaining == 0)
6149 {
6150 /* Fetch the first word. */
6151 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6152 &word, &addr))
6153 return;
6154 remaining = 4;
6155 }
6156
6157 if ((word & 0x80000000) == 0)
6158 {
6159 /* Expand prel31 for personality routine. */
6160 bfd_vma fn;
6161 const char *procname;
6162
6163 fn = word;
6164 if (fn & 0x40000000)
6165 fn |= ~ (bfd_vma) 0x7fffffff;
6166 fn = fn + data_sec->sh_addr + data_offset;
6167
6168 printf (_(" Personality routine: "));
6169 procname = arm_print_vma_and_name (aux, fn, addr);
6170 fputc ('\n', stdout);
6171
6172 /* The GCC personality routines use the standard compact
6173 encoding, starting with one byte giving the number of
6174 words. */
6175 if (procname != NULL
6176 && (const_strneq (procname, "__gcc_personality_v0")
6177 || const_strneq (procname, "__gxx_personality_v0")
6178 || const_strneq (procname, "__gcj_personality_v0")
6179 || const_strneq (procname, "__gnu_objc_personality_v0")))
6180 {
6181 remaining = 0;
6182 more_words = 1;
6183 ADVANCE;
6184 if (!remaining)
6185 {
6186 printf (_(" [Truncated data]\n"));
6187 return;
6188 }
6189 more_words = word >> 24;
6190 word <<= 8;
6191 remaining--;
6192 }
6193 else
6194 return;
6195 }
6196 else
6197 {
6198
6199 per_index = (word >> 24) & 0x7f;
6200 if (per_index != 0 && per_index != 1 && per_index != 2)
6201 {
6202 printf (_(" [reserved compact index %d]\n"), per_index);
6203 return;
6204 }
6205
6206 printf (_(" Compact model %d\n"), per_index);
6207 if (per_index == 0)
6208 {
6209 more_words = 0;
6210 word <<= 8;
6211 remaining--;
6212 }
6213 else
6214 {
6215 more_words = (word >> 16) & 0xff;
6216 word <<= 16;
6217 remaining -= 2;
6218 }
6219 }
6220
6221 /* Decode the unwinding instructions. */
6222 while (1)
6223 {
6224 unsigned int op, op2;
6225
6226 ADVANCE;
6227 if (remaining == 0)
6228 break;
6229 remaining--;
6230 op = word >> 24;
6231 word <<= 8;
6232
6233 printf (_(" 0x%02x "), op);
6234
6235 if ((op & 0xc0) == 0x00)
6236 {
6237 int offset = ((op & 0x3f) << 2) + 4;
6238 printf (_(" vsp = vsp + %d"), offset);
6239 }
6240 else if ((op & 0xc0) == 0x40)
6241 {
6242 int offset = ((op & 0x3f) << 2) + 4;
6243 printf (_(" vsp = vsp - %d"), offset);
6244 }
6245 else if ((op & 0xf0) == 0x80)
6246 {
6247 GET_OP (op2);
6248 if (op == 0x80 && op2 == 0)
6249 printf (_("Refuse to unwind"));
6250 else
6251 {
6252 unsigned int mask = ((op & 0x0f) << 8) | op2;
6253 int first = 1;
6254 int i;
6255
6256 printf ("pop {");
6257 for (i = 0; i < 12; i++)
6258 if (mask & (1 << i))
6259 {
6260 if (first)
6261 first = 0;
6262 else
6263 printf (", ");
6264 printf ("r%d", 4 + i);
6265 }
6266 printf ("}");
6267 }
6268 }
6269 else if ((op & 0xf0) == 0x90)
6270 {
6271 if (op == 0x9d || op == 0x9f)
6272 printf (_(" [Reserved]"));
6273 else
6274 printf (_(" vsp = r%d"), op & 0x0f);
6275 }
6276 else if ((op & 0xf0) == 0xa0)
6277 {
6278 int end = 4 + (op & 0x07);
6279 int first = 1;
6280 int i;
6281 printf (" pop {");
6282 for (i = 4; i <= end; i++)
6283 {
6284 if (first)
6285 first = 0;
6286 else
6287 printf (", ");
6288 printf ("r%d", i);
6289 }
6290 if (op & 0x08)
6291 {
6292 if (first)
6293 printf (", ");
6294 printf ("r14");
6295 }
6296 printf ("}");
6297 }
6298 else if (op == 0xb0)
6299 printf (_(" finish"));
6300 else if (op == 0xb1)
6301 {
6302 GET_OP (op2);
6303 if (op2 == 0 || (op2 & 0xf0) != 0)
6304 printf (_("[Spare]"));
6305 else
6306 {
6307 unsigned int mask = op2 & 0x0f;
6308 int first = 1;
6309 int i;
6310 printf ("pop {");
6311 for (i = 0; i < 12; i++)
6312 if (mask & (1 << i))
6313 {
6314 if (first)
6315 first = 0;
6316 else
6317 printf (", ");
6318 printf ("r%d", i);
6319 }
6320 printf ("}");
6321 }
6322 }
6323 else if (op == 0xb2)
6324 {
6325 unsigned char buf[9];
6326 unsigned int i, len;
6327 unsigned long offset;
6328 for (i = 0; i < sizeof (buf); i++)
6329 {
6330 GET_OP (buf[i]);
6331 if ((buf[i] & 0x80) == 0)
6332 break;
6333 }
6334 assert (i < sizeof (buf));
6335 offset = read_uleb128 (buf, &len);
6336 assert (len == i + 1);
6337 offset = offset * 4 + 0x204;
6338 printf (_("vsp = vsp + %ld"), offset);
6339 }
6340 else
6341 {
6342 if (op == 0xb3 || op == 0xc6 || op == 0xc7 || op == 0xc8 || op == 0xc9)
6343 {
6344 GET_OP (op2);
6345 printf (_("[unsupported two-byte opcode]"));
6346 }
6347 else
6348 {
6349 printf (_(" [unsupported opcode]"));
6350 }
6351 }
6352 printf ("\n");
6353 }
6354
6355 /* Decode the descriptors. Not implemented. */
6356 }
6357
6358 static void
6359 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6360 {
6361 struct arm_section exidx_arm_sec, extab_arm_sec;
6362 unsigned int i, exidx_len;
6363
6364 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6365 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6366 exidx_len = exidx_sec->sh_size / 8;
6367
6368 for (i = 0; i < exidx_len; i++)
6369 {
6370 unsigned int exidx_fn, exidx_entry;
6371 struct absaddr fn_addr, entry_addr;
6372 bfd_vma fn;
6373
6374 fputc ('\n', stdout);
6375
6376 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6377 8 * i, &exidx_fn, &fn_addr)
6378 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6379 8 * i + 4, &exidx_entry, &entry_addr))
6380 {
6381 arm_free_section (&exidx_arm_sec);
6382 arm_free_section (&extab_arm_sec);
6383 return;
6384 }
6385
6386 fn = exidx_fn & 0x7fffffff;
6387 if (fn & 0x40000000)
6388 fn |= ~ (bfd_vma) 0x7fffffff;
6389 fn = fn + exidx_sec->sh_addr + 8 * i;
6390
6391 arm_print_vma_and_name (aux, fn, entry_addr);
6392 fputs (": ", stdout);
6393
6394 if (exidx_entry == 1)
6395 {
6396 print_vma (exidx_entry, PREFIX_HEX);
6397 fputs (" [cantunwind]\n", stdout);
6398 }
6399 else if (exidx_entry & 0x80000000)
6400 {
6401 print_vma (exidx_entry, PREFIX_HEX);
6402 fputc ('\n', stdout);
6403 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6404 }
6405 else
6406 {
6407 bfd_vma table, table_offset = 0;
6408 Elf_Internal_Shdr *table_sec;
6409
6410 fputs ("@", stdout);
6411 table = exidx_entry;
6412 if (table & 0x40000000)
6413 table |= ~ (bfd_vma) 0x7fffffff;
6414 table = table + exidx_sec->sh_addr + 8 * i + 4;
6415 print_vma (table, PREFIX_HEX);
6416 printf ("\n");
6417
6418 /* Locate the matching .ARM.extab. */
6419 if (entry_addr.section != SHN_UNDEF
6420 && entry_addr.section < elf_header.e_shnum)
6421 {
6422 table_sec = section_headers + entry_addr.section;
6423 table_offset = entry_addr.offset;
6424 }
6425 else
6426 {
6427 table_sec = find_section_by_address (table);
6428 if (table_sec != NULL)
6429 table_offset = table - table_sec->sh_addr;
6430 }
6431 if (table_sec == NULL)
6432 {
6433 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6434 (unsigned long) table);
6435 continue;
6436 }
6437 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
6438 &extab_arm_sec);
6439 }
6440 }
6441
6442 printf ("\n");
6443
6444 arm_free_section (&exidx_arm_sec);
6445 arm_free_section (&extab_arm_sec);
6446 }
6447
6448 static int
6449 arm_process_unwind (FILE *file)
6450 {
6451 struct arm_unw_aux_info aux;
6452 Elf_Internal_Shdr *unwsec = NULL;
6453 Elf_Internal_Shdr *strsec;
6454 Elf_Internal_Shdr *sec;
6455 unsigned long i;
6456
6457 memset (& aux, 0, sizeof (aux));
6458 aux.file = file;
6459
6460 if (string_table == NULL)
6461 return 1;
6462
6463 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6464 {
6465 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
6466 {
6467 aux.nsyms = sec->sh_size / sec->sh_entsize;
6468 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6469
6470 strsec = section_headers + sec->sh_link;
6471 aux.strtab = get_data (NULL, file, strsec->sh_offset,
6472 1, strsec->sh_size, _("string table"));
6473 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6474 }
6475 else if (sec->sh_type == SHT_ARM_EXIDX)
6476 unwsec = sec;
6477 }
6478
6479 if (!unwsec)
6480 printf (_("\nThere are no unwind sections in this file.\n"));
6481
6482 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6483 {
6484 if (sec->sh_type == SHT_ARM_EXIDX)
6485 {
6486 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6487 SECTION_NAME (sec),
6488 (unsigned long) sec->sh_offset,
6489 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
6490
6491 dump_arm_unwind (&aux, sec);
6492 }
6493 }
6494
6495 if (aux.symtab)
6496 free (aux.symtab);
6497 if (aux.strtab)
6498 free ((char *) aux.strtab);
6499
6500 return 1;
6501 }
6502
6503 static int
6504 process_unwind (FILE * file)
6505 {
6506 struct unwind_handler
6507 {
6508 int machtype;
6509 int (* handler)(FILE *);
6510 } handlers[] =
6511 {
6512 { EM_ARM, arm_process_unwind },
6513 { EM_IA_64, ia64_process_unwind },
6514 { EM_PARISC, hppa_process_unwind },
6515 { 0, 0 }
6516 };
6517 int i;
6518
6519 if (!do_unwind)
6520 return 1;
6521
6522 for (i = 0; handlers[i].handler != NULL; i++)
6523 if (elf_header.e_machine == handlers[i].machtype)
6524 return handlers[i].handler (file);
6525
6526 printf (_("\nThere are no unwind sections in this file.\n"));
6527 return 1;
6528 }
6529
6530 static void
6531 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
6532 {
6533 switch (entry->d_tag)
6534 {
6535 case DT_MIPS_FLAGS:
6536 if (entry->d_un.d_val == 0)
6537 printf (_("NONE\n"));
6538 else
6539 {
6540 static const char * opts[] =
6541 {
6542 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6543 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6544 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6545 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6546 "RLD_ORDER_SAFE"
6547 };
6548 unsigned int cnt;
6549 int first = 1;
6550
6551 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
6552 if (entry->d_un.d_val & (1 << cnt))
6553 {
6554 printf ("%s%s", first ? "" : " ", opts[cnt]);
6555 first = 0;
6556 }
6557 puts ("");
6558 }
6559 break;
6560
6561 case DT_MIPS_IVERSION:
6562 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6563 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
6564 else
6565 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
6566 break;
6567
6568 case DT_MIPS_TIME_STAMP:
6569 {
6570 char timebuf[20];
6571 struct tm * tmp;
6572
6573 time_t atime = entry->d_un.d_val;
6574 tmp = gmtime (&atime);
6575 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
6576 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6577 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6578 printf (_("Time Stamp: %s\n"), timebuf);
6579 }
6580 break;
6581
6582 case DT_MIPS_RLD_VERSION:
6583 case DT_MIPS_LOCAL_GOTNO:
6584 case DT_MIPS_CONFLICTNO:
6585 case DT_MIPS_LIBLISTNO:
6586 case DT_MIPS_SYMTABNO:
6587 case DT_MIPS_UNREFEXTNO:
6588 case DT_MIPS_HIPAGENO:
6589 case DT_MIPS_DELTA_CLASS_NO:
6590 case DT_MIPS_DELTA_INSTANCE_NO:
6591 case DT_MIPS_DELTA_RELOC_NO:
6592 case DT_MIPS_DELTA_SYM_NO:
6593 case DT_MIPS_DELTA_CLASSSYM_NO:
6594 case DT_MIPS_COMPACT_SIZE:
6595 printf ("%ld\n", (long) entry->d_un.d_ptr);
6596 break;
6597
6598 default:
6599 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
6600 }
6601 }
6602
6603 static void
6604 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
6605 {
6606 switch (entry->d_tag)
6607 {
6608 case DT_HP_DLD_FLAGS:
6609 {
6610 static struct
6611 {
6612 long int bit;
6613 const char * str;
6614 }
6615 flags[] =
6616 {
6617 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
6618 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
6619 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
6620 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
6621 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
6622 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
6623 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
6624 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
6625 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
6626 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
6627 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
6628 { DT_HP_GST, "HP_GST" },
6629 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
6630 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
6631 { DT_HP_NODELETE, "HP_NODELETE" },
6632 { DT_HP_GROUP, "HP_GROUP" },
6633 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
6634 };
6635 int first = 1;
6636 size_t cnt;
6637 bfd_vma val = entry->d_un.d_val;
6638
6639 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
6640 if (val & flags[cnt].bit)
6641 {
6642 if (! first)
6643 putchar (' ');
6644 fputs (flags[cnt].str, stdout);
6645 first = 0;
6646 val ^= flags[cnt].bit;
6647 }
6648
6649 if (val != 0 || first)
6650 {
6651 if (! first)
6652 putchar (' ');
6653 print_vma (val, HEX);
6654 }
6655 }
6656 break;
6657
6658 default:
6659 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6660 break;
6661 }
6662 putchar ('\n');
6663 }
6664
6665 static void
6666 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
6667 {
6668 switch (entry->d_tag)
6669 {
6670 case DT_IA_64_PLT_RESERVE:
6671 /* First 3 slots reserved. */
6672 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6673 printf (" -- ");
6674 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
6675 break;
6676
6677 default:
6678 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6679 break;
6680 }
6681 putchar ('\n');
6682 }
6683
6684 static int
6685 get_32bit_dynamic_section (FILE * file)
6686 {
6687 Elf32_External_Dyn * edyn;
6688 Elf32_External_Dyn * ext;
6689 Elf_Internal_Dyn * entry;
6690
6691 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
6692 dynamic_size, _("dynamic section"));
6693 if (!edyn)
6694 return 0;
6695
6696 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6697 might not have the luxury of section headers. Look for the DT_NULL
6698 terminator to determine the number of entries. */
6699 for (ext = edyn, dynamic_nent = 0;
6700 (char *) ext < (char *) edyn + dynamic_size;
6701 ext++)
6702 {
6703 dynamic_nent++;
6704 if (BYTE_GET (ext->d_tag) == DT_NULL)
6705 break;
6706 }
6707
6708 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
6709 sizeof (* entry));
6710 if (dynamic_section == NULL)
6711 {
6712 error (_("Out of memory\n"));
6713 free (edyn);
6714 return 0;
6715 }
6716
6717 for (ext = edyn, entry = dynamic_section;
6718 entry < dynamic_section + dynamic_nent;
6719 ext++, entry++)
6720 {
6721 entry->d_tag = BYTE_GET (ext->d_tag);
6722 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
6723 }
6724
6725 free (edyn);
6726
6727 return 1;
6728 }
6729
6730 static int
6731 get_64bit_dynamic_section (FILE * file)
6732 {
6733 Elf64_External_Dyn * edyn;
6734 Elf64_External_Dyn * ext;
6735 Elf_Internal_Dyn * entry;
6736
6737 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
6738 dynamic_size, _("dynamic section"));
6739 if (!edyn)
6740 return 0;
6741
6742 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6743 might not have the luxury of section headers. Look for the DT_NULL
6744 terminator to determine the number of entries. */
6745 for (ext = edyn, dynamic_nent = 0;
6746 (char *) ext < (char *) edyn + dynamic_size;
6747 ext++)
6748 {
6749 dynamic_nent++;
6750 if (BYTE_GET (ext->d_tag) == DT_NULL)
6751 break;
6752 }
6753
6754 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
6755 sizeof (* entry));
6756 if (dynamic_section == NULL)
6757 {
6758 error (_("Out of memory\n"));
6759 free (edyn);
6760 return 0;
6761 }
6762
6763 for (ext = edyn, entry = dynamic_section;
6764 entry < dynamic_section + dynamic_nent;
6765 ext++, entry++)
6766 {
6767 entry->d_tag = BYTE_GET (ext->d_tag);
6768 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
6769 }
6770
6771 free (edyn);
6772
6773 return 1;
6774 }
6775
6776 static void
6777 print_dynamic_flags (bfd_vma flags)
6778 {
6779 int first = 1;
6780
6781 while (flags)
6782 {
6783 bfd_vma flag;
6784
6785 flag = flags & - flags;
6786 flags &= ~ flag;
6787
6788 if (first)
6789 first = 0;
6790 else
6791 putc (' ', stdout);
6792
6793 switch (flag)
6794 {
6795 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
6796 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
6797 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
6798 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
6799 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
6800 default: fputs (_("unknown"), stdout); break;
6801 }
6802 }
6803 puts ("");
6804 }
6805
6806 /* Parse and display the contents of the dynamic section. */
6807
6808 static int
6809 process_dynamic_section (FILE * file)
6810 {
6811 Elf_Internal_Dyn * entry;
6812
6813 if (dynamic_size == 0)
6814 {
6815 if (do_dynamic)
6816 printf (_("\nThere is no dynamic section in this file.\n"));
6817
6818 return 1;
6819 }
6820
6821 if (is_32bit_elf)
6822 {
6823 if (! get_32bit_dynamic_section (file))
6824 return 0;
6825 }
6826 else if (! get_64bit_dynamic_section (file))
6827 return 0;
6828
6829 /* Find the appropriate symbol table. */
6830 if (dynamic_symbols == NULL)
6831 {
6832 for (entry = dynamic_section;
6833 entry < dynamic_section + dynamic_nent;
6834 ++entry)
6835 {
6836 Elf_Internal_Shdr section;
6837
6838 if (entry->d_tag != DT_SYMTAB)
6839 continue;
6840
6841 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
6842
6843 /* Since we do not know how big the symbol table is,
6844 we default to reading in the entire file (!) and
6845 processing that. This is overkill, I know, but it
6846 should work. */
6847 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
6848
6849 if (archive_file_offset != 0)
6850 section.sh_size = archive_file_size - section.sh_offset;
6851 else
6852 {
6853 if (fseek (file, 0, SEEK_END))
6854 error (_("Unable to seek to end of file!\n"));
6855
6856 section.sh_size = ftell (file) - section.sh_offset;
6857 }
6858
6859 if (is_32bit_elf)
6860 section.sh_entsize = sizeof (Elf32_External_Sym);
6861 else
6862 section.sh_entsize = sizeof (Elf64_External_Sym);
6863
6864 num_dynamic_syms = section.sh_size / section.sh_entsize;
6865 if (num_dynamic_syms < 1)
6866 {
6867 error (_("Unable to determine the number of symbols to load\n"));
6868 continue;
6869 }
6870
6871 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
6872 }
6873 }
6874
6875 /* Similarly find a string table. */
6876 if (dynamic_strings == NULL)
6877 {
6878 for (entry = dynamic_section;
6879 entry < dynamic_section + dynamic_nent;
6880 ++entry)
6881 {
6882 unsigned long offset;
6883 long str_tab_len;
6884
6885 if (entry->d_tag != DT_STRTAB)
6886 continue;
6887
6888 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
6889
6890 /* Since we do not know how big the string table is,
6891 we default to reading in the entire file (!) and
6892 processing that. This is overkill, I know, but it
6893 should work. */
6894
6895 offset = offset_from_vma (file, entry->d_un.d_val, 0);
6896
6897 if (archive_file_offset != 0)
6898 str_tab_len = archive_file_size - offset;
6899 else
6900 {
6901 if (fseek (file, 0, SEEK_END))
6902 error (_("Unable to seek to end of file\n"));
6903 str_tab_len = ftell (file) - offset;
6904 }
6905
6906 if (str_tab_len < 1)
6907 {
6908 error
6909 (_("Unable to determine the length of the dynamic string table\n"));
6910 continue;
6911 }
6912
6913 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
6914 str_tab_len,
6915 _("dynamic string table"));
6916 dynamic_strings_length = str_tab_len;
6917 break;
6918 }
6919 }
6920
6921 /* And find the syminfo section if available. */
6922 if (dynamic_syminfo == NULL)
6923 {
6924 unsigned long syminsz = 0;
6925
6926 for (entry = dynamic_section;
6927 entry < dynamic_section + dynamic_nent;
6928 ++entry)
6929 {
6930 if (entry->d_tag == DT_SYMINENT)
6931 {
6932 /* Note: these braces are necessary to avoid a syntax
6933 error from the SunOS4 C compiler. */
6934 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
6935 }
6936 else if (entry->d_tag == DT_SYMINSZ)
6937 syminsz = entry->d_un.d_val;
6938 else if (entry->d_tag == DT_SYMINFO)
6939 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
6940 syminsz);
6941 }
6942
6943 if (dynamic_syminfo_offset != 0 && syminsz != 0)
6944 {
6945 Elf_External_Syminfo * extsyminfo;
6946 Elf_External_Syminfo * extsym;
6947 Elf_Internal_Syminfo * syminfo;
6948
6949 /* There is a syminfo section. Read the data. */
6950 extsyminfo = (Elf_External_Syminfo *)
6951 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
6952 _("symbol information"));
6953 if (!extsyminfo)
6954 return 0;
6955
6956 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
6957 if (dynamic_syminfo == NULL)
6958 {
6959 error (_("Out of memory\n"));
6960 return 0;
6961 }
6962
6963 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
6964 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
6965 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
6966 ++syminfo, ++extsym)
6967 {
6968 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
6969 syminfo->si_flags = BYTE_GET (extsym->si_flags);
6970 }
6971
6972 free (extsyminfo);
6973 }
6974 }
6975
6976 if (do_dynamic && dynamic_addr)
6977 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6978 dynamic_addr, dynamic_nent);
6979 if (do_dynamic)
6980 printf (_(" Tag Type Name/Value\n"));
6981
6982 for (entry = dynamic_section;
6983 entry < dynamic_section + dynamic_nent;
6984 entry++)
6985 {
6986 if (do_dynamic)
6987 {
6988 const char * dtype;
6989
6990 putchar (' ');
6991 print_vma (entry->d_tag, FULL_HEX);
6992 dtype = get_dynamic_type (entry->d_tag);
6993 printf (" (%s)%*s", dtype,
6994 ((is_32bit_elf ? 27 : 19)
6995 - (int) strlen (dtype)),
6996 " ");
6997 }
6998
6999 switch (entry->d_tag)
7000 {
7001 case DT_FLAGS:
7002 if (do_dynamic)
7003 print_dynamic_flags (entry->d_un.d_val);
7004 break;
7005
7006 case DT_AUXILIARY:
7007 case DT_FILTER:
7008 case DT_CONFIG:
7009 case DT_DEPAUDIT:
7010 case DT_AUDIT:
7011 if (do_dynamic)
7012 {
7013 switch (entry->d_tag)
7014 {
7015 case DT_AUXILIARY:
7016 printf (_("Auxiliary library"));
7017 break;
7018
7019 case DT_FILTER:
7020 printf (_("Filter library"));
7021 break;
7022
7023 case DT_CONFIG:
7024 printf (_("Configuration file"));
7025 break;
7026
7027 case DT_DEPAUDIT:
7028 printf (_("Dependency audit library"));
7029 break;
7030
7031 case DT_AUDIT:
7032 printf (_("Audit library"));
7033 break;
7034 }
7035
7036 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7037 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7038 else
7039 {
7040 printf (": ");
7041 print_vma (entry->d_un.d_val, PREFIX_HEX);
7042 putchar ('\n');
7043 }
7044 }
7045 break;
7046
7047 case DT_FEATURE:
7048 if (do_dynamic)
7049 {
7050 printf (_("Flags:"));
7051
7052 if (entry->d_un.d_val == 0)
7053 printf (_(" None\n"));
7054 else
7055 {
7056 unsigned long int val = entry->d_un.d_val;
7057
7058 if (val & DTF_1_PARINIT)
7059 {
7060 printf (" PARINIT");
7061 val ^= DTF_1_PARINIT;
7062 }
7063 if (val & DTF_1_CONFEXP)
7064 {
7065 printf (" CONFEXP");
7066 val ^= DTF_1_CONFEXP;
7067 }
7068 if (val != 0)
7069 printf (" %lx", val);
7070 puts ("");
7071 }
7072 }
7073 break;
7074
7075 case DT_POSFLAG_1:
7076 if (do_dynamic)
7077 {
7078 printf (_("Flags:"));
7079
7080 if (entry->d_un.d_val == 0)
7081 printf (_(" None\n"));
7082 else
7083 {
7084 unsigned long int val = entry->d_un.d_val;
7085
7086 if (val & DF_P1_LAZYLOAD)
7087 {
7088 printf (" LAZYLOAD");
7089 val ^= DF_P1_LAZYLOAD;
7090 }
7091 if (val & DF_P1_GROUPPERM)
7092 {
7093 printf (" GROUPPERM");
7094 val ^= DF_P1_GROUPPERM;
7095 }
7096 if (val != 0)
7097 printf (" %lx", val);
7098 puts ("");
7099 }
7100 }
7101 break;
7102
7103 case DT_FLAGS_1:
7104 if (do_dynamic)
7105 {
7106 printf (_("Flags:"));
7107 if (entry->d_un.d_val == 0)
7108 printf (_(" None\n"));
7109 else
7110 {
7111 unsigned long int val = entry->d_un.d_val;
7112
7113 if (val & DF_1_NOW)
7114 {
7115 printf (" NOW");
7116 val ^= DF_1_NOW;
7117 }
7118 if (val & DF_1_GLOBAL)
7119 {
7120 printf (" GLOBAL");
7121 val ^= DF_1_GLOBAL;
7122 }
7123 if (val & DF_1_GROUP)
7124 {
7125 printf (" GROUP");
7126 val ^= DF_1_GROUP;
7127 }
7128 if (val & DF_1_NODELETE)
7129 {
7130 printf (" NODELETE");
7131 val ^= DF_1_NODELETE;
7132 }
7133 if (val & DF_1_LOADFLTR)
7134 {
7135 printf (" LOADFLTR");
7136 val ^= DF_1_LOADFLTR;
7137 }
7138 if (val & DF_1_INITFIRST)
7139 {
7140 printf (" INITFIRST");
7141 val ^= DF_1_INITFIRST;
7142 }
7143 if (val & DF_1_NOOPEN)
7144 {
7145 printf (" NOOPEN");
7146 val ^= DF_1_NOOPEN;
7147 }
7148 if (val & DF_1_ORIGIN)
7149 {
7150 printf (" ORIGIN");
7151 val ^= DF_1_ORIGIN;
7152 }
7153 if (val & DF_1_DIRECT)
7154 {
7155 printf (" DIRECT");
7156 val ^= DF_1_DIRECT;
7157 }
7158 if (val & DF_1_TRANS)
7159 {
7160 printf (" TRANS");
7161 val ^= DF_1_TRANS;
7162 }
7163 if (val & DF_1_INTERPOSE)
7164 {
7165 printf (" INTERPOSE");
7166 val ^= DF_1_INTERPOSE;
7167 }
7168 if (val & DF_1_NODEFLIB)
7169 {
7170 printf (" NODEFLIB");
7171 val ^= DF_1_NODEFLIB;
7172 }
7173 if (val & DF_1_NODUMP)
7174 {
7175 printf (" NODUMP");
7176 val ^= DF_1_NODUMP;
7177 }
7178 if (val & DF_1_CONLFAT)
7179 {
7180 printf (" CONLFAT");
7181 val ^= DF_1_CONLFAT;
7182 }
7183 if (val != 0)
7184 printf (" %lx", val);
7185 puts ("");
7186 }
7187 }
7188 break;
7189
7190 case DT_PLTREL:
7191 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7192 if (do_dynamic)
7193 puts (get_dynamic_type (entry->d_un.d_val));
7194 break;
7195
7196 case DT_NULL :
7197 case DT_NEEDED :
7198 case DT_PLTGOT :
7199 case DT_HASH :
7200 case DT_STRTAB :
7201 case DT_SYMTAB :
7202 case DT_RELA :
7203 case DT_INIT :
7204 case DT_FINI :
7205 case DT_SONAME :
7206 case DT_RPATH :
7207 case DT_SYMBOLIC:
7208 case DT_REL :
7209 case DT_DEBUG :
7210 case DT_TEXTREL :
7211 case DT_JMPREL :
7212 case DT_RUNPATH :
7213 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7214
7215 if (do_dynamic)
7216 {
7217 char * name;
7218
7219 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7220 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7221 else
7222 name = NULL;
7223
7224 if (name)
7225 {
7226 switch (entry->d_tag)
7227 {
7228 case DT_NEEDED:
7229 printf (_("Shared library: [%s]"), name);
7230
7231 if (streq (name, program_interpreter))
7232 printf (_(" program interpreter"));
7233 break;
7234
7235 case DT_SONAME:
7236 printf (_("Library soname: [%s]"), name);
7237 break;
7238
7239 case DT_RPATH:
7240 printf (_("Library rpath: [%s]"), name);
7241 break;
7242
7243 case DT_RUNPATH:
7244 printf (_("Library runpath: [%s]"), name);
7245 break;
7246
7247 default:
7248 print_vma (entry->d_un.d_val, PREFIX_HEX);
7249 break;
7250 }
7251 }
7252 else
7253 print_vma (entry->d_un.d_val, PREFIX_HEX);
7254
7255 putchar ('\n');
7256 }
7257 break;
7258
7259 case DT_PLTRELSZ:
7260 case DT_RELASZ :
7261 case DT_STRSZ :
7262 case DT_RELSZ :
7263 case DT_RELAENT :
7264 case DT_SYMENT :
7265 case DT_RELENT :
7266 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7267 case DT_PLTPADSZ:
7268 case DT_MOVEENT :
7269 case DT_MOVESZ :
7270 case DT_INIT_ARRAYSZ:
7271 case DT_FINI_ARRAYSZ:
7272 case DT_GNU_CONFLICTSZ:
7273 case DT_GNU_LIBLISTSZ:
7274 if (do_dynamic)
7275 {
7276 print_vma (entry->d_un.d_val, UNSIGNED);
7277 printf (_(" (bytes)\n"));
7278 }
7279 break;
7280
7281 case DT_VERDEFNUM:
7282 case DT_VERNEEDNUM:
7283 case DT_RELACOUNT:
7284 case DT_RELCOUNT:
7285 if (do_dynamic)
7286 {
7287 print_vma (entry->d_un.d_val, UNSIGNED);
7288 putchar ('\n');
7289 }
7290 break;
7291
7292 case DT_SYMINSZ:
7293 case DT_SYMINENT:
7294 case DT_SYMINFO:
7295 case DT_USED:
7296 case DT_INIT_ARRAY:
7297 case DT_FINI_ARRAY:
7298 if (do_dynamic)
7299 {
7300 if (entry->d_tag == DT_USED
7301 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
7302 {
7303 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7304
7305 if (*name)
7306 {
7307 printf (_("Not needed object: [%s]\n"), name);
7308 break;
7309 }
7310 }
7311
7312 print_vma (entry->d_un.d_val, PREFIX_HEX);
7313 putchar ('\n');
7314 }
7315 break;
7316
7317 case DT_BIND_NOW:
7318 /* The value of this entry is ignored. */
7319 if (do_dynamic)
7320 putchar ('\n');
7321 break;
7322
7323 case DT_GNU_PRELINKED:
7324 if (do_dynamic)
7325 {
7326 struct tm * tmp;
7327 time_t atime = entry->d_un.d_val;
7328
7329 tmp = gmtime (&atime);
7330 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7331 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7332 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7333
7334 }
7335 break;
7336
7337 case DT_GNU_HASH:
7338 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7339 if (do_dynamic)
7340 {
7341 print_vma (entry->d_un.d_val, PREFIX_HEX);
7342 putchar ('\n');
7343 }
7344 break;
7345
7346 default:
7347 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
7348 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
7349 entry->d_un.d_val;
7350
7351 if (do_dynamic)
7352 {
7353 switch (elf_header.e_machine)
7354 {
7355 case EM_MIPS:
7356 case EM_MIPS_RS3_LE:
7357 dynamic_section_mips_val (entry);
7358 break;
7359 case EM_PARISC:
7360 dynamic_section_parisc_val (entry);
7361 break;
7362 case EM_IA_64:
7363 dynamic_section_ia64_val (entry);
7364 break;
7365 default:
7366 print_vma (entry->d_un.d_val, PREFIX_HEX);
7367 putchar ('\n');
7368 }
7369 }
7370 break;
7371 }
7372 }
7373
7374 return 1;
7375 }
7376
7377 static char *
7378 get_ver_flags (unsigned int flags)
7379 {
7380 static char buff[32];
7381
7382 buff[0] = 0;
7383
7384 if (flags == 0)
7385 return _("none");
7386
7387 if (flags & VER_FLG_BASE)
7388 strcat (buff, "BASE ");
7389
7390 if (flags & VER_FLG_WEAK)
7391 {
7392 if (flags & VER_FLG_BASE)
7393 strcat (buff, "| ");
7394
7395 strcat (buff, "WEAK ");
7396 }
7397
7398 if (flags & VER_FLG_INFO)
7399 {
7400 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
7401 strcat (buff, "| ");
7402
7403 strcat (buff, "INFO ");
7404 }
7405
7406 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
7407 strcat (buff, _("| <unknown>"));
7408
7409 return buff;
7410 }
7411
7412 /* Display the contents of the version sections. */
7413
7414 static int
7415 process_version_sections (FILE * file)
7416 {
7417 Elf_Internal_Shdr * section;
7418 unsigned i;
7419 int found = 0;
7420
7421 if (! do_version)
7422 return 1;
7423
7424 for (i = 0, section = section_headers;
7425 i < elf_header.e_shnum;
7426 i++, section++)
7427 {
7428 switch (section->sh_type)
7429 {
7430 case SHT_GNU_verdef:
7431 {
7432 Elf_External_Verdef * edefs;
7433 unsigned int idx;
7434 unsigned int cnt;
7435 char * endbuf;
7436
7437 found = 1;
7438
7439 printf
7440 (_("\nVersion definition section '%s' contains %u entries:\n"),
7441 SECTION_NAME (section), section->sh_info);
7442
7443 printf (_(" Addr: 0x"));
7444 printf_vma (section->sh_addr);
7445 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7446 (unsigned long) section->sh_offset, section->sh_link,
7447 section->sh_link < elf_header.e_shnum
7448 ? SECTION_NAME (section_headers + section->sh_link)
7449 : _("<corrupt>"));
7450
7451 edefs = (Elf_External_Verdef *)
7452 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
7453 _("version definition section"));
7454 endbuf = (char *) edefs + section->sh_size;
7455 if (!edefs)
7456 break;
7457
7458 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
7459 {
7460 char * vstart;
7461 Elf_External_Verdef * edef;
7462 Elf_Internal_Verdef ent;
7463 Elf_External_Verdaux * eaux;
7464 Elf_Internal_Verdaux aux;
7465 int j;
7466 int isum;
7467
7468 vstart = ((char *) edefs) + idx;
7469 if (vstart + sizeof (*edef) > endbuf)
7470 break;
7471
7472 edef = (Elf_External_Verdef *) vstart;
7473
7474 ent.vd_version = BYTE_GET (edef->vd_version);
7475 ent.vd_flags = BYTE_GET (edef->vd_flags);
7476 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
7477 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
7478 ent.vd_hash = BYTE_GET (edef->vd_hash);
7479 ent.vd_aux = BYTE_GET (edef->vd_aux);
7480 ent.vd_next = BYTE_GET (edef->vd_next);
7481
7482 printf (_(" %#06x: Rev: %d Flags: %s"),
7483 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
7484
7485 printf (_(" Index: %d Cnt: %d "),
7486 ent.vd_ndx, ent.vd_cnt);
7487
7488 vstart += ent.vd_aux;
7489
7490 eaux = (Elf_External_Verdaux *) vstart;
7491
7492 aux.vda_name = BYTE_GET (eaux->vda_name);
7493 aux.vda_next = BYTE_GET (eaux->vda_next);
7494
7495 if (VALID_DYNAMIC_NAME (aux.vda_name))
7496 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
7497 else
7498 printf (_("Name index: %ld\n"), aux.vda_name);
7499
7500 isum = idx + ent.vd_aux;
7501
7502 for (j = 1; j < ent.vd_cnt; j++)
7503 {
7504 isum += aux.vda_next;
7505 vstart += aux.vda_next;
7506
7507 eaux = (Elf_External_Verdaux *) vstart;
7508 if (vstart + sizeof (*eaux) > endbuf)
7509 break;
7510
7511 aux.vda_name = BYTE_GET (eaux->vda_name);
7512 aux.vda_next = BYTE_GET (eaux->vda_next);
7513
7514 if (VALID_DYNAMIC_NAME (aux.vda_name))
7515 printf (_(" %#06x: Parent %d: %s\n"),
7516 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
7517 else
7518 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7519 isum, j, aux.vda_name);
7520 }
7521 if (j < ent.vd_cnt)
7522 printf (_(" Version def aux past end of section\n"));
7523
7524 idx += ent.vd_next;
7525 }
7526 if (cnt < section->sh_info)
7527 printf (_(" Version definition past end of section\n"));
7528
7529 free (edefs);
7530 }
7531 break;
7532
7533 case SHT_GNU_verneed:
7534 {
7535 Elf_External_Verneed * eneed;
7536 unsigned int idx;
7537 unsigned int cnt;
7538 char * endbuf;
7539
7540 found = 1;
7541
7542 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
7543 SECTION_NAME (section), section->sh_info);
7544
7545 printf (_(" Addr: 0x"));
7546 printf_vma (section->sh_addr);
7547 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7548 (unsigned long) section->sh_offset, section->sh_link,
7549 section->sh_link < elf_header.e_shnum
7550 ? SECTION_NAME (section_headers + section->sh_link)
7551 : _("<corrupt>"));
7552
7553 eneed = (Elf_External_Verneed *) get_data (NULL, file,
7554 section->sh_offset, 1,
7555 section->sh_size,
7556 _("version need section"));
7557 endbuf = (char *) eneed + section->sh_size;
7558 if (!eneed)
7559 break;
7560
7561 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
7562 {
7563 Elf_External_Verneed * entry;
7564 Elf_Internal_Verneed ent;
7565 int j;
7566 int isum;
7567 char * vstart;
7568
7569 vstart = ((char *) eneed) + idx;
7570 if (vstart + sizeof (*entry) > endbuf)
7571 break;
7572
7573 entry = (Elf_External_Verneed *) vstart;
7574
7575 ent.vn_version = BYTE_GET (entry->vn_version);
7576 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
7577 ent.vn_file = BYTE_GET (entry->vn_file);
7578 ent.vn_aux = BYTE_GET (entry->vn_aux);
7579 ent.vn_next = BYTE_GET (entry->vn_next);
7580
7581 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
7582
7583 if (VALID_DYNAMIC_NAME (ent.vn_file))
7584 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
7585 else
7586 printf (_(" File: %lx"), ent.vn_file);
7587
7588 printf (_(" Cnt: %d\n"), ent.vn_cnt);
7589
7590 vstart += ent.vn_aux;
7591
7592 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
7593 {
7594 Elf_External_Vernaux * eaux;
7595 Elf_Internal_Vernaux aux;
7596
7597 if (vstart + sizeof (*eaux) > endbuf)
7598 break;
7599 eaux = (Elf_External_Vernaux *) vstart;
7600
7601 aux.vna_hash = BYTE_GET (eaux->vna_hash);
7602 aux.vna_flags = BYTE_GET (eaux->vna_flags);
7603 aux.vna_other = BYTE_GET (eaux->vna_other);
7604 aux.vna_name = BYTE_GET (eaux->vna_name);
7605 aux.vna_next = BYTE_GET (eaux->vna_next);
7606
7607 if (VALID_DYNAMIC_NAME (aux.vna_name))
7608 printf (_(" %#06x: Name: %s"),
7609 isum, GET_DYNAMIC_NAME (aux.vna_name));
7610 else
7611 printf (_(" %#06x: Name index: %lx"),
7612 isum, aux.vna_name);
7613
7614 printf (_(" Flags: %s Version: %d\n"),
7615 get_ver_flags (aux.vna_flags), aux.vna_other);
7616
7617 isum += aux.vna_next;
7618 vstart += aux.vna_next;
7619 }
7620 if (j < ent.vn_cnt)
7621 printf (_(" Version need aux past end of section\n"));
7622
7623 idx += ent.vn_next;
7624 }
7625 if (cnt < section->sh_info)
7626 printf (_(" Version need past end of section\n"));
7627
7628 free (eneed);
7629 }
7630 break;
7631
7632 case SHT_GNU_versym:
7633 {
7634 Elf_Internal_Shdr * link_section;
7635 int total;
7636 int cnt;
7637 unsigned char * edata;
7638 unsigned short * data;
7639 char * strtab;
7640 Elf_Internal_Sym * symbols;
7641 Elf_Internal_Shdr * string_sec;
7642 long off;
7643
7644 if (section->sh_link >= elf_header.e_shnum)
7645 break;
7646
7647 link_section = section_headers + section->sh_link;
7648 total = section->sh_size / sizeof (Elf_External_Versym);
7649
7650 if (link_section->sh_link >= elf_header.e_shnum)
7651 break;
7652
7653 found = 1;
7654
7655 symbols = GET_ELF_SYMBOLS (file, link_section);
7656
7657 string_sec = section_headers + link_section->sh_link;
7658
7659 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
7660 string_sec->sh_size,
7661 _("version string table"));
7662 if (!strtab)
7663 break;
7664
7665 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
7666 SECTION_NAME (section), total);
7667
7668 printf (_(" Addr: "));
7669 printf_vma (section->sh_addr);
7670 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7671 (unsigned long) section->sh_offset, section->sh_link,
7672 SECTION_NAME (link_section));
7673
7674 off = offset_from_vma (file,
7675 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7676 total * sizeof (short));
7677 edata = (unsigned char *) get_data (NULL, file, off, total,
7678 sizeof (short),
7679 _("version symbol data"));
7680 if (!edata)
7681 {
7682 free (strtab);
7683 break;
7684 }
7685
7686 data = (short unsigned int *) cmalloc (total, sizeof (short));
7687
7688 for (cnt = total; cnt --;)
7689 data[cnt] = byte_get (edata + cnt * sizeof (short),
7690 sizeof (short));
7691
7692 free (edata);
7693
7694 for (cnt = 0; cnt < total; cnt += 4)
7695 {
7696 int j, nn;
7697 int check_def, check_need;
7698 char * name;
7699
7700 printf (" %03x:", cnt);
7701
7702 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
7703 switch (data[cnt + j])
7704 {
7705 case 0:
7706 fputs (_(" 0 (*local*) "), stdout);
7707 break;
7708
7709 case 1:
7710 fputs (_(" 1 (*global*) "), stdout);
7711 break;
7712
7713 default:
7714 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
7715 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
7716
7717 check_def = 1;
7718 check_need = 1;
7719 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
7720 || section_headers[symbols[cnt + j].st_shndx].sh_type
7721 != SHT_NOBITS)
7722 {
7723 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
7724 check_def = 0;
7725 else
7726 check_need = 0;
7727 }
7728
7729 if (check_need
7730 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
7731 {
7732 Elf_Internal_Verneed ivn;
7733 unsigned long offset;
7734
7735 offset = offset_from_vma
7736 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7737 sizeof (Elf_External_Verneed));
7738
7739 do
7740 {
7741 Elf_Internal_Vernaux ivna;
7742 Elf_External_Verneed evn;
7743 Elf_External_Vernaux evna;
7744 unsigned long a_off;
7745
7746 get_data (&evn, file, offset, sizeof (evn), 1,
7747 _("version need"));
7748
7749 ivn.vn_aux = BYTE_GET (evn.vn_aux);
7750 ivn.vn_next = BYTE_GET (evn.vn_next);
7751
7752 a_off = offset + ivn.vn_aux;
7753
7754 do
7755 {
7756 get_data (&evna, file, a_off, sizeof (evna),
7757 1, _("version need aux (2)"));
7758
7759 ivna.vna_next = BYTE_GET (evna.vna_next);
7760 ivna.vna_other = BYTE_GET (evna.vna_other);
7761
7762 a_off += ivna.vna_next;
7763 }
7764 while (ivna.vna_other != data[cnt + j]
7765 && ivna.vna_next != 0);
7766
7767 if (ivna.vna_other == data[cnt + j])
7768 {
7769 ivna.vna_name = BYTE_GET (evna.vna_name);
7770
7771 if (ivna.vna_name >= string_sec->sh_size)
7772 name = _("*invalid*");
7773 else
7774 name = strtab + ivna.vna_name;
7775 nn += printf ("(%s%-*s",
7776 name,
7777 12 - (int) strlen (name),
7778 ")");
7779 check_def = 0;
7780 break;
7781 }
7782
7783 offset += ivn.vn_next;
7784 }
7785 while (ivn.vn_next);
7786 }
7787
7788 if (check_def && data[cnt + j] != 0x8001
7789 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7790 {
7791 Elf_Internal_Verdef ivd;
7792 Elf_External_Verdef evd;
7793 unsigned long offset;
7794
7795 offset = offset_from_vma
7796 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7797 sizeof evd);
7798
7799 do
7800 {
7801 get_data (&evd, file, offset, sizeof (evd), 1,
7802 _("version def"));
7803
7804 ivd.vd_next = BYTE_GET (evd.vd_next);
7805 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7806
7807 offset += ivd.vd_next;
7808 }
7809 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
7810 && ivd.vd_next != 0);
7811
7812 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
7813 {
7814 Elf_External_Verdaux evda;
7815 Elf_Internal_Verdaux ivda;
7816
7817 ivd.vd_aux = BYTE_GET (evd.vd_aux);
7818
7819 get_data (&evda, file,
7820 offset - ivd.vd_next + ivd.vd_aux,
7821 sizeof (evda), 1,
7822 _("version def aux"));
7823
7824 ivda.vda_name = BYTE_GET (evda.vda_name);
7825
7826 if (ivda.vda_name >= string_sec->sh_size)
7827 name = _("*invalid*");
7828 else
7829 name = strtab + ivda.vda_name;
7830 nn += printf ("(%s%-*s",
7831 name,
7832 12 - (int) strlen (name),
7833 ")");
7834 }
7835 }
7836
7837 if (nn < 18)
7838 printf ("%*c", 18 - nn, ' ');
7839 }
7840
7841 putchar ('\n');
7842 }
7843
7844 free (data);
7845 free (strtab);
7846 free (symbols);
7847 }
7848 break;
7849
7850 default:
7851 break;
7852 }
7853 }
7854
7855 if (! found)
7856 printf (_("\nNo version information found in this file.\n"));
7857
7858 return 1;
7859 }
7860
7861 static const char *
7862 get_symbol_binding (unsigned int binding)
7863 {
7864 static char buff[32];
7865
7866 switch (binding)
7867 {
7868 case STB_LOCAL: return "LOCAL";
7869 case STB_GLOBAL: return "GLOBAL";
7870 case STB_WEAK: return "WEAK";
7871 default:
7872 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
7873 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
7874 binding);
7875 else if (binding >= STB_LOOS && binding <= STB_HIOS)
7876 {
7877 if (binding == STB_GNU_UNIQUE
7878 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
7879 /* GNU/Linux is still using the default value 0. */
7880 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
7881 return "UNIQUE";
7882 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
7883 }
7884 else
7885 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
7886 return buff;
7887 }
7888 }
7889
7890 static const char *
7891 get_symbol_type (unsigned int type)
7892 {
7893 static char buff[32];
7894
7895 switch (type)
7896 {
7897 case STT_NOTYPE: return "NOTYPE";
7898 case STT_OBJECT: return "OBJECT";
7899 case STT_FUNC: return "FUNC";
7900 case STT_SECTION: return "SECTION";
7901 case STT_FILE: return "FILE";
7902 case STT_COMMON: return "COMMON";
7903 case STT_TLS: return "TLS";
7904 case STT_RELC: return "RELC";
7905 case STT_SRELC: return "SRELC";
7906 default:
7907 if (type >= STT_LOPROC && type <= STT_HIPROC)
7908 {
7909 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
7910 return "THUMB_FUNC";
7911
7912 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
7913 return "REGISTER";
7914
7915 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
7916 return "PARISC_MILLI";
7917
7918 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
7919 }
7920 else if (type >= STT_LOOS && type <= STT_HIOS)
7921 {
7922 if (elf_header.e_machine == EM_PARISC)
7923 {
7924 if (type == STT_HP_OPAQUE)
7925 return "HP_OPAQUE";
7926 if (type == STT_HP_STUB)
7927 return "HP_STUB";
7928 }
7929
7930 if (type == STT_GNU_IFUNC
7931 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
7932 /* GNU/Linux is still using the default value 0. */
7933 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
7934 return "IFUNC";
7935
7936 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
7937 }
7938 else
7939 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
7940 return buff;
7941 }
7942 }
7943
7944 static const char *
7945 get_symbol_visibility (unsigned int visibility)
7946 {
7947 switch (visibility)
7948 {
7949 case STV_DEFAULT: return "DEFAULT";
7950 case STV_INTERNAL: return "INTERNAL";
7951 case STV_HIDDEN: return "HIDDEN";
7952 case STV_PROTECTED: return "PROTECTED";
7953 default: abort ();
7954 }
7955 }
7956
7957 static const char *
7958 get_mips_symbol_other (unsigned int other)
7959 {
7960 switch (other)
7961 {
7962 case STO_OPTIONAL: return "OPTIONAL";
7963 case STO_MIPS16: return "MIPS16";
7964 case STO_MIPS_PLT: return "MIPS PLT";
7965 case STO_MIPS_PIC: return "MIPS PIC";
7966 default: return NULL;
7967 }
7968 }
7969
7970 static const char *
7971 get_symbol_other (unsigned int other)
7972 {
7973 const char * result = NULL;
7974 static char buff [32];
7975
7976 if (other == 0)
7977 return "";
7978
7979 switch (elf_header.e_machine)
7980 {
7981 case EM_MIPS:
7982 result = get_mips_symbol_other (other);
7983 default:
7984 break;
7985 }
7986
7987 if (result)
7988 return result;
7989
7990 snprintf (buff, sizeof buff, _("<other>: %x"), other);
7991 return buff;
7992 }
7993
7994 static const char *
7995 get_symbol_index_type (unsigned int type)
7996 {
7997 static char buff[32];
7998
7999 switch (type)
8000 {
8001 case SHN_UNDEF: return "UND";
8002 case SHN_ABS: return "ABS";
8003 case SHN_COMMON: return "COM";
8004 default:
8005 if (type == SHN_IA_64_ANSI_COMMON
8006 && elf_header.e_machine == EM_IA_64
8007 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8008 return "ANSI_COM";
8009 else if ((elf_header.e_machine == EM_X86_64
8010 || elf_header.e_machine == EM_L1OM)
8011 && type == SHN_X86_64_LCOMMON)
8012 return "LARGE_COM";
8013 else if (type == SHN_MIPS_SCOMMON
8014 && elf_header.e_machine == EM_MIPS)
8015 return "SCOM";
8016 else if (type == SHN_MIPS_SUNDEFINED
8017 && elf_header.e_machine == EM_MIPS)
8018 return "SUND";
8019 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
8020 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
8021 else if (type >= SHN_LOOS && type <= SHN_HIOS)
8022 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8023 else if (type >= SHN_LORESERVE)
8024 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
8025 else
8026 sprintf (buff, "%3d", type);
8027 break;
8028 }
8029
8030 return buff;
8031 }
8032
8033 static bfd_vma *
8034 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
8035 {
8036 unsigned char * e_data;
8037 bfd_vma * i_data;
8038
8039 e_data = (unsigned char *) cmalloc (number, ent_size);
8040
8041 if (e_data == NULL)
8042 {
8043 error (_("Out of memory\n"));
8044 return NULL;
8045 }
8046
8047 if (fread (e_data, ent_size, number, file) != number)
8048 {
8049 error (_("Unable to read in dynamic data\n"));
8050 return NULL;
8051 }
8052
8053 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
8054
8055 if (i_data == NULL)
8056 {
8057 error (_("Out of memory\n"));
8058 free (e_data);
8059 return NULL;
8060 }
8061
8062 while (number--)
8063 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
8064
8065 free (e_data);
8066
8067 return i_data;
8068 }
8069
8070 static void
8071 print_dynamic_symbol (bfd_vma si, unsigned long hn)
8072 {
8073 Elf_Internal_Sym * psym;
8074 int n;
8075
8076 psym = dynamic_symbols + si;
8077
8078 n = print_vma (si, DEC_5);
8079 if (n < 5)
8080 fputs (" " + n, stdout);
8081 printf (" %3lu: ", hn);
8082 print_vma (psym->st_value, LONG_HEX);
8083 putchar (' ');
8084 print_vma (psym->st_size, DEC_5);
8085
8086 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8087 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8088 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8089 /* Check to see if any other bits in the st_other field are set.
8090 Note - displaying this information disrupts the layout of the
8091 table being generated, but for the moment this case is very
8092 rare. */
8093 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8094 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8095 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8096 if (VALID_DYNAMIC_NAME (psym->st_name))
8097 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8098 else
8099 printf (_(" <corrupt: %14ld>"), psym->st_name);
8100 putchar ('\n');
8101 }
8102
8103 /* Dump the symbol table. */
8104 static int
8105 process_symbol_table (FILE * file)
8106 {
8107 Elf_Internal_Shdr * section;
8108 bfd_vma nbuckets = 0;
8109 bfd_vma nchains = 0;
8110 bfd_vma * buckets = NULL;
8111 bfd_vma * chains = NULL;
8112 bfd_vma ngnubuckets = 0;
8113 bfd_vma * gnubuckets = NULL;
8114 bfd_vma * gnuchains = NULL;
8115 bfd_vma gnusymidx = 0;
8116
8117 if (!do_syms && !do_dyn_syms && !do_histogram)
8118 return 1;
8119
8120 if (dynamic_info[DT_HASH]
8121 && (do_histogram
8122 || (do_using_dynamic
8123 && !do_dyn_syms
8124 && dynamic_strings != NULL)))
8125 {
8126 unsigned char nb[8];
8127 unsigned char nc[8];
8128 int hash_ent_size = 4;
8129
8130 if ((elf_header.e_machine == EM_ALPHA
8131 || elf_header.e_machine == EM_S390
8132 || elf_header.e_machine == EM_S390_OLD)
8133 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8134 hash_ent_size = 8;
8135
8136 if (fseek (file,
8137 (archive_file_offset
8138 + offset_from_vma (file, dynamic_info[DT_HASH],
8139 sizeof nb + sizeof nc)),
8140 SEEK_SET))
8141 {
8142 error (_("Unable to seek to start of dynamic information\n"));
8143 goto no_hash;
8144 }
8145
8146 if (fread (nb, hash_ent_size, 1, file) != 1)
8147 {
8148 error (_("Failed to read in number of buckets\n"));
8149 goto no_hash;
8150 }
8151
8152 if (fread (nc, hash_ent_size, 1, file) != 1)
8153 {
8154 error (_("Failed to read in number of chains\n"));
8155 goto no_hash;
8156 }
8157
8158 nbuckets = byte_get (nb, hash_ent_size);
8159 nchains = byte_get (nc, hash_ent_size);
8160
8161 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8162 chains = get_dynamic_data (file, nchains, hash_ent_size);
8163
8164 no_hash:
8165 if (buckets == NULL || chains == NULL)
8166 {
8167 if (do_using_dynamic)
8168 return 0;
8169 free (buckets);
8170 free (chains);
8171 buckets = NULL;
8172 chains = NULL;
8173 nbuckets = 0;
8174 nchains = 0;
8175 }
8176 }
8177
8178 if (dynamic_info_DT_GNU_HASH
8179 && (do_histogram
8180 || (do_using_dynamic
8181 && !do_dyn_syms
8182 && dynamic_strings != NULL)))
8183 {
8184 unsigned char nb[16];
8185 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8186 bfd_vma buckets_vma;
8187
8188 if (fseek (file,
8189 (archive_file_offset
8190 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8191 sizeof nb)),
8192 SEEK_SET))
8193 {
8194 error (_("Unable to seek to start of dynamic information\n"));
8195 goto no_gnu_hash;
8196 }
8197
8198 if (fread (nb, 16, 1, file) != 1)
8199 {
8200 error (_("Failed to read in number of buckets\n"));
8201 goto no_gnu_hash;
8202 }
8203
8204 ngnubuckets = byte_get (nb, 4);
8205 gnusymidx = byte_get (nb + 4, 4);
8206 bitmaskwords = byte_get (nb + 8, 4);
8207 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
8208 if (is_32bit_elf)
8209 buckets_vma += bitmaskwords * 4;
8210 else
8211 buckets_vma += bitmaskwords * 8;
8212
8213 if (fseek (file,
8214 (archive_file_offset
8215 + offset_from_vma (file, buckets_vma, 4)),
8216 SEEK_SET))
8217 {
8218 error (_("Unable to seek to start of dynamic information\n"));
8219 goto no_gnu_hash;
8220 }
8221
8222 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
8223
8224 if (gnubuckets == NULL)
8225 goto no_gnu_hash;
8226
8227 for (i = 0; i < ngnubuckets; i++)
8228 if (gnubuckets[i] != 0)
8229 {
8230 if (gnubuckets[i] < gnusymidx)
8231 return 0;
8232
8233 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
8234 maxchain = gnubuckets[i];
8235 }
8236
8237 if (maxchain == 0xffffffff)
8238 goto no_gnu_hash;
8239
8240 maxchain -= gnusymidx;
8241
8242 if (fseek (file,
8243 (archive_file_offset
8244 + offset_from_vma (file, buckets_vma
8245 + 4 * (ngnubuckets + maxchain), 4)),
8246 SEEK_SET))
8247 {
8248 error (_("Unable to seek to start of dynamic information\n"));
8249 goto no_gnu_hash;
8250 }
8251
8252 do
8253 {
8254 if (fread (nb, 4, 1, file) != 1)
8255 {
8256 error (_("Failed to determine last chain length\n"));
8257 goto no_gnu_hash;
8258 }
8259
8260 if (maxchain + 1 == 0)
8261 goto no_gnu_hash;
8262
8263 ++maxchain;
8264 }
8265 while ((byte_get (nb, 4) & 1) == 0);
8266
8267 if (fseek (file,
8268 (archive_file_offset
8269 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
8270 SEEK_SET))
8271 {
8272 error (_("Unable to seek to start of dynamic information\n"));
8273 goto no_gnu_hash;
8274 }
8275
8276 gnuchains = get_dynamic_data (file, maxchain, 4);
8277
8278 no_gnu_hash:
8279 if (gnuchains == NULL)
8280 {
8281 free (gnubuckets);
8282 gnubuckets = NULL;
8283 ngnubuckets = 0;
8284 if (do_using_dynamic)
8285 return 0;
8286 }
8287 }
8288
8289 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
8290 && do_syms
8291 && do_using_dynamic
8292 && dynamic_strings != NULL)
8293 {
8294 unsigned long hn;
8295
8296 if (dynamic_info[DT_HASH])
8297 {
8298 bfd_vma si;
8299
8300 printf (_("\nSymbol table for image:\n"));
8301 if (is_32bit_elf)
8302 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8303 else
8304 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8305
8306 for (hn = 0; hn < nbuckets; hn++)
8307 {
8308 if (! buckets[hn])
8309 continue;
8310
8311 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
8312 print_dynamic_symbol (si, hn);
8313 }
8314 }
8315
8316 if (dynamic_info_DT_GNU_HASH)
8317 {
8318 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8319 if (is_32bit_elf)
8320 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8321 else
8322 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8323
8324 for (hn = 0; hn < ngnubuckets; ++hn)
8325 if (gnubuckets[hn] != 0)
8326 {
8327 bfd_vma si = gnubuckets[hn];
8328 bfd_vma off = si - gnusymidx;
8329
8330 do
8331 {
8332 print_dynamic_symbol (si, hn);
8333 si++;
8334 }
8335 while ((gnuchains[off++] & 1) == 0);
8336 }
8337 }
8338 }
8339 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
8340 {
8341 unsigned int i;
8342
8343 for (i = 0, section = section_headers;
8344 i < elf_header.e_shnum;
8345 i++, section++)
8346 {
8347 unsigned int si;
8348 char * strtab = NULL;
8349 unsigned long int strtab_size = 0;
8350 Elf_Internal_Sym * symtab;
8351 Elf_Internal_Sym * psym;
8352
8353 if ((section->sh_type != SHT_SYMTAB
8354 && section->sh_type != SHT_DYNSYM)
8355 || (!do_syms
8356 && section->sh_type == SHT_SYMTAB))
8357 continue;
8358
8359 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8360 SECTION_NAME (section),
8361 (unsigned long) (section->sh_size / section->sh_entsize));
8362 if (is_32bit_elf)
8363 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8364 else
8365 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8366
8367 symtab = GET_ELF_SYMBOLS (file, section);
8368 if (symtab == NULL)
8369 continue;
8370
8371 if (section->sh_link == elf_header.e_shstrndx)
8372 {
8373 strtab = string_table;
8374 strtab_size = string_table_length;
8375 }
8376 else if (section->sh_link < elf_header.e_shnum)
8377 {
8378 Elf_Internal_Shdr * string_sec;
8379
8380 string_sec = section_headers + section->sh_link;
8381
8382 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
8383 1, string_sec->sh_size,
8384 _("string table"));
8385 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
8386 }
8387
8388 for (si = 0, psym = symtab;
8389 si < section->sh_size / section->sh_entsize;
8390 si++, psym++)
8391 {
8392 printf ("%6d: ", si);
8393 print_vma (psym->st_value, LONG_HEX);
8394 putchar (' ');
8395 print_vma (psym->st_size, DEC_5);
8396 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8397 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8398 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8399 /* Check to see if any other bits in the st_other field are set.
8400 Note - displaying this information disrupts the layout of the
8401 table being generated, but for the moment this case is very rare. */
8402 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8403 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8404 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
8405 print_symbol (25, psym->st_name < strtab_size
8406 ? strtab + psym->st_name : _("<corrupt>"));
8407
8408 if (section->sh_type == SHT_DYNSYM &&
8409 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
8410 {
8411 unsigned char data[2];
8412 unsigned short vers_data;
8413 unsigned long offset;
8414 int is_nobits;
8415 int check_def;
8416
8417 offset = offset_from_vma
8418 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8419 sizeof data + si * sizeof (vers_data));
8420
8421 get_data (&data, file, offset + si * sizeof (vers_data),
8422 sizeof (data), 1, _("version data"));
8423
8424 vers_data = byte_get (data, 2);
8425
8426 is_nobits = (psym->st_shndx < elf_header.e_shnum
8427 && section_headers[psym->st_shndx].sh_type
8428 == SHT_NOBITS);
8429
8430 check_def = (psym->st_shndx != SHN_UNDEF);
8431
8432 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
8433 {
8434 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
8435 && (is_nobits || ! check_def))
8436 {
8437 Elf_External_Verneed evn;
8438 Elf_Internal_Verneed ivn;
8439 Elf_Internal_Vernaux ivna;
8440
8441 /* We must test both. */
8442 offset = offset_from_vma
8443 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8444 sizeof evn);
8445
8446 do
8447 {
8448 unsigned long vna_off;
8449
8450 get_data (&evn, file, offset, sizeof (evn), 1,
8451 _("version need"));
8452
8453 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8454 ivn.vn_next = BYTE_GET (evn.vn_next);
8455
8456 vna_off = offset + ivn.vn_aux;
8457
8458 do
8459 {
8460 Elf_External_Vernaux evna;
8461
8462 get_data (&evna, file, vna_off,
8463 sizeof (evna), 1,
8464 _("version need aux (3)"));
8465
8466 ivna.vna_other = BYTE_GET (evna.vna_other);
8467 ivna.vna_next = BYTE_GET (evna.vna_next);
8468 ivna.vna_name = BYTE_GET (evna.vna_name);
8469
8470 vna_off += ivna.vna_next;
8471 }
8472 while (ivna.vna_other != vers_data
8473 && ivna.vna_next != 0);
8474
8475 if (ivna.vna_other == vers_data)
8476 break;
8477
8478 offset += ivn.vn_next;
8479 }
8480 while (ivn.vn_next != 0);
8481
8482 if (ivna.vna_other == vers_data)
8483 {
8484 printf ("@%s (%d)",
8485 ivna.vna_name < strtab_size
8486 ? strtab + ivna.vna_name : _("<corrupt>"),
8487 ivna.vna_other);
8488 check_def = 0;
8489 }
8490 else if (! is_nobits)
8491 error (_("bad dynamic symbol\n"));
8492 else
8493 check_def = 1;
8494 }
8495
8496 if (check_def)
8497 {
8498 if (vers_data != 0x8001
8499 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8500 {
8501 Elf_Internal_Verdef ivd;
8502 Elf_Internal_Verdaux ivda;
8503 Elf_External_Verdaux evda;
8504 unsigned long off;
8505
8506 off = offset_from_vma
8507 (file,
8508 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8509 sizeof (Elf_External_Verdef));
8510
8511 do
8512 {
8513 Elf_External_Verdef evd;
8514
8515 get_data (&evd, file, off, sizeof (evd),
8516 1, _("version def"));
8517
8518 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8519 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8520 ivd.vd_next = BYTE_GET (evd.vd_next);
8521
8522 off += ivd.vd_next;
8523 }
8524 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
8525 && ivd.vd_next != 0);
8526
8527 off -= ivd.vd_next;
8528 off += ivd.vd_aux;
8529
8530 get_data (&evda, file, off, sizeof (evda),
8531 1, _("version def aux"));
8532
8533 ivda.vda_name = BYTE_GET (evda.vda_name);
8534
8535 if (psym->st_name != ivda.vda_name)
8536 printf ((vers_data & VERSYM_HIDDEN)
8537 ? "@%s" : "@@%s",
8538 ivda.vda_name < strtab_size
8539 ? strtab + ivda.vda_name : _("<corrupt>"));
8540 }
8541 }
8542 }
8543 }
8544
8545 putchar ('\n');
8546 }
8547
8548 free (symtab);
8549 if (strtab != string_table)
8550 free (strtab);
8551 }
8552 }
8553 else if (do_syms)
8554 printf
8555 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
8556
8557 if (do_histogram && buckets != NULL)
8558 {
8559 unsigned long * lengths;
8560 unsigned long * counts;
8561 unsigned long hn;
8562 bfd_vma si;
8563 unsigned long maxlength = 0;
8564 unsigned long nzero_counts = 0;
8565 unsigned long nsyms = 0;
8566
8567 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
8568 (unsigned long) nbuckets);
8569 printf (_(" Length Number %% of total Coverage\n"));
8570
8571 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
8572 if (lengths == NULL)
8573 {
8574 error (_("Out of memory\n"));
8575 return 0;
8576 }
8577 for (hn = 0; hn < nbuckets; ++hn)
8578 {
8579 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
8580 {
8581 ++nsyms;
8582 if (maxlength < ++lengths[hn])
8583 ++maxlength;
8584 }
8585 }
8586
8587 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
8588 if (counts == NULL)
8589 {
8590 error (_("Out of memory\n"));
8591 return 0;
8592 }
8593
8594 for (hn = 0; hn < nbuckets; ++hn)
8595 ++counts[lengths[hn]];
8596
8597 if (nbuckets > 0)
8598 {
8599 unsigned long i;
8600 printf (" 0 %-10lu (%5.1f%%)\n",
8601 counts[0], (counts[0] * 100.0) / nbuckets);
8602 for (i = 1; i <= maxlength; ++i)
8603 {
8604 nzero_counts += counts[i] * i;
8605 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
8606 i, counts[i], (counts[i] * 100.0) / nbuckets,
8607 (nzero_counts * 100.0) / nsyms);
8608 }
8609 }
8610
8611 free (counts);
8612 free (lengths);
8613 }
8614
8615 if (buckets != NULL)
8616 {
8617 free (buckets);
8618 free (chains);
8619 }
8620
8621 if (do_histogram && gnubuckets != NULL)
8622 {
8623 unsigned long * lengths;
8624 unsigned long * counts;
8625 unsigned long hn;
8626 unsigned long maxlength = 0;
8627 unsigned long nzero_counts = 0;
8628 unsigned long nsyms = 0;
8629
8630 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
8631 if (lengths == NULL)
8632 {
8633 error (_("Out of memory\n"));
8634 return 0;
8635 }
8636
8637 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
8638 (unsigned long) ngnubuckets);
8639 printf (_(" Length Number %% of total Coverage\n"));
8640
8641 for (hn = 0; hn < ngnubuckets; ++hn)
8642 if (gnubuckets[hn] != 0)
8643 {
8644 bfd_vma off, length = 1;
8645
8646 for (off = gnubuckets[hn] - gnusymidx;
8647 (gnuchains[off] & 1) == 0; ++off)
8648 ++length;
8649 lengths[hn] = length;
8650 if (length > maxlength)
8651 maxlength = length;
8652 nsyms += length;
8653 }
8654
8655 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
8656 if (counts == NULL)
8657 {
8658 error (_("Out of memory\n"));
8659 return 0;
8660 }
8661
8662 for (hn = 0; hn < ngnubuckets; ++hn)
8663 ++counts[lengths[hn]];
8664
8665 if (ngnubuckets > 0)
8666 {
8667 unsigned long j;
8668 printf (" 0 %-10lu (%5.1f%%)\n",
8669 counts[0], (counts[0] * 100.0) / ngnubuckets);
8670 for (j = 1; j <= maxlength; ++j)
8671 {
8672 nzero_counts += counts[j] * j;
8673 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
8674 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
8675 (nzero_counts * 100.0) / nsyms);
8676 }
8677 }
8678
8679 free (counts);
8680 free (lengths);
8681 free (gnubuckets);
8682 free (gnuchains);
8683 }
8684
8685 return 1;
8686 }
8687
8688 static int
8689 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
8690 {
8691 unsigned int i;
8692
8693 if (dynamic_syminfo == NULL
8694 || !do_dynamic)
8695 /* No syminfo, this is ok. */
8696 return 1;
8697
8698 /* There better should be a dynamic symbol section. */
8699 if (dynamic_symbols == NULL || dynamic_strings == NULL)
8700 return 0;
8701
8702 if (dynamic_addr)
8703 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
8704 dynamic_syminfo_offset, dynamic_syminfo_nent);
8705
8706 printf (_(" Num: Name BoundTo Flags\n"));
8707 for (i = 0; i < dynamic_syminfo_nent; ++i)
8708 {
8709 unsigned short int flags = dynamic_syminfo[i].si_flags;
8710
8711 printf ("%4d: ", i);
8712 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
8713 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
8714 else
8715 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
8716 putchar (' ');
8717
8718 switch (dynamic_syminfo[i].si_boundto)
8719 {
8720 case SYMINFO_BT_SELF:
8721 fputs ("SELF ", stdout);
8722 break;
8723 case SYMINFO_BT_PARENT:
8724 fputs ("PARENT ", stdout);
8725 break;
8726 default:
8727 if (dynamic_syminfo[i].si_boundto > 0
8728 && dynamic_syminfo[i].si_boundto < dynamic_nent
8729 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
8730 {
8731 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
8732 putchar (' ' );
8733 }
8734 else
8735 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
8736 break;
8737 }
8738
8739 if (flags & SYMINFO_FLG_DIRECT)
8740 printf (" DIRECT");
8741 if (flags & SYMINFO_FLG_PASSTHRU)
8742 printf (" PASSTHRU");
8743 if (flags & SYMINFO_FLG_COPY)
8744 printf (" COPY");
8745 if (flags & SYMINFO_FLG_LAZYLOAD)
8746 printf (" LAZYLOAD");
8747
8748 puts ("");
8749 }
8750
8751 return 1;
8752 }
8753
8754 /* Check to see if the given reloc needs to be handled in a target specific
8755 manner. If so then process the reloc and return TRUE otherwise return
8756 FALSE. */
8757
8758 static bfd_boolean
8759 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
8760 unsigned char * start,
8761 Elf_Internal_Sym * symtab)
8762 {
8763 unsigned int reloc_type = get_reloc_type (reloc->r_info);
8764
8765 switch (elf_header.e_machine)
8766 {
8767 case EM_MN10300:
8768 case EM_CYGNUS_MN10300:
8769 {
8770 static Elf_Internal_Sym * saved_sym = NULL;
8771
8772 switch (reloc_type)
8773 {
8774 case 34: /* R_MN10300_ALIGN */
8775 return TRUE;
8776 case 33: /* R_MN10300_SYM_DIFF */
8777 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
8778 return TRUE;
8779 case 1: /* R_MN10300_32 */
8780 case 2: /* R_MN10300_16 */
8781 if (saved_sym != NULL)
8782 {
8783 bfd_vma value;
8784
8785 value = reloc->r_addend
8786 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
8787 - saved_sym->st_value);
8788
8789 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
8790
8791 saved_sym = NULL;
8792 return TRUE;
8793 }
8794 break;
8795 default:
8796 if (saved_sym != NULL)
8797 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
8798 break;
8799 }
8800 break;
8801 }
8802 }
8803
8804 return FALSE;
8805 }
8806
8807 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8808 DWARF debug sections. This is a target specific test. Note - we do not
8809 go through the whole including-target-headers-multiple-times route, (as
8810 we have already done with <elf/h8.h>) because this would become very
8811 messy and even then this function would have to contain target specific
8812 information (the names of the relocs instead of their numeric values).
8813 FIXME: This is not the correct way to solve this problem. The proper way
8814 is to have target specific reloc sizing and typing functions created by
8815 the reloc-macros.h header, in the same way that it already creates the
8816 reloc naming functions. */
8817
8818 static bfd_boolean
8819 is_32bit_abs_reloc (unsigned int reloc_type)
8820 {
8821 switch (elf_header.e_machine)
8822 {
8823 case EM_386:
8824 case EM_486:
8825 return reloc_type == 1; /* R_386_32. */
8826 case EM_68K:
8827 return reloc_type == 1; /* R_68K_32. */
8828 case EM_860:
8829 return reloc_type == 1; /* R_860_32. */
8830 case EM_ALPHA:
8831 return reloc_type == 1; /* XXX Is this right ? */
8832 case EM_ARC:
8833 return reloc_type == 1; /* R_ARC_32. */
8834 case EM_ARM:
8835 return reloc_type == 2; /* R_ARM_ABS32 */
8836 case EM_AVR_OLD:
8837 case EM_AVR:
8838 return reloc_type == 1;
8839 case EM_BLACKFIN:
8840 return reloc_type == 0x12; /* R_byte4_data. */
8841 case EM_CRIS:
8842 return reloc_type == 3; /* R_CRIS_32. */
8843 case EM_CR16:
8844 case EM_CR16_OLD:
8845 return reloc_type == 3; /* R_CR16_NUM32. */
8846 case EM_CRX:
8847 return reloc_type == 15; /* R_CRX_NUM32. */
8848 case EM_CYGNUS_FRV:
8849 return reloc_type == 1;
8850 case EM_CYGNUS_D10V:
8851 case EM_D10V:
8852 return reloc_type == 6; /* R_D10V_32. */
8853 case EM_CYGNUS_D30V:
8854 case EM_D30V:
8855 return reloc_type == 12; /* R_D30V_32_NORMAL. */
8856 case EM_DLX:
8857 return reloc_type == 3; /* R_DLX_RELOC_32. */
8858 case EM_CYGNUS_FR30:
8859 case EM_FR30:
8860 return reloc_type == 3; /* R_FR30_32. */
8861 case EM_H8S:
8862 case EM_H8_300:
8863 case EM_H8_300H:
8864 return reloc_type == 1; /* R_H8_DIR32. */
8865 case EM_IA_64:
8866 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
8867 case EM_IP2K_OLD:
8868 case EM_IP2K:
8869 return reloc_type == 2; /* R_IP2K_32. */
8870 case EM_IQ2000:
8871 return reloc_type == 2; /* R_IQ2000_32. */
8872 case EM_LATTICEMICO32:
8873 return reloc_type == 3; /* R_LM32_32. */
8874 case EM_M32C_OLD:
8875 case EM_M32C:
8876 return reloc_type == 3; /* R_M32C_32. */
8877 case EM_M32R:
8878 return reloc_type == 34; /* R_M32R_32_RELA. */
8879 case EM_MCORE:
8880 return reloc_type == 1; /* R_MCORE_ADDR32. */
8881 case EM_CYGNUS_MEP:
8882 return reloc_type == 4; /* R_MEP_32. */
8883 case EM_MIPS:
8884 return reloc_type == 2; /* R_MIPS_32. */
8885 case EM_MMIX:
8886 return reloc_type == 4; /* R_MMIX_32. */
8887 case EM_CYGNUS_MN10200:
8888 case EM_MN10200:
8889 return reloc_type == 1; /* R_MN10200_32. */
8890 case EM_CYGNUS_MN10300:
8891 case EM_MN10300:
8892 return reloc_type == 1; /* R_MN10300_32. */
8893 case EM_MSP430_OLD:
8894 case EM_MSP430:
8895 return reloc_type == 1; /* R_MSP43_32. */
8896 case EM_MT:
8897 return reloc_type == 2; /* R_MT_32. */
8898 case EM_ALTERA_NIOS2:
8899 case EM_NIOS32:
8900 return reloc_type == 1; /* R_NIOS_32. */
8901 case EM_OPENRISC:
8902 case EM_OR32:
8903 return reloc_type == 1; /* R_OR32_32. */
8904 case EM_PARISC:
8905 return (reloc_type == 1 /* R_PARISC_DIR32. */
8906 || reloc_type == 41); /* R_PARISC_SECREL32. */
8907 case EM_PJ:
8908 case EM_PJ_OLD:
8909 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
8910 case EM_PPC64:
8911 return reloc_type == 1; /* R_PPC64_ADDR32. */
8912 case EM_PPC:
8913 return reloc_type == 1; /* R_PPC_ADDR32. */
8914 case EM_RX:
8915 return reloc_type == 1; /* R_RX_DIR32. */
8916 case EM_S370:
8917 return reloc_type == 1; /* R_I370_ADDR31. */
8918 case EM_S390_OLD:
8919 case EM_S390:
8920 return reloc_type == 4; /* R_S390_32. */
8921 case EM_SCORE:
8922 return reloc_type == 8; /* R_SCORE_ABS32. */
8923 case EM_SH:
8924 return reloc_type == 1; /* R_SH_DIR32. */
8925 case EM_SPARC32PLUS:
8926 case EM_SPARCV9:
8927 case EM_SPARC:
8928 return reloc_type == 3 /* R_SPARC_32. */
8929 || reloc_type == 23; /* R_SPARC_UA32. */
8930 case EM_SPU:
8931 return reloc_type == 6; /* R_SPU_ADDR32 */
8932 case EM_TI_C6000:
8933 return reloc_type == 1; /* R_C6000_ABS32. */
8934 case EM_CYGNUS_V850:
8935 case EM_V850:
8936 return reloc_type == 6; /* R_V850_ABS32. */
8937 case EM_VAX:
8938 return reloc_type == 1; /* R_VAX_32. */
8939 case EM_X86_64:
8940 case EM_L1OM:
8941 return reloc_type == 10; /* R_X86_64_32. */
8942 case EM_XC16X:
8943 case EM_C166:
8944 return reloc_type == 3; /* R_XC16C_ABS_32. */
8945 case EM_XSTORMY16:
8946 return reloc_type == 1; /* R_XSTROMY16_32. */
8947 case EM_XTENSA_OLD:
8948 case EM_XTENSA:
8949 return reloc_type == 1; /* R_XTENSA_32. */
8950 default:
8951 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8952 elf_header.e_machine);
8953 abort ();
8954 }
8955 }
8956
8957 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8958 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8959
8960 static bfd_boolean
8961 is_32bit_pcrel_reloc (unsigned int reloc_type)
8962 {
8963 switch (elf_header.e_machine)
8964 {
8965 case EM_386:
8966 case EM_486:
8967 return reloc_type == 2; /* R_386_PC32. */
8968 case EM_68K:
8969 return reloc_type == 4; /* R_68K_PC32. */
8970 case EM_ALPHA:
8971 return reloc_type == 10; /* R_ALPHA_SREL32. */
8972 case EM_ARM:
8973 return reloc_type == 3; /* R_ARM_REL32 */
8974 case EM_PARISC:
8975 return reloc_type == 9; /* R_PARISC_PCREL32. */
8976 case EM_PPC:
8977 return reloc_type == 26; /* R_PPC_REL32. */
8978 case EM_PPC64:
8979 return reloc_type == 26; /* R_PPC64_REL32. */
8980 case EM_S390_OLD:
8981 case EM_S390:
8982 return reloc_type == 5; /* R_390_PC32. */
8983 case EM_SH:
8984 return reloc_type == 2; /* R_SH_REL32. */
8985 case EM_SPARC32PLUS:
8986 case EM_SPARCV9:
8987 case EM_SPARC:
8988 return reloc_type == 6; /* R_SPARC_DISP32. */
8989 case EM_SPU:
8990 return reloc_type == 13; /* R_SPU_REL32. */
8991 case EM_X86_64:
8992 case EM_L1OM:
8993 return reloc_type == 2; /* R_X86_64_PC32. */
8994 case EM_XTENSA_OLD:
8995 case EM_XTENSA:
8996 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
8997 default:
8998 /* Do not abort or issue an error message here. Not all targets use
8999 pc-relative 32-bit relocs in their DWARF debug information and we
9000 have already tested for target coverage in is_32bit_abs_reloc. A
9001 more helpful warning message will be generated by apply_relocations
9002 anyway, so just return. */
9003 return FALSE;
9004 }
9005 }
9006
9007 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9008 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9009
9010 static bfd_boolean
9011 is_64bit_abs_reloc (unsigned int reloc_type)
9012 {
9013 switch (elf_header.e_machine)
9014 {
9015 case EM_ALPHA:
9016 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
9017 case EM_IA_64:
9018 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
9019 case EM_PARISC:
9020 return reloc_type == 80; /* R_PARISC_DIR64. */
9021 case EM_PPC64:
9022 return reloc_type == 38; /* R_PPC64_ADDR64. */
9023 case EM_SPARC32PLUS:
9024 case EM_SPARCV9:
9025 case EM_SPARC:
9026 return reloc_type == 54; /* R_SPARC_UA64. */
9027 case EM_X86_64:
9028 case EM_L1OM:
9029 return reloc_type == 1; /* R_X86_64_64. */
9030 case EM_S390_OLD:
9031 case EM_S390:
9032 return reloc_type == 22; /* R_S390_64 */
9033 case EM_MIPS:
9034 return reloc_type == 18; /* R_MIPS_64 */
9035 default:
9036 return FALSE;
9037 }
9038 }
9039
9040 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9041 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9042
9043 static bfd_boolean
9044 is_64bit_pcrel_reloc (unsigned int reloc_type)
9045 {
9046 switch (elf_header.e_machine)
9047 {
9048 case EM_ALPHA:
9049 return reloc_type == 11; /* R_ALPHA_SREL64 */
9050 case EM_IA_64:
9051 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
9052 case EM_PARISC:
9053 return reloc_type == 72; /* R_PARISC_PCREL64 */
9054 case EM_PPC64:
9055 return reloc_type == 44; /* R_PPC64_REL64 */
9056 case EM_SPARC32PLUS:
9057 case EM_SPARCV9:
9058 case EM_SPARC:
9059 return reloc_type == 46; /* R_SPARC_DISP64 */
9060 case EM_X86_64:
9061 case EM_L1OM:
9062 return reloc_type == 24; /* R_X86_64_PC64 */
9063 case EM_S390_OLD:
9064 case EM_S390:
9065 return reloc_type == 23; /* R_S390_PC64 */
9066 default:
9067 return FALSE;
9068 }
9069 }
9070
9071 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9072 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9073
9074 static bfd_boolean
9075 is_24bit_abs_reloc (unsigned int reloc_type)
9076 {
9077 switch (elf_header.e_machine)
9078 {
9079 case EM_CYGNUS_MN10200:
9080 case EM_MN10200:
9081 return reloc_type == 4; /* R_MN10200_24. */
9082 default:
9083 return FALSE;
9084 }
9085 }
9086
9087 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9088 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9089
9090 static bfd_boolean
9091 is_16bit_abs_reloc (unsigned int reloc_type)
9092 {
9093 switch (elf_header.e_machine)
9094 {
9095 case EM_AVR_OLD:
9096 case EM_AVR:
9097 return reloc_type == 4; /* R_AVR_16. */
9098 case EM_CYGNUS_D10V:
9099 case EM_D10V:
9100 return reloc_type == 3; /* R_D10V_16. */
9101 case EM_H8S:
9102 case EM_H8_300:
9103 case EM_H8_300H:
9104 return reloc_type == R_H8_DIR16;
9105 case EM_IP2K_OLD:
9106 case EM_IP2K:
9107 return reloc_type == 1; /* R_IP2K_16. */
9108 case EM_M32C_OLD:
9109 case EM_M32C:
9110 return reloc_type == 1; /* R_M32C_16 */
9111 case EM_MSP430_OLD:
9112 case EM_MSP430:
9113 return reloc_type == 5; /* R_MSP430_16_BYTE. */
9114 case EM_ALTERA_NIOS2:
9115 case EM_NIOS32:
9116 return reloc_type == 9; /* R_NIOS_16. */
9117 case EM_TI_C6000:
9118 return reloc_type == 2; /* R_C6000_ABS16. */
9119 case EM_XC16X:
9120 case EM_C166:
9121 return reloc_type == 2; /* R_XC16C_ABS_16. */
9122 default:
9123 return FALSE;
9124 }
9125 }
9126
9127 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9128 relocation entries (possibly formerly used for SHT_GROUP sections). */
9129
9130 static bfd_boolean
9131 is_none_reloc (unsigned int reloc_type)
9132 {
9133 switch (elf_header.e_machine)
9134 {
9135 case EM_68K: /* R_68K_NONE. */
9136 case EM_386: /* R_386_NONE. */
9137 case EM_SPARC32PLUS:
9138 case EM_SPARCV9:
9139 case EM_SPARC: /* R_SPARC_NONE. */
9140 case EM_MIPS: /* R_MIPS_NONE. */
9141 case EM_PARISC: /* R_PARISC_NONE. */
9142 case EM_ALPHA: /* R_ALPHA_NONE. */
9143 case EM_PPC: /* R_PPC_NONE. */
9144 case EM_PPC64: /* R_PPC64_NONE. */
9145 case EM_ARM: /* R_ARM_NONE. */
9146 case EM_IA_64: /* R_IA64_NONE. */
9147 case EM_SH: /* R_SH_NONE. */
9148 case EM_S390_OLD:
9149 case EM_S390: /* R_390_NONE. */
9150 case EM_CRIS: /* R_CRIS_NONE. */
9151 case EM_X86_64: /* R_X86_64_NONE. */
9152 case EM_L1OM: /* R_X86_64_NONE. */
9153 case EM_MN10300: /* R_MN10300_NONE. */
9154 case EM_M32R: /* R_M32R_NONE. */
9155 case EM_TI_C6000:/* R_C6000_NONE. */
9156 case EM_XC16X:
9157 case EM_C166: /* R_XC16X_NONE. */
9158 return reloc_type == 0;
9159 case EM_XTENSA_OLD:
9160 case EM_XTENSA:
9161 return (reloc_type == 0 /* R_XTENSA_NONE. */
9162 || reloc_type == 17 /* R_XTENSA_DIFF8. */
9163 || reloc_type == 18 /* R_XTENSA_DIFF16. */
9164 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
9165 }
9166 return FALSE;
9167 }
9168
9169 /* Apply relocations to a section.
9170 Note: So far support has been added only for those relocations
9171 which can be found in debug sections.
9172 FIXME: Add support for more relocations ? */
9173
9174 static void
9175 apply_relocations (void * file,
9176 Elf_Internal_Shdr * section,
9177 unsigned char * start)
9178 {
9179 Elf_Internal_Shdr * relsec;
9180 unsigned char * end = start + section->sh_size;
9181
9182 if (elf_header.e_type != ET_REL)
9183 return;
9184
9185 /* Find the reloc section associated with the section. */
9186 for (relsec = section_headers;
9187 relsec < section_headers + elf_header.e_shnum;
9188 ++relsec)
9189 {
9190 bfd_boolean is_rela;
9191 unsigned long num_relocs;
9192 Elf_Internal_Rela * relocs;
9193 Elf_Internal_Rela * rp;
9194 Elf_Internal_Shdr * symsec;
9195 Elf_Internal_Sym * symtab;
9196 Elf_Internal_Sym * sym;
9197
9198 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9199 || relsec->sh_info >= elf_header.e_shnum
9200 || section_headers + relsec->sh_info != section
9201 || relsec->sh_size == 0
9202 || relsec->sh_link >= elf_header.e_shnum)
9203 continue;
9204
9205 is_rela = relsec->sh_type == SHT_RELA;
9206
9207 if (is_rela)
9208 {
9209 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
9210 relsec->sh_size, & relocs, & num_relocs))
9211 return;
9212 }
9213 else
9214 {
9215 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
9216 relsec->sh_size, & relocs, & num_relocs))
9217 return;
9218 }
9219
9220 /* SH uses RELA but uses in place value instead of the addend field. */
9221 if (elf_header.e_machine == EM_SH)
9222 is_rela = FALSE;
9223
9224 symsec = section_headers + relsec->sh_link;
9225 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
9226
9227 for (rp = relocs; rp < relocs + num_relocs; ++rp)
9228 {
9229 bfd_vma addend;
9230 unsigned int reloc_type;
9231 unsigned int reloc_size;
9232 unsigned char * rloc;
9233
9234 reloc_type = get_reloc_type (rp->r_info);
9235
9236 if (target_specific_reloc_handling (rp, start, symtab))
9237 continue;
9238 else if (is_none_reloc (reloc_type))
9239 continue;
9240 else if (is_32bit_abs_reloc (reloc_type)
9241 || is_32bit_pcrel_reloc (reloc_type))
9242 reloc_size = 4;
9243 else if (is_64bit_abs_reloc (reloc_type)
9244 || is_64bit_pcrel_reloc (reloc_type))
9245 reloc_size = 8;
9246 else if (is_24bit_abs_reloc (reloc_type))
9247 reloc_size = 3;
9248 else if (is_16bit_abs_reloc (reloc_type))
9249 reloc_size = 2;
9250 else
9251 {
9252 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9253 reloc_type, SECTION_NAME (section));
9254 continue;
9255 }
9256
9257 rloc = start + rp->r_offset;
9258 if ((rloc + reloc_size) > end)
9259 {
9260 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9261 (unsigned long) rp->r_offset,
9262 SECTION_NAME (section));
9263 continue;
9264 }
9265
9266 sym = symtab + get_reloc_symindex (rp->r_info);
9267
9268 /* If the reloc has a symbol associated with it,
9269 make sure that it is of an appropriate type.
9270
9271 Relocations against symbols without type can happen.
9272 Gcc -feliminate-dwarf2-dups may generate symbols
9273 without type for debug info.
9274
9275 Icc generates relocations against function symbols
9276 instead of local labels.
9277
9278 Relocations against object symbols can happen, eg when
9279 referencing a global array. For an example of this see
9280 the _clz.o binary in libgcc.a. */
9281 if (sym != symtab
9282 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
9283 {
9284 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9285 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
9286 (long int)(rp - relocs),
9287 SECTION_NAME (relsec));
9288 continue;
9289 }
9290
9291 addend = 0;
9292 if (is_rela)
9293 addend += rp->r_addend;
9294 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
9295 if (!is_rela
9296 || (elf_header.e_machine == EM_XTENSA
9297 && reloc_type == 1)
9298 || ((elf_header.e_machine == EM_PJ
9299 || elf_header.e_machine == EM_PJ_OLD)
9300 && reloc_type == 1))
9301 addend += byte_get (rloc, reloc_size);
9302
9303 if (is_32bit_pcrel_reloc (reloc_type)
9304 || is_64bit_pcrel_reloc (reloc_type))
9305 {
9306 /* On HPPA, all pc-relative relocations are biased by 8. */
9307 if (elf_header.e_machine == EM_PARISC)
9308 addend -= 8;
9309 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
9310 reloc_size);
9311 }
9312 else
9313 byte_put (rloc, addend + sym->st_value, reloc_size);
9314 }
9315
9316 free (symtab);
9317 free (relocs);
9318 break;
9319 }
9320 }
9321
9322 #ifdef SUPPORT_DISASSEMBLY
9323 static int
9324 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
9325 {
9326 printf (_("\nAssembly dump of section %s\n"),
9327 SECTION_NAME (section));
9328
9329 /* XXX -- to be done --- XXX */
9330
9331 return 1;
9332 }
9333 #endif
9334
9335 /* Reads in the contents of SECTION from FILE, returning a pointer
9336 to a malloc'ed buffer or NULL if something went wrong. */
9337
9338 static char *
9339 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
9340 {
9341 bfd_size_type num_bytes;
9342
9343 num_bytes = section->sh_size;
9344
9345 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
9346 {
9347 printf (_("\nSection '%s' has no data to dump.\n"),
9348 SECTION_NAME (section));
9349 return NULL;
9350 }
9351
9352 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
9353 _("section contents"));
9354 }
9355
9356
9357 static void
9358 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
9359 {
9360 Elf_Internal_Shdr * relsec;
9361 bfd_size_type num_bytes;
9362 char * data;
9363 char * end;
9364 char * start;
9365 char * name = SECTION_NAME (section);
9366 bfd_boolean some_strings_shown;
9367
9368 start = get_section_contents (section, file);
9369 if (start == NULL)
9370 return;
9371
9372 printf (_("\nString dump of section '%s':\n"), name);
9373
9374 /* If the section being dumped has relocations against it the user might
9375 be expecting these relocations to have been applied. Check for this
9376 case and issue a warning message in order to avoid confusion.
9377 FIXME: Maybe we ought to have an option that dumps a section with
9378 relocs applied ? */
9379 for (relsec = section_headers;
9380 relsec < section_headers + elf_header.e_shnum;
9381 ++relsec)
9382 {
9383 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9384 || relsec->sh_info >= elf_header.e_shnum
9385 || section_headers + relsec->sh_info != section
9386 || relsec->sh_size == 0
9387 || relsec->sh_link >= elf_header.e_shnum)
9388 continue;
9389
9390 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9391 break;
9392 }
9393
9394 num_bytes = section->sh_size;
9395 data = start;
9396 end = start + num_bytes;
9397 some_strings_shown = FALSE;
9398
9399 while (data < end)
9400 {
9401 while (!ISPRINT (* data))
9402 if (++ data >= end)
9403 break;
9404
9405 if (data < end)
9406 {
9407 #ifndef __MSVCRT__
9408 /* PR 11128: Use two separate invocations in order to work
9409 around bugs in the Solaris 8 implementation of printf. */
9410 printf (" [%6tx] ", data - start);
9411 printf ("%s\n", data);
9412 #else
9413 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
9414 #endif
9415 data += strlen (data);
9416 some_strings_shown = TRUE;
9417 }
9418 }
9419
9420 if (! some_strings_shown)
9421 printf (_(" No strings found in this section."));
9422
9423 free (start);
9424
9425 putchar ('\n');
9426 }
9427
9428 static void
9429 dump_section_as_bytes (Elf_Internal_Shdr * section,
9430 FILE * file,
9431 bfd_boolean relocate)
9432 {
9433 Elf_Internal_Shdr * relsec;
9434 bfd_size_type bytes;
9435 bfd_vma addr;
9436 unsigned char * data;
9437 unsigned char * start;
9438
9439 start = (unsigned char *) get_section_contents (section, file);
9440 if (start == NULL)
9441 return;
9442
9443 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
9444
9445 if (relocate)
9446 {
9447 apply_relocations (file, section, start);
9448 }
9449 else
9450 {
9451 /* If the section being dumped has relocations against it the user might
9452 be expecting these relocations to have been applied. Check for this
9453 case and issue a warning message in order to avoid confusion.
9454 FIXME: Maybe we ought to have an option that dumps a section with
9455 relocs applied ? */
9456 for (relsec = section_headers;
9457 relsec < section_headers + elf_header.e_shnum;
9458 ++relsec)
9459 {
9460 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9461 || relsec->sh_info >= elf_header.e_shnum
9462 || section_headers + relsec->sh_info != section
9463 || relsec->sh_size == 0
9464 || relsec->sh_link >= elf_header.e_shnum)
9465 continue;
9466
9467 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9468 break;
9469 }
9470 }
9471
9472 addr = section->sh_addr;
9473 bytes = section->sh_size;
9474 data = start;
9475
9476 while (bytes)
9477 {
9478 int j;
9479 int k;
9480 int lbytes;
9481
9482 lbytes = (bytes > 16 ? 16 : bytes);
9483
9484 printf (" 0x%8.8lx ", (unsigned long) addr);
9485
9486 for (j = 0; j < 16; j++)
9487 {
9488 if (j < lbytes)
9489 printf ("%2.2x", data[j]);
9490 else
9491 printf (" ");
9492
9493 if ((j & 3) == 3)
9494 printf (" ");
9495 }
9496
9497 for (j = 0; j < lbytes; j++)
9498 {
9499 k = data[j];
9500 if (k >= ' ' && k < 0x7f)
9501 printf ("%c", k);
9502 else
9503 printf (".");
9504 }
9505
9506 putchar ('\n');
9507
9508 data += lbytes;
9509 addr += lbytes;
9510 bytes -= lbytes;
9511 }
9512
9513 free (start);
9514
9515 putchar ('\n');
9516 }
9517
9518 /* Uncompresses a section that was compressed using zlib, in place.
9519 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
9520
9521 static int
9522 uncompress_section_contents (unsigned char ** buffer, dwarf_size_type * size)
9523 {
9524 #ifndef HAVE_ZLIB_H
9525 /* These are just to quiet gcc. */
9526 buffer = 0;
9527 size = 0;
9528 return FALSE;
9529 #else
9530 dwarf_size_type compressed_size = *size;
9531 unsigned char * compressed_buffer = *buffer;
9532 dwarf_size_type uncompressed_size;
9533 unsigned char * uncompressed_buffer;
9534 z_stream strm;
9535 int rc;
9536 dwarf_size_type header_size = 12;
9537
9538 /* Read the zlib header. In this case, it should be "ZLIB" followed
9539 by the uncompressed section size, 8 bytes in big-endian order. */
9540 if (compressed_size < header_size
9541 || ! streq ((char *) compressed_buffer, "ZLIB"))
9542 return 0;
9543
9544 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
9545 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
9546 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
9547 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
9548 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
9549 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
9550 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
9551 uncompressed_size += compressed_buffer[11];
9552
9553 /* It is possible the section consists of several compressed
9554 buffers concatenated together, so we uncompress in a loop. */
9555 strm.zalloc = NULL;
9556 strm.zfree = NULL;
9557 strm.opaque = NULL;
9558 strm.avail_in = compressed_size - header_size;
9559 strm.next_in = (Bytef *) compressed_buffer + header_size;
9560 strm.avail_out = uncompressed_size;
9561 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
9562
9563 rc = inflateInit (& strm);
9564 while (strm.avail_in > 0)
9565 {
9566 if (rc != Z_OK)
9567 goto fail;
9568 strm.next_out = ((Bytef *) uncompressed_buffer
9569 + (uncompressed_size - strm.avail_out));
9570 rc = inflate (&strm, Z_FINISH);
9571 if (rc != Z_STREAM_END)
9572 goto fail;
9573 rc = inflateReset (& strm);
9574 }
9575 rc = inflateEnd (& strm);
9576 if (rc != Z_OK
9577 || strm.avail_out != 0)
9578 goto fail;
9579
9580 free (compressed_buffer);
9581 *buffer = uncompressed_buffer;
9582 *size = uncompressed_size;
9583 return 1;
9584
9585 fail:
9586 free (uncompressed_buffer);
9587 return 0;
9588 #endif /* HAVE_ZLIB_H */
9589 }
9590
9591 static int
9592 load_specific_debug_section (enum dwarf_section_display_enum debug,
9593 Elf_Internal_Shdr * sec, void * file)
9594 {
9595 struct dwarf_section * section = &debug_displays [debug].section;
9596 char buf [64];
9597 int section_is_compressed;
9598
9599 /* If it is already loaded, do nothing. */
9600 if (section->start != NULL)
9601 return 1;
9602
9603 section_is_compressed = section->name == section->compressed_name;
9604
9605 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
9606 section->address = sec->sh_addr;
9607 section->size = sec->sh_size;
9608 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
9609 sec->sh_offset, 1,
9610 sec->sh_size, buf);
9611 if (section->start == NULL)
9612 return 0;
9613
9614 if (section_is_compressed)
9615 if (! uncompress_section_contents (&section->start, &section->size))
9616 return 0;
9617
9618 if (debug_displays [debug].relocate)
9619 apply_relocations ((FILE *) file, sec, section->start);
9620
9621 return 1;
9622 }
9623
9624 int
9625 load_debug_section (enum dwarf_section_display_enum debug, void * file)
9626 {
9627 struct dwarf_section * section = &debug_displays [debug].section;
9628 Elf_Internal_Shdr * sec;
9629
9630 /* Locate the debug section. */
9631 sec = find_section (section->uncompressed_name);
9632 if (sec != NULL)
9633 section->name = section->uncompressed_name;
9634 else
9635 {
9636 sec = find_section (section->compressed_name);
9637 if (sec != NULL)
9638 section->name = section->compressed_name;
9639 }
9640 if (sec == NULL)
9641 return 0;
9642
9643 return load_specific_debug_section (debug, sec, (FILE *) file);
9644 }
9645
9646 void
9647 free_debug_section (enum dwarf_section_display_enum debug)
9648 {
9649 struct dwarf_section * section = &debug_displays [debug].section;
9650
9651 if (section->start == NULL)
9652 return;
9653
9654 free ((char *) section->start);
9655 section->start = NULL;
9656 section->address = 0;
9657 section->size = 0;
9658 }
9659
9660 static int
9661 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
9662 {
9663 char * name = SECTION_NAME (section);
9664 bfd_size_type length;
9665 int result = 1;
9666 int i;
9667
9668 length = section->sh_size;
9669 if (length == 0)
9670 {
9671 printf (_("\nSection '%s' has no debugging data.\n"), name);
9672 return 0;
9673 }
9674 if (section->sh_type == SHT_NOBITS)
9675 {
9676 /* There is no point in dumping the contents of a debugging section
9677 which has the NOBITS type - the bits in the file will be random.
9678 This can happen when a file containing a .eh_frame section is
9679 stripped with the --only-keep-debug command line option. */
9680 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
9681 return 0;
9682 }
9683
9684 if (const_strneq (name, ".gnu.linkonce.wi."))
9685 name = ".debug_info";
9686
9687 /* See if we know how to display the contents of this section. */
9688 for (i = 0; i < max; i++)
9689 if (streq (debug_displays[i].section.uncompressed_name, name)
9690 || streq (debug_displays[i].section.compressed_name, name))
9691 {
9692 struct dwarf_section * sec = &debug_displays [i].section;
9693 int secondary = (section != find_section (name));
9694
9695 if (secondary)
9696 free_debug_section ((enum dwarf_section_display_enum) i);
9697
9698 if (streq (sec->uncompressed_name, name))
9699 sec->name = sec->uncompressed_name;
9700 else
9701 sec->name = sec->compressed_name;
9702 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
9703 section, file))
9704 {
9705 result &= debug_displays[i].display (sec, file);
9706
9707 if (secondary || (i != info && i != abbrev))
9708 free_debug_section ((enum dwarf_section_display_enum) i);
9709 }
9710
9711 break;
9712 }
9713
9714 if (i == max)
9715 {
9716 printf (_("Unrecognized debug section: %s\n"), name);
9717 result = 0;
9718 }
9719
9720 return result;
9721 }
9722
9723 /* Set DUMP_SECTS for all sections where dumps were requested
9724 based on section name. */
9725
9726 static void
9727 initialise_dumps_byname (void)
9728 {
9729 struct dump_list_entry * cur;
9730
9731 for (cur = dump_sects_byname; cur; cur = cur->next)
9732 {
9733 unsigned int i;
9734 int any;
9735
9736 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
9737 if (streq (SECTION_NAME (section_headers + i), cur->name))
9738 {
9739 request_dump_bynumber (i, cur->type);
9740 any = 1;
9741 }
9742
9743 if (!any)
9744 warn (_("Section '%s' was not dumped because it does not exist!\n"),
9745 cur->name);
9746 }
9747 }
9748
9749 static void
9750 process_section_contents (FILE * file)
9751 {
9752 Elf_Internal_Shdr * section;
9753 unsigned int i;
9754
9755 if (! do_dump)
9756 return;
9757
9758 initialise_dumps_byname ();
9759
9760 for (i = 0, section = section_headers;
9761 i < elf_header.e_shnum && i < num_dump_sects;
9762 i++, section++)
9763 {
9764 #ifdef SUPPORT_DISASSEMBLY
9765 if (dump_sects[i] & DISASS_DUMP)
9766 disassemble_section (section, file);
9767 #endif
9768 if (dump_sects[i] & HEX_DUMP)
9769 dump_section_as_bytes (section, file, FALSE);
9770
9771 if (dump_sects[i] & RELOC_DUMP)
9772 dump_section_as_bytes (section, file, TRUE);
9773
9774 if (dump_sects[i] & STRING_DUMP)
9775 dump_section_as_strings (section, file);
9776
9777 if (dump_sects[i] & DEBUG_DUMP)
9778 display_debug_section (section, file);
9779 }
9780
9781 /* Check to see if the user requested a
9782 dump of a section that does not exist. */
9783 while (i++ < num_dump_sects)
9784 if (dump_sects[i])
9785 warn (_("Section %d was not dumped because it does not exist!\n"), i);
9786 }
9787
9788 static void
9789 process_mips_fpe_exception (int mask)
9790 {
9791 if (mask)
9792 {
9793 int first = 1;
9794 if (mask & OEX_FPU_INEX)
9795 fputs ("INEX", stdout), first = 0;
9796 if (mask & OEX_FPU_UFLO)
9797 printf ("%sUFLO", first ? "" : "|"), first = 0;
9798 if (mask & OEX_FPU_OFLO)
9799 printf ("%sOFLO", first ? "" : "|"), first = 0;
9800 if (mask & OEX_FPU_DIV0)
9801 printf ("%sDIV0", first ? "" : "|"), first = 0;
9802 if (mask & OEX_FPU_INVAL)
9803 printf ("%sINVAL", first ? "" : "|");
9804 }
9805 else
9806 fputs ("0", stdout);
9807 }
9808
9809 /* ARM EABI attributes section. */
9810 typedef struct
9811 {
9812 int tag;
9813 const char * name;
9814 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
9815 int type;
9816 const char ** table;
9817 } arm_attr_public_tag;
9818
9819 static const char * arm_attr_tag_CPU_arch[] =
9820 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9821 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
9822 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
9823 static const char * arm_attr_tag_THUMB_ISA_use[] =
9824 {"No", "Thumb-1", "Thumb-2"};
9825 static const char * arm_attr_tag_FP_arch[] =
9826 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
9827 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
9828 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
9829 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
9830 static const char * arm_attr_tag_PCS_config[] =
9831 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
9832 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
9833 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
9834 {"V6", "SB", "TLS", "Unused"};
9835 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
9836 {"Absolute", "PC-relative", "SB-relative", "None"};
9837 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
9838 {"Absolute", "PC-relative", "None"};
9839 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
9840 {"None", "direct", "GOT-indirect"};
9841 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
9842 {"None", "??? 1", "2", "??? 3", "4"};
9843 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
9844 static const char * arm_attr_tag_ABI_FP_denormal[] =
9845 {"Unused", "Needed", "Sign only"};
9846 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
9847 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
9848 static const char * arm_attr_tag_ABI_FP_number_model[] =
9849 {"Unused", "Finite", "RTABI", "IEEE 754"};
9850 static const char * arm_attr_tag_ABI_enum_size[] =
9851 {"Unused", "small", "int", "forced to int"};
9852 static const char * arm_attr_tag_ABI_HardFP_use[] =
9853 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
9854 static const char * arm_attr_tag_ABI_VFP_args[] =
9855 {"AAPCS", "VFP registers", "custom"};
9856 static const char * arm_attr_tag_ABI_WMMX_args[] =
9857 {"AAPCS", "WMMX registers", "custom"};
9858 static const char * arm_attr_tag_ABI_optimization_goals[] =
9859 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9860 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
9861 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
9862 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9863 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
9864 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
9865 static const char * arm_attr_tag_FP_HP_extension[] =
9866 {"Not Allowed", "Allowed"};
9867 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
9868 {"None", "IEEE 754", "Alternative Format"};
9869 static const char * arm_attr_tag_MPextension_use[] =
9870 {"Not Allowed", "Allowed"};
9871 static const char * arm_attr_tag_DIV_use[] =
9872 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
9873 "Allowed in v7-A with integer division extension"};
9874 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
9875 static const char * arm_attr_tag_Virtualization_use[] =
9876 {"Not Allowed", "TrustZone", "Virtualization Extensions",
9877 "TrustZone and Virtualization Extensions"};
9878 static const char * arm_attr_tag_MPextension_use_legacy[] =
9879 {"Not Allowed", "Allowed"};
9880
9881 #define LOOKUP(id, name) \
9882 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9883 static arm_attr_public_tag arm_attr_public_tags[] =
9884 {
9885 {4, "CPU_raw_name", 1, NULL},
9886 {5, "CPU_name", 1, NULL},
9887 LOOKUP(6, CPU_arch),
9888 {7, "CPU_arch_profile", 0, NULL},
9889 LOOKUP(8, ARM_ISA_use),
9890 LOOKUP(9, THUMB_ISA_use),
9891 LOOKUP(10, FP_arch),
9892 LOOKUP(11, WMMX_arch),
9893 LOOKUP(12, Advanced_SIMD_arch),
9894 LOOKUP(13, PCS_config),
9895 LOOKUP(14, ABI_PCS_R9_use),
9896 LOOKUP(15, ABI_PCS_RW_data),
9897 LOOKUP(16, ABI_PCS_RO_data),
9898 LOOKUP(17, ABI_PCS_GOT_use),
9899 LOOKUP(18, ABI_PCS_wchar_t),
9900 LOOKUP(19, ABI_FP_rounding),
9901 LOOKUP(20, ABI_FP_denormal),
9902 LOOKUP(21, ABI_FP_exceptions),
9903 LOOKUP(22, ABI_FP_user_exceptions),
9904 LOOKUP(23, ABI_FP_number_model),
9905 {24, "ABI_align_needed", 0, NULL},
9906 {25, "ABI_align_preserved", 0, NULL},
9907 LOOKUP(26, ABI_enum_size),
9908 LOOKUP(27, ABI_HardFP_use),
9909 LOOKUP(28, ABI_VFP_args),
9910 LOOKUP(29, ABI_WMMX_args),
9911 LOOKUP(30, ABI_optimization_goals),
9912 LOOKUP(31, ABI_FP_optimization_goals),
9913 {32, "compatibility", 0, NULL},
9914 LOOKUP(34, CPU_unaligned_access),
9915 LOOKUP(36, FP_HP_extension),
9916 LOOKUP(38, ABI_FP_16bit_format),
9917 LOOKUP(42, MPextension_use),
9918 LOOKUP(44, DIV_use),
9919 {64, "nodefaults", 0, NULL},
9920 {65, "also_compatible_with", 0, NULL},
9921 LOOKUP(66, T2EE_use),
9922 {67, "conformance", 1, NULL},
9923 LOOKUP(68, Virtualization_use),
9924 LOOKUP(70, MPextension_use_legacy)
9925 };
9926 #undef LOOKUP
9927
9928 static unsigned char *
9929 display_arm_attribute (unsigned char * p)
9930 {
9931 int tag;
9932 unsigned int len;
9933 int val;
9934 arm_attr_public_tag * attr;
9935 unsigned i;
9936 int type;
9937
9938 tag = read_uleb128 (p, &len);
9939 p += len;
9940 attr = NULL;
9941 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
9942 {
9943 if (arm_attr_public_tags[i].tag == tag)
9944 {
9945 attr = &arm_attr_public_tags[i];
9946 break;
9947 }
9948 }
9949
9950 if (attr)
9951 {
9952 printf (" Tag_%s: ", attr->name);
9953 switch (attr->type)
9954 {
9955 case 0:
9956 switch (tag)
9957 {
9958 case 7: /* Tag_CPU_arch_profile. */
9959 val = read_uleb128 (p, &len);
9960 p += len;
9961 switch (val)
9962 {
9963 case 0: printf (_("None\n")); break;
9964 case 'A': printf (_("Application\n")); break;
9965 case 'R': printf (_("Realtime\n")); break;
9966 case 'M': printf (_("Microcontroller\n")); break;
9967 case 'S': printf (_("Application or Realtime\n")); break;
9968 default: printf ("??? (%d)\n", val); break;
9969 }
9970 break;
9971
9972 case 24: /* Tag_align_needed. */
9973 val = read_uleb128 (p, &len);
9974 p += len;
9975 switch (val)
9976 {
9977 case 0: printf (_("None\n")); break;
9978 case 1: printf (_("8-byte\n")); break;
9979 case 2: printf (_("4-byte\n")); break;
9980 case 3: printf ("??? 3\n"); break;
9981 default:
9982 if (val <= 12)
9983 printf (_("8-byte and up to %d-byte extended\n"),
9984 1 << val);
9985 else
9986 printf ("??? (%d)\n", val);
9987 break;
9988 }
9989 break;
9990
9991 case 25: /* Tag_align_preserved. */
9992 val = read_uleb128 (p, &len);
9993 p += len;
9994 switch (val)
9995 {
9996 case 0: printf (_("None\n")); break;
9997 case 1: printf (_("8-byte, except leaf SP\n")); break;
9998 case 2: printf (_("8-byte\n")); break;
9999 case 3: printf ("??? 3\n"); break;
10000 default:
10001 if (val <= 12)
10002 printf (_("8-byte and up to %d-byte extended\n"),
10003 1 << val);
10004 else
10005 printf ("??? (%d)\n", val);
10006 break;
10007 }
10008 break;
10009
10010 case 32: /* Tag_compatibility. */
10011 val = read_uleb128 (p, &len);
10012 p += len;
10013 printf (_("flag = %d, vendor = %s\n"), val, p);
10014 p += strlen ((char *) p) + 1;
10015 break;
10016
10017 case 64: /* Tag_nodefaults. */
10018 p++;
10019 printf (_("True\n"));
10020 break;
10021
10022 case 65: /* Tag_also_compatible_with. */
10023 val = read_uleb128 (p, &len);
10024 p += len;
10025 if (val == 6 /* Tag_CPU_arch. */)
10026 {
10027 val = read_uleb128 (p, &len);
10028 p += len;
10029 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
10030 printf ("??? (%d)\n", val);
10031 else
10032 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10033 }
10034 else
10035 printf ("???\n");
10036 while (*(p++) != '\0' /* NUL terminator. */);
10037 break;
10038
10039 default:
10040 abort ();
10041 }
10042 return p;
10043
10044 case 1:
10045 case 2:
10046 type = attr->type;
10047 break;
10048
10049 default:
10050 assert (attr->type & 0x80);
10051 val = read_uleb128 (p, &len);
10052 p += len;
10053 type = attr->type & 0x7f;
10054 if (val >= type)
10055 printf ("??? (%d)\n", val);
10056 else
10057 printf ("%s\n", attr->table[val]);
10058 return p;
10059 }
10060 }
10061 else
10062 {
10063 if (tag & 1)
10064 type = 1; /* String. */
10065 else
10066 type = 2; /* uleb128. */
10067 printf (" Tag_unknown_%d: ", tag);
10068 }
10069
10070 if (type == 1)
10071 {
10072 printf ("\"%s\"\n", p);
10073 p += strlen ((char *) p) + 1;
10074 }
10075 else
10076 {
10077 val = read_uleb128 (p, &len);
10078 p += len;
10079 printf ("%d (0x%x)\n", val, val);
10080 }
10081
10082 return p;
10083 }
10084
10085 static unsigned char *
10086 display_gnu_attribute (unsigned char * p,
10087 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10088 {
10089 int tag;
10090 unsigned int len;
10091 int val;
10092 int type;
10093
10094 tag = read_uleb128 (p, &len);
10095 p += len;
10096
10097 /* Tag_compatibility is the only generic GNU attribute defined at
10098 present. */
10099 if (tag == 32)
10100 {
10101 val = read_uleb128 (p, &len);
10102 p += len;
10103 printf (_("flag = %d, vendor = %s\n"), val, p);
10104 p += strlen ((char *) p) + 1;
10105 return p;
10106 }
10107
10108 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10109 return display_proc_gnu_attribute (p, tag);
10110
10111 if (tag & 1)
10112 type = 1; /* String. */
10113 else
10114 type = 2; /* uleb128. */
10115 printf (" Tag_unknown_%d: ", tag);
10116
10117 if (type == 1)
10118 {
10119 printf ("\"%s\"\n", p);
10120 p += strlen ((char *) p) + 1;
10121 }
10122 else
10123 {
10124 val = read_uleb128 (p, &len);
10125 p += len;
10126 printf ("%d (0x%x)\n", val, val);
10127 }
10128
10129 return p;
10130 }
10131
10132 static unsigned char *
10133 display_power_gnu_attribute (unsigned char * p, int tag)
10134 {
10135 int type;
10136 unsigned int len;
10137 int val;
10138
10139 if (tag == Tag_GNU_Power_ABI_FP)
10140 {
10141 val = read_uleb128 (p, &len);
10142 p += len;
10143 printf (" Tag_GNU_Power_ABI_FP: ");
10144
10145 switch (val)
10146 {
10147 case 0:
10148 printf (_("Hard or soft float\n"));
10149 break;
10150 case 1:
10151 printf (_("Hard float\n"));
10152 break;
10153 case 2:
10154 printf (_("Soft float\n"));
10155 break;
10156 case 3:
10157 printf (_("Single-precision hard float\n"));
10158 break;
10159 default:
10160 printf ("??? (%d)\n", val);
10161 break;
10162 }
10163 return p;
10164 }
10165
10166 if (tag == Tag_GNU_Power_ABI_Vector)
10167 {
10168 val = read_uleb128 (p, &len);
10169 p += len;
10170 printf (" Tag_GNU_Power_ABI_Vector: ");
10171 switch (val)
10172 {
10173 case 0:
10174 printf (_("Any\n"));
10175 break;
10176 case 1:
10177 printf (_("Generic\n"));
10178 break;
10179 case 2:
10180 printf ("AltiVec\n");
10181 break;
10182 case 3:
10183 printf ("SPE\n");
10184 break;
10185 default:
10186 printf ("??? (%d)\n", val);
10187 break;
10188 }
10189 return p;
10190 }
10191
10192 if (tag == Tag_GNU_Power_ABI_Struct_Return)
10193 {
10194 val = read_uleb128 (p, &len);
10195 p += len;
10196 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10197 switch (val)
10198 {
10199 case 0:
10200 printf (_("Any\n"));
10201 break;
10202 case 1:
10203 printf ("r3/r4\n");
10204 break;
10205 case 2:
10206 printf (_("Memory\n"));
10207 break;
10208 default:
10209 printf ("??? (%d)\n", val);
10210 break;
10211 }
10212 return p;
10213 }
10214
10215 if (tag & 1)
10216 type = 1; /* String. */
10217 else
10218 type = 2; /* uleb128. */
10219 printf (" Tag_unknown_%d: ", tag);
10220
10221 if (type == 1)
10222 {
10223 printf ("\"%s\"\n", p);
10224 p += strlen ((char *) p) + 1;
10225 }
10226 else
10227 {
10228 val = read_uleb128 (p, &len);
10229 p += len;
10230 printf ("%d (0x%x)\n", val, val);
10231 }
10232
10233 return p;
10234 }
10235
10236 static unsigned char *
10237 display_mips_gnu_attribute (unsigned char * p, int tag)
10238 {
10239 int type;
10240 unsigned int len;
10241 int val;
10242
10243 if (tag == Tag_GNU_MIPS_ABI_FP)
10244 {
10245 val = read_uleb128 (p, &len);
10246 p += len;
10247 printf (" Tag_GNU_MIPS_ABI_FP: ");
10248
10249 switch (val)
10250 {
10251 case 0:
10252 printf (_("Hard or soft float\n"));
10253 break;
10254 case 1:
10255 printf (_("Hard float (double precision)\n"));
10256 break;
10257 case 2:
10258 printf (_("Hard float (single precision)\n"));
10259 break;
10260 case 3:
10261 printf (_("Soft float\n"));
10262 break;
10263 case 4:
10264 printf (_("64-bit float (-mips32r2 -mfp64)\n"));
10265 break;
10266 default:
10267 printf ("??? (%d)\n", val);
10268 break;
10269 }
10270 return p;
10271 }
10272
10273 if (tag & 1)
10274 type = 1; /* String. */
10275 else
10276 type = 2; /* uleb128. */
10277 printf (" Tag_unknown_%d: ", tag);
10278
10279 if (type == 1)
10280 {
10281 printf ("\"%s\"\n", p);
10282 p += strlen ((char *) p) + 1;
10283 }
10284 else
10285 {
10286 val = read_uleb128 (p, &len);
10287 p += len;
10288 printf ("%d (0x%x)\n", val, val);
10289 }
10290
10291 return p;
10292 }
10293
10294 static int
10295 process_attributes (FILE * file,
10296 const char * public_name,
10297 unsigned int proc_type,
10298 unsigned char * (* display_pub_attribute) (unsigned char *),
10299 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10300 {
10301 Elf_Internal_Shdr * sect;
10302 unsigned char * contents;
10303 unsigned char * p;
10304 unsigned char * end;
10305 bfd_vma section_len;
10306 bfd_vma len;
10307 unsigned i;
10308
10309 /* Find the section header so that we get the size. */
10310 for (i = 0, sect = section_headers;
10311 i < elf_header.e_shnum;
10312 i++, sect++)
10313 {
10314 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
10315 continue;
10316
10317 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
10318 sect->sh_size, _("attributes"));
10319 if (contents == NULL)
10320 continue;
10321
10322 p = contents;
10323 if (*p == 'A')
10324 {
10325 len = sect->sh_size - 1;
10326 p++;
10327
10328 while (len > 0)
10329 {
10330 int namelen;
10331 bfd_boolean public_section;
10332 bfd_boolean gnu_section;
10333
10334 section_len = byte_get (p, 4);
10335 p += 4;
10336
10337 if (section_len > len)
10338 {
10339 printf (_("ERROR: Bad section length (%d > %d)\n"),
10340 (int) section_len, (int) len);
10341 section_len = len;
10342 }
10343
10344 len -= section_len;
10345 printf (_("Attribute Section: %s\n"), p);
10346
10347 if (public_name && streq ((char *) p, public_name))
10348 public_section = TRUE;
10349 else
10350 public_section = FALSE;
10351
10352 if (streq ((char *) p, "gnu"))
10353 gnu_section = TRUE;
10354 else
10355 gnu_section = FALSE;
10356
10357 namelen = strlen ((char *) p) + 1;
10358 p += namelen;
10359 section_len -= namelen + 4;
10360
10361 while (section_len > 0)
10362 {
10363 int tag = *(p++);
10364 int val;
10365 bfd_vma size;
10366
10367 size = byte_get (p, 4);
10368 if (size > section_len)
10369 {
10370 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
10371 (int) size, (int) section_len);
10372 size = section_len;
10373 }
10374
10375 section_len -= size;
10376 end = p + size - 1;
10377 p += 4;
10378
10379 switch (tag)
10380 {
10381 case 1:
10382 printf (_("File Attributes\n"));
10383 break;
10384 case 2:
10385 printf (_("Section Attributes:"));
10386 goto do_numlist;
10387 case 3:
10388 printf (_("Symbol Attributes:"));
10389 do_numlist:
10390 for (;;)
10391 {
10392 unsigned int j;
10393
10394 val = read_uleb128 (p, &j);
10395 p += j;
10396 if (val == 0)
10397 break;
10398 printf (" %d", val);
10399 }
10400 printf ("\n");
10401 break;
10402 default:
10403 printf (_("Unknown tag: %d\n"), tag);
10404 public_section = FALSE;
10405 break;
10406 }
10407
10408 if (public_section)
10409 {
10410 while (p < end)
10411 p = display_pub_attribute (p);
10412 }
10413 else if (gnu_section)
10414 {
10415 while (p < end)
10416 p = display_gnu_attribute (p,
10417 display_proc_gnu_attribute);
10418 }
10419 else
10420 {
10421 /* ??? Do something sensible, like dump hex. */
10422 printf (_(" Unknown section contexts\n"));
10423 p = end;
10424 }
10425 }
10426 }
10427 }
10428 else
10429 printf (_("Unknown format '%c'\n"), *p);
10430
10431 free (contents);
10432 }
10433 return 1;
10434 }
10435
10436 static int
10437 process_arm_specific (FILE * file)
10438 {
10439 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
10440 display_arm_attribute, NULL);
10441 }
10442
10443 static int
10444 process_power_specific (FILE * file)
10445 {
10446 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
10447 display_power_gnu_attribute);
10448 }
10449
10450 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
10451 Print the Address, Access and Initial fields of an entry at VMA ADDR
10452 and return the VMA of the next entry. */
10453
10454 static bfd_vma
10455 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
10456 {
10457 printf (" ");
10458 print_vma (addr, LONG_HEX);
10459 printf (" ");
10460 if (addr < pltgot + 0xfff0)
10461 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
10462 else
10463 printf ("%10s", "");
10464 printf (" ");
10465 if (data == NULL)
10466 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
10467 else
10468 {
10469 bfd_vma entry;
10470
10471 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
10472 print_vma (entry, LONG_HEX);
10473 }
10474 return addr + (is_32bit_elf ? 4 : 8);
10475 }
10476
10477 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
10478 PLTGOT. Print the Address and Initial fields of an entry at VMA
10479 ADDR and return the VMA of the next entry. */
10480
10481 static bfd_vma
10482 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
10483 {
10484 printf (" ");
10485 print_vma (addr, LONG_HEX);
10486 printf (" ");
10487 if (data == NULL)
10488 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
10489 else
10490 {
10491 bfd_vma entry;
10492
10493 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
10494 print_vma (entry, LONG_HEX);
10495 }
10496 return addr + (is_32bit_elf ? 4 : 8);
10497 }
10498
10499 static int
10500 process_mips_specific (FILE * file)
10501 {
10502 Elf_Internal_Dyn * entry;
10503 size_t liblist_offset = 0;
10504 size_t liblistno = 0;
10505 size_t conflictsno = 0;
10506 size_t options_offset = 0;
10507 size_t conflicts_offset = 0;
10508 size_t pltrelsz = 0;
10509 size_t pltrel = 0;
10510 bfd_vma pltgot = 0;
10511 bfd_vma mips_pltgot = 0;
10512 bfd_vma jmprel = 0;
10513 bfd_vma local_gotno = 0;
10514 bfd_vma gotsym = 0;
10515 bfd_vma symtabno = 0;
10516
10517 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
10518 display_mips_gnu_attribute);
10519
10520 /* We have a lot of special sections. Thanks SGI! */
10521 if (dynamic_section == NULL)
10522 /* No information available. */
10523 return 0;
10524
10525 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
10526 switch (entry->d_tag)
10527 {
10528 case DT_MIPS_LIBLIST:
10529 liblist_offset
10530 = offset_from_vma (file, entry->d_un.d_val,
10531 liblistno * sizeof (Elf32_External_Lib));
10532 break;
10533 case DT_MIPS_LIBLISTNO:
10534 liblistno = entry->d_un.d_val;
10535 break;
10536 case DT_MIPS_OPTIONS:
10537 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
10538 break;
10539 case DT_MIPS_CONFLICT:
10540 conflicts_offset
10541 = offset_from_vma (file, entry->d_un.d_val,
10542 conflictsno * sizeof (Elf32_External_Conflict));
10543 break;
10544 case DT_MIPS_CONFLICTNO:
10545 conflictsno = entry->d_un.d_val;
10546 break;
10547 case DT_PLTGOT:
10548 pltgot = entry->d_un.d_ptr;
10549 break;
10550 case DT_MIPS_LOCAL_GOTNO:
10551 local_gotno = entry->d_un.d_val;
10552 break;
10553 case DT_MIPS_GOTSYM:
10554 gotsym = entry->d_un.d_val;
10555 break;
10556 case DT_MIPS_SYMTABNO:
10557 symtabno = entry->d_un.d_val;
10558 break;
10559 case DT_MIPS_PLTGOT:
10560 mips_pltgot = entry->d_un.d_ptr;
10561 break;
10562 case DT_PLTREL:
10563 pltrel = entry->d_un.d_val;
10564 break;
10565 case DT_PLTRELSZ:
10566 pltrelsz = entry->d_un.d_val;
10567 break;
10568 case DT_JMPREL:
10569 jmprel = entry->d_un.d_ptr;
10570 break;
10571 default:
10572 break;
10573 }
10574
10575 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
10576 {
10577 Elf32_External_Lib * elib;
10578 size_t cnt;
10579
10580 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
10581 liblistno,
10582 sizeof (Elf32_External_Lib),
10583 _("liblist"));
10584 if (elib)
10585 {
10586 printf (_("\nSection '.liblist' contains %lu entries:\n"),
10587 (unsigned long) liblistno);
10588 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
10589 stdout);
10590
10591 for (cnt = 0; cnt < liblistno; ++cnt)
10592 {
10593 Elf32_Lib liblist;
10594 time_t atime;
10595 char timebuf[20];
10596 struct tm * tmp;
10597
10598 liblist.l_name = BYTE_GET (elib[cnt].l_name);
10599 atime = BYTE_GET (elib[cnt].l_time_stamp);
10600 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
10601 liblist.l_version = BYTE_GET (elib[cnt].l_version);
10602 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
10603
10604 tmp = gmtime (&atime);
10605 snprintf (timebuf, sizeof (timebuf),
10606 "%04u-%02u-%02uT%02u:%02u:%02u",
10607 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10608 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10609
10610 printf ("%3lu: ", (unsigned long) cnt);
10611 if (VALID_DYNAMIC_NAME (liblist.l_name))
10612 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
10613 else
10614 printf (_("<corrupt: %9ld>"), liblist.l_name);
10615 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
10616 liblist.l_version);
10617
10618 if (liblist.l_flags == 0)
10619 puts (_(" NONE"));
10620 else
10621 {
10622 static const struct
10623 {
10624 const char * name;
10625 int bit;
10626 }
10627 l_flags_vals[] =
10628 {
10629 { " EXACT_MATCH", LL_EXACT_MATCH },
10630 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
10631 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
10632 { " EXPORTS", LL_EXPORTS },
10633 { " DELAY_LOAD", LL_DELAY_LOAD },
10634 { " DELTA", LL_DELTA }
10635 };
10636 int flags = liblist.l_flags;
10637 size_t fcnt;
10638
10639 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
10640 if ((flags & l_flags_vals[fcnt].bit) != 0)
10641 {
10642 fputs (l_flags_vals[fcnt].name, stdout);
10643 flags ^= l_flags_vals[fcnt].bit;
10644 }
10645 if (flags != 0)
10646 printf (" %#x", (unsigned int) flags);
10647
10648 puts ("");
10649 }
10650 }
10651
10652 free (elib);
10653 }
10654 }
10655
10656 if (options_offset != 0)
10657 {
10658 Elf_External_Options * eopt;
10659 Elf_Internal_Shdr * sect = section_headers;
10660 Elf_Internal_Options * iopt;
10661 Elf_Internal_Options * option;
10662 size_t offset;
10663 int cnt;
10664
10665 /* Find the section header so that we get the size. */
10666 while (sect->sh_type != SHT_MIPS_OPTIONS)
10667 ++sect;
10668
10669 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
10670 sect->sh_size, _("options"));
10671 if (eopt)
10672 {
10673 iopt = (Elf_Internal_Options *)
10674 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
10675 if (iopt == NULL)
10676 {
10677 error (_("Out of memory\n"));
10678 return 0;
10679 }
10680
10681 offset = cnt = 0;
10682 option = iopt;
10683
10684 while (offset < sect->sh_size)
10685 {
10686 Elf_External_Options * eoption;
10687
10688 eoption = (Elf_External_Options *) ((char *) eopt + offset);
10689
10690 option->kind = BYTE_GET (eoption->kind);
10691 option->size = BYTE_GET (eoption->size);
10692 option->section = BYTE_GET (eoption->section);
10693 option->info = BYTE_GET (eoption->info);
10694
10695 offset += option->size;
10696
10697 ++option;
10698 ++cnt;
10699 }
10700
10701 printf (_("\nSection '%s' contains %d entries:\n"),
10702 SECTION_NAME (sect), cnt);
10703
10704 option = iopt;
10705
10706 while (cnt-- > 0)
10707 {
10708 size_t len;
10709
10710 switch (option->kind)
10711 {
10712 case ODK_NULL:
10713 /* This shouldn't happen. */
10714 printf (" NULL %d %lx", option->section, option->info);
10715 break;
10716 case ODK_REGINFO:
10717 printf (" REGINFO ");
10718 if (elf_header.e_machine == EM_MIPS)
10719 {
10720 /* 32bit form. */
10721 Elf32_External_RegInfo * ereg;
10722 Elf32_RegInfo reginfo;
10723
10724 ereg = (Elf32_External_RegInfo *) (option + 1);
10725 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
10726 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
10727 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
10728 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
10729 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
10730 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
10731
10732 printf ("GPR %08lx GP 0x%lx\n",
10733 reginfo.ri_gprmask,
10734 (unsigned long) reginfo.ri_gp_value);
10735 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10736 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
10737 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
10738 }
10739 else
10740 {
10741 /* 64 bit form. */
10742 Elf64_External_RegInfo * ereg;
10743 Elf64_Internal_RegInfo reginfo;
10744
10745 ereg = (Elf64_External_RegInfo *) (option + 1);
10746 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
10747 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
10748 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
10749 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
10750 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
10751 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
10752
10753 printf ("GPR %08lx GP 0x",
10754 reginfo.ri_gprmask);
10755 printf_vma (reginfo.ri_gp_value);
10756 printf ("\n");
10757
10758 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10759 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
10760 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
10761 }
10762 ++option;
10763 continue;
10764 case ODK_EXCEPTIONS:
10765 fputs (" EXCEPTIONS fpe_min(", stdout);
10766 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
10767 fputs (") fpe_max(", stdout);
10768 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
10769 fputs (")", stdout);
10770
10771 if (option->info & OEX_PAGE0)
10772 fputs (" PAGE0", stdout);
10773 if (option->info & OEX_SMM)
10774 fputs (" SMM", stdout);
10775 if (option->info & OEX_FPDBUG)
10776 fputs (" FPDBUG", stdout);
10777 if (option->info & OEX_DISMISS)
10778 fputs (" DISMISS", stdout);
10779 break;
10780 case ODK_PAD:
10781 fputs (" PAD ", stdout);
10782 if (option->info & OPAD_PREFIX)
10783 fputs (" PREFIX", stdout);
10784 if (option->info & OPAD_POSTFIX)
10785 fputs (" POSTFIX", stdout);
10786 if (option->info & OPAD_SYMBOL)
10787 fputs (" SYMBOL", stdout);
10788 break;
10789 case ODK_HWPATCH:
10790 fputs (" HWPATCH ", stdout);
10791 if (option->info & OHW_R4KEOP)
10792 fputs (" R4KEOP", stdout);
10793 if (option->info & OHW_R8KPFETCH)
10794 fputs (" R8KPFETCH", stdout);
10795 if (option->info & OHW_R5KEOP)
10796 fputs (" R5KEOP", stdout);
10797 if (option->info & OHW_R5KCVTL)
10798 fputs (" R5KCVTL", stdout);
10799 break;
10800 case ODK_FILL:
10801 fputs (" FILL ", stdout);
10802 /* XXX Print content of info word? */
10803 break;
10804 case ODK_TAGS:
10805 fputs (" TAGS ", stdout);
10806 /* XXX Print content of info word? */
10807 break;
10808 case ODK_HWAND:
10809 fputs (" HWAND ", stdout);
10810 if (option->info & OHWA0_R4KEOP_CHECKED)
10811 fputs (" R4KEOP_CHECKED", stdout);
10812 if (option->info & OHWA0_R4KEOP_CLEAN)
10813 fputs (" R4KEOP_CLEAN", stdout);
10814 break;
10815 case ODK_HWOR:
10816 fputs (" HWOR ", stdout);
10817 if (option->info & OHWA0_R4KEOP_CHECKED)
10818 fputs (" R4KEOP_CHECKED", stdout);
10819 if (option->info & OHWA0_R4KEOP_CLEAN)
10820 fputs (" R4KEOP_CLEAN", stdout);
10821 break;
10822 case ODK_GP_GROUP:
10823 printf (" GP_GROUP %#06lx self-contained %#06lx",
10824 option->info & OGP_GROUP,
10825 (option->info & OGP_SELF) >> 16);
10826 break;
10827 case ODK_IDENT:
10828 printf (" IDENT %#06lx self-contained %#06lx",
10829 option->info & OGP_GROUP,
10830 (option->info & OGP_SELF) >> 16);
10831 break;
10832 default:
10833 /* This shouldn't happen. */
10834 printf (" %3d ??? %d %lx",
10835 option->kind, option->section, option->info);
10836 break;
10837 }
10838
10839 len = sizeof (* eopt);
10840 while (len < option->size)
10841 if (((char *) option)[len] >= ' '
10842 && ((char *) option)[len] < 0x7f)
10843 printf ("%c", ((char *) option)[len++]);
10844 else
10845 printf ("\\%03o", ((char *) option)[len++]);
10846
10847 fputs ("\n", stdout);
10848 ++option;
10849 }
10850
10851 free (eopt);
10852 }
10853 }
10854
10855 if (conflicts_offset != 0 && conflictsno != 0)
10856 {
10857 Elf32_Conflict * iconf;
10858 size_t cnt;
10859
10860 if (dynamic_symbols == NULL)
10861 {
10862 error (_("conflict list found without a dynamic symbol table\n"));
10863 return 0;
10864 }
10865
10866 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
10867 if (iconf == NULL)
10868 {
10869 error (_("Out of memory\n"));
10870 return 0;
10871 }
10872
10873 if (is_32bit_elf)
10874 {
10875 Elf32_External_Conflict * econf32;
10876
10877 econf32 = (Elf32_External_Conflict *)
10878 get_data (NULL, file, conflicts_offset, conflictsno,
10879 sizeof (* econf32), _("conflict"));
10880 if (!econf32)
10881 return 0;
10882
10883 for (cnt = 0; cnt < conflictsno; ++cnt)
10884 iconf[cnt] = BYTE_GET (econf32[cnt]);
10885
10886 free (econf32);
10887 }
10888 else
10889 {
10890 Elf64_External_Conflict * econf64;
10891
10892 econf64 = (Elf64_External_Conflict *)
10893 get_data (NULL, file, conflicts_offset, conflictsno,
10894 sizeof (* econf64), _("conflict"));
10895 if (!econf64)
10896 return 0;
10897
10898 for (cnt = 0; cnt < conflictsno; ++cnt)
10899 iconf[cnt] = BYTE_GET (econf64[cnt]);
10900
10901 free (econf64);
10902 }
10903
10904 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10905 (unsigned long) conflictsno);
10906 puts (_(" Num: Index Value Name"));
10907
10908 for (cnt = 0; cnt < conflictsno; ++cnt)
10909 {
10910 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
10911
10912 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
10913 print_vma (psym->st_value, FULL_HEX);
10914 putchar (' ');
10915 if (VALID_DYNAMIC_NAME (psym->st_name))
10916 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10917 else
10918 printf (_("<corrupt: %14ld>"), psym->st_name);
10919 putchar ('\n');
10920 }
10921
10922 free (iconf);
10923 }
10924
10925 if (pltgot != 0 && local_gotno != 0)
10926 {
10927 bfd_vma ent, local_end, global_end;
10928 size_t i, offset;
10929 unsigned char * data;
10930 int addr_size;
10931
10932 ent = pltgot;
10933 addr_size = (is_32bit_elf ? 4 : 8);
10934 local_end = pltgot + local_gotno * addr_size;
10935 global_end = local_end + (symtabno - gotsym) * addr_size;
10936
10937 offset = offset_from_vma (file, pltgot, global_end - pltgot);
10938 data = (unsigned char *) get_data (NULL, file, offset,
10939 global_end - pltgot, 1, _("GOT"));
10940 printf (_("\nPrimary GOT:\n"));
10941 printf (_(" Canonical gp value: "));
10942 print_vma (pltgot + 0x7ff0, LONG_HEX);
10943 printf ("\n\n");
10944
10945 printf (_(" Reserved entries:\n"));
10946 printf (_(" %*s %10s %*s Purpose\n"),
10947 addr_size * 2, _("Address"), _("Access"),
10948 addr_size * 2, _("Initial"));
10949 ent = print_mips_got_entry (data, pltgot, ent);
10950 printf (_(" Lazy resolver\n"));
10951 if (data
10952 && (byte_get (data + ent - pltgot, addr_size)
10953 >> (addr_size * 8 - 1)) != 0)
10954 {
10955 ent = print_mips_got_entry (data, pltgot, ent);
10956 printf (_(" Module pointer (GNU extension)\n"));
10957 }
10958 printf ("\n");
10959
10960 if (ent < local_end)
10961 {
10962 printf (_(" Local entries:\n"));
10963 printf (_(" %*s %10s %*s\n"),
10964 addr_size * 2, _("Address"), _("Access"),
10965 addr_size * 2, _("Initial"));
10966 while (ent < local_end)
10967 {
10968 ent = print_mips_got_entry (data, pltgot, ent);
10969 printf ("\n");
10970 }
10971 printf ("\n");
10972 }
10973
10974 if (gotsym < symtabno)
10975 {
10976 int sym_width;
10977
10978 printf (_(" Global entries:\n"));
10979 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
10980 addr_size * 2, _("Address"), _("Access"),
10981 addr_size * 2, _("Initial"),
10982 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
10983 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
10984 for (i = gotsym; i < symtabno; i++)
10985 {
10986 Elf_Internal_Sym * psym;
10987
10988 psym = dynamic_symbols + i;
10989 ent = print_mips_got_entry (data, pltgot, ent);
10990 printf (" ");
10991 print_vma (psym->st_value, LONG_HEX);
10992 printf (" %-7s %3s ",
10993 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
10994 get_symbol_index_type (psym->st_shndx));
10995 if (VALID_DYNAMIC_NAME (psym->st_name))
10996 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
10997 else
10998 printf (_("<corrupt: %14ld>"), psym->st_name);
10999 printf ("\n");
11000 }
11001 printf ("\n");
11002 }
11003
11004 if (data)
11005 free (data);
11006 }
11007
11008 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
11009 {
11010 bfd_vma ent, end;
11011 size_t offset, rel_offset;
11012 unsigned long count, i;
11013 unsigned char * data;
11014 int addr_size, sym_width;
11015 Elf_Internal_Rela * rels;
11016
11017 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
11018 if (pltrel == DT_RELA)
11019 {
11020 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
11021 return 0;
11022 }
11023 else
11024 {
11025 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
11026 return 0;
11027 }
11028
11029 ent = mips_pltgot;
11030 addr_size = (is_32bit_elf ? 4 : 8);
11031 end = mips_pltgot + (2 + count) * addr_size;
11032
11033 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
11034 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
11035 1, _("PLT GOT"));
11036 printf (_("\nPLT GOT:\n\n"));
11037 printf (_(" Reserved entries:\n"));
11038 printf (_(" %*s %*s Purpose\n"),
11039 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
11040 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11041 printf (_(" PLT lazy resolver\n"));
11042 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11043 printf (_(" Module pointer\n"));
11044 printf ("\n");
11045
11046 printf (_(" Entries:\n"));
11047 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
11048 addr_size * 2, _("Address"),
11049 addr_size * 2, _("Initial"),
11050 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11051 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
11052 for (i = 0; i < count; i++)
11053 {
11054 Elf_Internal_Sym * psym;
11055
11056 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
11057 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11058 printf (" ");
11059 print_vma (psym->st_value, LONG_HEX);
11060 printf (" %-7s %3s ",
11061 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11062 get_symbol_index_type (psym->st_shndx));
11063 if (VALID_DYNAMIC_NAME (psym->st_name))
11064 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11065 else
11066 printf (_("<corrupt: %14ld>"), psym->st_name);
11067 printf ("\n");
11068 }
11069 printf ("\n");
11070
11071 if (data)
11072 free (data);
11073 free (rels);
11074 }
11075
11076 return 1;
11077 }
11078
11079 static int
11080 process_gnu_liblist (FILE * file)
11081 {
11082 Elf_Internal_Shdr * section;
11083 Elf_Internal_Shdr * string_sec;
11084 Elf32_External_Lib * elib;
11085 char * strtab;
11086 size_t strtab_size;
11087 size_t cnt;
11088 unsigned i;
11089
11090 if (! do_arch)
11091 return 0;
11092
11093 for (i = 0, section = section_headers;
11094 i < elf_header.e_shnum;
11095 i++, section++)
11096 {
11097 switch (section->sh_type)
11098 {
11099 case SHT_GNU_LIBLIST:
11100 if (section->sh_link >= elf_header.e_shnum)
11101 break;
11102
11103 elib = (Elf32_External_Lib *)
11104 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
11105 _("liblist"));
11106
11107 if (elib == NULL)
11108 break;
11109 string_sec = section_headers + section->sh_link;
11110
11111 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
11112 string_sec->sh_size,
11113 _("liblist string table"));
11114 strtab_size = string_sec->sh_size;
11115
11116 if (strtab == NULL
11117 || section->sh_entsize != sizeof (Elf32_External_Lib))
11118 {
11119 free (elib);
11120 break;
11121 }
11122
11123 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11124 SECTION_NAME (section),
11125 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
11126
11127 puts (_(" Library Time Stamp Checksum Version Flags"));
11128
11129 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
11130 ++cnt)
11131 {
11132 Elf32_Lib liblist;
11133 time_t atime;
11134 char timebuf[20];
11135 struct tm * tmp;
11136
11137 liblist.l_name = BYTE_GET (elib[cnt].l_name);
11138 atime = BYTE_GET (elib[cnt].l_time_stamp);
11139 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11140 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11141 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11142
11143 tmp = gmtime (&atime);
11144 snprintf (timebuf, sizeof (timebuf),
11145 "%04u-%02u-%02uT%02u:%02u:%02u",
11146 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11147 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11148
11149 printf ("%3lu: ", (unsigned long) cnt);
11150 if (do_wide)
11151 printf ("%-20s", liblist.l_name < strtab_size
11152 ? strtab + liblist.l_name : _("<corrupt>"));
11153 else
11154 printf ("%-20.20s", liblist.l_name < strtab_size
11155 ? strtab + liblist.l_name : _("<corrupt>"));
11156 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
11157 liblist.l_version, liblist.l_flags);
11158 }
11159
11160 free (elib);
11161 }
11162 }
11163
11164 return 1;
11165 }
11166
11167 static const char *
11168 get_note_type (unsigned e_type)
11169 {
11170 static char buff[64];
11171
11172 if (elf_header.e_type == ET_CORE)
11173 switch (e_type)
11174 {
11175 case NT_AUXV:
11176 return _("NT_AUXV (auxiliary vector)");
11177 case NT_PRSTATUS:
11178 return _("NT_PRSTATUS (prstatus structure)");
11179 case NT_FPREGSET:
11180 return _("NT_FPREGSET (floating point registers)");
11181 case NT_PRPSINFO:
11182 return _("NT_PRPSINFO (prpsinfo structure)");
11183 case NT_TASKSTRUCT:
11184 return _("NT_TASKSTRUCT (task structure)");
11185 case NT_PRXFPREG:
11186 return _("NT_PRXFPREG (user_xfpregs structure)");
11187 case NT_PPC_VMX:
11188 return _("NT_PPC_VMX (ppc Altivec registers)");
11189 case NT_PPC_VSX:
11190 return _("NT_PPC_VSX (ppc VSX registers)");
11191 case NT_X86_XSTATE:
11192 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11193 case NT_S390_HIGH_GPRS:
11194 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11195 case NT_S390_TIMER:
11196 return _("NT_S390_TIMER (s390 timer register)");
11197 case NT_S390_TODCMP:
11198 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11199 case NT_S390_TODPREG:
11200 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11201 case NT_S390_CTRS:
11202 return _("NT_S390_CTRS (s390 control registers)");
11203 case NT_S390_PREFIX:
11204 return _("NT_S390_PREFIX (s390 prefix register)");
11205 case NT_PSTATUS:
11206 return _("NT_PSTATUS (pstatus structure)");
11207 case NT_FPREGS:
11208 return _("NT_FPREGS (floating point registers)");
11209 case NT_PSINFO:
11210 return _("NT_PSINFO (psinfo structure)");
11211 case NT_LWPSTATUS:
11212 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11213 case NT_LWPSINFO:
11214 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11215 case NT_WIN32PSTATUS:
11216 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11217 default:
11218 break;
11219 }
11220 else
11221 switch (e_type)
11222 {
11223 case NT_VERSION:
11224 return _("NT_VERSION (version)");
11225 case NT_ARCH:
11226 return _("NT_ARCH (architecture)");
11227 default:
11228 break;
11229 }
11230
11231 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11232 return buff;
11233 }
11234
11235 static const char *
11236 get_gnu_elf_note_type (unsigned e_type)
11237 {
11238 static char buff[64];
11239
11240 switch (e_type)
11241 {
11242 case NT_GNU_ABI_TAG:
11243 return _("NT_GNU_ABI_TAG (ABI version tag)");
11244 case NT_GNU_HWCAP:
11245 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11246 case NT_GNU_BUILD_ID:
11247 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11248 case NT_GNU_GOLD_VERSION:
11249 return _("NT_GNU_GOLD_VERSION (gold version)");
11250 default:
11251 break;
11252 }
11253
11254 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11255 return buff;
11256 }
11257
11258 static const char *
11259 get_netbsd_elfcore_note_type (unsigned e_type)
11260 {
11261 static char buff[64];
11262
11263 if (e_type == NT_NETBSDCORE_PROCINFO)
11264 {
11265 /* NetBSD core "procinfo" structure. */
11266 return _("NetBSD procinfo structure");
11267 }
11268
11269 /* As of Jan 2002 there are no other machine-independent notes
11270 defined for NetBSD core files. If the note type is less
11271 than the start of the machine-dependent note types, we don't
11272 understand it. */
11273
11274 if (e_type < NT_NETBSDCORE_FIRSTMACH)
11275 {
11276 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11277 return buff;
11278 }
11279
11280 switch (elf_header.e_machine)
11281 {
11282 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11283 and PT_GETFPREGS == mach+2. */
11284
11285 case EM_OLD_ALPHA:
11286 case EM_ALPHA:
11287 case EM_SPARC:
11288 case EM_SPARC32PLUS:
11289 case EM_SPARCV9:
11290 switch (e_type)
11291 {
11292 case NT_NETBSDCORE_FIRSTMACH + 0:
11293 return _("PT_GETREGS (reg structure)");
11294 case NT_NETBSDCORE_FIRSTMACH + 2:
11295 return _("PT_GETFPREGS (fpreg structure)");
11296 default:
11297 break;
11298 }
11299 break;
11300
11301 /* On all other arch's, PT_GETREGS == mach+1 and
11302 PT_GETFPREGS == mach+3. */
11303 default:
11304 switch (e_type)
11305 {
11306 case NT_NETBSDCORE_FIRSTMACH + 1:
11307 return _("PT_GETREGS (reg structure)");
11308 case NT_NETBSDCORE_FIRSTMACH + 3:
11309 return _("PT_GETFPREGS (fpreg structure)");
11310 default:
11311 break;
11312 }
11313 }
11314
11315 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
11316 e_type - NT_NETBSDCORE_FIRSTMACH);
11317 return buff;
11318 }
11319
11320 /* Note that by the ELF standard, the name field is already null byte
11321 terminated, and namesz includes the terminating null byte.
11322 I.E. the value of namesz for the name "FSF" is 4.
11323
11324 If the value of namesz is zero, there is no name present. */
11325 static int
11326 process_note (Elf_Internal_Note * pnote)
11327 {
11328 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
11329 const char * nt;
11330
11331 if (pnote->namesz == 0)
11332 /* If there is no note name, then use the default set of
11333 note type strings. */
11334 nt = get_note_type (pnote->type);
11335
11336 else if (const_strneq (pnote->namedata, "GNU"))
11337 /* GNU-specific object file notes. */
11338 nt = get_gnu_elf_note_type (pnote->type);
11339
11340 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
11341 /* NetBSD-specific core file notes. */
11342 nt = get_netbsd_elfcore_note_type (pnote->type);
11343
11344 else if (strneq (pnote->namedata, "SPU/", 4))
11345 {
11346 /* SPU-specific core file notes. */
11347 nt = pnote->namedata + 4;
11348 name = "SPU";
11349 }
11350
11351 else
11352 /* Don't recognize this note name; just use the default set of
11353 note type strings. */
11354 nt = get_note_type (pnote->type);
11355
11356 printf (" %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
11357 return 1;
11358 }
11359
11360
11361 static int
11362 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
11363 {
11364 Elf_External_Note * pnotes;
11365 Elf_External_Note * external;
11366 int res = 1;
11367
11368 if (length <= 0)
11369 return 0;
11370
11371 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
11372 _("notes"));
11373 if (!pnotes)
11374 return 0;
11375
11376 external = pnotes;
11377
11378 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11379 (unsigned long) offset, (unsigned long) length);
11380 printf (_(" Owner\t\tData size\tDescription\n"));
11381
11382 while (external < (Elf_External_Note *) ((char *) pnotes + length))
11383 {
11384 Elf_External_Note * next;
11385 Elf_Internal_Note inote;
11386 char * temp = NULL;
11387
11388 inote.type = BYTE_GET (external->type);
11389 inote.namesz = BYTE_GET (external->namesz);
11390 inote.namedata = external->name;
11391 inote.descsz = BYTE_GET (external->descsz);
11392 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
11393 inote.descpos = offset + (inote.descdata - (char *) pnotes);
11394
11395 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
11396
11397 if (((char *) next) > (((char *) pnotes) + length))
11398 {
11399 warn (_("corrupt note found at offset %lx into core notes\n"),
11400 (unsigned long) ((char *) external - (char *) pnotes));
11401 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11402 inote.type, inote.namesz, inote.descsz);
11403 break;
11404 }
11405
11406 external = next;
11407
11408 /* Verify that name is null terminated. It appears that at least
11409 one version of Linux (RedHat 6.0) generates corefiles that don't
11410 comply with the ELF spec by failing to include the null byte in
11411 namesz. */
11412 if (inote.namedata[inote.namesz] != '\0')
11413 {
11414 temp = (char *) malloc (inote.namesz + 1);
11415
11416 if (temp == NULL)
11417 {
11418 error (_("Out of memory\n"));
11419 res = 0;
11420 break;
11421 }
11422
11423 strncpy (temp, inote.namedata, inote.namesz);
11424 temp[inote.namesz] = 0;
11425
11426 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11427 inote.namedata = temp;
11428 }
11429
11430 res &= process_note (& inote);
11431
11432 if (temp != NULL)
11433 {
11434 free (temp);
11435 temp = NULL;
11436 }
11437 }
11438
11439 free (pnotes);
11440
11441 return res;
11442 }
11443
11444 static int
11445 process_corefile_note_segments (FILE * file)
11446 {
11447 Elf_Internal_Phdr * segment;
11448 unsigned int i;
11449 int res = 1;
11450
11451 if (! get_program_headers (file))
11452 return 0;
11453
11454 for (i = 0, segment = program_headers;
11455 i < elf_header.e_phnum;
11456 i++, segment++)
11457 {
11458 if (segment->p_type == PT_NOTE)
11459 res &= process_corefile_note_segment (file,
11460 (bfd_vma) segment->p_offset,
11461 (bfd_vma) segment->p_filesz);
11462 }
11463
11464 return res;
11465 }
11466
11467 static int
11468 process_note_sections (FILE * file)
11469 {
11470 Elf_Internal_Shdr * section;
11471 unsigned long i;
11472 int res = 1;
11473
11474 for (i = 0, section = section_headers;
11475 i < elf_header.e_shnum;
11476 i++, section++)
11477 if (section->sh_type == SHT_NOTE)
11478 res &= process_corefile_note_segment (file,
11479 (bfd_vma) section->sh_offset,
11480 (bfd_vma) section->sh_size);
11481
11482 return res;
11483 }
11484
11485 static int
11486 process_notes (FILE * file)
11487 {
11488 /* If we have not been asked to display the notes then do nothing. */
11489 if (! do_notes)
11490 return 1;
11491
11492 if (elf_header.e_type != ET_CORE)
11493 return process_note_sections (file);
11494
11495 /* No program headers means no NOTE segment. */
11496 if (elf_header.e_phnum > 0)
11497 return process_corefile_note_segments (file);
11498
11499 printf (_("No note segments present in the core file.\n"));
11500 return 1;
11501 }
11502
11503 static int
11504 process_arch_specific (FILE * file)
11505 {
11506 if (! do_arch)
11507 return 1;
11508
11509 switch (elf_header.e_machine)
11510 {
11511 case EM_ARM:
11512 return process_arm_specific (file);
11513 case EM_MIPS:
11514 case EM_MIPS_RS3_LE:
11515 return process_mips_specific (file);
11516 break;
11517 case EM_PPC:
11518 return process_power_specific (file);
11519 break;
11520 default:
11521 break;
11522 }
11523 return 1;
11524 }
11525
11526 static int
11527 get_file_header (FILE * file)
11528 {
11529 /* Read in the identity array. */
11530 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
11531 return 0;
11532
11533 /* Determine how to read the rest of the header. */
11534 switch (elf_header.e_ident[EI_DATA])
11535 {
11536 default: /* fall through */
11537 case ELFDATANONE: /* fall through */
11538 case ELFDATA2LSB:
11539 byte_get = byte_get_little_endian;
11540 byte_put = byte_put_little_endian;
11541 break;
11542 case ELFDATA2MSB:
11543 byte_get = byte_get_big_endian;
11544 byte_put = byte_put_big_endian;
11545 break;
11546 }
11547
11548 /* For now we only support 32 bit and 64 bit ELF files. */
11549 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
11550
11551 /* Read in the rest of the header. */
11552 if (is_32bit_elf)
11553 {
11554 Elf32_External_Ehdr ehdr32;
11555
11556 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
11557 return 0;
11558
11559 elf_header.e_type = BYTE_GET (ehdr32.e_type);
11560 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
11561 elf_header.e_version = BYTE_GET (ehdr32.e_version);
11562 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
11563 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
11564 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
11565 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
11566 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
11567 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
11568 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
11569 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
11570 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
11571 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
11572 }
11573 else
11574 {
11575 Elf64_External_Ehdr ehdr64;
11576
11577 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11578 we will not be able to cope with the 64bit data found in
11579 64 ELF files. Detect this now and abort before we start
11580 overwriting things. */
11581 if (sizeof (bfd_vma) < 8)
11582 {
11583 error (_("This instance of readelf has been built without support for a\n\
11584 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11585 return 0;
11586 }
11587
11588 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
11589 return 0;
11590
11591 elf_header.e_type = BYTE_GET (ehdr64.e_type);
11592 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
11593 elf_header.e_version = BYTE_GET (ehdr64.e_version);
11594 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
11595 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
11596 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
11597 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
11598 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
11599 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
11600 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
11601 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
11602 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
11603 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
11604 }
11605
11606 if (elf_header.e_shoff)
11607 {
11608 /* There may be some extensions in the first section header. Don't
11609 bomb if we can't read it. */
11610 if (is_32bit_elf)
11611 get_32bit_section_headers (file, 1);
11612 else
11613 get_64bit_section_headers (file, 1);
11614 }
11615
11616 return 1;
11617 }
11618
11619 /* Process one ELF object file according to the command line options.
11620 This file may actually be stored in an archive. The file is
11621 positioned at the start of the ELF object. */
11622
11623 static int
11624 process_object (char * file_name, FILE * file)
11625 {
11626 unsigned int i;
11627
11628 if (! get_file_header (file))
11629 {
11630 error (_("%s: Failed to read file header\n"), file_name);
11631 return 1;
11632 }
11633
11634 /* Initialise per file variables. */
11635 for (i = ARRAY_SIZE (version_info); i--;)
11636 version_info[i] = 0;
11637
11638 for (i = ARRAY_SIZE (dynamic_info); i--;)
11639 dynamic_info[i] = 0;
11640
11641 /* Process the file. */
11642 if (show_name)
11643 printf (_("\nFile: %s\n"), file_name);
11644
11645 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11646 Note we do this even if cmdline_dump_sects is empty because we
11647 must make sure that the dump_sets array is zeroed out before each
11648 object file is processed. */
11649 if (num_dump_sects > num_cmdline_dump_sects)
11650 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
11651
11652 if (num_cmdline_dump_sects > 0)
11653 {
11654 if (num_dump_sects == 0)
11655 /* A sneaky way of allocating the dump_sects array. */
11656 request_dump_bynumber (num_cmdline_dump_sects, 0);
11657
11658 assert (num_dump_sects >= num_cmdline_dump_sects);
11659 memcpy (dump_sects, cmdline_dump_sects,
11660 num_cmdline_dump_sects * sizeof (* dump_sects));
11661 }
11662
11663 if (! process_file_header ())
11664 return 1;
11665
11666 if (! process_section_headers (file))
11667 {
11668 /* Without loaded section headers we cannot process lots of
11669 things. */
11670 do_unwind = do_version = do_dump = do_arch = 0;
11671
11672 if (! do_using_dynamic)
11673 do_syms = do_dyn_syms = do_reloc = 0;
11674 }
11675
11676 if (! process_section_groups (file))
11677 {
11678 /* Without loaded section groups we cannot process unwind. */
11679 do_unwind = 0;
11680 }
11681
11682 if (process_program_headers (file))
11683 process_dynamic_section (file);
11684
11685 process_relocs (file);
11686
11687 process_unwind (file);
11688
11689 process_symbol_table (file);
11690
11691 process_syminfo (file);
11692
11693 process_version_sections (file);
11694
11695 process_section_contents (file);
11696
11697 process_notes (file);
11698
11699 process_gnu_liblist (file);
11700
11701 process_arch_specific (file);
11702
11703 if (program_headers)
11704 {
11705 free (program_headers);
11706 program_headers = NULL;
11707 }
11708
11709 if (section_headers)
11710 {
11711 free (section_headers);
11712 section_headers = NULL;
11713 }
11714
11715 if (string_table)
11716 {
11717 free (string_table);
11718 string_table = NULL;
11719 string_table_length = 0;
11720 }
11721
11722 if (dynamic_strings)
11723 {
11724 free (dynamic_strings);
11725 dynamic_strings = NULL;
11726 dynamic_strings_length = 0;
11727 }
11728
11729 if (dynamic_symbols)
11730 {
11731 free (dynamic_symbols);
11732 dynamic_symbols = NULL;
11733 num_dynamic_syms = 0;
11734 }
11735
11736 if (dynamic_syminfo)
11737 {
11738 free (dynamic_syminfo);
11739 dynamic_syminfo = NULL;
11740 }
11741
11742 if (section_headers_groups)
11743 {
11744 free (section_headers_groups);
11745 section_headers_groups = NULL;
11746 }
11747
11748 if (section_groups)
11749 {
11750 struct group_list * g;
11751 struct group_list * next;
11752
11753 for (i = 0; i < group_count; i++)
11754 {
11755 for (g = section_groups [i].root; g != NULL; g = next)
11756 {
11757 next = g->next;
11758 free (g);
11759 }
11760 }
11761
11762 free (section_groups);
11763 section_groups = NULL;
11764 }
11765
11766 free_debug_memory ();
11767
11768 return 0;
11769 }
11770
11771 /* Return the path name for a proxy entry in a thin archive, adjusted relative
11772 to the path name of the thin archive itself if necessary. Always returns
11773 a pointer to malloc'ed memory. */
11774
11775 static char *
11776 adjust_relative_path (char * file_name, char * name, int name_len)
11777 {
11778 char * member_file_name;
11779 const char * base_name = lbasename (file_name);
11780
11781 /* This is a proxy entry for a thin archive member.
11782 If the extended name table contains an absolute path
11783 name, or if the archive is in the current directory,
11784 use the path name as given. Otherwise, we need to
11785 find the member relative to the directory where the
11786 archive is located. */
11787 if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
11788 {
11789 member_file_name = (char *) malloc (name_len + 1);
11790 if (member_file_name == NULL)
11791 {
11792 error (_("Out of memory\n"));
11793 return NULL;
11794 }
11795 memcpy (member_file_name, name, name_len);
11796 member_file_name[name_len] = '\0';
11797 }
11798 else
11799 {
11800 /* Concatenate the path components of the archive file name
11801 to the relative path name from the extended name table. */
11802 size_t prefix_len = base_name - file_name;
11803 member_file_name = (char *) malloc (prefix_len + name_len + 1);
11804 if (member_file_name == NULL)
11805 {
11806 error (_("Out of memory\n"));
11807 return NULL;
11808 }
11809 memcpy (member_file_name, file_name, prefix_len);
11810 memcpy (member_file_name + prefix_len, name, name_len);
11811 member_file_name[prefix_len + name_len] = '\0';
11812 }
11813 return member_file_name;
11814 }
11815
11816 /* Structure to hold information about an archive file. */
11817
11818 struct archive_info
11819 {
11820 char * file_name; /* Archive file name. */
11821 FILE * file; /* Open file descriptor. */
11822 unsigned long index_num; /* Number of symbols in table. */
11823 unsigned long * index_array; /* The array of member offsets. */
11824 char * sym_table; /* The symbol table. */
11825 unsigned long sym_size; /* Size of the symbol table. */
11826 char * longnames; /* The long file names table. */
11827 unsigned long longnames_size; /* Size of the long file names table. */
11828 unsigned long nested_member_origin; /* Origin in the nested archive of the current member. */
11829 unsigned long next_arhdr_offset; /* Offset of the next archive header. */
11830 bfd_boolean is_thin_archive; /* TRUE if this is a thin archive. */
11831 struct ar_hdr arhdr; /* Current archive header. */
11832 };
11833
11834 /* Read the symbol table and long-name table from an archive. */
11835
11836 static int
11837 setup_archive (struct archive_info * arch, char * file_name, FILE * file,
11838 bfd_boolean is_thin_archive, bfd_boolean read_symbols)
11839 {
11840 size_t got;
11841 unsigned long size;
11842
11843 arch->file_name = strdup (file_name);
11844 arch->file = file;
11845 arch->index_num = 0;
11846 arch->index_array = NULL;
11847 arch->sym_table = NULL;
11848 arch->sym_size = 0;
11849 arch->longnames = NULL;
11850 arch->longnames_size = 0;
11851 arch->nested_member_origin = 0;
11852 arch->is_thin_archive = is_thin_archive;
11853 arch->next_arhdr_offset = SARMAG;
11854
11855 /* Read the first archive member header. */
11856 if (fseek (file, SARMAG, SEEK_SET) != 0)
11857 {
11858 error (_("%s: failed to seek to first archive header\n"), file_name);
11859 return 1;
11860 }
11861 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
11862 if (got != sizeof arch->arhdr)
11863 {
11864 if (got == 0)
11865 return 0;
11866
11867 error (_("%s: failed to read archive header\n"), file_name);
11868 return 1;
11869 }
11870
11871 /* See if this is the archive symbol table. */
11872 if (const_strneq (arch->arhdr.ar_name, "/ ")
11873 || const_strneq (arch->arhdr.ar_name, "/SYM64/ "))
11874 {
11875 size = strtoul (arch->arhdr.ar_size, NULL, 10);
11876 size = size + (size & 1);
11877
11878 arch->next_arhdr_offset += sizeof arch->arhdr + size;
11879
11880 if (read_symbols)
11881 {
11882 unsigned long i;
11883 /* A buffer used to hold numbers read in from an archive index.
11884 These are always 4 bytes long and stored in big-endian format. */
11885 #define SIZEOF_AR_INDEX_NUMBERS 4
11886 unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
11887 unsigned char * index_buffer;
11888
11889 /* Check the size of the archive index. */
11890 if (size < SIZEOF_AR_INDEX_NUMBERS)
11891 {
11892 error (_("%s: the archive index is empty\n"), file_name);
11893 return 1;
11894 }
11895
11896 /* Read the numer of entries in the archive index. */
11897 got = fread (integer_buffer, 1, sizeof integer_buffer, file);
11898 if (got != sizeof (integer_buffer))
11899 {
11900 error (_("%s: failed to read archive index\n"), file_name);
11901 return 1;
11902 }
11903 arch->index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
11904 size -= SIZEOF_AR_INDEX_NUMBERS;
11905
11906 /* Read in the archive index. */
11907 if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
11908 {
11909 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11910 file_name, arch->index_num);
11911 return 1;
11912 }
11913 index_buffer = (unsigned char *)
11914 malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
11915 if (index_buffer == NULL)
11916 {
11917 error (_("Out of memory whilst trying to read archive symbol index\n"));
11918 return 1;
11919 }
11920 got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, arch->index_num, file);
11921 if (got != arch->index_num)
11922 {
11923 free (index_buffer);
11924 error (_("%s: failed to read archive index\n"), file_name);
11925 return 1;
11926 }
11927 size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
11928
11929 /* Convert the index numbers into the host's numeric format. */
11930 arch->index_array = (long unsigned int *)
11931 malloc (arch->index_num * sizeof (* arch->index_array));
11932 if (arch->index_array == NULL)
11933 {
11934 free (index_buffer);
11935 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11936 return 1;
11937 }
11938
11939 for (i = 0; i < arch->index_num; i++)
11940 arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
11941 SIZEOF_AR_INDEX_NUMBERS);
11942 free (index_buffer);
11943
11944 /* The remaining space in the header is taken up by the symbol table. */
11945 if (size < 1)
11946 {
11947 error (_("%s: the archive has an index but no symbols\n"), file_name);
11948 return 1;
11949 }
11950 arch->sym_table = (char *) malloc (size);
11951 arch->sym_size = size;
11952 if (arch->sym_table == NULL)
11953 {
11954 error (_("Out of memory whilst trying to read archive index symbol table\n"));
11955 return 1;
11956 }
11957 got = fread (arch->sym_table, 1, size, file);
11958 if (got != size)
11959 {
11960 error (_("%s: failed to read archive index symbol table\n"), file_name);
11961 return 1;
11962 }
11963 }
11964 else
11965 {
11966 if (fseek (file, size, SEEK_CUR) != 0)
11967 {
11968 error (_("%s: failed to skip archive symbol table\n"), file_name);
11969 return 1;
11970 }
11971 }
11972
11973 /* Read the next archive header. */
11974 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
11975 if (got != sizeof arch->arhdr)
11976 {
11977 if (got == 0)
11978 return 0;
11979 error (_("%s: failed to read archive header following archive index\n"), file_name);
11980 return 1;
11981 }
11982 }
11983 else if (read_symbols)
11984 printf (_("%s has no archive index\n"), file_name);
11985
11986 if (const_strneq (arch->arhdr.ar_name, "// "))
11987 {
11988 /* This is the archive string table holding long member names. */
11989 arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
11990 arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
11991
11992 arch->longnames = (char *) malloc (arch->longnames_size);
11993 if (arch->longnames == NULL)
11994 {
11995 error (_("Out of memory reading long symbol names in archive\n"));
11996 return 1;
11997 }
11998
11999 if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
12000 {
12001 free (arch->longnames);
12002 arch->longnames = NULL;
12003 error (_("%s: failed to read long symbol name string table\n"), file_name);
12004 return 1;
12005 }
12006
12007 if ((arch->longnames_size & 1) != 0)
12008 getc (file);
12009 }
12010
12011 return 0;
12012 }
12013
12014 /* Release the memory used for the archive information. */
12015
12016 static void
12017 release_archive (struct archive_info * arch)
12018 {
12019 if (arch->file_name != NULL)
12020 free (arch->file_name);
12021 if (arch->index_array != NULL)
12022 free (arch->index_array);
12023 if (arch->sym_table != NULL)
12024 free (arch->sym_table);
12025 if (arch->longnames != NULL)
12026 free (arch->longnames);
12027 }
12028
12029 /* Open and setup a nested archive, if not already open. */
12030
12031 static int
12032 setup_nested_archive (struct archive_info * nested_arch, char * member_file_name)
12033 {
12034 FILE * member_file;
12035
12036 /* Have we already setup this archive? */
12037 if (nested_arch->file_name != NULL
12038 && streq (nested_arch->file_name, member_file_name))
12039 return 0;
12040
12041 /* Close previous file and discard cached information. */
12042 if (nested_arch->file != NULL)
12043 fclose (nested_arch->file);
12044 release_archive (nested_arch);
12045
12046 member_file = fopen (member_file_name, "rb");
12047 if (member_file == NULL)
12048 return 1;
12049 return setup_archive (nested_arch, member_file_name, member_file, FALSE, FALSE);
12050 }
12051
12052 static char *
12053 get_archive_member_name_at (struct archive_info * arch,
12054 unsigned long offset,
12055 struct archive_info * nested_arch);
12056
12057 /* Get the name of an archive member from the current archive header.
12058 For simple names, this will modify the ar_name field of the current
12059 archive header. For long names, it will return a pointer to the
12060 longnames table. For nested archives, it will open the nested archive
12061 and get the name recursively. NESTED_ARCH is a single-entry cache so
12062 we don't keep rereading the same information from a nested archive. */
12063
12064 static char *
12065 get_archive_member_name (struct archive_info * arch,
12066 struct archive_info * nested_arch)
12067 {
12068 unsigned long j, k;
12069
12070 if (arch->arhdr.ar_name[0] == '/')
12071 {
12072 /* We have a long name. */
12073 char * endp;
12074 char * member_file_name;
12075 char * member_name;
12076
12077 arch->nested_member_origin = 0;
12078 k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
12079 if (arch->is_thin_archive && endp != NULL && * endp == ':')
12080 arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
12081
12082 while ((j < arch->longnames_size)
12083 && (arch->longnames[j] != '\n')
12084 && (arch->longnames[j] != '\0'))
12085 j++;
12086 if (arch->longnames[j-1] == '/')
12087 j--;
12088 arch->longnames[j] = '\0';
12089
12090 if (!arch->is_thin_archive || arch->nested_member_origin == 0)
12091 return arch->longnames + k;
12092
12093 /* This is a proxy for a member of a nested archive.
12094 Find the name of the member in that archive. */
12095 member_file_name = adjust_relative_path (arch->file_name, arch->longnames + k, j - k);
12096 if (member_file_name != NULL
12097 && setup_nested_archive (nested_arch, member_file_name) == 0
12098 && (member_name = get_archive_member_name_at (nested_arch, arch->nested_member_origin, NULL)) != NULL)
12099 {
12100 free (member_file_name);
12101 return member_name;
12102 }
12103 free (member_file_name);
12104
12105 /* Last resort: just return the name of the nested archive. */
12106 return arch->longnames + k;
12107 }
12108
12109 /* We have a normal (short) name. */
12110 j = 0;
12111 while ((arch->arhdr.ar_name[j] != '/') && (j < 16))
12112 j++;
12113 arch->arhdr.ar_name[j] = '\0';
12114 return arch->arhdr.ar_name;
12115 }
12116
12117 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
12118
12119 static char *
12120 get_archive_member_name_at (struct archive_info * arch,
12121 unsigned long offset,
12122 struct archive_info * nested_arch)
12123 {
12124 size_t got;
12125
12126 if (fseek (arch->file, offset, SEEK_SET) != 0)
12127 {
12128 error (_("%s: failed to seek to next file name\n"), arch->file_name);
12129 return NULL;
12130 }
12131 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
12132 if (got != sizeof arch->arhdr)
12133 {
12134 error (_("%s: failed to read archive header\n"), arch->file_name);
12135 return NULL;
12136 }
12137 if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
12138 {
12139 error (_("%s: did not find a valid archive header\n"), arch->file_name);
12140 return NULL;
12141 }
12142
12143 return get_archive_member_name (arch, nested_arch);
12144 }
12145
12146 /* Construct a string showing the name of the archive member, qualified
12147 with the name of the containing archive file. For thin archives, we
12148 use square brackets to denote the indirection. For nested archives,
12149 we show the qualified name of the external member inside the square
12150 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
12151
12152 static char *
12153 make_qualified_name (struct archive_info * arch,
12154 struct archive_info * nested_arch,
12155 char * member_name)
12156 {
12157 size_t len;
12158 char * name;
12159
12160 len = strlen (arch->file_name) + strlen (member_name) + 3;
12161 if (arch->is_thin_archive && arch->nested_member_origin != 0)
12162 len += strlen (nested_arch->file_name) + 2;
12163
12164 name = (char *) malloc (len);
12165 if (name == NULL)
12166 {
12167 error (_("Out of memory\n"));
12168 return NULL;
12169 }
12170
12171 if (arch->is_thin_archive && arch->nested_member_origin != 0)
12172 snprintf (name, len, "%s[%s(%s)]", arch->file_name, nested_arch->file_name, member_name);
12173 else if (arch->is_thin_archive)
12174 snprintf (name, len, "%s[%s]", arch->file_name, member_name);
12175 else
12176 snprintf (name, len, "%s(%s)", arch->file_name, member_name);
12177
12178 return name;
12179 }
12180
12181 /* Process an ELF archive.
12182 On entry the file is positioned just after the ARMAG string. */
12183
12184 static int
12185 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
12186 {
12187 struct archive_info arch;
12188 struct archive_info nested_arch;
12189 size_t got;
12190 int ret;
12191
12192 show_name = 1;
12193
12194 /* The ARCH structure is used to hold information about this archive. */
12195 arch.file_name = NULL;
12196 arch.file = NULL;
12197 arch.index_array = NULL;
12198 arch.sym_table = NULL;
12199 arch.longnames = NULL;
12200
12201 /* The NESTED_ARCH structure is used as a single-item cache of information
12202 about a nested archive (when members of a thin archive reside within
12203 another regular archive file). */
12204 nested_arch.file_name = NULL;
12205 nested_arch.file = NULL;
12206 nested_arch.index_array = NULL;
12207 nested_arch.sym_table = NULL;
12208 nested_arch.longnames = NULL;
12209
12210 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
12211 {
12212 ret = 1;
12213 goto out;
12214 }
12215
12216 if (do_archive_index)
12217 {
12218 if (arch.sym_table == NULL)
12219 error (_("%s: unable to dump the index as none was found\n"), file_name);
12220 else
12221 {
12222 unsigned int i, l;
12223 unsigned long current_pos;
12224
12225 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12226 file_name, arch.index_num, arch.sym_size);
12227 current_pos = ftell (file);
12228
12229 for (i = l = 0; i < arch.index_num; i++)
12230 {
12231 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
12232 {
12233 char * member_name;
12234
12235 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
12236
12237 if (member_name != NULL)
12238 {
12239 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
12240
12241 if (qualified_name != NULL)
12242 {
12243 printf (_("Binary %s contains:\n"), qualified_name);
12244 free (qualified_name);
12245 }
12246 }
12247 }
12248
12249 if (l >= arch.sym_size)
12250 {
12251 error (_("%s: end of the symbol table reached before the end of the index\n"),
12252 file_name);
12253 break;
12254 }
12255 printf ("\t%s\n", arch.sym_table + l);
12256 l += strlen (arch.sym_table + l) + 1;
12257 }
12258
12259 if (l & 01)
12260 ++l;
12261 if (l < arch.sym_size)
12262 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12263 file_name);
12264
12265 if (fseek (file, current_pos, SEEK_SET) != 0)
12266 {
12267 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
12268 ret = 1;
12269 goto out;
12270 }
12271 }
12272
12273 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
12274 && !do_segments && !do_header && !do_dump && !do_version
12275 && !do_histogram && !do_debugging && !do_arch && !do_notes
12276 && !do_section_groups && !do_dyn_syms)
12277 {
12278 ret = 0; /* Archive index only. */
12279 goto out;
12280 }
12281 }
12282
12283 ret = 0;
12284
12285 while (1)
12286 {
12287 char * name;
12288 size_t namelen;
12289 char * qualified_name;
12290
12291 /* Read the next archive header. */
12292 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
12293 {
12294 error (_("%s: failed to seek to next archive header\n"), file_name);
12295 return 1;
12296 }
12297 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
12298 if (got != sizeof arch.arhdr)
12299 {
12300 if (got == 0)
12301 break;
12302 error (_("%s: failed to read archive header\n"), file_name);
12303 ret = 1;
12304 break;
12305 }
12306 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
12307 {
12308 error (_("%s: did not find a valid archive header\n"), arch.file_name);
12309 ret = 1;
12310 break;
12311 }
12312
12313 arch.next_arhdr_offset += sizeof arch.arhdr;
12314
12315 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
12316 if (archive_file_size & 01)
12317 ++archive_file_size;
12318
12319 name = get_archive_member_name (&arch, &nested_arch);
12320 if (name == NULL)
12321 {
12322 error (_("%s: bad archive file name\n"), file_name);
12323 ret = 1;
12324 break;
12325 }
12326 namelen = strlen (name);
12327
12328 qualified_name = make_qualified_name (&arch, &nested_arch, name);
12329 if (qualified_name == NULL)
12330 {
12331 error (_("%s: bad archive file name\n"), file_name);
12332 ret = 1;
12333 break;
12334 }
12335
12336 if (is_thin_archive && arch.nested_member_origin == 0)
12337 {
12338 /* This is a proxy for an external member of a thin archive. */
12339 FILE * member_file;
12340 char * member_file_name = adjust_relative_path (file_name, name, namelen);
12341 if (member_file_name == NULL)
12342 {
12343 ret = 1;
12344 break;
12345 }
12346
12347 member_file = fopen (member_file_name, "rb");
12348 if (member_file == NULL)
12349 {
12350 error (_("Input file '%s' is not readable.\n"), member_file_name);
12351 free (member_file_name);
12352 ret = 1;
12353 break;
12354 }
12355
12356 archive_file_offset = arch.nested_member_origin;
12357
12358 ret |= process_object (qualified_name, member_file);
12359
12360 fclose (member_file);
12361 free (member_file_name);
12362 }
12363 else if (is_thin_archive)
12364 {
12365 /* This is a proxy for a member of a nested archive. */
12366 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
12367
12368 /* The nested archive file will have been opened and setup by
12369 get_archive_member_name. */
12370 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
12371 {
12372 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
12373 ret = 1;
12374 break;
12375 }
12376
12377 ret |= process_object (qualified_name, nested_arch.file);
12378 }
12379 else
12380 {
12381 archive_file_offset = arch.next_arhdr_offset;
12382 arch.next_arhdr_offset += archive_file_size;
12383
12384 ret |= process_object (qualified_name, file);
12385 }
12386
12387 free (qualified_name);
12388 }
12389
12390 out:
12391 if (nested_arch.file != NULL)
12392 fclose (nested_arch.file);
12393 release_archive (&nested_arch);
12394 release_archive (&arch);
12395
12396 return ret;
12397 }
12398
12399 static int
12400 process_file (char * file_name)
12401 {
12402 FILE * file;
12403 struct stat statbuf;
12404 char armag[SARMAG];
12405 int ret;
12406
12407 if (stat (file_name, &statbuf) < 0)
12408 {
12409 if (errno == ENOENT)
12410 error (_("'%s': No such file\n"), file_name);
12411 else
12412 error (_("Could not locate '%s'. System error message: %s\n"),
12413 file_name, strerror (errno));
12414 return 1;
12415 }
12416
12417 if (! S_ISREG (statbuf.st_mode))
12418 {
12419 error (_("'%s' is not an ordinary file\n"), file_name);
12420 return 1;
12421 }
12422
12423 file = fopen (file_name, "rb");
12424 if (file == NULL)
12425 {
12426 error (_("Input file '%s' is not readable.\n"), file_name);
12427 return 1;
12428 }
12429
12430 if (fread (armag, SARMAG, 1, file) != 1)
12431 {
12432 error (_("%s: Failed to read file's magic number\n"), file_name);
12433 fclose (file);
12434 return 1;
12435 }
12436
12437 if (memcmp (armag, ARMAG, SARMAG) == 0)
12438 ret = process_archive (file_name, file, FALSE);
12439 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
12440 ret = process_archive (file_name, file, TRUE);
12441 else
12442 {
12443 if (do_archive_index)
12444 error (_("File %s is not an archive so its index cannot be displayed.\n"),
12445 file_name);
12446
12447 rewind (file);
12448 archive_file_size = archive_file_offset = 0;
12449 ret = process_object (file_name, file);
12450 }
12451
12452 fclose (file);
12453
12454 return ret;
12455 }
12456
12457 #ifdef SUPPORT_DISASSEMBLY
12458 /* Needed by the i386 disassembler. For extra credit, someone could
12459 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12460 symbols. */
12461
12462 void
12463 print_address (unsigned int addr, FILE * outfile)
12464 {
12465 fprintf (outfile,"0x%8.8x", addr);
12466 }
12467
12468 /* Needed by the i386 disassembler. */
12469 void
12470 db_task_printsym (unsigned int addr)
12471 {
12472 print_address (addr, stderr);
12473 }
12474 #endif
12475
12476 int
12477 main (int argc, char ** argv)
12478 {
12479 int err;
12480
12481 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12482 setlocale (LC_MESSAGES, "");
12483 #endif
12484 #if defined (HAVE_SETLOCALE)
12485 setlocale (LC_CTYPE, "");
12486 #endif
12487 bindtextdomain (PACKAGE, LOCALEDIR);
12488 textdomain (PACKAGE);
12489
12490 expandargv (&argc, &argv);
12491
12492 parse_args (argc, argv);
12493
12494 if (num_dump_sects > 0)
12495 {
12496 /* Make a copy of the dump_sects array. */
12497 cmdline_dump_sects = (dump_type *)
12498 malloc (num_dump_sects * sizeof (* dump_sects));
12499 if (cmdline_dump_sects == NULL)
12500 error (_("Out of memory allocating dump request table.\n"));
12501 else
12502 {
12503 memcpy (cmdline_dump_sects, dump_sects,
12504 num_dump_sects * sizeof (* dump_sects));
12505 num_cmdline_dump_sects = num_dump_sects;
12506 }
12507 }
12508
12509 if (optind < (argc - 1))
12510 show_name = 1;
12511
12512 err = 0;
12513 while (optind < argc)
12514 err |= process_file (argv[optind++]);
12515
12516 if (dump_sects != NULL)
12517 free (dump_sects);
12518 if (cmdline_dump_sects != NULL)
12519 free (cmdline_dump_sects);
12520
12521 return err;
12522 }