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