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