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