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