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