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