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