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