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