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