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