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