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