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