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