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