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