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