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