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