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