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