projects / deliverable / binutils-gdb.git / blob
? search:


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