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