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