projects / binutils-gdb.git / blob
? search:


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