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