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