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