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