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