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