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