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