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