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