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