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