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