sim/ChangeLog: Correct bug number in previous commit.
[deliverable/binutils-gdb.git] / binutils / objdump.c
CommitLineData
252b5132 1/* objdump.c -- dump information about an object file.
aebcf7b7 2 Copyright 1990-2013 Free Software Foundation, Inc.
252b5132 3
b5e2a4f3 4 This file is part of GNU Binutils.
252b5132 5
b5e2a4f3
NC
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
32866df7 8 the Free Software Foundation; either version 3, or (at your option)
b5e2a4f3 9 any later version.
252b5132 10
b5e2a4f3
NC
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
252b5132 15
b5e2a4f3
NC
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
32866df7
NC
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
252b5132 21
155e0d23
NC
22/* Objdump overview.
23
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
28
29 The flow of execution is as follows:
30
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
33
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
37
50c2245b 38 3. The file's target architecture and binary file format are determined
155e0d23
NC
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
40 called.
41
50c2245b
KH
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
aaad4cf3 44 a disassembly has been requested.
155e0d23
NC
45
46 When disassembling the code loops through blocks of instructions bounded
50c2245b 47 by symbols, calling disassemble_bytes() on each block. The actual
155e0d23
NC
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
50
3db64b00 51#include "sysdep.h"
252b5132 52#include "bfd.h"
2dc4cec1 53#include "elf-bfd.h"
252b5132
RH
54#include "progress.h"
55#include "bucomm.h"
3284fe0c 56#include "elfcomm.h"
365544c3 57#include "dwarf.h"
d7a283d4 58#include "getopt.h"
3882b010 59#include "safe-ctype.h"
252b5132
RH
60#include "dis-asm.h"
61#include "libiberty.h"
62#include "demangle.h"
0dafdf3f 63#include "filenames.h"
252b5132
RH
64#include "debug.h"
65#include "budbg.h"
6abcee90 66#include "objdump.h"
252b5132 67
e8f5eee4
NC
68#ifdef HAVE_MMAP
69#include <sys/mman.h>
70#endif
71
252b5132
RH
72/* Internal headers for the ELF .stab-dump code - sorry. */
73#define BYTES_IN_WORD 32
74#include "aout/aout64.h"
75
75cd796a
ILT
76/* Exit status. */
77static int exit_status = 0;
78
98a91d6a 79static char *default_target = NULL; /* Default at runtime. */
252b5132 80
3b9ad1cc
AM
81/* The following variables are set based on arguments passed on the
82 command line. */
98a91d6a 83static int show_version = 0; /* Show the version number. */
252b5132
RH
84static int dump_section_contents; /* -s */
85static int dump_section_headers; /* -h */
b34976b6 86static bfd_boolean dump_file_header; /* -f */
252b5132
RH
87static int dump_symtab; /* -t */
88static int dump_dynamic_symtab; /* -T */
89static int dump_reloc_info; /* -r */
90static int dump_dynamic_reloc_info; /* -R */
91static int dump_ar_hdrs; /* -a */
92static int dump_private_headers; /* -p */
6abcee90 93static char *dump_private_options; /* -P */
252b5132
RH
94static int prefix_addresses; /* --prefix-addresses */
95static int with_line_numbers; /* -l */
b34976b6 96static bfd_boolean with_source_code; /* -S */
252b5132 97static int show_raw_insn; /* --show-raw-insn */
365544c3 98static int dump_dwarf_section_info; /* --dwarf */
252b5132
RH
99static int dump_stab_section_info; /* --stabs */
100static int do_demangle; /* -C, --demangle */
b34976b6
AM
101static bfd_boolean disassemble; /* -d */
102static bfd_boolean disassemble_all; /* -D */
252b5132 103static int disassemble_zeroes; /* --disassemble-zeroes */
b34976b6 104static bfd_boolean formats_info; /* -i */
252b5132 105static int wide_output; /* -w */
3dcb3fcb 106static int insn_width; /* --insn-width */
252b5132
RH
107static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
108static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
109static int dump_debugging; /* --debugging */
51cdc6e0 110static int dump_debugging_tags; /* --debugging-tags */
fd2f0033 111static int suppress_bfd_header;
3c9458e9 112static int dump_special_syms = 0; /* --special-syms */
252b5132 113static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
f1563258 114static int file_start_context = 0; /* --file-start-context */
98ec6e72 115static bfd_boolean display_file_offsets;/* -F */
0dafdf3f
L
116static const char *prefix; /* --prefix */
117static int prefix_strip; /* --prefix-strip */
118static size_t prefix_length;
252b5132 119
70ecb384
NC
120/* A structure to record the sections mentioned in -j switches. */
121struct only
122{
123 const char * name; /* The name of the section. */
124 bfd_boolean seen; /* A flag to indicate that the section has been found in one or more input files. */
125 struct only * next; /* Pointer to the next structure in the list. */
126};
127/* Pointer to an array of 'only' structures.
128 This pointer is NULL if the -j switch has not been used. */
129static struct only * only_list = NULL;
155e0d23 130
43ac9881
AM
131/* Variables for handling include file path table. */
132static const char **include_paths;
133static int include_path_count;
134
3b9ad1cc
AM
135/* Extra info to pass to the section disassembler and address printing
136 function. */
026df7c5
NC
137struct objdump_disasm_info
138{
155e0d23
NC
139 bfd * abfd;
140 asection * sec;
141 bfd_boolean require_sec;
142 arelent ** dynrelbuf;
143 long dynrelcount;
144 disassembler_ftype disassemble_fn;
ce04548a 145 arelent * reloc;
252b5132
RH
146};
147
148/* Architecture to disassemble for, or default if NULL. */
d3ba0551 149static char *machine = NULL;
252b5132 150
dd92f639 151/* Target specific options to the disassembler. */
d3ba0551 152static char *disassembler_options = NULL;
dd92f639 153
252b5132
RH
154/* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
155static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
156
157/* The symbol table. */
158static asymbol **syms;
159
160/* Number of symbols in `syms'. */
161static long symcount = 0;
162
163/* The sorted symbol table. */
164static asymbol **sorted_syms;
165
166/* Number of symbols in `sorted_syms'. */
167static long sorted_symcount = 0;
168
169/* The dynamic symbol table. */
170static asymbol **dynsyms;
171
4c45e5c9
JJ
172/* The synthetic symbol table. */
173static asymbol *synthsyms;
174static long synthcount = 0;
175
252b5132
RH
176/* Number of symbols in `dynsyms'. */
177static long dynsymcount = 0;
178
98a91d6a
NC
179static bfd_byte *stabs;
180static bfd_size_type stab_size;
181
182static char *strtab;
183static bfd_size_type stabstr_size;
41e92641
NC
184
185static bfd_boolean is_relocatable = FALSE;
6abcee90
TG
186
187/* Handlers for -P/--private. */
188static const struct objdump_private_desc * const objdump_private_vectors[] =
189 {
190 OBJDUMP_PRIVATE_VECTORS
191 NULL
192 };
252b5132 193\f
aebcf7b7 194static void usage (FILE *, int) ATTRIBUTE_NORETURN;
252b5132 195static void
46dca2e0 196usage (FILE *stream, int status)
252b5132 197{
8b53311e
NC
198 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
199 fprintf (stream, _(" Display information from object <file(s)>.\n"));
200 fprintf (stream, _(" At least one of the following switches must be given:\n"));
252b5132 201 fprintf (stream, _("\
86d65c94
MK
202 -a, --archive-headers Display archive header information\n\
203 -f, --file-headers Display the contents of the overall file header\n\
204 -p, --private-headers Display object format specific file header contents\n\
6abcee90 205 -P, --private=OPT,OPT... Display object format specific contents\n\
86d65c94
MK
206 -h, --[section-]headers Display the contents of the section headers\n\
207 -x, --all-headers Display the contents of all headers\n\
208 -d, --disassemble Display assembler contents of executable sections\n\
209 -D, --disassemble-all Display assembler contents of all sections\n\
210 -S, --source Intermix source code with disassembly\n\
211 -s, --full-contents Display the full contents of all sections requested\n\
212 -g, --debugging Display debug information in object file\n\
51cdc6e0 213 -e, --debugging-tags Display debug information using ctags style\n\
86d65c94 214 -G, --stabs Display (in raw form) any STABS info in the file\n\
f9f0e732 215 -W[lLiaprmfFsoRt] or\n\
1ed06042 216 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 217 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC
218 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
219 =addr,=cu_index]\n\
4cb93e3b 220 Display DWARF info in the file\n\
86d65c94
MK
221 -t, --syms Display the contents of the symbol table(s)\n\
222 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
223 -r, --reloc Display the relocation entries in the file\n\
224 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
07012eee 225 @<file> Read options from <file>\n\
8b53311e 226 -v, --version Display this program's version number\n\
86d65c94
MK
227 -i, --info List object formats and architectures supported\n\
228 -H, --help Display this information\n\
1dada9c5
NC
229"));
230 if (status != 2)
231 {
6abcee90
TG
232 const struct objdump_private_desc * const *desc;
233
1dada9c5
NC
234 fprintf (stream, _("\n The following switches are optional:\n"));
235 fprintf (stream, _("\
86d65c94
MK
236 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
237 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
238 -j, --section=NAME Only display information for section NAME\n\
239 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
1dada9c5
NC
240 -EB --endian=big Assume big endian format when disassembling\n\
241 -EL --endian=little Assume little endian format when disassembling\n\
f1563258 242 --file-start-context Include context from start of file (with -S)\n\
43ac9881 243 -I, --include=DIR Add DIR to search list for source files\n\
86d65c94 244 -l, --line-numbers Include line numbers and filenames in output\n\
98ec6e72 245 -F, --file-offsets Include file offsets when displaying information\n\
28c309a2 246 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
f0c8c24a
NC
247 The STYLE, if specified, can be `auto', `gnu',\n\
248 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
249 or `gnat'\n\
86d65c94
MK
250 -w, --wide Format output for more than 80 columns\n\
251 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
f0c8c24a
NC
252 --start-address=ADDR Only process data whose address is >= ADDR\n\
253 --stop-address=ADDR Only process data whose address is <= ADDR\n\
1dada9c5
NC
254 --prefix-addresses Print complete address alongside disassembly\n\
255 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
505f1412 256 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
86d65c94 257 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
3c9458e9 258 --special-syms Include special symbols in symbol dumps\n\
0dafdf3f 259 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
fd2f0033
TT
260 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
261 fprintf (stream, _("\
262 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
263 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4723351a
CC
264 or deeper\n\
265 --dwarf-check Make additional dwarf internal consistency checks.\
266 \n\n"));
1dada9c5 267 list_supported_targets (program_name, stream);
2f83960e 268 list_supported_architectures (program_name, stream);
86d65c94 269
94470b23 270 disassembler_usage (stream);
6abcee90
TG
271
272 if (objdump_private_vectors[0] != NULL)
273 {
274 fprintf (stream,
275 _("\nOptions supported for -P/--private switch:\n"));
276 for (desc = objdump_private_vectors; *desc != NULL; desc++)
277 (*desc)->help (stream);
278 }
1dada9c5 279 }
92f01d61 280 if (REPORT_BUGS_TO[0] && status == 0)
86d65c94 281 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
252b5132
RH
282 exit (status);
283}
284
285/* 150 isn't special; it's just an arbitrary non-ASCII char value. */
46dca2e0
NC
286enum option_values
287 {
288 OPTION_ENDIAN=150,
289 OPTION_START_ADDRESS,
290 OPTION_STOP_ADDRESS,
4cb93e3b 291 OPTION_DWARF,
0dafdf3f
L
292 OPTION_PREFIX,
293 OPTION_PREFIX_STRIP,
3dcb3fcb 294 OPTION_INSN_WIDTH,
fd2f0033
TT
295 OPTION_ADJUST_VMA,
296 OPTION_DWARF_DEPTH,
4723351a 297 OPTION_DWARF_CHECK,
fd2f0033 298 OPTION_DWARF_START
46dca2e0 299 };
252b5132
RH
300
301static struct option long_options[]=
302{
303 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
304 {"all-headers", no_argument, NULL, 'x'},
305 {"private-headers", no_argument, NULL, 'p'},
6abcee90 306 {"private", required_argument, NULL, 'P'},
252b5132
RH
307 {"architecture", required_argument, NULL, 'm'},
308 {"archive-headers", no_argument, NULL, 'a'},
1dada9c5 309 {"debugging", no_argument, NULL, 'g'},
51cdc6e0 310 {"debugging-tags", no_argument, NULL, 'e'},
28c309a2 311 {"demangle", optional_argument, NULL, 'C'},
252b5132
RH
312 {"disassemble", no_argument, NULL, 'd'},
313 {"disassemble-all", no_argument, NULL, 'D'},
dd92f639 314 {"disassembler-options", required_argument, NULL, 'M'},
1dada9c5 315 {"disassemble-zeroes", no_argument, NULL, 'z'},
252b5132
RH
316 {"dynamic-reloc", no_argument, NULL, 'R'},
317 {"dynamic-syms", no_argument, NULL, 'T'},
318 {"endian", required_argument, NULL, OPTION_ENDIAN},
319 {"file-headers", no_argument, NULL, 'f'},
98ec6e72 320 {"file-offsets", no_argument, NULL, 'F'},
f1563258 321 {"file-start-context", no_argument, &file_start_context, 1},
252b5132
RH
322 {"full-contents", no_argument, NULL, 's'},
323 {"headers", no_argument, NULL, 'h'},
324 {"help", no_argument, NULL, 'H'},
325 {"info", no_argument, NULL, 'i'},
326 {"line-numbers", no_argument, NULL, 'l'},
327 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
328 {"prefix-addresses", no_argument, &prefix_addresses, 1},
329 {"reloc", no_argument, NULL, 'r'},
330 {"section", required_argument, NULL, 'j'},
331 {"section-headers", no_argument, NULL, 'h'},
332 {"show-raw-insn", no_argument, &show_raw_insn, 1},
333 {"source", no_argument, NULL, 'S'},
3c9458e9 334 {"special-syms", no_argument, &dump_special_syms, 1},
43ac9881 335 {"include", required_argument, NULL, 'I'},
4cb93e3b 336 {"dwarf", optional_argument, NULL, OPTION_DWARF},
1dada9c5 337 {"stabs", no_argument, NULL, 'G'},
252b5132
RH
338 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
339 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
340 {"syms", no_argument, NULL, 't'},
341 {"target", required_argument, NULL, 'b'},
1dada9c5
NC
342 {"version", no_argument, NULL, 'V'},
343 {"wide", no_argument, NULL, 'w'},
0dafdf3f
L
344 {"prefix", required_argument, NULL, OPTION_PREFIX},
345 {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
3dcb3fcb 346 {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
fd2f0033
TT
347 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
348 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 349 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
252b5132
RH
350 {0, no_argument, 0, 0}
351};
352\f
353static void
46dca2e0 354nonfatal (const char *msg)
75cd796a
ILT
355{
356 bfd_nonfatal (msg);
357 exit_status = 1;
358}
359\f
d2fcac5c
NC
360/* Returns TRUE if the specified section should be dumped. */
361
362static bfd_boolean
363process_section_p (asection * section)
364{
70ecb384 365 struct only * only;
d2fcac5c 366
70ecb384 367 if (only_list == NULL)
d2fcac5c
NC
368 return TRUE;
369
70ecb384
NC
370 for (only = only_list; only; only = only->next)
371 if (strcmp (only->name, section->name) == 0)
372 {
373 only->seen = TRUE;
374 return TRUE;
375 }
d2fcac5c
NC
376
377 return FALSE;
378}
70ecb384
NC
379
380/* Add an entry to the 'only' list. */
381
382static void
383add_only (char * name)
384{
385 struct only * only;
386
387 /* First check to make sure that we do not
388 already have an entry for this name. */
389 for (only = only_list; only; only = only->next)
390 if (strcmp (only->name, name) == 0)
391 return;
392
393 only = xmalloc (sizeof * only);
394 only->name = name;
395 only->seen = FALSE;
396 only->next = only_list;
397 only_list = only;
398}
399
400/* Release the memory used by the 'only' list.
401 PR 11225: Issue a warning message for unseen sections.
402 Only do this if none of the sections were seen. This is mainly to support
403 tools like the GAS testsuite where an object file is dumped with a list of
404 generic section names known to be present in a range of different file
405 formats. */
406
407static void
408free_only_list (void)
409{
410 bfd_boolean at_least_one_seen = FALSE;
411 struct only * only;
412 struct only * next;
413
414 if (only_list == NULL)
415 return;
416
417 for (only = only_list; only; only = only->next)
418 if (only->seen)
419 {
420 at_least_one_seen = TRUE;
421 break;
422 }
423
424 for (only = only_list; only; only = next)
425 {
426 if (! at_least_one_seen)
427 {
a8c62f1c
AM
428 non_fatal (_("section '%s' mentioned in a -j option, "
429 "but not found in any input file"),
70ecb384
NC
430 only->name);
431 exit_status = 1;
432 }
433 next = only->next;
434 free (only);
435 }
436}
437
d2fcac5c 438\f
75cd796a 439static void
ebe372c1 440dump_section_header (bfd *abfd, asection *section,
46dca2e0 441 void *ignored ATTRIBUTE_UNUSED)
252b5132
RH
442{
443 char *comma = "";
f6af82bd 444 unsigned int opb = bfd_octets_per_byte (abfd);
252b5132 445
3bee8bcd
L
446 /* Ignore linker created section. See elfNN_ia64_object_p in
447 bfd/elfxx-ia64.c. */
448 if (section->flags & SEC_LINKER_CREATED)
449 return;
450
d2fcac5c
NC
451 /* PR 10413: Skip sections that we are ignoring. */
452 if (! process_section_p (section))
453 return;
454
252b5132
RH
455 printf ("%3d %-13s %08lx ", section->index,
456 bfd_get_section_name (abfd, section),
940b2b78 457 (unsigned long) bfd_section_size (abfd, section) / opb);
d8180c76 458 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
252b5132 459 printf (" ");
d8180c76 460 bfd_printf_vma (abfd, section->lma);
e59b4dfb 461 printf (" %08lx 2**%u", (unsigned long) section->filepos,
252b5132
RH
462 bfd_get_section_alignment (abfd, section));
463 if (! wide_output)
464 printf ("\n ");
465 printf (" ");
466
467#define PF(x, y) \
468 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
469
470 PF (SEC_HAS_CONTENTS, "CONTENTS");
471 PF (SEC_ALLOC, "ALLOC");
472 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
252b5132
RH
473 PF (SEC_LOAD, "LOAD");
474 PF (SEC_RELOC, "RELOC");
252b5132
RH
475 PF (SEC_READONLY, "READONLY");
476 PF (SEC_CODE, "CODE");
477 PF (SEC_DATA, "DATA");
478 PF (SEC_ROM, "ROM");
479 PF (SEC_DEBUGGING, "DEBUGGING");
480 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
481 PF (SEC_EXCLUDE, "EXCLUDE");
482 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
ebe372c1
L
483 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
484 {
485 PF (SEC_TIC54X_BLOCK, "BLOCK");
486 PF (SEC_TIC54X_CLINK, "CLINK");
487 }
24c411ed 488 PF (SEC_SMALL_DATA, "SMALL_DATA");
ebe372c1
L
489 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
490 PF (SEC_COFF_SHARED, "SHARED");
13ae64f3 491 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
64c1196b 492 PF (SEC_GROUP, "GROUP");
252b5132
RH
493
494 if ((section->flags & SEC_LINK_ONCE) != 0)
495 {
496 const char *ls;
082b7297 497 struct coff_comdat_info *comdat;
252b5132
RH
498
499 switch (section->flags & SEC_LINK_DUPLICATES)
500 {
501 default:
502 abort ();
503 case SEC_LINK_DUPLICATES_DISCARD:
504 ls = "LINK_ONCE_DISCARD";
505 break;
506 case SEC_LINK_DUPLICATES_ONE_ONLY:
507 ls = "LINK_ONCE_ONE_ONLY";
508 break;
509 case SEC_LINK_DUPLICATES_SAME_SIZE:
510 ls = "LINK_ONCE_SAME_SIZE";
511 break;
512 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
513 ls = "LINK_ONCE_SAME_CONTENTS";
514 break;
515 }
516 printf ("%s%s", comma, ls);
deecf979 517
082b7297
L
518 comdat = bfd_coff_get_comdat_section (abfd, section);
519 if (comdat != NULL)
520 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
deecf979 521
252b5132
RH
522 comma = ", ";
523 }
524
525 printf ("\n");
526#undef PF
527}
528
529static void
46dca2e0 530dump_headers (bfd *abfd)
252b5132
RH
531{
532 printf (_("Sections:\n"));
8bea4d5c 533
252b5132 534#ifndef BFD64
8bea4d5c 535 printf (_("Idx Name Size VMA LMA File off Algn"));
252b5132 536#else
21611032
TS
537 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
538 if (bfd_get_arch_size (abfd) == 32)
539 printf (_("Idx Name Size VMA LMA File off Algn"));
540 else
541 printf (_("Idx Name Size VMA LMA File off Algn"));
252b5132 542#endif
8bea4d5c
ILT
543
544 if (wide_output)
545 printf (_(" Flags"));
546 printf ("\n");
547
46dca2e0 548 bfd_map_over_sections (abfd, dump_section_header, NULL);
252b5132
RH
549}
550\f
551static asymbol **
46dca2e0 552slurp_symtab (bfd *abfd)
252b5132 553{
d3ba0551 554 asymbol **sy = NULL;
252b5132
RH
555 long storage;
556
557 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
558 {
252b5132
RH
559 symcount = 0;
560 return NULL;
561 }
562
563 storage = bfd_get_symtab_upper_bound (abfd);
564 if (storage < 0)
565 bfd_fatal (bfd_get_filename (abfd));
252b5132 566 if (storage)
3f5e193b 567 sy = (asymbol **) xmalloc (storage);
28b18af1 568
252b5132
RH
569 symcount = bfd_canonicalize_symtab (abfd, sy);
570 if (symcount < 0)
571 bfd_fatal (bfd_get_filename (abfd));
252b5132
RH
572 return sy;
573}
574
575/* Read in the dynamic symbols. */
576
577static asymbol **
46dca2e0 578slurp_dynamic_symtab (bfd *abfd)
252b5132 579{
d3ba0551 580 asymbol **sy = NULL;
252b5132
RH
581 long storage;
582
583 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
584 if (storage < 0)
585 {
586 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
587 {
37cc8ec1 588 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
a8c62f1c 589 exit_status = 1;
252b5132
RH
590 dynsymcount = 0;
591 return NULL;
592 }
593
594 bfd_fatal (bfd_get_filename (abfd));
595 }
252b5132 596 if (storage)
3f5e193b 597 sy = (asymbol **) xmalloc (storage);
28b18af1 598
252b5132
RH
599 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
600 if (dynsymcount < 0)
601 bfd_fatal (bfd_get_filename (abfd));
252b5132
RH
602 return sy;
603}
604
605/* Filter out (in place) symbols that are useless for disassembly.
606 COUNT is the number of elements in SYMBOLS.
0af11b59 607 Return the number of useful symbols. */
252b5132
RH
608
609static long
46dca2e0 610remove_useless_symbols (asymbol **symbols, long count)
252b5132 611{
46dca2e0 612 asymbol **in_ptr = symbols, **out_ptr = symbols;
252b5132
RH
613
614 while (--count >= 0)
615 {
616 asymbol *sym = *in_ptr++;
617
618 if (sym->name == NULL || sym->name[0] == '\0')
619 continue;
180e47e2 620 if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
252b5132
RH
621 continue;
622 if (bfd_is_und_section (sym->section)
623 || bfd_is_com_section (sym->section))
624 continue;
625
626 *out_ptr++ = sym;
627 }
628 return out_ptr - symbols;
629}
630
631/* Sort symbols into value order. */
632
0af11b59 633static int
46dca2e0 634compare_symbols (const void *ap, const void *bp)
252b5132 635{
46dca2e0
NC
636 const asymbol *a = * (const asymbol **) ap;
637 const asymbol *b = * (const asymbol **) bp;
638 const char *an;
639 const char *bn;
640 size_t anl;
641 size_t bnl;
642 bfd_boolean af;
643 bfd_boolean bf;
644 flagword aflags;
645 flagword bflags;
252b5132
RH
646
647 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
648 return 1;
649 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
650 return -1;
651
652 if (a->section > b->section)
653 return 1;
654 else if (a->section < b->section)
655 return -1;
656
657 an = bfd_asymbol_name (a);
658 bn = bfd_asymbol_name (b);
659 anl = strlen (an);
660 bnl = strlen (bn);
661
662 /* The symbols gnu_compiled and gcc2_compiled convey no real
663 information, so put them after other symbols with the same value. */
252b5132
RH
664 af = (strstr (an, "gnu_compiled") != NULL
665 || strstr (an, "gcc2_compiled") != NULL);
666 bf = (strstr (bn, "gnu_compiled") != NULL
667 || strstr (bn, "gcc2_compiled") != NULL);
668
669 if (af && ! bf)
670 return 1;
671 if (! af && bf)
672 return -1;
673
674 /* We use a heuristic for the file name, to try to sort it after
675 more useful symbols. It may not work on non Unix systems, but it
676 doesn't really matter; the only difference is precisely which
677 symbol names get printed. */
678
679#define file_symbol(s, sn, snl) \
680 (((s)->flags & BSF_FILE) != 0 \
681 || ((sn)[(snl) - 2] == '.' \
682 && ((sn)[(snl) - 1] == 'o' \
683 || (sn)[(snl) - 1] == 'a')))
684
685 af = file_symbol (a, an, anl);
686 bf = file_symbol (b, bn, bnl);
687
688 if (af && ! bf)
689 return 1;
690 if (! af && bf)
691 return -1;
692
693 /* Try to sort global symbols before local symbols before function
694 symbols before debugging symbols. */
695
696 aflags = a->flags;
697 bflags = b->flags;
698
699 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
700 {
701 if ((aflags & BSF_DEBUGGING) != 0)
702 return 1;
703 else
704 return -1;
705 }
706 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
707 {
708 if ((aflags & BSF_FUNCTION) != 0)
709 return -1;
710 else
711 return 1;
712 }
713 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
714 {
715 if ((aflags & BSF_LOCAL) != 0)
716 return 1;
717 else
718 return -1;
719 }
720 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
721 {
722 if ((aflags & BSF_GLOBAL) != 0)
723 return -1;
724 else
725 return 1;
726 }
727
728 /* Symbols that start with '.' might be section names, so sort them
729 after symbols that don't start with '.'. */
730 if (an[0] == '.' && bn[0] != '.')
731 return 1;
732 if (an[0] != '.' && bn[0] == '.')
733 return -1;
734
735 /* Finally, if we can't distinguish them in any other way, try to
736 get consistent results by sorting the symbols by name. */
737 return strcmp (an, bn);
738}
739
740/* Sort relocs into address order. */
741
742static int
46dca2e0 743compare_relocs (const void *ap, const void *bp)
252b5132 744{
46dca2e0
NC
745 const arelent *a = * (const arelent **) ap;
746 const arelent *b = * (const arelent **) bp;
252b5132
RH
747
748 if (a->address > b->address)
749 return 1;
750 else if (a->address < b->address)
751 return -1;
752
753 /* So that associated relocations tied to the same address show up
754 in the correct order, we don't do any further sorting. */
755 if (a > b)
756 return 1;
757 else if (a < b)
758 return -1;
759 else
760 return 0;
761}
762
155e0d23
NC
763/* Print an address (VMA) to the output stream in INFO.
764 If SKIP_ZEROES is TRUE, omit leading zeroes. */
252b5132
RH
765
766static void
91d6fa6a 767objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
46dca2e0 768 bfd_boolean skip_zeroes)
252b5132
RH
769{
770 char buf[30];
771 char *p;
3b9ad1cc 772 struct objdump_disasm_info *aux;
252b5132 773
91d6fa6a 774 aux = (struct objdump_disasm_info *) inf->application_data;
d8180c76 775 bfd_sprintf_vma (aux->abfd, buf, vma);
252b5132
RH
776 if (! skip_zeroes)
777 p = buf;
778 else
779 {
780 for (p = buf; *p == '0'; ++p)
781 ;
782 if (*p == '\0')
783 --p;
784 }
91d6fa6a 785 (*inf->fprintf_func) (inf->stream, "%s", p);
252b5132
RH
786}
787
788/* Print the name of a symbol. */
789
790static void
91d6fa6a 791objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
46dca2e0 792 asymbol *sym)
252b5132
RH
793{
794 char *alloc;
795 const char *name;
252b5132
RH
796
797 alloc = NULL;
798 name = bfd_asymbol_name (sym);
a6637ec0 799 if (do_demangle && name[0] != '\0')
252b5132
RH
800 {
801 /* Demangle the name. */
ed180cc5
AM
802 alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
803 if (alloc != NULL)
804 name = alloc;
252b5132
RH
805 }
806
91d6fa6a
NC
807 if (inf != NULL)
808 (*inf->fprintf_func) (inf->stream, "%s", name);
252b5132 809 else
a6637ec0 810 printf ("%s", name);
252b5132
RH
811
812 if (alloc != NULL)
813 free (alloc);
814}
815
22a398e1
NC
816/* Locate a symbol given a bfd and a section (from INFO->application_data),
817 and a VMA. If INFO->application_data->require_sec is TRUE, then always
818 require the symbol to be in the section. Returns NULL if there is no
819 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
820 of the symbol in sorted_syms. */
252b5132
RH
821
822static asymbol *
3b9ad1cc 823find_symbol_for_address (bfd_vma vma,
91d6fa6a 824 struct disassemble_info *inf,
3b9ad1cc 825 long *place)
252b5132
RH
826{
827 /* @@ Would it speed things up to cache the last two symbols returned,
828 and maybe their address ranges? For many processors, only one memory
829 operand can be present at a time, so the 2-entry cache wouldn't be
830 constantly churned by code doing heavy memory accesses. */
831
832 /* Indices in `sorted_syms'. */
833 long min = 0;
91d6fa6a 834 long max_count = sorted_symcount;
252b5132 835 long thisplace;
3b9ad1cc
AM
836 struct objdump_disasm_info *aux;
837 bfd *abfd;
838 asection *sec;
839 unsigned int opb;
e39ff52a 840 bfd_boolean want_section;
252b5132
RH
841
842 if (sorted_symcount < 1)
843 return NULL;
844
91d6fa6a 845 aux = (struct objdump_disasm_info *) inf->application_data;
3b9ad1cc
AM
846 abfd = aux->abfd;
847 sec = aux->sec;
91d6fa6a 848 opb = inf->octets_per_byte;
3b9ad1cc 849
252b5132 850 /* Perform a binary search looking for the closest symbol to the
91d6fa6a
NC
851 required value. We are searching the range (min, max_count]. */
852 while (min + 1 < max_count)
252b5132
RH
853 {
854 asymbol *sym;
855
91d6fa6a 856 thisplace = (max_count + min) / 2;
252b5132
RH
857 sym = sorted_syms[thisplace];
858
859 if (bfd_asymbol_value (sym) > vma)
91d6fa6a 860 max_count = thisplace;
252b5132
RH
861 else if (bfd_asymbol_value (sym) < vma)
862 min = thisplace;
863 else
864 {
865 min = thisplace;
866 break;
867 }
868 }
869
870 /* The symbol we want is now in min, the low end of the range we
871 were searching. If there are several symbols with the same
872 value, we want the first one. */
873 thisplace = min;
874 while (thisplace > 0
875 && (bfd_asymbol_value (sorted_syms[thisplace])
876 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
877 --thisplace;
878
2b4590fb
AM
879 /* Prefer a symbol in the current section if we have multple symbols
880 with the same value, as can occur with overlays or zero size
881 sections. */
882 min = thisplace;
91d6fa6a 883 while (min < max_count
2b4590fb
AM
884 && (bfd_asymbol_value (sorted_syms[min])
885 == bfd_asymbol_value (sorted_syms[thisplace])))
886 {
887 if (sorted_syms[min]->section == sec
91d6fa6a 888 && inf->symbol_is_valid (sorted_syms[min], inf))
2b4590fb
AM
889 {
890 thisplace = min;
891
892 if (place != NULL)
893 *place = thisplace;
894
895 return sorted_syms[thisplace];
896 }
897 ++min;
898 }
899
1049f94e 900 /* If the file is relocatable, and the symbol could be from this
252b5132
RH
901 section, prefer a symbol from this section over symbols from
902 others, even if the other symbol's value might be closer.
0af11b59 903
252b5132
RH
904 Note that this may be wrong for some symbol references if the
905 sections have overlapping memory ranges, but in that case there's
906 no way to tell what's desired without looking at the relocation
e39ff52a
PB
907 table.
908
909 Also give the target a chance to reject symbols. */
910 want_section = (aux->require_sec
911 || ((abfd->flags & HAS_RELOC) != 0
912 && vma >= bfd_get_section_vma (abfd, sec)
913 && vma < (bfd_get_section_vma (abfd, sec)
914 + bfd_section_size (abfd, sec) / opb)));
915 if ((sorted_syms[thisplace]->section != sec && want_section)
91d6fa6a 916 || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
252b5132
RH
917 {
918 long i;
2b4590fb 919 long newplace = sorted_symcount;
98a91d6a 920
2b4590fb 921 for (i = min - 1; i >= 0; i--)
252b5132 922 {
e39ff52a 923 if ((sorted_syms[i]->section == sec || !want_section)
91d6fa6a 924 && inf->symbol_is_valid (sorted_syms[i], inf))
252b5132 925 {
e39ff52a
PB
926 if (newplace == sorted_symcount)
927 newplace = i;
928
929 if (bfd_asymbol_value (sorted_syms[i])
930 != bfd_asymbol_value (sorted_syms[newplace]))
931 break;
932
933 /* Remember this symbol and keep searching until we reach
934 an earlier address. */
935 newplace = i;
252b5132
RH
936 }
937 }
938
e39ff52a
PB
939 if (newplace != sorted_symcount)
940 thisplace = newplace;
941 else
252b5132
RH
942 {
943 /* We didn't find a good symbol with a smaller value.
944 Look for one with a larger value. */
945 for (i = thisplace + 1; i < sorted_symcount; i++)
946 {
e39ff52a 947 if ((sorted_syms[i]->section == sec || !want_section)
91d6fa6a 948 && inf->symbol_is_valid (sorted_syms[i], inf))
252b5132
RH
949 {
950 thisplace = i;
951 break;
952 }
953 }
954 }
955
e39ff52a 956 if ((sorted_syms[thisplace]->section != sec && want_section)
91d6fa6a 957 || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
22a398e1
NC
958 /* There is no suitable symbol. */
959 return NULL;
960 }
961
252b5132
RH
962 if (place != NULL)
963 *place = thisplace;
964
965 return sorted_syms[thisplace];
966}
967
155e0d23 968/* Print an address and the offset to the nearest symbol. */
252b5132
RH
969
970static void
46dca2e0 971objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
91d6fa6a 972 bfd_vma vma, struct disassemble_info *inf,
46dca2e0 973 bfd_boolean skip_zeroes)
252b5132 974{
91d6fa6a 975 objdump_print_value (vma, inf, skip_zeroes);
252b5132
RH
976
977 if (sym == NULL)
978 {
979 bfd_vma secaddr;
980
91d6fa6a
NC
981 (*inf->fprintf_func) (inf->stream, " <%s",
982 bfd_get_section_name (abfd, sec));
252b5132
RH
983 secaddr = bfd_get_section_vma (abfd, sec);
984 if (vma < secaddr)
985 {
91d6fa6a
NC
986 (*inf->fprintf_func) (inf->stream, "-0x");
987 objdump_print_value (secaddr - vma, inf, TRUE);
252b5132
RH
988 }
989 else if (vma > secaddr)
990 {
91d6fa6a
NC
991 (*inf->fprintf_func) (inf->stream, "+0x");
992 objdump_print_value (vma - secaddr, inf, TRUE);
252b5132 993 }
91d6fa6a 994 (*inf->fprintf_func) (inf->stream, ">");
252b5132
RH
995 }
996 else
997 {
91d6fa6a
NC
998 (*inf->fprintf_func) (inf->stream, " <");
999 objdump_print_symname (abfd, inf, sym);
252b5132
RH
1000 if (bfd_asymbol_value (sym) > vma)
1001 {
91d6fa6a
NC
1002 (*inf->fprintf_func) (inf->stream, "-0x");
1003 objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
252b5132
RH
1004 }
1005 else if (vma > bfd_asymbol_value (sym))
1006 {
91d6fa6a
NC
1007 (*inf->fprintf_func) (inf->stream, "+0x");
1008 objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
252b5132 1009 }
91d6fa6a 1010 (*inf->fprintf_func) (inf->stream, ">");
252b5132 1011 }
98ec6e72
NC
1012
1013 if (display_file_offsets)
91d6fa6a 1014 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
98ec6e72 1015 (long int)(sec->filepos + (vma - sec->vma)));
252b5132
RH
1016}
1017
155e0d23
NC
1018/* Print an address (VMA), symbolically if possible.
1019 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
252b5132
RH
1020
1021static void
3b9ad1cc 1022objdump_print_addr (bfd_vma vma,
91d6fa6a 1023 struct disassemble_info *inf,
46dca2e0 1024 bfd_boolean skip_zeroes)
252b5132 1025{
3b9ad1cc 1026 struct objdump_disasm_info *aux;
d253b654 1027 asymbol *sym = NULL;
ce04548a 1028 bfd_boolean skip_find = FALSE;
252b5132 1029
91d6fa6a 1030 aux = (struct objdump_disasm_info *) inf->application_data;
32760852 1031
252b5132
RH
1032 if (sorted_symcount < 1)
1033 {
91d6fa6a
NC
1034 (*inf->fprintf_func) (inf->stream, "0x");
1035 objdump_print_value (vma, inf, skip_zeroes);
32760852
NC
1036
1037 if (display_file_offsets)
91d6fa6a
NC
1038 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1039 (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
252b5132
RH
1040 return;
1041 }
1042
ce04548a
NC
1043 if (aux->reloc != NULL
1044 && aux->reloc->sym_ptr_ptr != NULL
1045 && * aux->reloc->sym_ptr_ptr != NULL)
1046 {
1047 sym = * aux->reloc->sym_ptr_ptr;
1048
1049 /* Adjust the vma to the reloc. */
1050 vma += bfd_asymbol_value (sym);
1051
1052 if (bfd_is_und_section (bfd_get_section (sym)))
1053 skip_find = TRUE;
1054 }
1055
1056 if (!skip_find)
91d6fa6a 1057 sym = find_symbol_for_address (vma, inf, NULL);
ce04548a 1058
91d6fa6a 1059 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf,
252b5132
RH
1060 skip_zeroes);
1061}
1062
1063/* Print VMA to INFO. This function is passed to the disassembler
1064 routine. */
1065
1066static void
91d6fa6a 1067objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
252b5132 1068{
91d6fa6a 1069 objdump_print_addr (vma, inf, ! prefix_addresses);
252b5132
RH
1070}
1071
2ae86dfc 1072/* Determine if the given address has a symbol associated with it. */
252b5132
RH
1073
1074static int
91d6fa6a 1075objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
252b5132 1076{
252b5132
RH
1077 asymbol * sym;
1078
91d6fa6a 1079 sym = find_symbol_for_address (vma, inf, NULL);
252b5132
RH
1080
1081 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
1082}
1083
1084/* Hold the last function name and the last line number we displayed
1085 in a disassembly. */
1086
1087static char *prev_functionname;
1088static unsigned int prev_line;
9b8d1a36 1089static unsigned int prev_discriminator;
252b5132
RH
1090
1091/* We keep a list of all files that we have seen when doing a
50c2245b 1092 disassembly with source, so that we know how much of the file to
252b5132
RH
1093 display. This can be important for inlined functions. */
1094
1095struct print_file_list
1096{
1097 struct print_file_list *next;
43ac9881
AM
1098 const char *filename;
1099 const char *modname;
e8f5eee4
NC
1100 const char *map;
1101 size_t mapsize;
1102 const char **linemap;
1103 unsigned maxline;
1104 unsigned last_line;
1105 int first;
252b5132
RH
1106};
1107
1108static struct print_file_list *print_files;
1109
1110/* The number of preceding context lines to show when we start
1111 displaying a file for the first time. */
1112
1113#define SHOW_PRECEDING_CONTEXT_LINES (5)
1114
417ed8af 1115/* Read a complete file into memory. */
e8f5eee4
NC
1116
1117static const char *
1118slurp_file (const char *fn, size_t *size)
1119{
1120#ifdef HAVE_MMAP
1121 int ps = getpagesize ();
1122 size_t msize;
1123#endif
1124 const char *map;
1125 struct stat st;
417ed8af 1126 int fd = open (fn, O_RDONLY | O_BINARY);
e8f5eee4
NC
1127
1128 if (fd < 0)
1129 return NULL;
1130 if (fstat (fd, &st) < 0)
6c713012
AM
1131 {
1132 close (fd);
1133 return NULL;
1134 }
e8f5eee4
NC
1135 *size = st.st_size;
1136#ifdef HAVE_MMAP
1137 msize = (*size + ps - 1) & ~(ps - 1);
1138 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
6c713012 1139 if (map != (char *) -1L)
e8f5eee4 1140 {
6c713012
AM
1141 close (fd);
1142 return map;
e8f5eee4
NC
1143 }
1144#endif
3f5e193b 1145 map = (const char *) malloc (*size);
6c713012
AM
1146 if (!map || (size_t) read (fd, (char *) map, *size) != *size)
1147 {
1148 free ((void *) map);
e8f5eee4
NC
1149 map = NULL;
1150 }
1151 close (fd);
6c713012 1152 return map;
e8f5eee4
NC
1153}
1154
1155#define line_map_decrease 5
1156
1157/* Precompute array of lines for a mapped file. */
1158
1159static const char **
1160index_file (const char *map, size_t size, unsigned int *maxline)
1161{
1162 const char *p, *lstart, *end;
1163 int chars_per_line = 45; /* First iteration will use 40. */
1164 unsigned int lineno;
1165 const char **linemap = NULL;
1166 unsigned long line_map_size = 0;
1167
1168 lineno = 0;
1169 lstart = map;
1170 end = map + size;
1171
1172 for (p = map; p < end; p++)
1173 {
1174 if (*p == '\n')
1175 {
1176 if (p + 1 < end && p[1] == '\r')
1177 p++;
1178 }
1179 else if (*p == '\r')
1180 {
1181 if (p + 1 < end && p[1] == '\n')
1182 p++;
1183 }
1184 else
1185 continue;
1186
1187 /* End of line found. */
1188
1189 if (linemap == NULL || line_map_size < lineno + 1)
1190 {
1191 unsigned long newsize;
1192
1193 chars_per_line -= line_map_decrease;
1194 if (chars_per_line <= 1)
1195 chars_per_line = 1;
1196 line_map_size = size / chars_per_line + 1;
1197 if (line_map_size < lineno + 1)
1198 line_map_size = lineno + 1;
1199 newsize = line_map_size * sizeof (char *);
3f5e193b 1200 linemap = (const char **) xrealloc (linemap, newsize);
e8f5eee4
NC
1201 }
1202
1203 linemap[lineno++] = lstart;
1204 lstart = p + 1;
1205 }
1206
1207 *maxline = lineno;
1208 return linemap;
1209}
1210
43ac9881
AM
1211/* Tries to open MODNAME, and if successful adds a node to print_files
1212 linked list and returns that node. Returns NULL on failure. */
1213
1214static struct print_file_list *
1215try_print_file_open (const char *origname, const char *modname)
1216{
1217 struct print_file_list *p;
43ac9881 1218
3f5e193b 1219 p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
43ac9881 1220
e8f5eee4
NC
1221 p->map = slurp_file (modname, &p->mapsize);
1222 if (p->map == NULL)
43ac9881 1223 {
e8f5eee4
NC
1224 free (p);
1225 return NULL;
43ac9881 1226 }
e8f5eee4
NC
1227
1228 p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1229 p->last_line = 0;
43ac9881
AM
1230 p->filename = origname;
1231 p->modname = modname;
43ac9881 1232 p->next = print_files;
e8f5eee4 1233 p->first = 1;
43ac9881
AM
1234 print_files = p;
1235 return p;
1236}
1237
a8685210 1238/* If the source file, as described in the symtab, is not found
43ac9881
AM
1239 try to locate it in one of the paths specified with -I
1240 If found, add location to print_files linked list. */
1241
1242static struct print_file_list *
1243update_source_path (const char *filename)
1244{
1245 struct print_file_list *p;
1246 const char *fname;
1247 int i;
1248
43ac9881
AM
1249 p = try_print_file_open (filename, filename);
1250 if (p != NULL)
1251 return p;
1252
1253 if (include_path_count == 0)
1254 return NULL;
1255
1256 /* Get the name of the file. */
fd3a6816 1257 fname = lbasename (filename);
43ac9881
AM
1258
1259 /* If file exists under a new path, we need to add it to the list
1260 so that show_line knows about it. */
1261 for (i = 0; i < include_path_count; i++)
1262 {
1263 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1264
1265 p = try_print_file_open (filename, modname);
1266 if (p)
1267 return p;
1268
1269 free (modname);
1270 }
1271
1272 return NULL;
1273}
1274
e8f5eee4 1275/* Print a source file line. */
252b5132 1276
e8f5eee4 1277static void
91d6fa6a 1278print_line (struct print_file_list *p, unsigned int linenum)
252b5132 1279{
e8f5eee4 1280 const char *l;
615f3149 1281 size_t len;
e8f5eee4 1282
91d6fa6a
NC
1283 --linenum;
1284 if (linenum >= p->maxline)
e8f5eee4 1285 return;
91d6fa6a 1286 l = p->linemap [linenum];
615f3149
AM
1287 /* Test fwrite return value to quiet glibc warning. */
1288 len = strcspn (l, "\n\r");
1289 if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1290 putchar ('\n');
1291}
252b5132 1292
e8f5eee4 1293/* Print a range of source code lines. */
252b5132 1294
e8f5eee4
NC
1295static void
1296dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1297{
1298 if (p->map == NULL)
1299 return;
1300 while (start <= end)
1301 {
1302 print_line (p, start);
1303 start++;
252b5132 1304 }
0af11b59 1305}
252b5132 1306
50c2245b 1307/* Show the line number, or the source line, in a disassembly
252b5132
RH
1308 listing. */
1309
1310static void
46dca2e0 1311show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
252b5132 1312{
b1f88ebe
AM
1313 const char *filename;
1314 const char *functionname;
91d6fa6a 1315 unsigned int linenumber;
9b8d1a36 1316 unsigned int discriminator;
0dafdf3f 1317 bfd_boolean reloc;
252b5132
RH
1318
1319 if (! with_line_numbers && ! with_source_code)
1320 return;
1321
9b8d1a36
CC
1322 if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset,
1323 &filename, &functionname,
1324 &linenumber, &discriminator))
252b5132
RH
1325 return;
1326
1327 if (filename != NULL && *filename == '\0')
1328 filename = NULL;
1329 if (functionname != NULL && *functionname == '\0')
1330 functionname = NULL;
1331
0dafdf3f
L
1332 if (filename
1333 && IS_ABSOLUTE_PATH (filename)
1334 && prefix)
1335 {
1336 char *path_up;
1337 const char *fname = filename;
1338 char *path = (char *) alloca (prefix_length + PATH_MAX + 1);
1339
1340 if (prefix_length)
1341 memcpy (path, prefix, prefix_length);
1342 path_up = path + prefix_length;
1343
1344 /* Build relocated filename, stripping off leading directories
1345 from the initial filename if requested. */
1346 if (prefix_strip > 0)
1347 {
1348 int level = 0;
1349 const char *s;
1350
1351 /* Skip selected directory levels. */
1352 for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1353 if (IS_DIR_SEPARATOR(*s))
1354 {
1355 fname = s;
1356 level++;
1357 }
1358 }
1359
1360 /* Update complete filename. */
1361 strncpy (path_up, fname, PATH_MAX);
1362 path_up[PATH_MAX] = '\0';
1363
1364 filename = path;
1365 reloc = TRUE;
1366 }
1367 else
1368 reloc = FALSE;
1369
252b5132
RH
1370 if (with_line_numbers)
1371 {
1372 if (functionname != NULL
1373 && (prev_functionname == NULL
1374 || strcmp (functionname, prev_functionname) != 0))
1375 printf ("%s():\n", functionname);
9b8d1a36
CC
1376 if (linenumber > 0 && (linenumber != prev_line ||
1377 (discriminator != prev_discriminator)))
1378 {
1379 if (discriminator > 0)
1380 printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename,
1381 linenumber, discriminator);
1382 else
1383 printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
1384 }
252b5132
RH
1385 }
1386
1387 if (with_source_code
1388 && filename != NULL
91d6fa6a 1389 && linenumber > 0)
252b5132
RH
1390 {
1391 struct print_file_list **pp, *p;
e8f5eee4 1392 unsigned l;
252b5132
RH
1393
1394 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
8b6efd89 1395 if (filename_cmp ((*pp)->filename, filename) == 0)
252b5132
RH
1396 break;
1397 p = *pp;
1398
e8f5eee4 1399 if (p == NULL)
0dafdf3f
L
1400 {
1401 if (reloc)
1402 filename = xstrdup (filename);
43ac9881 1403 p = update_source_path (filename);
0dafdf3f 1404 }
252b5132 1405
91d6fa6a 1406 if (p != NULL && linenumber != p->last_line)
e8f5eee4
NC
1407 {
1408 if (file_start_context && p->first)
1409 l = 1;
1410 else
252b5132 1411 {
91d6fa6a
NC
1412 l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
1413 if (l >= linenumber)
e8f5eee4 1414 l = 1;
91d6fa6a 1415 if (p->last_line >= l && p->last_line <= linenumber)
e8f5eee4 1416 l = p->last_line + 1;
252b5132 1417 }
91d6fa6a
NC
1418 dump_lines (p, l, linenumber);
1419 p->last_line = linenumber;
e8f5eee4 1420 p->first = 0;
252b5132
RH
1421 }
1422 }
1423
1424 if (functionname != NULL
1425 && (prev_functionname == NULL
1426 || strcmp (functionname, prev_functionname) != 0))
1427 {
1428 if (prev_functionname != NULL)
1429 free (prev_functionname);
3f5e193b 1430 prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
252b5132
RH
1431 strcpy (prev_functionname, functionname);
1432 }
1433
91d6fa6a
NC
1434 if (linenumber > 0 && linenumber != prev_line)
1435 prev_line = linenumber;
9b8d1a36
CC
1436
1437 if (discriminator != prev_discriminator)
1438 prev_discriminator = discriminator;
252b5132
RH
1439}
1440
1441/* Pseudo FILE object for strings. */
1442typedef struct
1443{
1444 char *buffer;
6f104306
NS
1445 size_t pos;
1446 size_t alloc;
252b5132
RH
1447} SFILE;
1448
46dca2e0 1449/* sprintf to a "stream". */
252b5132 1450
0fd3a477 1451static int ATTRIBUTE_PRINTF_2
46dca2e0 1452objdump_sprintf (SFILE *f, const char *format, ...)
252b5132 1453{
252b5132 1454 size_t n;
46dca2e0 1455 va_list args;
252b5132 1456
6f104306 1457 while (1)
252b5132 1458 {
6f104306
NS
1459 size_t space = f->alloc - f->pos;
1460
1461 va_start (args, format);
1462 n = vsnprintf (f->buffer + f->pos, space, format, args);
451dad9c 1463 va_end (args);
252b5132 1464
6f104306
NS
1465 if (space > n)
1466 break;
1467
1468 f->alloc = (f->alloc + n) * 2;
3f5e193b 1469 f->buffer = (char *) xrealloc (f->buffer, f->alloc);
252b5132 1470 }
6f104306
NS
1471 f->pos += n;
1472
252b5132
RH
1473 return n;
1474}
1475
1476/* The number of zeroes we want to see before we start skipping them.
1477 The number is arbitrarily chosen. */
1478
0bcb06d2 1479#define DEFAULT_SKIP_ZEROES 8
252b5132
RH
1480
1481/* The number of zeroes to skip at the end of a section. If the
1482 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1483 SKIP_ZEROES, they will be disassembled. If there are fewer than
1484 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1485 attempt to avoid disassembling zeroes inserted by section
1486 alignment. */
1487
0bcb06d2 1488#define DEFAULT_SKIP_ZEROES_AT_END 3
252b5132
RH
1489
1490/* Disassemble some data in memory between given values. */
1491
1492static void
91d6fa6a 1493disassemble_bytes (struct disassemble_info * inf,
46dca2e0
NC
1494 disassembler_ftype disassemble_fn,
1495 bfd_boolean insns,
1496 bfd_byte * data,
1497 bfd_vma start_offset,
1498 bfd_vma stop_offset,
fd7bb956 1499 bfd_vma rel_offset,
46dca2e0
NC
1500 arelent *** relppp,
1501 arelent ** relppend)
252b5132
RH
1502{
1503 struct objdump_disasm_info *aux;
1504 asection *section;
940b2b78 1505 int octets_per_line;
252b5132 1506 int skip_addr_chars;
940b2b78 1507 bfd_vma addr_offset;
91d6fa6a
NC
1508 unsigned int opb = inf->octets_per_byte;
1509 unsigned int skip_zeroes = inf->skip_zeroes;
1510 unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
ce04548a 1511 int octets = opb;
6f104306 1512 SFILE sfile;
252b5132 1513
91d6fa6a 1514 aux = (struct objdump_disasm_info *) inf->application_data;
252b5132
RH
1515 section = aux->sec;
1516
6f104306 1517 sfile.alloc = 120;
3f5e193b 1518 sfile.buffer = (char *) xmalloc (sfile.alloc);
6f104306
NS
1519 sfile.pos = 0;
1520
3dcb3fcb
L
1521 if (insn_width)
1522 octets_per_line = insn_width;
1523 else if (insns)
940b2b78 1524 octets_per_line = 4;
252b5132 1525 else
940b2b78 1526 octets_per_line = 16;
252b5132
RH
1527
1528 /* Figure out how many characters to skip at the start of an
1529 address, to make the disassembly look nicer. We discard leading
1530 zeroes in chunks of 4, ensuring that there is always a leading
1531 zero remaining. */
1532 skip_addr_chars = 0;
1533 if (! prefix_addresses)
1534 {
1535 char buf[30];
17ceb936
AM
1536
1537 bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1538
1539 while (buf[skip_addr_chars] == '0')
1540 ++skip_addr_chars;
1541
1542 /* Don't discard zeros on overflow. */
1543 if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1544 skip_addr_chars = 0;
1545
1546 if (skip_addr_chars != 0)
1547 skip_addr_chars = (skip_addr_chars - 1) & -4;
252b5132
RH
1548 }
1549
91d6fa6a 1550 inf->insn_info_valid = 0;
252b5132 1551
940b2b78
TW
1552 addr_offset = start_offset;
1553 while (addr_offset < stop_offset)
252b5132
RH
1554 {
1555 bfd_vma z;
b34976b6 1556 bfd_boolean need_nl = FALSE;
ce04548a
NC
1557 int previous_octets;
1558
1559 /* Remember the length of the previous instruction. */
1560 previous_octets = octets;
ce04548a 1561 octets = 0;
252b5132 1562
bb7c70ed
NC
1563 /* Make sure we don't use relocs from previous instructions. */
1564 aux->reloc = NULL;
1565
940b2b78 1566 /* If we see more than SKIP_ZEROES octets of zeroes, we just
43ac9881 1567 print `...'. */
940b2b78 1568 for (z = addr_offset * opb; z < stop_offset * opb; z++)
252b5132
RH
1569 if (data[z] != 0)
1570 break;
1571 if (! disassemble_zeroes
91d6fa6a
NC
1572 && (inf->insn_info_valid == 0
1573 || inf->branch_delay_insns == 0)
0bcb06d2 1574 && (z - addr_offset * opb >= skip_zeroes
0af11b59 1575 || (z == stop_offset * opb &&
0bcb06d2 1576 z - addr_offset * opb < skip_zeroes_at_end)))
252b5132 1577 {
940b2b78 1578 /* If there are more nonzero octets to follow, we only skip
43ac9881
AM
1579 zeroes in multiples of 4, to try to avoid running over
1580 the start of an instruction which happens to start with
1581 zero. */
940b2b78
TW
1582 if (z != stop_offset * opb)
1583 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
252b5132 1584
940b2b78 1585 octets = z - addr_offset * opb;
98ec6e72
NC
1586
1587 /* If we are going to display more data, and we are displaying
1588 file offsets, then tell the user how many zeroes we skip
1589 and the file offset from where we resume dumping. */
1590 if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1591 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1592 octets / opb,
0af1713e
AM
1593 (unsigned long) (section->filepos
1594 + (addr_offset + (octets / opb))));
98ec6e72
NC
1595 else
1596 printf ("\t...\n");
252b5132
RH
1597 }
1598 else
1599 {
1600 char buf[50];
252b5132
RH
1601 int bpc = 0;
1602 int pb = 0;
1603
252b5132 1604 if (with_line_numbers || with_source_code)
bc79cded 1605 show_line (aux->abfd, section, addr_offset);
252b5132
RH
1606
1607 if (! prefix_addresses)
1608 {
1609 char *s;
1610
d8180c76 1611 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
252b5132
RH
1612 for (s = buf + skip_addr_chars; *s == '0'; s++)
1613 *s = ' ';
1614 if (*s == '\0')
1615 *--s = '0';
1616 printf ("%s:\t", buf + skip_addr_chars);
1617 }
1618 else
1619 {
b34976b6 1620 aux->require_sec = TRUE;
91d6fa6a 1621 objdump_print_address (section->vma + addr_offset, inf);
b34976b6 1622 aux->require_sec = FALSE;
252b5132
RH
1623 putchar (' ');
1624 }
1625
1626 if (insns)
1627 {
6f104306 1628 sfile.pos = 0;
91d6fa6a
NC
1629 inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
1630 inf->stream = &sfile;
1631 inf->bytes_per_line = 0;
1632 inf->bytes_per_chunk = 0;
1633 inf->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
0313a2b8 1634 if (machine)
91d6fa6a 1635 inf->flags |= USER_SPECIFIED_MACHINE_TYPE;
252b5132 1636
91d6fa6a 1637 if (inf->disassembler_needs_relocs
7df428b1
RS
1638 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1639 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
d99b6465 1640 && *relppp < relppend)
ce04548a
NC
1641 {
1642 bfd_signed_vma distance_to_rel;
1643
1644 distance_to_rel = (**relppp)->address
1645 - (rel_offset + addr_offset);
1646
1647 /* Check to see if the current reloc is associated with
1648 the instruction that we are about to disassemble. */
1649 if (distance_to_rel == 0
1650 /* FIXME: This is wrong. We are trying to catch
1651 relocs that are addressed part way through the
1652 current instruction, as might happen with a packed
1653 VLIW instruction. Unfortunately we do not know the
1654 length of the current instruction since we have not
1655 disassembled it yet. Instead we take a guess based
1656 upon the length of the previous instruction. The
1657 proper solution is to have a new target-specific
1658 disassembler function which just returns the length
1659 of an instruction at a given address without trying
1660 to display its disassembly. */
1661 || (distance_to_rel > 0
1662 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1663 {
91d6fa6a 1664 inf->flags |= INSN_HAS_RELOC;
ce04548a
NC
1665 aux->reloc = **relppp;
1666 }
ce04548a 1667 }
d99b6465 1668
91d6fa6a
NC
1669 octets = (*disassemble_fn) (section->vma + addr_offset, inf);
1670 inf->fprintf_func = (fprintf_ftype) fprintf;
1671 inf->stream = stdout;
1672 if (insn_width == 0 && inf->bytes_per_line != 0)
1673 octets_per_line = inf->bytes_per_line;
a8c62f1c 1674 if (octets < (int) opb)
e07bf1ac 1675 {
6f104306 1676 if (sfile.pos)
e07bf1ac 1677 printf ("%s\n", sfile.buffer);
a8c62f1c
AM
1678 if (octets >= 0)
1679 {
1680 non_fatal (_("disassemble_fn returned length %d"),
1681 octets);
1682 exit_status = 1;
1683 }
e07bf1ac
ILT
1684 break;
1685 }
252b5132
RH
1686 }
1687 else
1688 {
b4c96d0d 1689 bfd_vma j;
252b5132 1690
940b2b78
TW
1691 octets = octets_per_line;
1692 if (addr_offset + octets / opb > stop_offset)
1693 octets = (stop_offset - addr_offset) * opb;
252b5132 1694
940b2b78 1695 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
252b5132 1696 {
3882b010 1697 if (ISPRINT (data[j]))
940b2b78 1698 buf[j - addr_offset * opb] = data[j];
252b5132 1699 else
940b2b78 1700 buf[j - addr_offset * opb] = '.';
252b5132 1701 }
940b2b78 1702 buf[j - addr_offset * opb] = '\0';
252b5132
RH
1703 }
1704
1705 if (prefix_addresses
1706 ? show_raw_insn > 0
1707 : show_raw_insn >= 0)
1708 {
b4c96d0d 1709 bfd_vma j;
252b5132
RH
1710
1711 /* If ! prefix_addresses and ! wide_output, we print
43ac9881 1712 octets_per_line octets per line. */
940b2b78
TW
1713 pb = octets;
1714 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1715 pb = octets_per_line;
252b5132 1716
91d6fa6a
NC
1717 if (inf->bytes_per_chunk)
1718 bpc = inf->bytes_per_chunk;
252b5132
RH
1719 else
1720 bpc = 1;
1721
940b2b78 1722 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
252b5132
RH
1723 {
1724 int k;
ed049af3 1725
91d6fa6a 1726 if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
252b5132
RH
1727 {
1728 for (k = bpc - 1; k >= 0; k--)
1729 printf ("%02x", (unsigned) data[j + k]);
1730 putchar (' ');
1731 }
1732 else
1733 {
1734 for (k = 0; k < bpc; k++)
1735 printf ("%02x", (unsigned) data[j + k]);
1736 putchar (' ');
1737 }
1738 }
1739
940b2b78 1740 for (; pb < octets_per_line; pb += bpc)
252b5132
RH
1741 {
1742 int k;
1743
1744 for (k = 0; k < bpc; k++)
1745 printf (" ");
1746 putchar (' ');
1747 }
1748
1749 /* Separate raw data from instruction by extra space. */
1750 if (insns)
1751 putchar ('\t');
1752 else
1753 printf (" ");
1754 }
1755
1756 if (! insns)
1757 printf ("%s", buf);
6f104306
NS
1758 else if (sfile.pos)
1759 printf ("%s", sfile.buffer);
252b5132
RH
1760
1761 if (prefix_addresses
1762 ? show_raw_insn > 0
1763 : show_raw_insn >= 0)
1764 {
940b2b78 1765 while (pb < octets)
252b5132 1766 {
b4c96d0d 1767 bfd_vma j;
252b5132
RH
1768 char *s;
1769
1770 putchar ('\n');
940b2b78 1771 j = addr_offset * opb + pb;
252b5132 1772
d8180c76 1773 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
252b5132
RH
1774 for (s = buf + skip_addr_chars; *s == '0'; s++)
1775 *s = ' ';
1776 if (*s == '\0')
1777 *--s = '0';
1778 printf ("%s:\t", buf + skip_addr_chars);
1779
940b2b78
TW
1780 pb += octets_per_line;
1781 if (pb > octets)
1782 pb = octets;
1783 for (; j < addr_offset * opb + pb; j += bpc)
252b5132
RH
1784 {
1785 int k;
1786
91d6fa6a 1787 if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
252b5132
RH
1788 {
1789 for (k = bpc - 1; k >= 0; k--)
1790 printf ("%02x", (unsigned) data[j + k]);
1791 putchar (' ');
1792 }
1793 else
1794 {
1795 for (k = 0; k < bpc; k++)
1796 printf ("%02x", (unsigned) data[j + k]);
1797 putchar (' ');
1798 }
1799 }
1800 }
1801 }
1802
1803 if (!wide_output)
1804 putchar ('\n');
1805 else
b34976b6 1806 need_nl = TRUE;
252b5132
RH
1807 }
1808
fd7bb956
AM
1809 while ((*relppp) < relppend
1810 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
252b5132 1811 {
fd7bb956 1812 if (dump_reloc_info || dump_dynamic_reloc_info)
252b5132
RH
1813 {
1814 arelent *q;
1815
1816 q = **relppp;
1817
1818 if (wide_output)
1819 putchar ('\t');
1820 else
1821 printf ("\t\t\t");
1822
68b3b8dc 1823 objdump_print_value (section->vma - rel_offset + q->address,
91d6fa6a 1824 inf, TRUE);
252b5132 1825
f9ecb0a4
JJ
1826 if (q->howto == NULL)
1827 printf (": *unknown*\t");
1828 else if (q->howto->name)
1829 printf (": %s\t", q->howto->name);
1830 else
1831 printf (": %d\t", q->howto->type);
252b5132
RH
1832
1833 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1834 printf ("*unknown*");
1835 else
1836 {
1837 const char *sym_name;
1838
1839 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1840 if (sym_name != NULL && *sym_name != '\0')
91d6fa6a 1841 objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
252b5132
RH
1842 else
1843 {
1844 asection *sym_sec;
1845
1846 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1847 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1848 if (sym_name == NULL || *sym_name == '\0')
1849 sym_name = "*unknown*";
1850 printf ("%s", sym_name);
1851 }
1852 }
1853
1854 if (q->addend)
1855 {
343dbc36
L
1856 bfd_signed_vma addend = q->addend;
1857 if (addend < 0)
1858 {
1859 printf ("-0x");
1860 addend = -addend;
1861 }
1862 else
1863 printf ("+0x");
1864 objdump_print_value (addend, inf, TRUE);
252b5132
RH
1865 }
1866
1867 printf ("\n");
b34976b6 1868 need_nl = FALSE;
252b5132 1869 }
fd7bb956 1870 ++(*relppp);
252b5132
RH
1871 }
1872
1873 if (need_nl)
1874 printf ("\n");
1875
940b2b78 1876 addr_offset += octets / opb;
252b5132 1877 }
6f104306
NS
1878
1879 free (sfile.buffer);
252b5132
RH
1880}
1881
155e0d23 1882static void
91d6fa6a 1883disassemble_section (bfd *abfd, asection *section, void *inf)
155e0d23 1884{
1b0adfe0
NC
1885 const struct elf_backend_data * bed;
1886 bfd_vma sign_adjust = 0;
91d6fa6a 1887 struct disassemble_info * pinfo = (struct disassemble_info *) inf;
3b9ad1cc 1888 struct objdump_disasm_info * paux;
155e0d23
NC
1889 unsigned int opb = pinfo->octets_per_byte;
1890 bfd_byte * data = NULL;
1891 bfd_size_type datasize = 0;
1892 arelent ** rel_pp = NULL;
1893 arelent ** rel_ppstart = NULL;
1894 arelent ** rel_ppend;
1895 unsigned long stop_offset;
1896 asymbol * sym = NULL;
1897 long place = 0;
1898 long rel_count;
1899 bfd_vma rel_offset;
1900 unsigned long addr_offset;
1901
1902 /* Sections that do not contain machine
1903 code are not normally disassembled. */
1904 if (! disassemble_all
70ecb384 1905 && only_list == NULL
46212538
AM
1906 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1907 != (SEC_CODE | SEC_HAS_CONTENTS)))
155e0d23
NC
1908 return;
1909
1910 if (! process_section_p (section))
1911 return;
1912
135dfb4a 1913 datasize = bfd_get_section_size (section);
155e0d23
NC
1914 if (datasize == 0)
1915 return;
1916
643902a4
AS
1917 if (start_address == (bfd_vma) -1
1918 || start_address < section->vma)
1919 addr_offset = 0;
1920 else
1921 addr_offset = start_address - section->vma;
1922
1923 if (stop_address == (bfd_vma) -1)
1924 stop_offset = datasize / opb;
1925 else
1926 {
1927 if (stop_address < section->vma)
1928 stop_offset = 0;
1929 else
1930 stop_offset = stop_address - section->vma;
1931 if (stop_offset > datasize / opb)
1932 stop_offset = datasize / opb;
1933 }
1934
1935 if (addr_offset >= stop_offset)
1936 return;
1937
155e0d23 1938 /* Decide which set of relocs to use. Load them if necessary. */
3b9ad1cc 1939 paux = (struct objdump_disasm_info *) pinfo->application_data;
155e0d23
NC
1940 if (paux->dynrelbuf)
1941 {
1942 rel_pp = paux->dynrelbuf;
1943 rel_count = paux->dynrelcount;
1944 /* Dynamic reloc addresses are absolute, non-dynamic are section
50c2245b 1945 relative. REL_OFFSET specifies the reloc address corresponding
155e0d23 1946 to the start of this section. */
68b3b8dc 1947 rel_offset = section->vma;
155e0d23
NC
1948 }
1949 else
1950 {
1951 rel_count = 0;
1952 rel_pp = NULL;
1953 rel_offset = 0;
1954
1955 if ((section->flags & SEC_RELOC) != 0
d99b6465 1956 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
155e0d23
NC
1957 {
1958 long relsize;
1959
1960 relsize = bfd_get_reloc_upper_bound (abfd, section);
1961 if (relsize < 0)
1962 bfd_fatal (bfd_get_filename (abfd));
1963
1964 if (relsize > 0)
1965 {
3f5e193b 1966 rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
155e0d23
NC
1967 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1968 if (rel_count < 0)
1969 bfd_fatal (bfd_get_filename (abfd));
1970
1971 /* Sort the relocs by address. */
1972 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1973 }
1974 }
155e0d23
NC
1975 }
1976 rel_ppend = rel_pp + rel_count;
1977
3f5e193b 1978 data = (bfd_byte *) xmalloc (datasize);
155e0d23
NC
1979
1980 bfd_get_section_contents (abfd, section, data, 0, datasize);
1981
1982 paux->sec = section;
1983 pinfo->buffer = data;
1984 pinfo->buffer_vma = section->vma;
1985 pinfo->buffer_length = datasize;
1986 pinfo->section = section;
1987
155e0d23
NC
1988 /* Skip over the relocs belonging to addresses below the
1989 start address. */
1990 while (rel_pp < rel_ppend
1991 && (*rel_pp)->address < rel_offset + addr_offset)
1992 ++rel_pp;
1993
643902a4 1994 printf (_("\nDisassembly of section %s:\n"), section->name);
155e0d23
NC
1995
1996 /* Find the nearest symbol forwards from our current position. */
3b9ad1cc 1997 paux->require_sec = TRUE;
3f5e193b 1998 sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
91d6fa6a 1999 (struct disassemble_info *) inf,
3f5e193b 2000 &place);
3b9ad1cc 2001 paux->require_sec = FALSE;
155e0d23 2002
46bc35a9
RS
2003 /* PR 9774: If the target used signed addresses then we must make
2004 sure that we sign extend the value that we calculate for 'addr'
2005 in the loop below. */
1b0adfe0
NC
2006 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2007 && (bed = get_elf_backend_data (abfd)) != NULL
2008 && bed->sign_extend_vma)
46bc35a9 2009 sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
1b0adfe0 2010
155e0d23
NC
2011 /* Disassemble a block of instructions up to the address associated with
2012 the symbol we have just found. Then print the symbol and find the
2013 next symbol on. Repeat until we have disassembled the entire section
2014 or we have reached the end of the address range we are interested in. */
2015 while (addr_offset < stop_offset)
2016 {
22a398e1 2017 bfd_vma addr;
155e0d23
NC
2018 asymbol *nextsym;
2019 unsigned long nextstop_offset;
2020 bfd_boolean insns;
2021
22a398e1 2022 addr = section->vma + addr_offset;
095ad3b8 2023 addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
22a398e1
NC
2024
2025 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
155e0d23
NC
2026 {
2027 int x;
2028
2029 for (x = place;
2030 (x < sorted_symcount
22a398e1 2031 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
155e0d23
NC
2032 ++x)
2033 continue;
2034
22a398e1 2035 pinfo->symbols = sorted_syms + place;
155e0d23 2036 pinfo->num_symbols = x - place;
2087ad84 2037 pinfo->symtab_pos = place;
155e0d23
NC
2038 }
2039 else
22a398e1
NC
2040 {
2041 pinfo->symbols = NULL;
2042 pinfo->num_symbols = 0;
2087ad84 2043 pinfo->symtab_pos = -1;
22a398e1 2044 }
155e0d23
NC
2045
2046 if (! prefix_addresses)
2047 {
2048 pinfo->fprintf_func (pinfo->stream, "\n");
22a398e1 2049 objdump_print_addr_with_sym (abfd, section, sym, addr,
155e0d23
NC
2050 pinfo, FALSE);
2051 pinfo->fprintf_func (pinfo->stream, ":\n");
2052 }
2053
22a398e1 2054 if (sym != NULL && bfd_asymbol_value (sym) > addr)
155e0d23
NC
2055 nextsym = sym;
2056 else if (sym == NULL)
2057 nextsym = NULL;
2058 else
2059 {
22a398e1
NC
2060#define is_valid_next_sym(SYM) \
2061 ((SYM)->section == section \
2062 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2063 && pinfo->symbol_is_valid (SYM, pinfo))
2064
155e0d23
NC
2065 /* Search forward for the next appropriate symbol in
2066 SECTION. Note that all the symbols are sorted
2067 together into one big array, and that some sections
2068 may have overlapping addresses. */
2069 while (place < sorted_symcount
22a398e1 2070 && ! is_valid_next_sym (sorted_syms [place]))
155e0d23 2071 ++place;
22a398e1 2072
155e0d23
NC
2073 if (place >= sorted_symcount)
2074 nextsym = NULL;
2075 else
2076 nextsym = sorted_syms[place];
2077 }
2078
22a398e1
NC
2079 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2080 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
155e0d23
NC
2081 else if (nextsym == NULL)
2082 nextstop_offset = stop_offset;
2083 else
22a398e1
NC
2084 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
2085
84d7b001
NC
2086 if (nextstop_offset > stop_offset
2087 || nextstop_offset <= addr_offset)
22a398e1 2088 nextstop_offset = stop_offset;
155e0d23
NC
2089
2090 /* If a symbol is explicitly marked as being an object
2091 rather than a function, just dump the bytes without
2092 disassembling them. */
2093 if (disassemble_all
2094 || sym == NULL
abf71725 2095 || sym->section != section
22a398e1 2096 || bfd_asymbol_value (sym) > addr
155e0d23
NC
2097 || ((sym->flags & BSF_OBJECT) == 0
2098 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
2099 == NULL)
2100 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
2101 == NULL))
2102 || (sym->flags & BSF_FUNCTION) != 0)
2103 insns = TRUE;
2104 else
2105 insns = FALSE;
2106
2107 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2108 addr_offset, nextstop_offset,
2109 rel_offset, &rel_pp, rel_ppend);
84d7b001 2110
155e0d23
NC
2111 addr_offset = nextstop_offset;
2112 sym = nextsym;
2113 }
2114
2115 free (data);
2116
2117 if (rel_ppstart != NULL)
2118 free (rel_ppstart);
2119}
2120
252b5132
RH
2121/* Disassemble the contents of an object file. */
2122
2123static void
46dca2e0 2124disassemble_data (bfd *abfd)
252b5132 2125{
252b5132
RH
2126 struct disassemble_info disasm_info;
2127 struct objdump_disasm_info aux;
4c45e5c9 2128 long i;
252b5132
RH
2129
2130 print_files = NULL;
2131 prev_functionname = NULL;
2132 prev_line = -1;
9b8d1a36 2133 prev_discriminator = 0;
252b5132
RH
2134
2135 /* We make a copy of syms to sort. We don't want to sort syms
2136 because that will screw up the relocs. */
4c45e5c9 2137 sorted_symcount = symcount ? symcount : dynsymcount;
3f5e193b
NC
2138 sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2139 * sizeof (asymbol *));
4c45e5c9
JJ
2140 memcpy (sorted_syms, symcount ? syms : dynsyms,
2141 sorted_symcount * sizeof (asymbol *));
252b5132 2142
4c45e5c9
JJ
2143 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2144
2145 for (i = 0; i < synthcount; ++i)
2146 {
2147 sorted_syms[sorted_symcount] = synthsyms + i;
2148 ++sorted_symcount;
2149 }
252b5132 2150
98a91d6a 2151 /* Sort the symbols into section and symbol order. */
252b5132
RH
2152 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2153
22a398e1 2154 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
98a91d6a 2155
46dca2e0 2156 disasm_info.application_data = (void *) &aux;
252b5132 2157 aux.abfd = abfd;
b34976b6 2158 aux.require_sec = FALSE;
155e0d23
NC
2159 aux.dynrelbuf = NULL;
2160 aux.dynrelcount = 0;
ce04548a 2161 aux.reloc = NULL;
155e0d23 2162
252b5132
RH
2163 disasm_info.print_address_func = objdump_print_address;
2164 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2165
d3ba0551 2166 if (machine != NULL)
252b5132 2167 {
91d6fa6a 2168 const bfd_arch_info_type *inf = bfd_scan_arch (machine);
98a91d6a 2169
91d6fa6a 2170 if (inf == NULL)
a8c62f1c 2171 fatal (_("can't use supplied machine %s"), machine);
98a91d6a 2172
91d6fa6a 2173 abfd->arch_info = inf;
252b5132
RH
2174 }
2175
2176 if (endian != BFD_ENDIAN_UNKNOWN)
2177 {
2178 struct bfd_target *xvec;
2179
3f5e193b 2180 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
252b5132
RH
2181 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2182 xvec->byteorder = endian;
2183 abfd->xvec = xvec;
2184 }
2185
155e0d23
NC
2186 /* Use libopcodes to locate a suitable disassembler. */
2187 aux.disassemble_fn = disassembler (abfd);
2188 if (!aux.disassemble_fn)
252b5132 2189 {
a8c62f1c 2190 non_fatal (_("can't disassemble for architecture %s\n"),
37cc8ec1 2191 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
75cd796a 2192 exit_status = 1;
252b5132
RH
2193 return;
2194 }
2195
2196 disasm_info.flavour = bfd_get_flavour (abfd);
2197 disasm_info.arch = bfd_get_arch (abfd);
2198 disasm_info.mach = bfd_get_mach (abfd);
dd92f639 2199 disasm_info.disassembler_options = disassembler_options;
155e0d23 2200 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
0bcb06d2
AS
2201 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2202 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
d99b6465 2203 disasm_info.disassembler_needs_relocs = FALSE;
0af11b59 2204
252b5132 2205 if (bfd_big_endian (abfd))
a8a9050d 2206 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
252b5132 2207 else if (bfd_little_endian (abfd))
a8a9050d 2208 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
252b5132
RH
2209 else
2210 /* ??? Aborting here seems too drastic. We could default to big or little
2211 instead. */
2212 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2213
22a398e1
NC
2214 /* Allow the target to customize the info structure. */
2215 disassemble_init_for_target (& disasm_info);
2216
155e0d23
NC
2217 /* Pre-load the dynamic relocs if we are going
2218 to be dumping them along with the disassembly. */
fd7bb956
AM
2219 if (dump_dynamic_reloc_info)
2220 {
2221 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
155e0d23 2222
fd7bb956
AM
2223 if (relsize < 0)
2224 bfd_fatal (bfd_get_filename (abfd));
2225
2226 if (relsize > 0)
2227 {
3f5e193b 2228 aux.dynrelbuf = (arelent **) xmalloc (relsize);
3b9ad1cc
AM
2229 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2230 aux.dynrelbuf,
2231 dynsyms);
155e0d23 2232 if (aux.dynrelcount < 0)
fd7bb956
AM
2233 bfd_fatal (bfd_get_filename (abfd));
2234
2235 /* Sort the relocs by address. */
3b9ad1cc
AM
2236 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2237 compare_relocs);
fd7bb956
AM
2238 }
2239 }
2087ad84
PB
2240 disasm_info.symtab = sorted_syms;
2241 disasm_info.symtab_size = sorted_symcount;
fd7bb956 2242
155e0d23 2243 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
98a91d6a 2244
155e0d23
NC
2245 if (aux.dynrelbuf != NULL)
2246 free (aux.dynrelbuf);
252b5132
RH
2247 free (sorted_syms);
2248}
2249\f
7bcbeb0f
CC
2250static int
2251load_specific_debug_section (enum dwarf_section_display_enum debug,
2252 asection *sec, void *file)
365544c3
L
2253{
2254 struct dwarf_section *section = &debug_displays [debug].section;
3f5e193b 2255 bfd *abfd = (bfd *) file;
365544c3
L
2256 bfd_boolean ret;
2257
2258 /* If it is already loaded, do nothing. */
2259 if (section->start != NULL)
2260 return 1;
2261
f5913efe 2262 section->address = 0;
365544c3 2263 section->size = bfd_get_section_size (sec);
4a114e3e
L
2264 section->start = NULL;
2265 ret = bfd_get_full_section_contents (abfd, sec, &section->start);
365544c3 2266
1b315056 2267 if (! ret)
365544c3
L
2268 {
2269 free_debug_section (debug);
2270 printf (_("\nCan't get contents for section '%s'.\n"),
2271 section->name);
1b315056
CS
2272 return 0;
2273 }
2274
0acf065b
CC
2275 if (is_relocatable && debug_displays [debug].relocate)
2276 {
8a72cc6e 2277 bfd_cache_section_contents (sec, section->start);
0acf065b
CC
2278
2279 ret = bfd_simple_get_relocated_section_contents (abfd,
2280 sec,
2281 section->start,
2282 syms) != NULL;
2283
2284 if (! ret)
2285 {
2286 free_debug_section (debug);
2287 printf (_("\nCan't get contents for section '%s'.\n"),
2288 section->name);
2289 return 0;
2290 }
2291 }
2292
7bcbeb0f
CC
2293 return 1;
2294}
2295
2296int
2297load_debug_section (enum dwarf_section_display_enum debug, void *file)
2298{
2299 struct dwarf_section *section = &debug_displays [debug].section;
3f5e193b 2300 bfd *abfd = (bfd *) file;
7bcbeb0f
CC
2301 asection *sec;
2302
2303 /* If it is already loaded, do nothing. */
2304 if (section->start != NULL)
2305 return 1;
2306
2307 /* Locate the debug section. */
2308 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2309 if (sec != NULL)
2310 section->name = section->uncompressed_name;
2311 else
2312 {
2313 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2314 if (sec != NULL)
2315 section->name = section->compressed_name;
2316 }
2317 if (sec == NULL)
2318 return 0;
2319
2320 return load_specific_debug_section (debug, sec, file);
365544c3
L
2321}
2322
2323void
2324free_debug_section (enum dwarf_section_display_enum debug)
2325{
2326 struct dwarf_section *section = &debug_displays [debug].section;
2327
2328 if (section->start == NULL)
2329 return;
2330
2331 free ((char *) section->start);
2332 section->start = NULL;
2333 section->address = 0;
2334 section->size = 0;
2335}
2336
2337static void
2338dump_dwarf_section (bfd *abfd, asection *section,
2339 void *arg ATTRIBUTE_UNUSED)
2340{
2341 const char *name = bfd_get_section_name (abfd, section);
2342 const char *match;
3f5e193b 2343 int i;
365544c3 2344
0112cd26 2345 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
365544c3
L
2346 match = ".debug_info";
2347 else
2348 match = name;
2349
2350 for (i = 0; i < max; i++)
4cb93e3b
TG
2351 if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2352 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2353 && debug_displays [i].enabled != NULL
2354 && *debug_displays [i].enabled)
365544c3 2355 {
c8450da8 2356 struct dwarf_section *sec = &debug_displays [i].section;
365544c3 2357
c8450da8
TG
2358 if (strcmp (sec->uncompressed_name, match) == 0)
2359 sec->name = sec->uncompressed_name;
2360 else
2361 sec->name = sec->compressed_name;
3f5e193b
NC
2362 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2363 section, abfd))
c8450da8
TG
2364 {
2365 debug_displays [i].display (sec, abfd);
2366
2367 if (i != info && i != abbrev)
3f5e193b 2368 free_debug_section ((enum dwarf_section_display_enum) i);
365544c3
L
2369 }
2370 break;
2371 }
2372}
2373
2374/* Dump the dwarf debugging information. */
2375
2376static void
2377dump_dwarf (bfd *abfd)
2378{
5184c2ae 2379 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
365544c3 2380
09fc85f6 2381 eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
365544c3
L
2382
2383 if (bfd_big_endian (abfd))
2384 byte_get = byte_get_big_endian;
2385 else if (bfd_little_endian (abfd))
2386 byte_get = byte_get_little_endian;
2387 else
2388 abort ();
2389
b129eb0e 2390 switch (bfd_get_arch (abfd))
2dc4cec1 2391 {
b129eb0e
RH
2392 case bfd_arch_i386:
2393 switch (bfd_get_mach (abfd))
2394 {
2395 case bfd_mach_x86_64:
2396 case bfd_mach_x86_64_intel_syntax:
f24e5a8a
L
2397 case bfd_mach_x64_32:
2398 case bfd_mach_x64_32_intel_syntax:
b129eb0e
RH
2399 init_dwarf_regnames_x86_64 ();
2400 break;
2401
2402 default:
2403 init_dwarf_regnames_i386 ();
2404 break;
2405 }
2406 break;
2407
2408 default:
2409 break;
2dc4cec1
L
2410 }
2411
365544c3
L
2412 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2413
2414 free_debug_memory ();
2415}
2416\f
29ca8dc5
NS
2417/* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2418 it. Return NULL on failure. */
252b5132 2419
29ca8dc5
NS
2420static char *
2421read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
252b5132 2422{
29ca8dc5
NS
2423 asection *stabsect;
2424 bfd_size_type size;
2425 char *contents;
252b5132 2426
29ca8dc5 2427 stabsect = bfd_get_section_by_name (abfd, sect_name);
155e0d23 2428 if (stabsect == NULL)
252b5132 2429 {
29ca8dc5 2430 printf (_("No %s section present\n\n"), sect_name);
b34976b6 2431 return FALSE;
252b5132
RH
2432 }
2433
29ca8dc5 2434 size = bfd_section_size (abfd, stabsect);
3f5e193b 2435 contents = (char *) xmalloc (size);
0af11b59 2436
29ca8dc5 2437 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
252b5132 2438 {
a8c62f1c 2439 non_fatal (_("reading %s section of %s failed: %s"),
29ca8dc5 2440 sect_name, bfd_get_filename (abfd),
37cc8ec1 2441 bfd_errmsg (bfd_get_error ()));
75cd796a 2442 exit_status = 1;
a8c62f1c 2443 free (contents);
29ca8dc5 2444 return NULL;
252b5132
RH
2445 }
2446
29ca8dc5 2447 *size_ptr = size;
252b5132 2448
29ca8dc5 2449 return contents;
252b5132
RH
2450}
2451
2452/* Stabs entries use a 12 byte format:
2453 4 byte string table index
2454 1 byte stab type
2455 1 byte stab other field
2456 2 byte stab desc field
2457 4 byte stab value
2458 FIXME: This will have to change for a 64 bit object format. */
2459
46dca2e0
NC
2460#define STRDXOFF (0)
2461#define TYPEOFF (4)
2462#define OTHEROFF (5)
2463#define DESCOFF (6)
2464#define VALOFF (8)
252b5132
RH
2465#define STABSIZE (12)
2466
2467/* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2468 using string table section STRSECT_NAME (in `strtab'). */
2469
2470static void
3b9ad1cc
AM
2471print_section_stabs (bfd *abfd,
2472 const char *stabsect_name,
2473 unsigned *string_offset_ptr)
252b5132
RH
2474{
2475 int i;
46dca2e0 2476 unsigned file_string_table_offset = 0;
29ca8dc5 2477 unsigned next_file_string_table_offset = *string_offset_ptr;
252b5132
RH
2478 bfd_byte *stabp, *stabs_end;
2479
2480 stabp = stabs;
2481 stabs_end = stabp + stab_size;
2482
2483 printf (_("Contents of %s section:\n\n"), stabsect_name);
2484 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2485
2486 /* Loop through all symbols and print them.
2487
2488 We start the index at -1 because there is a dummy symbol on
2489 the front of stabs-in-{coff,elf} sections that supplies sizes. */
252b5132
RH
2490 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2491 {
2492 const char *name;
2493 unsigned long strx;
2494 unsigned char type, other;
2495 unsigned short desc;
2496 bfd_vma value;
2497
2498 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2499 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2500 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2501 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2502 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2503
2504 printf ("\n%-6d ", i);
2505 /* Either print the stab name, or, if unnamed, print its number
0af11b59 2506 again (makes consistent formatting for tools like awk). */
252b5132
RH
2507 name = bfd_get_stab_name (type);
2508 if (name != NULL)
2509 printf ("%-6s", name);
2510 else if (type == N_UNDF)
2511 printf ("HdrSym");
2512 else
2513 printf ("%-6d", type);
2514 printf (" %-6d %-6d ", other, desc);
d8180c76 2515 bfd_printf_vma (abfd, value);
252b5132
RH
2516 printf (" %-6lu", strx);
2517
2518 /* Symbols with type == 0 (N_UNDF) specify the length of the
2519 string table associated with this file. We use that info
2520 to know how to relocate the *next* file's string table indices. */
252b5132
RH
2521 if (type == N_UNDF)
2522 {
2523 file_string_table_offset = next_file_string_table_offset;
2524 next_file_string_table_offset += value;
2525 }
2526 else
2527 {
2528 /* Using the (possibly updated) string table offset, print the
2529 string (if any) associated with this symbol. */
252b5132
RH
2530 if ((strx + file_string_table_offset) < stabstr_size)
2531 printf (" %s", &strtab[strx + file_string_table_offset]);
2532 else
2533 printf (" *");
2534 }
2535 }
2536 printf ("\n\n");
29ca8dc5 2537 *string_offset_ptr = next_file_string_table_offset;
252b5132
RH
2538}
2539
155e0d23
NC
2540typedef struct
2541{
2542 const char * section_name;
2543 const char * string_section_name;
29ca8dc5 2544 unsigned string_offset;
155e0d23
NC
2545}
2546stab_section_names;
2547
252b5132 2548static void
155e0d23 2549find_stabs_section (bfd *abfd, asection *section, void *names)
252b5132 2550{
155e0d23
NC
2551 int len;
2552 stab_section_names * sought = (stab_section_names *) names;
252b5132
RH
2553
2554 /* Check for section names for which stabsect_name is a prefix, to
29ca8dc5 2555 handle .stab.N, etc. */
155e0d23
NC
2556 len = strlen (sought->section_name);
2557
2558 /* If the prefix matches, and the files section name ends with a
2559 nul or a digit, then we match. I.e., we want either an exact
2560 match or a section followed by a number. */
2561 if (strncmp (sought->section_name, section->name, len) == 0
2562 && (section->name[len] == 0
29ca8dc5 2563 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
252b5132 2564 {
29ca8dc5
NS
2565 if (strtab == NULL)
2566 strtab = read_section_stabs (abfd, sought->string_section_name,
2567 &stabstr_size);
2568
2569 if (strtab)
252b5132 2570 {
9210d879
AM
2571 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2572 &stab_size);
29ca8dc5
NS
2573 if (stabs)
2574 print_section_stabs (abfd, section->name, &sought->string_offset);
252b5132
RH
2575 }
2576 }
2577}
98a91d6a 2578
155e0d23
NC
2579static void
2580dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2581{
2582 stab_section_names s;
2583
2584 s.section_name = stabsect_name;
2585 s.string_section_name = strsect_name;
29ca8dc5
NS
2586 s.string_offset = 0;
2587
155e0d23 2588 bfd_map_over_sections (abfd, find_stabs_section, & s);
29ca8dc5
NS
2589
2590 free (strtab);
2591 strtab = NULL;
155e0d23
NC
2592}
2593
2594/* Dump the any sections containing stabs debugging information. */
2595
2596static void
2597dump_stabs (bfd *abfd)
2598{
2599 dump_stabs_section (abfd, ".stab", ".stabstr");
2600 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2601 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
62bb81b8
TG
2602
2603 /* For Darwin. */
2604 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2605
155e0d23
NC
2606 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2607}
252b5132
RH
2608\f
2609static void
46dca2e0 2610dump_bfd_header (bfd *abfd)
252b5132
RH
2611{
2612 char *comma = "";
2613
2614 printf (_("architecture: %s, "),
2615 bfd_printable_arch_mach (bfd_get_arch (abfd),
2616 bfd_get_mach (abfd)));
6b6bc957 2617 printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
252b5132
RH
2618
2619#define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2620 PF (HAS_RELOC, "HAS_RELOC");
2621 PF (EXEC_P, "EXEC_P");
2622 PF (HAS_LINENO, "HAS_LINENO");
2623 PF (HAS_DEBUG, "HAS_DEBUG");
2624 PF (HAS_SYMS, "HAS_SYMS");
2625 PF (HAS_LOCALS, "HAS_LOCALS");
2626 PF (DYNAMIC, "DYNAMIC");
2627 PF (WP_TEXT, "WP_TEXT");
2628 PF (D_PAGED, "D_PAGED");
2629 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
026df7c5 2630 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
252b5132 2631 printf (_("\nstart address 0x"));
d8180c76 2632 bfd_printf_vma (abfd, abfd->start_address);
252b5132
RH
2633 printf ("\n");
2634}
98a91d6a 2635
252b5132
RH
2636\f
2637static void
46dca2e0 2638dump_bfd_private_header (bfd *abfd)
252b5132
RH
2639{
2640 bfd_print_private_bfd_data (abfd, stdout);
2641}
2642
6abcee90
TG
2643static void
2644dump_target_specific (bfd *abfd)
2645{
2646 const struct objdump_private_desc * const *desc;
2647 struct objdump_private_option *opt;
2648 char *e, *b;
2649
2650 /* Find the desc. */
2651 for (desc = objdump_private_vectors; *desc != NULL; desc++)
2652 if ((*desc)->filter (abfd))
2653 break;
2654
c32d6f7b 2655 if (*desc == NULL)
6abcee90
TG
2656 {
2657 non_fatal (_("option -P/--private not supported by this file"));
2658 return;
2659 }
2660
2661 /* Clear all options. */
2662 for (opt = (*desc)->options; opt->name; opt++)
2663 opt->selected = FALSE;
2664
2665 /* Decode options. */
2666 b = dump_private_options;
2667 do
2668 {
2669 e = strchr (b, ',');
2670
2671 if (e)
2672 *e = 0;
2673
2674 for (opt = (*desc)->options; opt->name; opt++)
2675 if (strcmp (opt->name, b) == 0)
2676 {
2677 opt->selected = TRUE;
2678 break;
2679 }
2680 if (opt->name == NULL)
2681 non_fatal (_("target specific dump '%s' not supported"), b);
2682
2683 if (e)
2684 {
2685 *e = ',';
2686 b = e + 1;
2687 }
2688 }
2689 while (e != NULL);
2690
2691 /* Dump. */
2692 (*desc)->dump (abfd);
2693}
155e0d23
NC
2694\f
2695/* Display a section in hexadecimal format with associated characters.
2696 Each line prefixed by the zero padded address. */
d24de309 2697
252b5132 2698static void
155e0d23 2699dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
252b5132 2700{
155e0d23
NC
2701 bfd_byte *data = 0;
2702 bfd_size_type datasize;
2703 bfd_size_type addr_offset;
2704 bfd_size_type start_offset;
2705 bfd_size_type stop_offset;
2706 unsigned int opb = bfd_octets_per_byte (abfd);
2707 /* Bytes per line. */
2708 const int onaline = 16;
2709 char buf[64];
2710 int count;
2711 int width;
2712
2713 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2714 return;
2715
2716 if (! process_section_p (section))
2717 return;
2718
2719 if ((datasize = bfd_section_size (abfd, section)) == 0)
2720 return;
2721
155e0d23
NC
2722 /* Compute the address range to display. */
2723 if (start_address == (bfd_vma) -1
2724 || start_address < section->vma)
2725 start_offset = 0;
2726 else
2727 start_offset = start_address - section->vma;
2728
2729 if (stop_address == (bfd_vma) -1)
2730 stop_offset = datasize / opb;
2731 else
252b5132 2732 {
155e0d23
NC
2733 if (stop_address < section->vma)
2734 stop_offset = 0;
2735 else
2736 stop_offset = stop_address - section->vma;
252b5132 2737
155e0d23
NC
2738 if (stop_offset > datasize / opb)
2739 stop_offset = datasize / opb;
252b5132
RH
2740 }
2741
32760852
NC
2742 if (start_offset >= stop_offset)
2743 return;
2744
2745 printf (_("Contents of section %s:"), section->name);
2746 if (display_file_offsets)
0af1713e
AM
2747 printf (_(" (Starting at file offset: 0x%lx)"),
2748 (unsigned long) (section->filepos + start_offset));
32760852
NC
2749 printf ("\n");
2750
4a114e3e
L
2751 if (!bfd_get_full_section_contents (abfd, section, &data))
2752 {
2753 non_fatal (_("Reading section failed"));
2754 return;
2755 }
32760852 2756
155e0d23 2757 width = 4;
026df7c5 2758
155e0d23
NC
2759 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2760 if (strlen (buf) >= sizeof (buf))
2761 abort ();
026df7c5 2762
155e0d23
NC
2763 count = 0;
2764 while (buf[count] == '0' && buf[count+1] != '\0')
2765 count++;
2766 count = strlen (buf) - count;
2767 if (count > width)
2768 width = count;
252b5132 2769
155e0d23
NC
2770 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2771 if (strlen (buf) >= sizeof (buf))
2772 abort ();
026df7c5 2773
155e0d23
NC
2774 count = 0;
2775 while (buf[count] == '0' && buf[count+1] != '\0')
2776 count++;
2777 count = strlen (buf) - count;
2778 if (count > width)
2779 width = count;
026df7c5 2780
155e0d23
NC
2781 for (addr_offset = start_offset;
2782 addr_offset < stop_offset; addr_offset += onaline / opb)
d24de309 2783 {
155e0d23 2784 bfd_size_type j;
d24de309 2785
155e0d23
NC
2786 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2787 count = strlen (buf);
2788 if ((size_t) count >= sizeof (buf))
2789 abort ();
d24de309 2790
155e0d23
NC
2791 putchar (' ');
2792 while (count < width)
252b5132 2793 {
155e0d23
NC
2794 putchar ('0');
2795 count++;
2796 }
2797 fputs (buf + count - width, stdout);
2798 putchar (' ');
252b5132 2799
155e0d23
NC
2800 for (j = addr_offset * opb;
2801 j < addr_offset * opb + onaline; j++)
2802 {
2803 if (j < stop_offset * opb)
2804 printf ("%02x", (unsigned) (data[j]));
2805 else
2806 printf (" ");
2807 if ((j & 3) == 3)
2808 printf (" ");
252b5132
RH
2809 }
2810
155e0d23
NC
2811 printf (" ");
2812 for (j = addr_offset * opb;
2813 j < addr_offset * opb + onaline; j++)
2814 {
2815 if (j >= stop_offset * opb)
2816 printf (" ");
2817 else
2818 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2819 }
2820 putchar ('\n');
252b5132 2821 }
155e0d23 2822 free (data);
252b5132 2823}
155e0d23 2824
98a91d6a 2825/* Actually display the various requested regions. */
252b5132
RH
2826
2827static void
46dca2e0 2828dump_data (bfd *abfd)
252b5132 2829{
155e0d23 2830 bfd_map_over_sections (abfd, dump_section, NULL);
252b5132
RH
2831}
2832
98a91d6a
NC
2833/* Should perhaps share code and display with nm? */
2834
252b5132 2835static void
46dca2e0 2836dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
252b5132
RH
2837{
2838 asymbol **current;
91d6fa6a 2839 long max_count;
252b5132
RH
2840 long count;
2841
2842 if (dynamic)
2843 {
2844 current = dynsyms;
91d6fa6a 2845 max_count = dynsymcount;
252b5132
RH
2846 printf ("DYNAMIC SYMBOL TABLE:\n");
2847 }
2848 else
2849 {
2850 current = syms;
91d6fa6a 2851 max_count = symcount;
252b5132
RH
2852 printf ("SYMBOL TABLE:\n");
2853 }
2854
91d6fa6a 2855 if (max_count == 0)
a1df01d1
AM
2856 printf (_("no symbols\n"));
2857
91d6fa6a 2858 for (count = 0; count < max_count; count++)
252b5132 2859 {
155e0d23
NC
2860 bfd *cur_bfd;
2861
2862 if (*current == NULL)
83ef0798 2863 printf (_("no information for symbol number %ld\n"), count);
155e0d23
NC
2864
2865 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
83ef0798 2866 printf (_("could not determine the type of symbol number %ld\n"),
155e0d23
NC
2867 count);
2868
661f7c35
NC
2869 else if (process_section_p ((* current)->section)
2870 && (dump_special_syms
2871 || !bfd_is_target_special_symbol (cur_bfd, *current)))
252b5132 2872 {
155e0d23 2873 const char *name = (*current)->name;
252b5132 2874
155e0d23 2875 if (do_demangle && name != NULL && *name != '\0')
252b5132 2876 {
252b5132
RH
2877 char *alloc;
2878
155e0d23
NC
2879 /* If we want to demangle the name, we demangle it
2880 here, and temporarily clobber it while calling
2881 bfd_print_symbol. FIXME: This is a gross hack. */
ed180cc5
AM
2882 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2883 if (alloc != NULL)
2884 (*current)->name = alloc;
252b5132
RH
2885 bfd_print_symbol (cur_bfd, stdout, *current,
2886 bfd_print_symbol_all);
ed180cc5
AM
2887 if (alloc != NULL)
2888 {
2889 (*current)->name = name;
2890 free (alloc);
2891 }
252b5132 2892 }
252b5132 2893 else
155e0d23
NC
2894 bfd_print_symbol (cur_bfd, stdout, *current,
2895 bfd_print_symbol_all);
83ef0798 2896 printf ("\n");
252b5132 2897 }
661f7c35 2898
155e0d23 2899 current++;
252b5132 2900 }
155e0d23 2901 printf ("\n\n");
252b5132 2902}
155e0d23 2903\f
252b5132 2904static void
46dca2e0 2905dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
252b5132
RH
2906{
2907 arelent **p;
2908 char *last_filename, *last_functionname;
2909 unsigned int last_line;
9b8d1a36 2910 unsigned int last_discriminator;
252b5132
RH
2911
2912 /* Get column headers lined up reasonably. */
2913 {
2914 static int width;
98a91d6a 2915
252b5132
RH
2916 if (width == 0)
2917 {
2918 char buf[30];
155e0d23 2919
d8180c76 2920 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
252b5132
RH
2921 width = strlen (buf) - 7;
2922 }
2923 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2924 }
2925
2926 last_filename = NULL;
2927 last_functionname = NULL;
2928 last_line = 0;
9b8d1a36 2929 last_discriminator = 0;
252b5132 2930
d3ba0551 2931 for (p = relpp; relcount && *p != NULL; p++, relcount--)
252b5132
RH
2932 {
2933 arelent *q = *p;
2934 const char *filename, *functionname;
91d6fa6a 2935 unsigned int linenumber;
9b8d1a36 2936 unsigned int discriminator;
252b5132
RH
2937 const char *sym_name;
2938 const char *section_name;
bf03e632 2939 bfd_vma addend2 = 0;
252b5132
RH
2940
2941 if (start_address != (bfd_vma) -1
2942 && q->address < start_address)
2943 continue;
2944 if (stop_address != (bfd_vma) -1
2945 && q->address > stop_address)
2946 continue;
2947
2948 if (with_line_numbers
2949 && sec != NULL
9b8d1a36
CC
2950 && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
2951 &filename, &functionname,
2952 &linenumber, &discriminator))
252b5132
RH
2953 {
2954 if (functionname != NULL
2955 && (last_functionname == NULL
2956 || strcmp (functionname, last_functionname) != 0))
2957 {
2958 printf ("%s():\n", functionname);
2959 if (last_functionname != NULL)
2960 free (last_functionname);
2961 last_functionname = xstrdup (functionname);
2962 }
98a91d6a 2963
91d6fa6a
NC
2964 if (linenumber > 0
2965 && (linenumber != last_line
252b5132
RH
2966 || (filename != NULL
2967 && last_filename != NULL
9b8d1a36
CC
2968 && filename_cmp (filename, last_filename) != 0)
2969 || (discriminator != last_discriminator)))
252b5132 2970 {
9b8d1a36
CC
2971 if (discriminator > 0)
2972 printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
2973 else
2974 printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename,
2975 linenumber, discriminator);
91d6fa6a 2976 last_line = linenumber;
9b8d1a36 2977 last_discriminator = discriminator;
252b5132
RH
2978 if (last_filename != NULL)
2979 free (last_filename);
2980 if (filename == NULL)
2981 last_filename = NULL;
2982 else
2983 last_filename = xstrdup (filename);
2984 }
2985 }
2986
2987 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2988 {
2989 sym_name = (*(q->sym_ptr_ptr))->name;
2990 section_name = (*(q->sym_ptr_ptr))->section->name;
2991 }
2992 else
2993 {
2994 sym_name = NULL;
2995 section_name = NULL;
2996 }
98a91d6a 2997
f9ecb0a4
JJ
2998 bfd_printf_vma (abfd, q->address);
2999 if (q->howto == NULL)
3000 printf (" *unknown* ");
3001 else if (q->howto->name)
bf03e632
DM
3002 {
3003 const char *name = q->howto->name;
3004
3005 /* R_SPARC_OLO10 relocations contain two addends.
3006 But because 'arelent' lacks enough storage to
3007 store them both, the 64-bit ELF Sparc backend
3008 records this as two relocations. One R_SPARC_LO10
3009 and one R_SPARC_13, both pointing to the same
3010 address. This is merely so that we have some
3011 place to store both addend fields.
3012
3013 Undo this transformation, otherwise the output
3014 will be confusing. */
3015 if (abfd->xvec->flavour == bfd_target_elf_flavour
3016 && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
3017 && relcount > 1
3018 && !strcmp (q->howto->name, "R_SPARC_LO10"))
3019 {
3020 arelent *q2 = *(p + 1);
3021 if (q2 != NULL
3022 && q2->howto
3023 && q->address == q2->address
3024 && !strcmp (q2->howto->name, "R_SPARC_13"))
3025 {
3026 name = "R_SPARC_OLO10";
3027 addend2 = q2->addend;
3028 p++;
3029 }
3030 }
3031 printf (" %-16s ", name);
3032 }
f9ecb0a4
JJ
3033 else
3034 printf (" %-16d ", q->howto->type);
171191ba 3035
252b5132 3036 if (sym_name)
171191ba
NC
3037 {
3038 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
171191ba 3039 }
252b5132
RH
3040 else
3041 {
d3ba0551 3042 if (section_name == NULL)
252b5132 3043 section_name = "*unknown*";
f9ecb0a4 3044 printf ("[%s]", section_name);
252b5132 3045 }
98a91d6a 3046
252b5132
RH
3047 if (q->addend)
3048 {
343dbc36
L
3049 bfd_signed_vma addend = q->addend;
3050 if (addend < 0)
3051 {
3052 printf ("-0x");
3053 addend = -addend;
3054 }
3055 else
3056 printf ("+0x");
3057 bfd_printf_vma (abfd, addend);
252b5132 3058 }
bf03e632
DM
3059 if (addend2)
3060 {
3061 printf ("+0x");
3062 bfd_printf_vma (abfd, addend2);
3063 }
98a91d6a 3064
252b5132
RH
3065 printf ("\n");
3066 }
4b41844b
NC
3067
3068 if (last_filename != NULL)
3069 free (last_filename);
3070 if (last_functionname != NULL)
3071 free (last_functionname);
252b5132 3072}
43ac9881 3073
155e0d23 3074static void
3b9ad1cc
AM
3075dump_relocs_in_section (bfd *abfd,
3076 asection *section,
3077 void *dummy ATTRIBUTE_UNUSED)
155e0d23
NC
3078{
3079 arelent **relpp;
3080 long relcount;
3081 long relsize;
3082
3083 if ( bfd_is_abs_section (section)
3084 || bfd_is_und_section (section)
3085 || bfd_is_com_section (section)
3086 || (! process_section_p (section))
3087 || ((section->flags & SEC_RELOC) == 0))
3088 return;
3089
3090 relsize = bfd_get_reloc_upper_bound (abfd, section);
3091 if (relsize < 0)
3092 bfd_fatal (bfd_get_filename (abfd));
3093
3094 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
3095
3096 if (relsize == 0)
3097 {
3098 printf (" (none)\n\n");
3099 return;
3100 }
3101
3f5e193b 3102 relpp = (arelent **) xmalloc (relsize);
155e0d23
NC
3103 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
3104
3105 if (relcount < 0)
3106 bfd_fatal (bfd_get_filename (abfd));
3107 else if (relcount == 0)
3108 printf (" (none)\n\n");
3109 else
3110 {
3111 printf ("\n");
3112 dump_reloc_set (abfd, section, relpp, relcount);
3113 printf ("\n\n");
3114 }
3115 free (relpp);
3116}
3117
3118static void
3119dump_relocs (bfd *abfd)
3120{
3121 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3122}
3123
3124static void
3125dump_dynamic_relocs (bfd *abfd)
3126{
3127 long relsize;
3128 arelent **relpp;
3129 long relcount;
3130
3131 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3132 if (relsize < 0)
3133 bfd_fatal (bfd_get_filename (abfd));
3134
3135 printf ("DYNAMIC RELOCATION RECORDS");
3136
3137 if (relsize == 0)
3138 printf (" (none)\n\n");
3139 else
3140 {
3f5e193b 3141 relpp = (arelent **) xmalloc (relsize);
155e0d23
NC
3142 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3143
3144 if (relcount < 0)
3145 bfd_fatal (bfd_get_filename (abfd));
3146 else if (relcount == 0)
3147 printf (" (none)\n\n");
3148 else
3149 {
3150 printf ("\n");
3151 dump_reloc_set (abfd, NULL, relpp, relcount);
3152 printf ("\n\n");
3153 }
3154 free (relpp);
3155 }
3156}
3157
43ac9881
AM
3158/* Creates a table of paths, to search for source files. */
3159
3160static void
3161add_include_path (const char *path)
3162{
3163 if (path[0] == 0)
3164 return;
3165 include_path_count++;
3f5e193b
NC
3166 include_paths = (const char **)
3167 xrealloc (include_paths, include_path_count * sizeof (*include_paths));
43ac9881
AM
3168#ifdef HAVE_DOS_BASED_FILE_SYSTEM
3169 if (path[1] == ':' && path[2] == 0)
3170 path = concat (path, ".", (const char *) 0);
3171#endif
3172 include_paths[include_path_count - 1] = path;
3173}
155e0d23
NC
3174
3175static void
3b9ad1cc
AM
3176adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3177 asection *section,
bc79cded 3178 void *arg)
155e0d23 3179{
bc79cded
L
3180 if ((section->flags & SEC_DEBUGGING) == 0)
3181 {
3182 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3183 section->vma += adjust_section_vma;
3184 if (*has_reloc_p)
3185 section->lma += adjust_section_vma;
3186 }
155e0d23
NC
3187}
3188
3189/* Dump selected contents of ABFD. */
3190
3191static void
3192dump_bfd (bfd *abfd)
3193{
3194 /* If we are adjusting section VMA's, change them all now. Changing
3195 the BFD information is a hack. However, we must do it, or
3196 bfd_find_nearest_line will not do the right thing. */
3197 if (adjust_section_vma != 0)
bc79cded
L
3198 {
3199 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3200 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3201 }
155e0d23 3202
fd2f0033 3203 if (! dump_debugging_tags && ! suppress_bfd_header)
155e0d23
NC
3204 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
3205 abfd->xvec->name);
3206 if (dump_ar_hdrs)
3207 print_arelt_descr (stdout, abfd, TRUE);
3208 if (dump_file_header)
3209 dump_bfd_header (abfd);
3210 if (dump_private_headers)
3211 dump_bfd_private_header (abfd);
6abcee90
TG
3212 if (dump_private_options != NULL)
3213 dump_target_specific (abfd);
fd2f0033 3214 if (! dump_debugging_tags && ! suppress_bfd_header)
155e0d23 3215 putchar ('\n');
155e0d23 3216
365544c3
L
3217 if (dump_symtab
3218 || dump_reloc_info
3219 || disassemble
3220 || dump_debugging
3221 || dump_dwarf_section_info)
155e0d23 3222 syms = slurp_symtab (abfd);
a29a8af8
KT
3223
3224 if (dump_section_headers)
3225 dump_headers (abfd);
3226
4c45e5c9
JJ
3227 if (dump_dynamic_symtab || dump_dynamic_reloc_info
3228 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
155e0d23 3229 dynsyms = slurp_dynamic_symtab (abfd);
90e3cdf2 3230 if (disassemble)
4c45e5c9 3231 {
c9727e01
AM
3232 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
3233 dynsymcount, dynsyms, &synthsyms);
3234 if (synthcount < 0)
3235 synthcount = 0;
4c45e5c9 3236 }
155e0d23
NC
3237
3238 if (dump_symtab)
3239 dump_symbols (abfd, FALSE);
3240 if (dump_dynamic_symtab)
3241 dump_symbols (abfd, TRUE);
365544c3
L
3242 if (dump_dwarf_section_info)
3243 dump_dwarf (abfd);
155e0d23
NC
3244 if (dump_stab_section_info)
3245 dump_stabs (abfd);
3246 if (dump_reloc_info && ! disassemble)
3247 dump_relocs (abfd);
3248 if (dump_dynamic_reloc_info && ! disassemble)
3249 dump_dynamic_relocs (abfd);
3250 if (dump_section_contents)
3251 dump_data (abfd);
3252 if (disassemble)
3253 disassemble_data (abfd);
3254
3255 if (dump_debugging)
3256 {
3257 void *dhandle;
3258
b922d590 3259 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
155e0d23
NC
3260 if (dhandle != NULL)
3261 {
ed180cc5
AM
3262 if (!print_debugging_info (stdout, dhandle, abfd, syms,
3263 bfd_demangle,
3264 dump_debugging_tags ? TRUE : FALSE))
155e0d23
NC
3265 {
3266 non_fatal (_("%s: printing debugging information failed"),
3267 bfd_get_filename (abfd));
3268 exit_status = 1;
3269 }
3270 }
b922d590
NC
3271 /* PR 6483: If there was no STABS or IEEE debug
3272 info in the file, try DWARF instead. */
3273 else if (! dump_dwarf_section_info)
3274 {
1233b4a7 3275 dwarf_select_sections_all ();
b922d590
NC
3276 dump_dwarf (abfd);
3277 }
155e0d23
NC
3278 }
3279
3280 if (syms)
3281 {
3282 free (syms);
3283 syms = NULL;
3284 }
3285
3286 if (dynsyms)
3287 {
3288 free (dynsyms);
3289 dynsyms = NULL;
3290 }
4c45e5c9
JJ
3291
3292 if (synthsyms)
3293 {
3294 free (synthsyms);
3295 synthsyms = NULL;
3296 }
3297
3298 symcount = 0;
3299 dynsymcount = 0;
3300 synthcount = 0;
155e0d23
NC
3301}
3302
3303static void
1598539f 3304display_object_bfd (bfd *abfd)
155e0d23
NC
3305{
3306 char **matching;
3307
3308 if (bfd_check_format_matches (abfd, bfd_object, &matching))
3309 {
3310 dump_bfd (abfd);
3311 return;
3312 }
3313
3314 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3315 {
3316 nonfatal (bfd_get_filename (abfd));
3317 list_matching_formats (matching);
3318 free (matching);
3319 return;
3320 }
3321
3322 if (bfd_get_error () != bfd_error_file_not_recognized)
3323 {
3324 nonfatal (bfd_get_filename (abfd));
3325 return;
3326 }
3327
3328 if (bfd_check_format_matches (abfd, bfd_core, &matching))
3329 {
3330 dump_bfd (abfd);
3331 return;
3332 }
3333
3334 nonfatal (bfd_get_filename (abfd));
3335
3336 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3337 {
3338 list_matching_formats (matching);
3339 free (matching);
3340 }
3341}
3342
3343static void
1598539f 3344display_any_bfd (bfd *file, int level)
155e0d23 3345{
4a114e3e
L
3346 /* Decompress sections unless dumping the section contents. */
3347 if (!dump_section_contents)
3348 file->flags |= BFD_DECOMPRESS;
3349
155e0d23
NC
3350 /* If the file is an archive, process all of its elements. */
3351 if (bfd_check_format (file, bfd_archive))
3352 {
1598539f 3353 bfd *arfile = NULL;
155e0d23
NC
3354 bfd *last_arfile = NULL;
3355
1598539f
TG
3356 if (level == 0)
3357 printf (_("In archive %s:\n"), bfd_get_filename (file));
3358 else
3359 printf (_("In nested archive %s:\n"), bfd_get_filename (file));
3360
155e0d23
NC
3361 for (;;)
3362 {
3363 bfd_set_error (bfd_error_no_error);
3364
3365 arfile = bfd_openr_next_archived_file (file, arfile);
3366 if (arfile == NULL)
3367 {
3368 if (bfd_get_error () != bfd_error_no_more_archived_files)
3369 nonfatal (bfd_get_filename (file));
3370 break;
3371 }
3372
1598539f 3373 display_any_bfd (arfile, level + 1);
155e0d23
NC
3374
3375 if (last_arfile != NULL)
3376 bfd_close (last_arfile);
3377 last_arfile = arfile;
3378 }
3379
3380 if (last_arfile != NULL)
3381 bfd_close (last_arfile);
3382 }
3383 else
1598539f
TG
3384 display_object_bfd (file);
3385}
3386
3387static void
3388display_file (char *filename, char *target)
3389{
3390 bfd *file;
3391
3392 if (get_file_size (filename) < 1)
3393 {
3394 exit_status = 1;
3395 return;
3396 }
3397
3398 file = bfd_openr (filename, target);
3399 if (file == NULL)
3400 {
3401 nonfatal (filename);
3402 return;
3403 }
3404
3405 display_any_bfd (file, 0);
155e0d23
NC
3406
3407 bfd_close (file);
3408}
252b5132 3409\f
252b5132 3410int
46dca2e0 3411main (int argc, char **argv)
252b5132
RH
3412{
3413 int c;
3414 char *target = default_target;
b34976b6 3415 bfd_boolean seenflag = FALSE;
252b5132 3416
155e0d23
NC
3417#if defined (HAVE_SETLOCALE)
3418#if defined (HAVE_LC_MESSAGES)
252b5132 3419 setlocale (LC_MESSAGES, "");
3882b010 3420#endif
3882b010 3421 setlocale (LC_CTYPE, "");
252b5132 3422#endif
155e0d23 3423
252b5132
RH
3424 bindtextdomain (PACKAGE, LOCALEDIR);
3425 textdomain (PACKAGE);
3426
3427 program_name = *argv;
3428 xmalloc_set_program_name (program_name);
3429
3430 START_PROGRESS (program_name, 0);
3431
869b9d07
MM
3432 expandargv (&argc, &argv);
3433
252b5132
RH
3434 bfd_init ();
3435 set_default_bfd_target ();
3436
4cb93e3b 3437 while ((c = getopt_long (argc, argv,
6abcee90 3438 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
252b5132
RH
3439 long_options, (int *) 0))
3440 != EOF)
3441 {
252b5132
RH
3442 switch (c)
3443 {
3444 case 0:
8b53311e 3445 break; /* We've been given a long option. */
252b5132
RH
3446 case 'm':
3447 machine = optarg;
3448 break;
dd92f639 3449 case 'M':
073fbac6 3450 if (disassembler_options)
31e0f3cd 3451 /* Ignore potential memory leak for now. */
46dca2e0 3452 disassembler_options = concat (disassembler_options, ",",
ee832e18 3453 optarg, (const char *) NULL);
31e0f3cd
NC
3454 else
3455 disassembler_options = optarg;
dd92f639 3456 break;
252b5132 3457 case 'j':
70ecb384 3458 add_only (optarg);
252b5132 3459 break;
98ec6e72
NC
3460 case 'F':
3461 display_file_offsets = TRUE;
3462 break;
252b5132 3463 case 'l':
b34976b6 3464 with_line_numbers = TRUE;
252b5132
RH
3465 break;
3466 case 'b':
3467 target = optarg;
3468 break;
1dada9c5 3469 case 'C':
b34976b6 3470 do_demangle = TRUE;
28c309a2
NC
3471 if (optarg != NULL)
3472 {
3473 enum demangling_styles style;
8b53311e 3474
28c309a2 3475 style = cplus_demangle_name_to_style (optarg);
0af11b59 3476 if (style == unknown_demangling)
28c309a2
NC
3477 fatal (_("unknown demangling style `%s'"),
3478 optarg);
8b53311e 3479
28c309a2 3480 cplus_demangle_set_style (style);
0af11b59 3481 }
1dada9c5
NC
3482 break;
3483 case 'w':
b34976b6 3484 wide_output = TRUE;
1dada9c5
NC
3485 break;
3486 case OPTION_ADJUST_VMA:
3487 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3488 break;
3489 case OPTION_START_ADDRESS:
3490 start_address = parse_vma (optarg, "--start-address");
98ec6e72
NC
3491 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3492 fatal (_("error: the start address should be before the end address"));
1dada9c5
NC
3493 break;
3494 case OPTION_STOP_ADDRESS:
3495 stop_address = parse_vma (optarg, "--stop-address");
98ec6e72
NC
3496 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3497 fatal (_("error: the stop address should be after the start address"));
1dada9c5 3498 break;
0dafdf3f
L
3499 case OPTION_PREFIX:
3500 prefix = optarg;
3501 prefix_length = strlen (prefix);
3502 /* Remove an unnecessary trailing '/' */
3503 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3504 prefix_length--;
3505 break;
3506 case OPTION_PREFIX_STRIP:
3507 prefix_strip = atoi (optarg);
3508 if (prefix_strip < 0)
3509 fatal (_("error: prefix strip must be non-negative"));
3510 break;
3dcb3fcb
L
3511 case OPTION_INSN_WIDTH:
3512 insn_width = strtoul (optarg, NULL, 0);
3513 if (insn_width <= 0)
3514 fatal (_("error: instruction width must be positive"));
3515 break;
1dada9c5
NC
3516 case 'E':
3517 if (strcmp (optarg, "B") == 0)
3518 endian = BFD_ENDIAN_BIG;
3519 else if (strcmp (optarg, "L") == 0)
3520 endian = BFD_ENDIAN_LITTLE;
3521 else
3522 {
a8c62f1c 3523 nonfatal (_("unrecognized -E option"));
1dada9c5
NC
3524 usage (stderr, 1);
3525 }
3526 break;
3527 case OPTION_ENDIAN:
3528 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3529 endian = BFD_ENDIAN_BIG;
3530 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3531 endian = BFD_ENDIAN_LITTLE;
3532 else
3533 {
37cc8ec1 3534 non_fatal (_("unrecognized --endian type `%s'"), optarg);
a8c62f1c 3535 exit_status = 1;
1dada9c5
NC
3536 usage (stderr, 1);
3537 }
3538 break;
8b53311e 3539
252b5132 3540 case 'f':
b34976b6
AM
3541 dump_file_header = TRUE;
3542 seenflag = TRUE;
252b5132
RH
3543 break;
3544 case 'i':
b34976b6
AM
3545 formats_info = TRUE;
3546 seenflag = TRUE;
252b5132 3547 break;
43ac9881
AM
3548 case 'I':
3549 add_include_path (optarg);
3550 break;
252b5132 3551 case 'p':
b34976b6
AM
3552 dump_private_headers = TRUE;
3553 seenflag = TRUE;
252b5132 3554 break;
6abcee90
TG
3555 case 'P':
3556 dump_private_options = optarg;
3557 seenflag = TRUE;
3558 break;
252b5132 3559 case 'x':
b34976b6
AM
3560 dump_private_headers = TRUE;
3561 dump_symtab = TRUE;
3562 dump_reloc_info = TRUE;
3563 dump_file_header = TRUE;
3564 dump_ar_hdrs = TRUE;
3565 dump_section_headers = TRUE;
3566 seenflag = TRUE;
252b5132
RH
3567 break;
3568 case 't':
b34976b6
AM
3569 dump_symtab = TRUE;
3570 seenflag = TRUE;
252b5132
RH
3571 break;
3572 case 'T':
b34976b6
AM
3573 dump_dynamic_symtab = TRUE;
3574 seenflag = TRUE;
252b5132
RH
3575 break;
3576 case 'd':
b34976b6
AM
3577 disassemble = TRUE;
3578 seenflag = TRUE;
1dada9c5
NC
3579 break;
3580 case 'z':
b34976b6 3581 disassemble_zeroes = TRUE;
252b5132
RH
3582 break;
3583 case 'D':
b34976b6
AM
3584 disassemble = TRUE;
3585 disassemble_all = TRUE;
3586 seenflag = TRUE;
252b5132
RH
3587 break;
3588 case 'S':
b34976b6
AM
3589 disassemble = TRUE;
3590 with_source_code = TRUE;
3591 seenflag = TRUE;
1dada9c5
NC
3592 break;
3593 case 'g':
3594 dump_debugging = 1;
b34976b6 3595 seenflag = TRUE;
1dada9c5 3596 break;
51cdc6e0
NC
3597 case 'e':
3598 dump_debugging = 1;
3599 dump_debugging_tags = 1;
3600 do_demangle = TRUE;
3601 seenflag = TRUE;
3602 break;
365544c3
L
3603 case 'W':
3604 dump_dwarf_section_info = TRUE;
3605 seenflag = TRUE;
4cb93e3b
TG
3606 if (optarg)
3607 dwarf_select_sections_by_letters (optarg);
3608 else
3609 dwarf_select_sections_all ();
3610 break;
3611 case OPTION_DWARF:
3612 dump_dwarf_section_info = TRUE;
3613 seenflag = TRUE;
3614 if (optarg)
3615 dwarf_select_sections_by_names (optarg);
3616 else
3617 dwarf_select_sections_all ();
365544c3 3618 break;
fd2f0033
TT
3619 case OPTION_DWARF_DEPTH:
3620 {
3621 char *cp;
3622 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3623 }
3624 break;
3625 case OPTION_DWARF_START:
3626 {
3627 char *cp;
3628 dwarf_start_die = strtoul (optarg, & cp, 0);
3629 suppress_bfd_header = 1;
3630 }
3631 break;
4723351a
CC
3632 case OPTION_DWARF_CHECK:
3633 dwarf_check = TRUE;
3634 break;
1dada9c5 3635 case 'G':
b34976b6
AM
3636 dump_stab_section_info = TRUE;
3637 seenflag = TRUE;
252b5132
RH
3638 break;
3639 case 's':
b34976b6
AM
3640 dump_section_contents = TRUE;
3641 seenflag = TRUE;
252b5132
RH
3642 break;
3643 case 'r':
b34976b6
AM
3644 dump_reloc_info = TRUE;
3645 seenflag = TRUE;
252b5132
RH
3646 break;
3647 case 'R':
b34976b6
AM
3648 dump_dynamic_reloc_info = TRUE;
3649 seenflag = TRUE;
252b5132
RH
3650 break;
3651 case 'a':
b34976b6
AM
3652 dump_ar_hdrs = TRUE;
3653 seenflag = TRUE;
252b5132
RH
3654 break;
3655 case 'h':
b34976b6
AM
3656 dump_section_headers = TRUE;
3657 seenflag = TRUE;
252b5132 3658 break;
8b53311e 3659 case 'v':
252b5132 3660 case 'V':
b34976b6
AM
3661 show_version = TRUE;
3662 seenflag = TRUE;
252b5132 3663 break;
0af11b59 3664
aebcf7b7
NC
3665 case 'H':
3666 usage (stdout, 0);
3667 /* No need to set seenflag or to break - usage() does not return. */
252b5132
RH
3668 default:
3669 usage (stderr, 1);
3670 }
3671 }
3672
3673 if (show_version)
3674 print_version ("objdump");
3675
b34976b6 3676 if (!seenflag)
1dada9c5 3677 usage (stderr, 2);
252b5132
RH
3678
3679 if (formats_info)
06d86cf7 3680 exit_status = display_info ();
252b5132
RH
3681 else
3682 {
3683 if (optind == argc)
3684 display_file ("a.out", target);
3685 else
3686 for (; optind < argc;)
3687 display_file (argv[optind++], target);
3688 }
3689
70ecb384
NC
3690 free_only_list ();
3691
252b5132
RH
3692 END_PROGRESS (program_name);
3693
75cd796a 3694 return exit_status;
252b5132 3695}
This page took 1.220155 seconds and 4 git commands to generate.