projects / binutils-gdb.git / blob
? search:


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