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