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