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