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