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