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