projects / deliverable / binutils-gdb.git / blob
? search:


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