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