Add missing ChangeLog entries for
[deliverable/binutils-gdb.git] / binutils / objdump.c
CommitLineData
252b5132 1/* objdump.c -- dump information about an object file.
82704155 2 Copyright (C) 1990-2019 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:
3aade688 30
155e0d23
NC
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
3aade688 33
155e0d23
NC
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.
3aade688 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"
f4943d82 54#include "coff-bfd.h"
252b5132
RH
55#include "progress.h"
56#include "bucomm.h"
3284fe0c 57#include "elfcomm.h"
365544c3 58#include "dwarf.h"
7d9813f1 59#include "ctf-api.h"
d7a283d4 60#include "getopt.h"
3882b010 61#include "safe-ctype.h"
252b5132
RH
62#include "dis-asm.h"
63#include "libiberty.h"
64#include "demangle.h"
0dafdf3f 65#include "filenames.h"
252b5132
RH
66#include "debug.h"
67#include "budbg.h"
6abcee90 68#include "objdump.h"
252b5132 69
e8f5eee4
NC
70#ifdef HAVE_MMAP
71#include <sys/mman.h>
72#endif
73
252b5132
RH
74/* Internal headers for the ELF .stab-dump code - sorry. */
75#define BYTES_IN_WORD 32
76#include "aout/aout64.h"
77
75cd796a
ILT
78/* Exit status. */
79static int exit_status = 0;
80
98a91d6a 81static char *default_target = NULL; /* Default at runtime. */
252b5132 82
3b9ad1cc
AM
83/* The following variables are set based on arguments passed on the
84 command line. */
98a91d6a 85static int show_version = 0; /* Show the version number. */
252b5132
RH
86static int dump_section_contents; /* -s */
87static int dump_section_headers; /* -h */
b34976b6 88static bfd_boolean dump_file_header; /* -f */
252b5132
RH
89static int dump_symtab; /* -t */
90static int dump_dynamic_symtab; /* -T */
91static int dump_reloc_info; /* -r */
92static int dump_dynamic_reloc_info; /* -R */
93static int dump_ar_hdrs; /* -a */
94static int dump_private_headers; /* -p */
6abcee90 95static char *dump_private_options; /* -P */
252b5132
RH
96static int prefix_addresses; /* --prefix-addresses */
97static int with_line_numbers; /* -l */
b34976b6 98static bfd_boolean with_source_code; /* -S */
252b5132 99static int show_raw_insn; /* --show-raw-insn */
365544c3 100static int dump_dwarf_section_info; /* --dwarf */
252b5132 101static int dump_stab_section_info; /* --stabs */
7d9813f1
NA
102static int dump_ctf_section_info; /* --ctf */
103static char *dump_ctf_section_name;
104static char *dump_ctf_parent_name; /* --ctf-parent */
252b5132 105static int do_demangle; /* -C, --demangle */
b34976b6
AM
106static bfd_boolean disassemble; /* -d */
107static bfd_boolean disassemble_all; /* -D */
252b5132 108static int disassemble_zeroes; /* --disassemble-zeroes */
b34976b6 109static bfd_boolean formats_info; /* -i */
252b5132 110static int wide_output; /* -w */
3dcb3fcb 111static int insn_width; /* --insn-width */
252b5132
RH
112static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
113static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
114static int dump_debugging; /* --debugging */
51cdc6e0 115static int dump_debugging_tags; /* --debugging-tags */
fd2f0033 116static int suppress_bfd_header;
3c9458e9 117static int dump_special_syms = 0; /* --special-syms */
252b5132 118static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
f1563258 119static int file_start_context = 0; /* --file-start-context */
98ec6e72 120static bfd_boolean display_file_offsets;/* -F */
0dafdf3f
L
121static const char *prefix; /* --prefix */
122static int prefix_strip; /* --prefix-strip */
123static size_t prefix_length;
4a14e306 124static bfd_boolean unwind_inlines; /* --inlines. */
d3def5d7 125static const char * disasm_sym; /* Disassembly start symbol. */
252b5132 126
af03af8f
NC
127static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;
128
70ecb384
NC
129/* A structure to record the sections mentioned in -j switches. */
130struct only
131{
132 const char * name; /* The name of the section. */
133 bfd_boolean seen; /* A flag to indicate that the section has been found in one or more input files. */
134 struct only * next; /* Pointer to the next structure in the list. */
135};
136/* Pointer to an array of 'only' structures.
137 This pointer is NULL if the -j switch has not been used. */
138static struct only * only_list = NULL;
155e0d23 139
43ac9881
AM
140/* Variables for handling include file path table. */
141static const char **include_paths;
142static int include_path_count;
143
3b9ad1cc
AM
144/* Extra info to pass to the section disassembler and address printing
145 function. */
026df7c5
NC
146struct objdump_disasm_info
147{
155e0d23
NC
148 bfd * abfd;
149 asection * sec;
150 bfd_boolean require_sec;
151 arelent ** dynrelbuf;
152 long dynrelcount;
153 disassembler_ftype disassemble_fn;
ce04548a 154 arelent * reloc;
d3def5d7 155 const char * symbol;
252b5132
RH
156};
157
158/* Architecture to disassemble for, or default if NULL. */
d3ba0551 159static char *machine = NULL;
252b5132 160
dd92f639 161/* Target specific options to the disassembler. */
d3ba0551 162static char *disassembler_options = NULL;
dd92f639 163
252b5132
RH
164/* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
165static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
166
167/* The symbol table. */
168static asymbol **syms;
169
170/* Number of symbols in `syms'. */
171static long symcount = 0;
172
173/* The sorted symbol table. */
174static asymbol **sorted_syms;
175
176/* Number of symbols in `sorted_syms'. */
177static long sorted_symcount = 0;
178
179/* The dynamic symbol table. */
180static asymbol **dynsyms;
181
4c45e5c9
JJ
182/* The synthetic symbol table. */
183static asymbol *synthsyms;
184static long synthcount = 0;
185
252b5132
RH
186/* Number of symbols in `dynsyms'. */
187static long dynsymcount = 0;
188
98a91d6a
NC
189static bfd_byte *stabs;
190static bfd_size_type stab_size;
191
bae7501e 192static bfd_byte *strtab;
98a91d6a 193static bfd_size_type stabstr_size;
41e92641
NC
194
195static bfd_boolean is_relocatable = FALSE;
6abcee90
TG
196
197/* Handlers for -P/--private. */
198static const struct objdump_private_desc * const objdump_private_vectors[] =
199 {
200 OBJDUMP_PRIVATE_VECTORS
201 NULL
202 };
252b5132 203\f
aebcf7b7 204static void usage (FILE *, int) ATTRIBUTE_NORETURN;
252b5132 205static void
46dca2e0 206usage (FILE *stream, int status)
252b5132 207{
8b53311e
NC
208 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
209 fprintf (stream, _(" Display information from object <file(s)>.\n"));
210 fprintf (stream, _(" At least one of the following switches must be given:\n"));
252b5132 211 fprintf (stream, _("\
86d65c94
MK
212 -a, --archive-headers Display archive header information\n\
213 -f, --file-headers Display the contents of the overall file header\n\
214 -p, --private-headers Display object format specific file header contents\n\
6abcee90 215 -P, --private=OPT,OPT... Display object format specific contents\n\
86d65c94
MK
216 -h, --[section-]headers Display the contents of the section headers\n\
217 -x, --all-headers Display the contents of all headers\n\
218 -d, --disassemble Display assembler contents of executable sections\n\
219 -D, --disassemble-all Display assembler contents of all sections\n\
d3def5d7 220 --disassemble=<sym> Display assembler contents from <sym>\n\
86d65c94
MK
221 -S, --source Intermix source code with disassembly\n\
222 -s, --full-contents Display the full contents of all sections requested\n\
223 -g, --debugging Display debug information in object file\n\
51cdc6e0 224 -e, --debugging-tags Display debug information using ctags style\n\
86d65c94 225 -G, --stabs Display (in raw form) any STABS info in the file\n\
dda8d76d 226 -W[lLiaprmfFsoRtUuTgAckK] or\n\
1ed06042 227 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 228 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47 229 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
dda8d76d 230 =addr,=cu_index,=links,=follow-links]\n\
79b377b3
NC
231 Display DWARF info in the file\n\
232 --ctf=SECTION Display CTF info from SECTION\n\
86d65c94
MK
233 -t, --syms Display the contents of the symbol table(s)\n\
234 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
235 -r, --reloc Display the relocation entries in the file\n\
236 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
07012eee 237 @<file> Read options from <file>\n\
8b53311e 238 -v, --version Display this program's version number\n\
86d65c94
MK
239 -i, --info List object formats and architectures supported\n\
240 -H, --help Display this information\n\
1dada9c5
NC
241"));
242 if (status != 2)
243 {
6abcee90
TG
244 const struct objdump_private_desc * const *desc;
245
1dada9c5
NC
246 fprintf (stream, _("\n The following switches are optional:\n"));
247 fprintf (stream, _("\
86d65c94
MK
248 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
249 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
250 -j, --section=NAME Only display information for section NAME\n\
251 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
1dada9c5
NC
252 -EB --endian=big Assume big endian format when disassembling\n\
253 -EL --endian=little Assume little endian format when disassembling\n\
f1563258 254 --file-start-context Include context from start of file (with -S)\n\
43ac9881 255 -I, --include=DIR Add DIR to search list for source files\n\
86d65c94 256 -l, --line-numbers Include line numbers and filenames in output\n\
98ec6e72 257 -F, --file-offsets Include file offsets when displaying information\n\
28c309a2 258 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
f0c8c24a
NC
259 The STYLE, if specified, can be `auto', `gnu',\n\
260 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
261 or `gnat'\n\
af03af8f
NC
262 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
263 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
86d65c94
MK
264 -w, --wide Format output for more than 80 columns\n\
265 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
f0c8c24a
NC
266 --start-address=ADDR Only process data whose address is >= ADDR\n\
267 --stop-address=ADDR Only process data whose address is <= ADDR\n\
1dada9c5
NC
268 --prefix-addresses Print complete address alongside disassembly\n\
269 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
505f1412 270 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
86d65c94 271 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
3c9458e9 272 --special-syms Include special symbols in symbol dumps\n\
4a14e306 273 --inlines Print all inlines for source line (with -l)\n\
0dafdf3f 274 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
fd2f0033
TT
275 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
276 fprintf (stream, _("\
277 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
278 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4723351a
CC
279 or deeper\n\
280 --dwarf-check Make additional dwarf internal consistency checks.\
79b377b3 281 \n\
7d9813f1 282 --ctf-parent=SECTION Use SECTION as the CTF parent\n\n"));
1dada9c5 283 list_supported_targets (program_name, stream);
2f83960e 284 list_supported_architectures (program_name, stream);
86d65c94 285
94470b23 286 disassembler_usage (stream);
6abcee90
TG
287
288 if (objdump_private_vectors[0] != NULL)
289 {
290 fprintf (stream,
291 _("\nOptions supported for -P/--private switch:\n"));
292 for (desc = objdump_private_vectors; *desc != NULL; desc++)
293 (*desc)->help (stream);
294 }
1dada9c5 295 }
92f01d61 296 if (REPORT_BUGS_TO[0] && status == 0)
86d65c94 297 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
252b5132
RH
298 exit (status);
299}
300
301/* 150 isn't special; it's just an arbitrary non-ASCII char value. */
46dca2e0
NC
302enum option_values
303 {
304 OPTION_ENDIAN=150,
305 OPTION_START_ADDRESS,
306 OPTION_STOP_ADDRESS,
4cb93e3b 307 OPTION_DWARF,
0dafdf3f
L
308 OPTION_PREFIX,
309 OPTION_PREFIX_STRIP,
3dcb3fcb 310 OPTION_INSN_WIDTH,
fd2f0033
TT
311 OPTION_ADJUST_VMA,
312 OPTION_DWARF_DEPTH,
4723351a 313 OPTION_DWARF_CHECK,
4a14e306 314 OPTION_DWARF_START,
af03af8f
NC
315 OPTION_RECURSE_LIMIT,
316 OPTION_NO_RECURSE_LIMIT,
79b377b3 317 OPTION_INLINES,
7d9813f1 318 OPTION_CTF,
79b377b3 319 OPTION_CTF_PARENT
46dca2e0 320 };
252b5132
RH
321
322static struct option long_options[]=
323{
324 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
325 {"all-headers", no_argument, NULL, 'x'},
326 {"private-headers", no_argument, NULL, 'p'},
6abcee90 327 {"private", required_argument, NULL, 'P'},
252b5132
RH
328 {"architecture", required_argument, NULL, 'm'},
329 {"archive-headers", no_argument, NULL, 'a'},
1dada9c5 330 {"debugging", no_argument, NULL, 'g'},
51cdc6e0 331 {"debugging-tags", no_argument, NULL, 'e'},
28c309a2 332 {"demangle", optional_argument, NULL, 'C'},
d3def5d7 333 {"disassemble", optional_argument, NULL, 'd'},
252b5132 334 {"disassemble-all", no_argument, NULL, 'D'},
dd92f639 335 {"disassembler-options", required_argument, NULL, 'M'},
1dada9c5 336 {"disassemble-zeroes", no_argument, NULL, 'z'},
252b5132
RH
337 {"dynamic-reloc", no_argument, NULL, 'R'},
338 {"dynamic-syms", no_argument, NULL, 'T'},
339 {"endian", required_argument, NULL, OPTION_ENDIAN},
340 {"file-headers", no_argument, NULL, 'f'},
98ec6e72 341 {"file-offsets", no_argument, NULL, 'F'},
f1563258 342 {"file-start-context", no_argument, &file_start_context, 1},
252b5132
RH
343 {"full-contents", no_argument, NULL, 's'},
344 {"headers", no_argument, NULL, 'h'},
345 {"help", no_argument, NULL, 'H'},
346 {"info", no_argument, NULL, 'i'},
347 {"line-numbers", no_argument, NULL, 'l'},
348 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
349 {"prefix-addresses", no_argument, &prefix_addresses, 1},
af03af8f
NC
350 {"recurse-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
351 {"recursion-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
352 {"no-recurse-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
353 {"no-recursion-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
252b5132
RH
354 {"reloc", no_argument, NULL, 'r'},
355 {"section", required_argument, NULL, 'j'},
356 {"section-headers", no_argument, NULL, 'h'},
357 {"show-raw-insn", no_argument, &show_raw_insn, 1},
358 {"source", no_argument, NULL, 'S'},
3c9458e9 359 {"special-syms", no_argument, &dump_special_syms, 1},
43ac9881 360 {"include", required_argument, NULL, 'I'},
4cb93e3b 361 {"dwarf", optional_argument, NULL, OPTION_DWARF},
7d9813f1
NA
362 {"ctf", required_argument, NULL, OPTION_CTF},
363 {"ctf-parent", required_argument, NULL, OPTION_CTF_PARENT},
1dada9c5 364 {"stabs", no_argument, NULL, 'G'},
252b5132
RH
365 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
366 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
367 {"syms", no_argument, NULL, 't'},
368 {"target", required_argument, NULL, 'b'},
1dada9c5
NC
369 {"version", no_argument, NULL, 'V'},
370 {"wide", no_argument, NULL, 'w'},
0dafdf3f
L
371 {"prefix", required_argument, NULL, OPTION_PREFIX},
372 {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
3dcb3fcb 373 {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
dda8d76d
NC
374 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
375 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
376 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
377 {"inlines", no_argument, 0, OPTION_INLINES},
252b5132
RH
378 {0, no_argument, 0, 0}
379};
380\f
381static void
46dca2e0 382nonfatal (const char *msg)
75cd796a
ILT
383{
384 bfd_nonfatal (msg);
385 exit_status = 1;
386}
12add40e
NC
387
388/* Returns a version of IN with any control characters
389 replaced by escape sequences. Uses a static buffer
390 if necessary. */
391
392static const char *
393sanitize_string (const char * in)
394{
63455780
NC
395 static char * buffer = NULL;
396 static size_t buffer_len = 0;
397 const char * original = in;
398 char * out;
12add40e
NC
399
400 /* Paranoia. */
401 if (in == NULL)
402 return "";
403
404 /* See if any conversion is necessary. In the majority
405 of cases it will not be needed. */
406 do
407 {
408 char c = *in++;
409
410 if (c == 0)
411 return original;
412
413 if (ISCNTRL (c))
414 break;
415 }
416 while (1);
417
418 /* Copy the input, translating as needed. */
419 in = original;
420 if (buffer_len < (strlen (in) * 2))
421 {
422 free ((void *) buffer);
423 buffer_len = strlen (in) * 2;
424 buffer = xmalloc (buffer_len + 1);
425 }
426
427 out = buffer;
428 do
429 {
430 char c = *in++;
431
432 if (c == 0)
433 break;
434
435 if (!ISCNTRL (c))
436 *out++ = c;
437 else
438 {
439 *out++ = '^';
440 *out++ = c + 0x40;
441 }
442 }
443 while (1);
444
445 *out = 0;
446 return buffer;
447}
448
75cd796a 449\f
d2fcac5c
NC
450/* Returns TRUE if the specified section should be dumped. */
451
452static bfd_boolean
453process_section_p (asection * section)
454{
70ecb384 455 struct only * only;
d2fcac5c 456
70ecb384 457 if (only_list == NULL)
d2fcac5c
NC
458 return TRUE;
459
70ecb384
NC
460 for (only = only_list; only; only = only->next)
461 if (strcmp (only->name, section->name) == 0)
462 {
463 only->seen = TRUE;
464 return TRUE;
465 }
d2fcac5c
NC
466
467 return FALSE;
468}
70ecb384
NC
469
470/* Add an entry to the 'only' list. */
471
472static void
473add_only (char * name)
474{
475 struct only * only;
476
477 /* First check to make sure that we do not
478 already have an entry for this name. */
479 for (only = only_list; only; only = only->next)
480 if (strcmp (only->name, name) == 0)
481 return;
482
483 only = xmalloc (sizeof * only);
484 only->name = name;
485 only->seen = FALSE;
486 only->next = only_list;
487 only_list = only;
488}
489
490/* Release the memory used by the 'only' list.
491 PR 11225: Issue a warning message for unseen sections.
492 Only do this if none of the sections were seen. This is mainly to support
493 tools like the GAS testsuite where an object file is dumped with a list of
494 generic section names known to be present in a range of different file
495 formats. */
496
497static void
498free_only_list (void)
499{
500 bfd_boolean at_least_one_seen = FALSE;
501 struct only * only;
502 struct only * next;
503
504 if (only_list == NULL)
505 return;
506
507 for (only = only_list; only; only = only->next)
508 if (only->seen)
509 {
510 at_least_one_seen = TRUE;
511 break;
512 }
513
514 for (only = only_list; only; only = next)
515 {
516 if (! at_least_one_seen)
517 {
a8c62f1c
AM
518 non_fatal (_("section '%s' mentioned in a -j option, "
519 "but not found in any input file"),
70ecb384
NC
520 only->name);
521 exit_status = 1;
522 }
523 next = only->next;
524 free (only);
525 }
526}
527
d2fcac5c 528\f
75cd796a 529static void
1737c640 530dump_section_header (bfd *abfd, asection *section, void *data)
252b5132
RH
531{
532 char *comma = "";
f6af82bd 533 unsigned int opb = bfd_octets_per_byte (abfd);
1737c640 534 int longest_section_name = *((int *) data);
252b5132 535
3bee8bcd
L
536 /* Ignore linker created section. See elfNN_ia64_object_p in
537 bfd/elfxx-ia64.c. */
538 if (section->flags & SEC_LINKER_CREATED)
539 return;
540
d2fcac5c
NC
541 /* PR 10413: Skip sections that we are ignoring. */
542 if (! process_section_p (section))
543 return;
544
1737c640 545 printf ("%3d %-*s %08lx ", section->index, longest_section_name,
12add40e 546 sanitize_string (bfd_get_section_name (abfd, section)),
940b2b78 547 (unsigned long) bfd_section_size (abfd, section) / opb);
d8180c76 548 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
252b5132 549 printf (" ");
d8180c76 550 bfd_printf_vma (abfd, section->lma);
e59b4dfb 551 printf (" %08lx 2**%u", (unsigned long) section->filepos,
252b5132
RH
552 bfd_get_section_alignment (abfd, section));
553 if (! wide_output)
554 printf ("\n ");
555 printf (" ");
556
557#define PF(x, y) \
558 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
559
560 PF (SEC_HAS_CONTENTS, "CONTENTS");
561 PF (SEC_ALLOC, "ALLOC");
562 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
252b5132
RH
563 PF (SEC_LOAD, "LOAD");
564 PF (SEC_RELOC, "RELOC");
252b5132
RH
565 PF (SEC_READONLY, "READONLY");
566 PF (SEC_CODE, "CODE");
567 PF (SEC_DATA, "DATA");
568 PF (SEC_ROM, "ROM");
569 PF (SEC_DEBUGGING, "DEBUGGING");
570 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
571 PF (SEC_EXCLUDE, "EXCLUDE");
572 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
ebe372c1
L
573 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
574 {
575 PF (SEC_TIC54X_BLOCK, "BLOCK");
576 PF (SEC_TIC54X_CLINK, "CLINK");
577 }
24c411ed 578 PF (SEC_SMALL_DATA, "SMALL_DATA");
ebe372c1 579 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
91f68a68
MG
580 {
581 PF (SEC_COFF_SHARED, "SHARED");
582 PF (SEC_COFF_NOREAD, "NOREAD");
583 }
584 else if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
f0728ee3 585 PF (SEC_ELF_PURECODE, "PURECODE");
13ae64f3 586 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
64c1196b 587 PF (SEC_GROUP, "GROUP");
91f68a68
MG
588 if (bfd_get_arch (abfd) == bfd_arch_mep)
589 {
590 PF (SEC_MEP_VLIW, "VLIW");
591 }
252b5132
RH
592
593 if ((section->flags & SEC_LINK_ONCE) != 0)
594 {
595 const char *ls;
082b7297 596 struct coff_comdat_info *comdat;
252b5132
RH
597
598 switch (section->flags & SEC_LINK_DUPLICATES)
599 {
600 default:
601 abort ();
602 case SEC_LINK_DUPLICATES_DISCARD:
603 ls = "LINK_ONCE_DISCARD";
604 break;
605 case SEC_LINK_DUPLICATES_ONE_ONLY:
606 ls = "LINK_ONCE_ONE_ONLY";
607 break;
608 case SEC_LINK_DUPLICATES_SAME_SIZE:
609 ls = "LINK_ONCE_SAME_SIZE";
610 break;
611 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
612 ls = "LINK_ONCE_SAME_CONTENTS";
613 break;
614 }
615 printf ("%s%s", comma, ls);
deecf979 616
082b7297
L
617 comdat = bfd_coff_get_comdat_section (abfd, section);
618 if (comdat != NULL)
619 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
deecf979 620
252b5132
RH
621 comma = ", ";
622 }
623
624 printf ("\n");
625#undef PF
626}
627
1737c640
AB
628/* Called on each SECTION in ABFD, update the int variable pointed to by
629 DATA which contains the string length of the longest section name. */
630
631static void
632find_longest_section_name (bfd *abfd, asection *section, void *data)
633{
634 int *longest_so_far = (int *) data;
635 const char *name;
636 int len;
637
638 /* Ignore linker created section. */
639 if (section->flags & SEC_LINKER_CREATED)
640 return;
641
642 /* Skip sections that we are ignoring. */
643 if (! process_section_p (section))
644 return;
645
646 name = bfd_get_section_name (abfd, section);
647 len = (int) strlen (name);
648 if (len > *longest_so_far)
649 *longest_so_far = len;
650}
651
252b5132 652static void
46dca2e0 653dump_headers (bfd *abfd)
252b5132 654{
1737c640
AB
655 /* The default width of 13 is just an arbitrary choice. */
656 int max_section_name_length = 13;
657 int bfd_vma_width;
8bea4d5c 658
252b5132 659#ifndef BFD64
1737c640 660 bfd_vma_width = 10;
252b5132 661#else
21611032
TS
662 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
663 if (bfd_get_arch_size (abfd) == 32)
1737c640 664 bfd_vma_width = 10;
21611032 665 else
1737c640 666 bfd_vma_width = 18;
252b5132 667#endif
8bea4d5c 668
1737c640
AB
669 printf (_("Sections:\n"));
670
671 if (wide_output)
672 bfd_map_over_sections (abfd, find_longest_section_name,
673 &max_section_name_length);
674
675 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
676 max_section_name_length, "Name",
677 bfd_vma_width, "VMA",
678 bfd_vma_width, "LMA");
679
8bea4d5c
ILT
680 if (wide_output)
681 printf (_(" Flags"));
682 printf ("\n");
683
1737c640
AB
684 bfd_map_over_sections (abfd, dump_section_header,
685 &max_section_name_length);
252b5132
RH
686}
687\f
688static asymbol **
46dca2e0 689slurp_symtab (bfd *abfd)
252b5132 690{
d3ba0551 691 asymbol **sy = NULL;
252b5132
RH
692 long storage;
693
694 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
695 {
252b5132
RH
696 symcount = 0;
697 return NULL;
698 }
699
700 storage = bfd_get_symtab_upper_bound (abfd);
701 if (storage < 0)
5a3f568b
NC
702 {
703 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd));
704 bfd_fatal (_("error message was"));
705 }
252b5132 706 if (storage)
781152ec
NC
707 {
708 off_t filesize = bfd_get_file_size (abfd);
709
710 /* qv PR 24707. */
7e56c51c
NC
711 if (filesize > 0
712 && filesize < storage
713 /* The MMO file format supports its own special compression
714 technique, so its sections can be larger than the file size. */
715 && bfd_get_flavour (abfd) != bfd_target_mmo_flavour)
781152ec
NC
716 {
717 bfd_nonfatal_message (bfd_get_filename (abfd), abfd, NULL,
718 _("error: symbol table size (%#lx) is larger than filesize (%#lx)"),
719 storage, (long) filesize);
720 exit_status = 1;
721 symcount = 0;
722 return NULL;
723 }
724
725 sy = (asymbol **) xmalloc (storage);
726 }
28b18af1 727
252b5132
RH
728 symcount = bfd_canonicalize_symtab (abfd, sy);
729 if (symcount < 0)
730 bfd_fatal (bfd_get_filename (abfd));
252b5132
RH
731 return sy;
732}
733
734/* Read in the dynamic symbols. */
735
736static asymbol **
46dca2e0 737slurp_dynamic_symtab (bfd *abfd)
252b5132 738{
d3ba0551 739 asymbol **sy = NULL;
252b5132
RH
740 long storage;
741
742 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
743 if (storage < 0)
744 {
745 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
746 {
37cc8ec1 747 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
a8c62f1c 748 exit_status = 1;
252b5132
RH
749 dynsymcount = 0;
750 return NULL;
751 }
752
753 bfd_fatal (bfd_get_filename (abfd));
754 }
252b5132 755 if (storage)
3f5e193b 756 sy = (asymbol **) xmalloc (storage);
28b18af1 757
252b5132
RH
758 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
759 if (dynsymcount < 0)
760 bfd_fatal (bfd_get_filename (abfd));
252b5132
RH
761 return sy;
762}
763
a24bb4f0
NC
764/* Some symbol names are significant and should be kept in the
765 table of sorted symbol names, even if they are marked as
766 debugging/section symbols. */
767
768static bfd_boolean
769is_significant_symbol_name (const char * name)
770{
0e70b27b 771 return strncmp (name, ".plt", 4) == 0 || strcmp (name, ".got") == 0;
a24bb4f0
NC
772}
773
252b5132
RH
774/* Filter out (in place) symbols that are useless for disassembly.
775 COUNT is the number of elements in SYMBOLS.
0af11b59 776 Return the number of useful symbols. */
252b5132
RH
777
778static long
46dca2e0 779remove_useless_symbols (asymbol **symbols, long count)
252b5132 780{
46dca2e0 781 asymbol **in_ptr = symbols, **out_ptr = symbols;
252b5132
RH
782
783 while (--count >= 0)
784 {
785 asymbol *sym = *in_ptr++;
786
787 if (sym->name == NULL || sym->name[0] == '\0')
788 continue;
a24bb4f0
NC
789 if ((sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
790 && ! is_significant_symbol_name (sym->name))
252b5132
RH
791 continue;
792 if (bfd_is_und_section (sym->section)
793 || bfd_is_com_section (sym->section))
794 continue;
795
796 *out_ptr++ = sym;
797 }
798 return out_ptr - symbols;
799}
800
801/* Sort symbols into value order. */
802
0af11b59 803static int
46dca2e0 804compare_symbols (const void *ap, const void *bp)
252b5132 805{
46dca2e0
NC
806 const asymbol *a = * (const asymbol **) ap;
807 const asymbol *b = * (const asymbol **) bp;
808 const char *an;
809 const char *bn;
810 size_t anl;
811 size_t bnl;
812 bfd_boolean af;
813 bfd_boolean bf;
814 flagword aflags;
815 flagword bflags;
252b5132
RH
816
817 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
818 return 1;
819 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
820 return -1;
821
822 if (a->section > b->section)
823 return 1;
824 else if (a->section < b->section)
825 return -1;
826
827 an = bfd_asymbol_name (a);
828 bn = bfd_asymbol_name (b);
829 anl = strlen (an);
830 bnl = strlen (bn);
831
832 /* The symbols gnu_compiled and gcc2_compiled convey no real
833 information, so put them after other symbols with the same value. */
252b5132
RH
834 af = (strstr (an, "gnu_compiled") != NULL
835 || strstr (an, "gcc2_compiled") != NULL);
836 bf = (strstr (bn, "gnu_compiled") != NULL
837 || strstr (bn, "gcc2_compiled") != NULL);
838
839 if (af && ! bf)
840 return 1;
841 if (! af && bf)
842 return -1;
843
844 /* We use a heuristic for the file name, to try to sort it after
845 more useful symbols. It may not work on non Unix systems, but it
846 doesn't really matter; the only difference is precisely which
847 symbol names get printed. */
848
849#define file_symbol(s, sn, snl) \
850 (((s)->flags & BSF_FILE) != 0 \
851 || ((sn)[(snl) - 2] == '.' \
852 && ((sn)[(snl) - 1] == 'o' \
853 || (sn)[(snl) - 1] == 'a')))
854
855 af = file_symbol (a, an, anl);
856 bf = file_symbol (b, bn, bnl);
857
858 if (af && ! bf)
859 return 1;
860 if (! af && bf)
861 return -1;
862
863 /* Try to sort global symbols before local symbols before function
864 symbols before debugging symbols. */
865
866 aflags = a->flags;
867 bflags = b->flags;
868
869 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
870 {
871 if ((aflags & BSF_DEBUGGING) != 0)
872 return 1;
873 else
874 return -1;
875 }
876 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
877 {
878 if ((aflags & BSF_FUNCTION) != 0)
879 return -1;
880 else
881 return 1;
882 }
883 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
884 {
885 if ((aflags & BSF_LOCAL) != 0)
886 return 1;
887 else
888 return -1;
889 }
890 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
891 {
892 if ((aflags & BSF_GLOBAL) != 0)
893 return -1;
894 else
895 return 1;
896 }
897
32a0481f
AM
898 if (bfd_get_flavour (bfd_asymbol_bfd (a)) == bfd_target_elf_flavour
899 && bfd_get_flavour (bfd_asymbol_bfd (b)) == bfd_target_elf_flavour)
900 {
901 bfd_vma asz, bsz;
902
903 asz = 0;
160b1a61 904 if ((a->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
32a0481f
AM
905 asz = ((elf_symbol_type *) a)->internal_elf_sym.st_size;
906 bsz = 0;
160b1a61 907 if ((b->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
32a0481f
AM
908 bsz = ((elf_symbol_type *) b)->internal_elf_sym.st_size;
909 if (asz != bsz)
910 return asz > bsz ? -1 : 1;
911 }
912
252b5132
RH
913 /* Symbols that start with '.' might be section names, so sort them
914 after symbols that don't start with '.'. */
915 if (an[0] == '.' && bn[0] != '.')
916 return 1;
917 if (an[0] != '.' && bn[0] == '.')
918 return -1;
919
920 /* Finally, if we can't distinguish them in any other way, try to
921 get consistent results by sorting the symbols by name. */
922 return strcmp (an, bn);
923}
924
925/* Sort relocs into address order. */
926
927static int
46dca2e0 928compare_relocs (const void *ap, const void *bp)
252b5132 929{
46dca2e0
NC
930 const arelent *a = * (const arelent **) ap;
931 const arelent *b = * (const arelent **) bp;
252b5132
RH
932
933 if (a->address > b->address)
934 return 1;
935 else if (a->address < b->address)
936 return -1;
937
938 /* So that associated relocations tied to the same address show up
939 in the correct order, we don't do any further sorting. */
940 if (a > b)
941 return 1;
942 else if (a < b)
943 return -1;
944 else
945 return 0;
946}
947
155e0d23
NC
948/* Print an address (VMA) to the output stream in INFO.
949 If SKIP_ZEROES is TRUE, omit leading zeroes. */
252b5132
RH
950
951static void
91d6fa6a 952objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
46dca2e0 953 bfd_boolean skip_zeroes)
252b5132
RH
954{
955 char buf[30];
956 char *p;
3b9ad1cc 957 struct objdump_disasm_info *aux;
252b5132 958
91d6fa6a 959 aux = (struct objdump_disasm_info *) inf->application_data;
d8180c76 960 bfd_sprintf_vma (aux->abfd, buf, vma);
252b5132
RH
961 if (! skip_zeroes)
962 p = buf;
963 else
964 {
965 for (p = buf; *p == '0'; ++p)
966 ;
967 if (*p == '\0')
968 --p;
969 }
91d6fa6a 970 (*inf->fprintf_func) (inf->stream, "%s", p);
252b5132
RH
971}
972
973/* Print the name of a symbol. */
974
975static void
91d6fa6a 976objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
46dca2e0 977 asymbol *sym)
252b5132
RH
978{
979 char *alloc;
bb4d2ac2
L
980 const char *name, *version_string = NULL;
981 bfd_boolean hidden = FALSE;
252b5132
RH
982
983 alloc = NULL;
984 name = bfd_asymbol_name (sym);
a6637ec0 985 if (do_demangle && name[0] != '\0')
252b5132
RH
986 {
987 /* Demangle the name. */
af03af8f 988 alloc = bfd_demangle (abfd, name, demangle_flags);
ed180cc5
AM
989 if (alloc != NULL)
990 name = alloc;
252b5132
RH
991 }
992
160b1a61 993 if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
f2b2af2c 994 version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
bb4d2ac2
L
995
996 if (bfd_is_und_section (bfd_get_section (sym)))
997 hidden = TRUE;
998
12add40e
NC
999 name = sanitize_string (name);
1000
91d6fa6a 1001 if (inf != NULL)
bb4d2ac2
L
1002 {
1003 (*inf->fprintf_func) (inf->stream, "%s", name);
1004 if (version_string && *version_string != '\0')
1005 (*inf->fprintf_func) (inf->stream, hidden ? "@%s" : "@@%s",
1006 version_string);
1007 }
252b5132 1008 else
bb4d2ac2
L
1009 {
1010 printf ("%s", name);
1011 if (version_string && *version_string != '\0')
1012 printf (hidden ? "@%s" : "@@%s", version_string);
1013 }
252b5132
RH
1014
1015 if (alloc != NULL)
1016 free (alloc);
1017}
1018
39f0547e
NC
1019static inline bfd_boolean
1020sym_ok (bfd_boolean want_section,
1021 bfd * abfd ATTRIBUTE_UNUSED,
1022 long place,
1023 asection * sec,
1024 struct disassemble_info * inf)
1025{
1026 if (want_section)
1027 {
1028 /* Note - we cannot just compare section pointers because they could
1029 be different, but the same... Ie the symbol that we are trying to
1030 find could have come from a separate debug info file. Under such
1031 circumstances the symbol will be associated with a section in the
1032 debug info file, whilst the section we want is in a normal file.
1033 So the section pointers will be different, but the section names
1034 will be the same. */
1035 if (strcmp (bfd_section_name (abfd, sorted_syms[place]->section),
1036 bfd_section_name (abfd, sec)) != 0)
1037 return FALSE;
1038 }
1039
1040 return inf->symbol_is_valid (sorted_syms[place], inf);
1041}
1042
22a398e1
NC
1043/* Locate a symbol given a bfd and a section (from INFO->application_data),
1044 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1045 require the symbol to be in the section. Returns NULL if there is no
1046 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1047 of the symbol in sorted_syms. */
252b5132
RH
1048
1049static asymbol *
3b9ad1cc 1050find_symbol_for_address (bfd_vma vma,
91d6fa6a 1051 struct disassemble_info *inf,
3b9ad1cc 1052 long *place)
252b5132
RH
1053{
1054 /* @@ Would it speed things up to cache the last two symbols returned,
1055 and maybe their address ranges? For many processors, only one memory
1056 operand can be present at a time, so the 2-entry cache wouldn't be
1057 constantly churned by code doing heavy memory accesses. */
1058
1059 /* Indices in `sorted_syms'. */
1060 long min = 0;
91d6fa6a 1061 long max_count = sorted_symcount;
252b5132 1062 long thisplace;
3b9ad1cc
AM
1063 struct objdump_disasm_info *aux;
1064 bfd *abfd;
1065 asection *sec;
1066 unsigned int opb;
e39ff52a 1067 bfd_boolean want_section;
0e70b27b 1068 long rel_count;
252b5132
RH
1069
1070 if (sorted_symcount < 1)
1071 return NULL;
1072
91d6fa6a 1073 aux = (struct objdump_disasm_info *) inf->application_data;
3b9ad1cc
AM
1074 abfd = aux->abfd;
1075 sec = aux->sec;
91d6fa6a 1076 opb = inf->octets_per_byte;
3b9ad1cc 1077
252b5132 1078 /* Perform a binary search looking for the closest symbol to the
91d6fa6a
NC
1079 required value. We are searching the range (min, max_count]. */
1080 while (min + 1 < max_count)
252b5132
RH
1081 {
1082 asymbol *sym;
1083
91d6fa6a 1084 thisplace = (max_count + min) / 2;
252b5132
RH
1085 sym = sorted_syms[thisplace];
1086
1087 if (bfd_asymbol_value (sym) > vma)
91d6fa6a 1088 max_count = thisplace;
252b5132
RH
1089 else if (bfd_asymbol_value (sym) < vma)
1090 min = thisplace;
1091 else
1092 {
1093 min = thisplace;
1094 break;
1095 }
1096 }
1097
1098 /* The symbol we want is now in min, the low end of the range we
1099 were searching. If there are several symbols with the same
a24bb4f0 1100 value, we want the first (non-section/non-debugging) one. */
252b5132
RH
1101 thisplace = min;
1102 while (thisplace > 0
1103 && (bfd_asymbol_value (sorted_syms[thisplace])
a24bb4f0
NC
1104 == bfd_asymbol_value (sorted_syms[thisplace - 1]))
1105 && ((sorted_syms[thisplace - 1]->flags
1106 & (BSF_SECTION_SYM | BSF_DEBUGGING)) == 0)
1107 )
252b5132
RH
1108 --thisplace;
1109
2b4590fb
AM
1110 /* Prefer a symbol in the current section if we have multple symbols
1111 with the same value, as can occur with overlays or zero size
1112 sections. */
1113 min = thisplace;
91d6fa6a 1114 while (min < max_count
2b4590fb
AM
1115 && (bfd_asymbol_value (sorted_syms[min])
1116 == bfd_asymbol_value (sorted_syms[thisplace])))
1117 {
39f0547e 1118 if (sym_ok (TRUE, abfd, min, sec, inf))
2b4590fb
AM
1119 {
1120 thisplace = min;
1121
1122 if (place != NULL)
1123 *place = thisplace;
1124
1125 return sorted_syms[thisplace];
1126 }
1127 ++min;
1128 }
1129
1049f94e 1130 /* If the file is relocatable, and the symbol could be from this
252b5132
RH
1131 section, prefer a symbol from this section over symbols from
1132 others, even if the other symbol's value might be closer.
0af11b59 1133
252b5132
RH
1134 Note that this may be wrong for some symbol references if the
1135 sections have overlapping memory ranges, but in that case there's
1136 no way to tell what's desired without looking at the relocation
e39ff52a 1137 table.
3aade688 1138
e39ff52a
PB
1139 Also give the target a chance to reject symbols. */
1140 want_section = (aux->require_sec
1141 || ((abfd->flags & HAS_RELOC) != 0
1142 && vma >= bfd_get_section_vma (abfd, sec)
1143 && vma < (bfd_get_section_vma (abfd, sec)
1144 + bfd_section_size (abfd, sec) / opb)));
39f0547e
NC
1145
1146 if (! sym_ok (want_section, abfd, thisplace, sec, inf))
252b5132
RH
1147 {
1148 long i;
2b4590fb 1149 long newplace = sorted_symcount;
98a91d6a 1150
2b4590fb 1151 for (i = min - 1; i >= 0; i--)
252b5132 1152 {
39f0547e 1153 if (sym_ok (want_section, abfd, i, sec, inf))
252b5132 1154 {
e39ff52a
PB
1155 if (newplace == sorted_symcount)
1156 newplace = i;
1157
1158 if (bfd_asymbol_value (sorted_syms[i])
1159 != bfd_asymbol_value (sorted_syms[newplace]))
1160 break;
1161
1162 /* Remember this symbol and keep searching until we reach
1163 an earlier address. */
1164 newplace = i;
252b5132
RH
1165 }
1166 }
1167
e39ff52a
PB
1168 if (newplace != sorted_symcount)
1169 thisplace = newplace;
1170 else
252b5132
RH
1171 {
1172 /* We didn't find a good symbol with a smaller value.
1173 Look for one with a larger value. */
1174 for (i = thisplace + 1; i < sorted_symcount; i++)
1175 {
39f0547e 1176 if (sym_ok (want_section, abfd, i, sec, inf))
252b5132
RH
1177 {
1178 thisplace = i;
1179 break;
1180 }
1181 }
1182 }
1183
39f0547e 1184 if (! sym_ok (want_section, abfd, thisplace, sec, inf))
22a398e1
NC
1185 /* There is no suitable symbol. */
1186 return NULL;
1187 }
1188
a24bb4f0
NC
1189 /* If we have not found an exact match for the specified address
1190 and we have dynamic relocations available, then we can produce
1191 a better result by matching a relocation to the address and
1192 using the symbol associated with that relocation. */
0e70b27b 1193 rel_count = aux->dynrelcount;
a24bb4f0 1194 if (!want_section
a24bb4f0 1195 && sorted_syms[thisplace]->value != vma
0e70b27b
L
1196 && rel_count > 0
1197 && aux->dynrelbuf != NULL
1198 && aux->dynrelbuf[0]->address <= vma
1199 && aux->dynrelbuf[rel_count - 1]->address >= vma
a24bb4f0
NC
1200 /* If we have matched a synthetic symbol, then stick with that. */
1201 && (sorted_syms[thisplace]->flags & BSF_SYNTHETIC) == 0)
1202 {
0e70b27b
L
1203 arelent ** rel_low;
1204 arelent ** rel_high;
a24bb4f0 1205
0e70b27b
L
1206 rel_low = aux->dynrelbuf;
1207 rel_high = rel_low + rel_count - 1;
1208 while (rel_low <= rel_high)
a24bb4f0 1209 {
0e70b27b
L
1210 arelent **rel_mid = &rel_low[(rel_high - rel_low) / 2];
1211 arelent * rel = *rel_mid;
a24bb4f0 1212
0e70b27b 1213 if (rel->address == vma)
a24bb4f0 1214 {
0e70b27b
L
1215 /* Absolute relocations do not provide a more helpful
1216 symbolic address. Find a non-absolute relocation
1217 with the same address. */
1218 arelent **rel_vma = rel_mid;
1219 for (rel_mid--;
1220 rel_mid >= rel_low && rel_mid[0]->address == vma;
1221 rel_mid--)
1222 rel_vma = rel_mid;
1223
1224 for (; rel_vma <= rel_high && rel_vma[0]->address == vma;
1225 rel_vma++)
1226 {
1227 rel = *rel_vma;
1228 if (rel->sym_ptr_ptr != NULL
1229 && ! bfd_is_abs_section ((* rel->sym_ptr_ptr)->section))
1230 {
1231 if (place != NULL)
1232 * place = thisplace;
1233 return * rel->sym_ptr_ptr;
1234 }
1235 }
1236 break;
a24bb4f0
NC
1237 }
1238
0e70b27b
L
1239 if (vma < rel->address)
1240 rel_high = rel_mid;
1241 else if (vma >= rel_mid[1]->address)
1242 rel_low = rel_mid + 1;
1243 else
a24bb4f0
NC
1244 break;
1245 }
1246 }
1247
252b5132
RH
1248 if (place != NULL)
1249 *place = thisplace;
1250
1251 return sorted_syms[thisplace];
1252}
1253
155e0d23 1254/* Print an address and the offset to the nearest symbol. */
252b5132
RH
1255
1256static void
46dca2e0 1257objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
91d6fa6a 1258 bfd_vma vma, struct disassemble_info *inf,
46dca2e0 1259 bfd_boolean skip_zeroes)
252b5132 1260{
91d6fa6a 1261 objdump_print_value (vma, inf, skip_zeroes);
252b5132
RH
1262
1263 if (sym == NULL)
1264 {
1265 bfd_vma secaddr;
1266
91d6fa6a 1267 (*inf->fprintf_func) (inf->stream, " <%s",
12add40e 1268 sanitize_string (bfd_get_section_name (abfd, sec)));
252b5132
RH
1269 secaddr = bfd_get_section_vma (abfd, sec);
1270 if (vma < secaddr)
1271 {
91d6fa6a
NC
1272 (*inf->fprintf_func) (inf->stream, "-0x");
1273 objdump_print_value (secaddr - vma, inf, TRUE);
252b5132
RH
1274 }
1275 else if (vma > secaddr)
1276 {
91d6fa6a
NC
1277 (*inf->fprintf_func) (inf->stream, "+0x");
1278 objdump_print_value (vma - secaddr, inf, TRUE);
252b5132 1279 }
91d6fa6a 1280 (*inf->fprintf_func) (inf->stream, ">");
252b5132
RH
1281 }
1282 else
1283 {
91d6fa6a 1284 (*inf->fprintf_func) (inf->stream, " <");
a24bb4f0 1285
91d6fa6a 1286 objdump_print_symname (abfd, inf, sym);
a24bb4f0
NC
1287
1288 if (bfd_asymbol_value (sym) == vma)
1289 ;
1290 /* Undefined symbols in an executables and dynamic objects do not have
1291 a value associated with them, so it does not make sense to display
1292 an offset relative to them. Normally we would not be provided with
1293 this kind of symbol, but the target backend might choose to do so,
1294 and the code in find_symbol_for_address might return an as yet
1295 unresolved symbol associated with a dynamic reloc. */
1296 else if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
1297 && bfd_is_und_section (sym->section))
1298 ;
1299 else if (bfd_asymbol_value (sym) > vma)
252b5132 1300 {
91d6fa6a
NC
1301 (*inf->fprintf_func) (inf->stream, "-0x");
1302 objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
252b5132
RH
1303 }
1304 else if (vma > bfd_asymbol_value (sym))
1305 {
91d6fa6a
NC
1306 (*inf->fprintf_func) (inf->stream, "+0x");
1307 objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
252b5132 1308 }
a24bb4f0 1309
91d6fa6a 1310 (*inf->fprintf_func) (inf->stream, ">");
252b5132 1311 }
98ec6e72
NC
1312
1313 if (display_file_offsets)
91d6fa6a 1314 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
98ec6e72 1315 (long int)(sec->filepos + (vma - sec->vma)));
252b5132
RH
1316}
1317
155e0d23
NC
1318/* Print an address (VMA), symbolically if possible.
1319 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
252b5132
RH
1320
1321static void
3b9ad1cc 1322objdump_print_addr (bfd_vma vma,
91d6fa6a 1323 struct disassemble_info *inf,
46dca2e0 1324 bfd_boolean skip_zeroes)
252b5132 1325{
3b9ad1cc 1326 struct objdump_disasm_info *aux;
d253b654 1327 asymbol *sym = NULL;
ce04548a 1328 bfd_boolean skip_find = FALSE;
252b5132 1329
91d6fa6a 1330 aux = (struct objdump_disasm_info *) inf->application_data;
32760852 1331
252b5132
RH
1332 if (sorted_symcount < 1)
1333 {
91d6fa6a
NC
1334 (*inf->fprintf_func) (inf->stream, "0x");
1335 objdump_print_value (vma, inf, skip_zeroes);
32760852
NC
1336
1337 if (display_file_offsets)
91d6fa6a
NC
1338 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1339 (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
252b5132
RH
1340 return;
1341 }
1342
ce04548a
NC
1343 if (aux->reloc != NULL
1344 && aux->reloc->sym_ptr_ptr != NULL
1345 && * aux->reloc->sym_ptr_ptr != NULL)
1346 {
1347 sym = * aux->reloc->sym_ptr_ptr;
1348
1349 /* Adjust the vma to the reloc. */
1350 vma += bfd_asymbol_value (sym);
1351
1352 if (bfd_is_und_section (bfd_get_section (sym)))
1353 skip_find = TRUE;
1354 }
1355
1356 if (!skip_find)
91d6fa6a 1357 sym = find_symbol_for_address (vma, inf, NULL);
ce04548a 1358
91d6fa6a 1359 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf,
252b5132
RH
1360 skip_zeroes);
1361}
1362
1363/* Print VMA to INFO. This function is passed to the disassembler
1364 routine. */
1365
1366static void
91d6fa6a 1367objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
252b5132 1368{
91d6fa6a 1369 objdump_print_addr (vma, inf, ! prefix_addresses);
252b5132
RH
1370}
1371
2ae86dfc 1372/* Determine if the given address has a symbol associated with it. */
252b5132
RH
1373
1374static int
91d6fa6a 1375objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
252b5132 1376{
252b5132
RH
1377 asymbol * sym;
1378
91d6fa6a 1379 sym = find_symbol_for_address (vma, inf, NULL);
252b5132
RH
1380
1381 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
1382}
1383
1384/* Hold the last function name and the last line number we displayed
1385 in a disassembly. */
1386
1387static char *prev_functionname;
1388static unsigned int prev_line;
9b8d1a36 1389static unsigned int prev_discriminator;
252b5132
RH
1390
1391/* We keep a list of all files that we have seen when doing a
50c2245b 1392 disassembly with source, so that we know how much of the file to
252b5132
RH
1393 display. This can be important for inlined functions. */
1394
1395struct print_file_list
1396{
1397 struct print_file_list *next;
43ac9881
AM
1398 const char *filename;
1399 const char *modname;
3aade688 1400 const char *map;
e8f5eee4 1401 size_t mapsize;
3aade688 1402 const char **linemap;
e8f5eee4
NC
1403 unsigned maxline;
1404 unsigned last_line;
43339b1d 1405 unsigned max_printed;
e8f5eee4 1406 int first;
252b5132
RH
1407};
1408
1409static struct print_file_list *print_files;
1410
1411/* The number of preceding context lines to show when we start
1412 displaying a file for the first time. */
1413
1414#define SHOW_PRECEDING_CONTEXT_LINES (5)
1415
417ed8af 1416/* Read a complete file into memory. */
e8f5eee4
NC
1417
1418static const char *
5ef2d51b 1419slurp_file (const char *fn, size_t *size, struct stat *fst)
e8f5eee4
NC
1420{
1421#ifdef HAVE_MMAP
1422 int ps = getpagesize ();
1423 size_t msize;
1424#endif
1425 const char *map;
417ed8af 1426 int fd = open (fn, O_RDONLY | O_BINARY);
e8f5eee4
NC
1427
1428 if (fd < 0)
1429 return NULL;
5ef2d51b 1430 if (fstat (fd, fst) < 0)
6c713012
AM
1431 {
1432 close (fd);
1433 return NULL;
1434 }
5ef2d51b 1435 *size = fst->st_size;
e8f5eee4
NC
1436#ifdef HAVE_MMAP
1437 msize = (*size + ps - 1) & ~(ps - 1);
1438 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
6c713012 1439 if (map != (char *) -1L)
e8f5eee4 1440 {
6c713012
AM
1441 close (fd);
1442 return map;
e8f5eee4
NC
1443 }
1444#endif
3f5e193b 1445 map = (const char *) malloc (*size);
6c713012
AM
1446 if (!map || (size_t) read (fd, (char *) map, *size) != *size)
1447 {
1448 free ((void *) map);
e8f5eee4
NC
1449 map = NULL;
1450 }
1451 close (fd);
6c713012 1452 return map;
e8f5eee4
NC
1453}
1454
1455#define line_map_decrease 5
1456
1457/* Precompute array of lines for a mapped file. */
1458
3aade688
L
1459static const char **
1460index_file (const char *map, size_t size, unsigned int *maxline)
e8f5eee4
NC
1461{
1462 const char *p, *lstart, *end;
1463 int chars_per_line = 45; /* First iteration will use 40. */
1464 unsigned int lineno;
3aade688 1465 const char **linemap = NULL;
e8f5eee4 1466 unsigned long line_map_size = 0;
3aade688 1467
e8f5eee4
NC
1468 lineno = 0;
1469 lstart = map;
1470 end = map + size;
1471
3aade688
L
1472 for (p = map; p < end; p++)
1473 {
1474 if (*p == '\n')
1475 {
1476 if (p + 1 < end && p[1] == '\r')
1477 p++;
1478 }
1479 else if (*p == '\r')
1480 {
e8f5eee4
NC
1481 if (p + 1 < end && p[1] == '\n')
1482 p++;
1483 }
1484 else
1485 continue;
3aade688 1486
e8f5eee4
NC
1487 /* End of line found. */
1488
3aade688
L
1489 if (linemap == NULL || line_map_size < lineno + 1)
1490 {
e8f5eee4
NC
1491 unsigned long newsize;
1492
1493 chars_per_line -= line_map_decrease;
1494 if (chars_per_line <= 1)
1495 chars_per_line = 1;
1496 line_map_size = size / chars_per_line + 1;
1497 if (line_map_size < lineno + 1)
1498 line_map_size = lineno + 1;
1499 newsize = line_map_size * sizeof (char *);
3f5e193b 1500 linemap = (const char **) xrealloc (linemap, newsize);
e8f5eee4
NC
1501 }
1502
3aade688
L
1503 linemap[lineno++] = lstart;
1504 lstart = p + 1;
e8f5eee4 1505 }
3aade688
L
1506
1507 *maxline = lineno;
e8f5eee4
NC
1508 return linemap;
1509}
1510
43ac9881
AM
1511/* Tries to open MODNAME, and if successful adds a node to print_files
1512 linked list and returns that node. Returns NULL on failure. */
1513
1514static struct print_file_list *
5ef2d51b 1515try_print_file_open (const char *origname, const char *modname, struct stat *fst)
43ac9881
AM
1516{
1517 struct print_file_list *p;
43ac9881 1518
3f5e193b 1519 p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
43ac9881 1520
5ef2d51b 1521 p->map = slurp_file (modname, &p->mapsize, fst);
e8f5eee4 1522 if (p->map == NULL)
43ac9881 1523 {
e8f5eee4
NC
1524 free (p);
1525 return NULL;
43ac9881 1526 }
3aade688 1527
e8f5eee4
NC
1528 p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1529 p->last_line = 0;
43339b1d 1530 p->max_printed = 0;
43ac9881
AM
1531 p->filename = origname;
1532 p->modname = modname;
43ac9881 1533 p->next = print_files;
e8f5eee4 1534 p->first = 1;
43ac9881
AM
1535 print_files = p;
1536 return p;
1537}
1538
a8685210 1539/* If the source file, as described in the symtab, is not found
43ac9881
AM
1540 try to locate it in one of the paths specified with -I
1541 If found, add location to print_files linked list. */
1542
1543static struct print_file_list *
5ef2d51b 1544update_source_path (const char *filename, bfd *abfd)
43ac9881
AM
1545{
1546 struct print_file_list *p;
1547 const char *fname;
5ef2d51b 1548 struct stat fst;
43ac9881
AM
1549 int i;
1550
5ef2d51b
AM
1551 p = try_print_file_open (filename, filename, &fst);
1552 if (p == NULL)
1553 {
1554 if (include_path_count == 0)
1555 return NULL;
43ac9881 1556
5ef2d51b
AM
1557 /* Get the name of the file. */
1558 fname = lbasename (filename);
43ac9881 1559
5ef2d51b
AM
1560 /* If file exists under a new path, we need to add it to the list
1561 so that show_line knows about it. */
1562 for (i = 0; i < include_path_count; i++)
1563 {
1564 char *modname = concat (include_paths[i], "/", fname,
1565 (const char *) 0);
43ac9881 1566
5ef2d51b
AM
1567 p = try_print_file_open (filename, modname, &fst);
1568 if (p)
1569 break;
43ac9881 1570
5ef2d51b
AM
1571 free (modname);
1572 }
1573 }
1574
1575 if (p != NULL)
1576 {
1577 long mtime = bfd_get_mtime (abfd);
43ac9881 1578
5ef2d51b
AM
1579 if (fst.st_mtime > mtime)
1580 warn (_("source file %s is more recent than object file\n"),
1581 filename);
43ac9881
AM
1582 }
1583
5ef2d51b 1584 return p;
43ac9881
AM
1585}
1586
e8f5eee4 1587/* Print a source file line. */
252b5132 1588
3aade688 1589static void
91d6fa6a 1590print_line (struct print_file_list *p, unsigned int linenum)
252b5132 1591{
e8f5eee4 1592 const char *l;
615f3149 1593 size_t len;
3aade688
L
1594
1595 --linenum;
91d6fa6a 1596 if (linenum >= p->maxline)
e8f5eee4 1597 return;
91d6fa6a 1598 l = p->linemap [linenum];
615f3149
AM
1599 /* Test fwrite return value to quiet glibc warning. */
1600 len = strcspn (l, "\n\r");
1601 if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1602 putchar ('\n');
1603}
252b5132 1604
e8f5eee4 1605/* Print a range of source code lines. */
252b5132 1606
e8f5eee4
NC
1607static void
1608dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1609{
1610 if (p->map == NULL)
1611 return;
3aade688 1612 while (start <= end)
e8f5eee4
NC
1613 {
1614 print_line (p, start);
1615 start++;
252b5132 1616 }
0af11b59 1617}
252b5132 1618
50c2245b 1619/* Show the line number, or the source line, in a disassembly
252b5132
RH
1620 listing. */
1621
1622static void
46dca2e0 1623show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
252b5132 1624{
b1f88ebe
AM
1625 const char *filename;
1626 const char *functionname;
91d6fa6a 1627 unsigned int linenumber;
9b8d1a36 1628 unsigned int discriminator;
0dafdf3f 1629 bfd_boolean reloc;
e1fa0163 1630 char *path = NULL;
252b5132
RH
1631
1632 if (! with_line_numbers && ! with_source_code)
1633 return;
1634
9b8d1a36 1635 if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset,
8b5b2529
AM
1636 &filename, &functionname,
1637 &linenumber, &discriminator))
252b5132
RH
1638 return;
1639
1640 if (filename != NULL && *filename == '\0')
1641 filename = NULL;
1642 if (functionname != NULL && *functionname == '\0')
1643 functionname = NULL;
1644
0dafdf3f
L
1645 if (filename
1646 && IS_ABSOLUTE_PATH (filename)
1647 && prefix)
1648 {
1649 char *path_up;
1650 const char *fname = filename;
e1fa0163
NC
1651
1652 path = xmalloc (prefix_length + PATH_MAX + 1);
0dafdf3f
L
1653
1654 if (prefix_length)
1655 memcpy (path, prefix, prefix_length);
1656 path_up = path + prefix_length;
1657
1658 /* Build relocated filename, stripping off leading directories
e1fa0163 1659 from the initial filename if requested. */
0dafdf3f
L
1660 if (prefix_strip > 0)
1661 {
1662 int level = 0;
1663 const char *s;
1664
e1fa0163 1665 /* Skip selected directory levels. */
0dafdf3f
L
1666 for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1667 if (IS_DIR_SEPARATOR(*s))
1668 {
1669 fname = s;
1670 level++;
1671 }
1672 }
1673
e1fa0163 1674 /* Update complete filename. */
0dafdf3f
L
1675 strncpy (path_up, fname, PATH_MAX);
1676 path_up[PATH_MAX] = '\0';
1677
1678 filename = path;
1679 reloc = TRUE;
1680 }
1681 else
1682 reloc = FALSE;
1683
252b5132
RH
1684 if (with_line_numbers)
1685 {
1686 if (functionname != NULL
1687 && (prev_functionname == NULL
1688 || strcmp (functionname, prev_functionname) != 0))
8b5b2529 1689 {
12add40e 1690 printf ("%s():\n", sanitize_string (functionname));
8b5b2529
AM
1691 prev_line = -1;
1692 }
1693 if (linenumber > 0
1694 && (linenumber != prev_line
1695 || discriminator != prev_discriminator))
1696 {
1697 if (discriminator > 0)
1698 printf ("%s:%u (discriminator %u)\n",
12add40e 1699 filename == NULL ? "???" : sanitize_string (filename),
8b5b2529
AM
1700 linenumber, discriminator);
1701 else
12add40e
NC
1702 printf ("%s:%u\n", filename == NULL
1703 ? "???" : sanitize_string (filename),
8b5b2529
AM
1704 linenumber);
1705 }
4a14e306
AK
1706 if (unwind_inlines)
1707 {
1708 const char *filename2;
1709 const char *functionname2;
1710 unsigned line2;
1711
1712 while (bfd_find_inliner_info (abfd, &filename2, &functionname2,
1713 &line2))
12add40e
NC
1714 {
1715 printf ("inlined by %s:%u",
1716 sanitize_string (filename2), line2);
1717 printf (" (%s)\n", sanitize_string (functionname2));
1718 }
4a14e306 1719 }
252b5132
RH
1720 }
1721
1722 if (with_source_code
1723 && filename != NULL
91d6fa6a 1724 && linenumber > 0)
252b5132
RH
1725 {
1726 struct print_file_list **pp, *p;
e8f5eee4 1727 unsigned l;
252b5132
RH
1728
1729 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
8b6efd89 1730 if (filename_cmp ((*pp)->filename, filename) == 0)
252b5132
RH
1731 break;
1732 p = *pp;
1733
e8f5eee4 1734 if (p == NULL)
0dafdf3f
L
1735 {
1736 if (reloc)
1737 filename = xstrdup (filename);
5ef2d51b 1738 p = update_source_path (filename, abfd);
0dafdf3f 1739 }
252b5132 1740
91d6fa6a 1741 if (p != NULL && linenumber != p->last_line)
e8f5eee4 1742 {
3aade688 1743 if (file_start_context && p->first)
e8f5eee4 1744 l = 1;
3aade688 1745 else
252b5132 1746 {
91d6fa6a 1747 l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
3aade688 1748 if (l >= linenumber)
e8f5eee4 1749 l = 1;
43339b1d
AM
1750 if (p->max_printed >= l)
1751 {
1752 if (p->max_printed < linenumber)
1753 l = p->max_printed + 1;
1754 else
1755 l = linenumber;
1756 }
252b5132 1757 }
91d6fa6a 1758 dump_lines (p, l, linenumber);
43339b1d
AM
1759 if (p->max_printed < linenumber)
1760 p->max_printed = linenumber;
91d6fa6a 1761 p->last_line = linenumber;
e8f5eee4 1762 p->first = 0;
252b5132
RH
1763 }
1764 }
1765
1766 if (functionname != NULL
1767 && (prev_functionname == NULL
1768 || strcmp (functionname, prev_functionname) != 0))
1769 {
1770 if (prev_functionname != NULL)
1771 free (prev_functionname);
3f5e193b 1772 prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
252b5132
RH
1773 strcpy (prev_functionname, functionname);
1774 }
1775
91d6fa6a
NC
1776 if (linenumber > 0 && linenumber != prev_line)
1777 prev_line = linenumber;
9b8d1a36
CC
1778
1779 if (discriminator != prev_discriminator)
1780 prev_discriminator = discriminator;
e1fa0163
NC
1781
1782 if (path)
1783 free (path);
252b5132
RH
1784}
1785
1786/* Pseudo FILE object for strings. */
1787typedef struct
1788{
1789 char *buffer;
6f104306
NS
1790 size_t pos;
1791 size_t alloc;
252b5132
RH
1792} SFILE;
1793
46dca2e0 1794/* sprintf to a "stream". */
252b5132 1795
0fd3a477 1796static int ATTRIBUTE_PRINTF_2
46dca2e0 1797objdump_sprintf (SFILE *f, const char *format, ...)
252b5132 1798{
252b5132 1799 size_t n;
46dca2e0 1800 va_list args;
252b5132 1801
6f104306 1802 while (1)
252b5132 1803 {
6f104306 1804 size_t space = f->alloc - f->pos;
3aade688 1805
6f104306
NS
1806 va_start (args, format);
1807 n = vsnprintf (f->buffer + f->pos, space, format, args);
451dad9c 1808 va_end (args);
252b5132 1809
6f104306
NS
1810 if (space > n)
1811 break;
3aade688 1812
6f104306 1813 f->alloc = (f->alloc + n) * 2;
3f5e193b 1814 f->buffer = (char *) xrealloc (f->buffer, f->alloc);
252b5132 1815 }
6f104306 1816 f->pos += n;
3aade688 1817
252b5132
RH
1818 return n;
1819}
1820
1821/* The number of zeroes we want to see before we start skipping them.
1822 The number is arbitrarily chosen. */
1823
0bcb06d2 1824#define DEFAULT_SKIP_ZEROES 8
252b5132
RH
1825
1826/* The number of zeroes to skip at the end of a section. If the
1827 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1828 SKIP_ZEROES, they will be disassembled. If there are fewer than
1829 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1830 attempt to avoid disassembling zeroes inserted by section
1831 alignment. */
1832
0bcb06d2 1833#define DEFAULT_SKIP_ZEROES_AT_END 3
252b5132
RH
1834
1835/* Disassemble some data in memory between given values. */
1836
1837static void
91d6fa6a 1838disassemble_bytes (struct disassemble_info * inf,
46dca2e0
NC
1839 disassembler_ftype disassemble_fn,
1840 bfd_boolean insns,
1841 bfd_byte * data,
1842 bfd_vma start_offset,
1843 bfd_vma stop_offset,
fd7bb956 1844 bfd_vma rel_offset,
46dca2e0
NC
1845 arelent *** relppp,
1846 arelent ** relppend)
252b5132
RH
1847{
1848 struct objdump_disasm_info *aux;
1849 asection *section;
940b2b78 1850 int octets_per_line;
252b5132 1851 int skip_addr_chars;
940b2b78 1852 bfd_vma addr_offset;
91d6fa6a
NC
1853 unsigned int opb = inf->octets_per_byte;
1854 unsigned int skip_zeroes = inf->skip_zeroes;
1855 unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
ce04548a 1856 int octets = opb;
6f104306 1857 SFILE sfile;
252b5132 1858
91d6fa6a 1859 aux = (struct objdump_disasm_info *) inf->application_data;
252b5132
RH
1860 section = aux->sec;
1861
6f104306 1862 sfile.alloc = 120;
3f5e193b 1863 sfile.buffer = (char *) xmalloc (sfile.alloc);
6f104306 1864 sfile.pos = 0;
3aade688 1865
3dcb3fcb
L
1866 if (insn_width)
1867 octets_per_line = insn_width;
1868 else if (insns)
940b2b78 1869 octets_per_line = 4;
252b5132 1870 else
940b2b78 1871 octets_per_line = 16;
252b5132
RH
1872
1873 /* Figure out how many characters to skip at the start of an
1874 address, to make the disassembly look nicer. We discard leading
1875 zeroes in chunks of 4, ensuring that there is always a leading
1876 zero remaining. */
1877 skip_addr_chars = 0;
1878 if (! prefix_addresses)
1879 {
1880 char buf[30];
17ceb936
AM
1881
1882 bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1883
1884 while (buf[skip_addr_chars] == '0')
1885 ++skip_addr_chars;
1886
1887 /* Don't discard zeros on overflow. */
1888 if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1889 skip_addr_chars = 0;
1890
1891 if (skip_addr_chars != 0)
1892 skip_addr_chars = (skip_addr_chars - 1) & -4;
252b5132
RH
1893 }
1894
91d6fa6a 1895 inf->insn_info_valid = 0;
252b5132 1896
940b2b78
TW
1897 addr_offset = start_offset;
1898 while (addr_offset < stop_offset)
252b5132
RH
1899 {
1900 bfd_vma z;
b34976b6 1901 bfd_boolean need_nl = FALSE;
ce04548a
NC
1902 int previous_octets;
1903
1904 /* Remember the length of the previous instruction. */
1905 previous_octets = octets;
ce04548a 1906 octets = 0;
252b5132 1907
bb7c70ed
NC
1908 /* Make sure we don't use relocs from previous instructions. */
1909 aux->reloc = NULL;
1910
940b2b78 1911 /* If we see more than SKIP_ZEROES octets of zeroes, we just
43ac9881 1912 print `...'. */
940b2b78 1913 for (z = addr_offset * opb; z < stop_offset * opb; z++)
252b5132
RH
1914 if (data[z] != 0)
1915 break;
1916 if (! disassemble_zeroes
91d6fa6a
NC
1917 && (inf->insn_info_valid == 0
1918 || inf->branch_delay_insns == 0)
0bcb06d2 1919 && (z - addr_offset * opb >= skip_zeroes
0af11b59 1920 || (z == stop_offset * opb &&
0bcb06d2 1921 z - addr_offset * opb < skip_zeroes_at_end)))
252b5132 1922 {
940b2b78 1923 /* If there are more nonzero octets to follow, we only skip
43ac9881
AM
1924 zeroes in multiples of 4, to try to avoid running over
1925 the start of an instruction which happens to start with
1926 zero. */
940b2b78
TW
1927 if (z != stop_offset * opb)
1928 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
252b5132 1929
940b2b78 1930 octets = z - addr_offset * opb;
98ec6e72
NC
1931
1932 /* If we are going to display more data, and we are displaying
1933 file offsets, then tell the user how many zeroes we skip
1934 and the file offset from where we resume dumping. */
1935 if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1936 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1937 octets / opb,
0af1713e
AM
1938 (unsigned long) (section->filepos
1939 + (addr_offset + (octets / opb))));
98ec6e72
NC
1940 else
1941 printf ("\t...\n");
252b5132
RH
1942 }
1943 else
1944 {
1945 char buf[50];
252b5132
RH
1946 int bpc = 0;
1947 int pb = 0;
1948
252b5132 1949 if (with_line_numbers || with_source_code)
bc79cded 1950 show_line (aux->abfd, section, addr_offset);
252b5132
RH
1951
1952 if (! prefix_addresses)
1953 {
1954 char *s;
1955
d8180c76 1956 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
252b5132
RH
1957 for (s = buf + skip_addr_chars; *s == '0'; s++)
1958 *s = ' ';
1959 if (*s == '\0')
1960 *--s = '0';
1961 printf ("%s:\t", buf + skip_addr_chars);
1962 }
1963 else
1964 {
b34976b6 1965 aux->require_sec = TRUE;
91d6fa6a 1966 objdump_print_address (section->vma + addr_offset, inf);
b34976b6 1967 aux->require_sec = FALSE;
252b5132
RH
1968 putchar (' ');
1969 }
1970
1971 if (insns)
1972 {
6f104306 1973 sfile.pos = 0;
91d6fa6a
NC
1974 inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
1975 inf->stream = &sfile;
1976 inf->bytes_per_line = 0;
1977 inf->bytes_per_chunk = 0;
dd7efa79
PB
1978 inf->flags = ((disassemble_all ? DISASSEMBLE_DATA : 0)
1979 | (wide_output ? WIDE_OUTPUT : 0));
0313a2b8 1980 if (machine)
91d6fa6a 1981 inf->flags |= USER_SPECIFIED_MACHINE_TYPE;
252b5132 1982
91d6fa6a 1983 if (inf->disassembler_needs_relocs
7df428b1
RS
1984 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1985 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
d99b6465 1986 && *relppp < relppend)
ce04548a
NC
1987 {
1988 bfd_signed_vma distance_to_rel;
1989
1990 distance_to_rel = (**relppp)->address
1991 - (rel_offset + addr_offset);
1992
1993 /* Check to see if the current reloc is associated with
1994 the instruction that we are about to disassemble. */
1995 if (distance_to_rel == 0
1996 /* FIXME: This is wrong. We are trying to catch
1997 relocs that are addressed part way through the
1998 current instruction, as might happen with a packed
1999 VLIW instruction. Unfortunately we do not know the
2000 length of the current instruction since we have not
2001 disassembled it yet. Instead we take a guess based
2002 upon the length of the previous instruction. The
2003 proper solution is to have a new target-specific
2004 disassembler function which just returns the length
2005 of an instruction at a given address without trying
2006 to display its disassembly. */
2007 || (distance_to_rel > 0
2008 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
2009 {
91d6fa6a 2010 inf->flags |= INSN_HAS_RELOC;
ce04548a
NC
2011 aux->reloc = **relppp;
2012 }
ce04548a 2013 }
d99b6465 2014
bdc4de1b
NC
2015 if (! disassemble_all
2016 && (section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
2017 == (SEC_CODE | SEC_HAS_CONTENTS))
2018 /* Set a stop_vma so that the disassembler will not read
2019 beyond the next symbol. We assume that symbols appear on
2020 the boundaries between instructions. We only do this when
2021 disassembling code of course, and when -D is in effect. */
2022 inf->stop_vma = section->vma + stop_offset;
3aade688 2023
53b2f36b 2024 inf->stop_offset = stop_offset;
91d6fa6a 2025 octets = (*disassemble_fn) (section->vma + addr_offset, inf);
bdc4de1b
NC
2026
2027 inf->stop_vma = 0;
91d6fa6a
NC
2028 inf->fprintf_func = (fprintf_ftype) fprintf;
2029 inf->stream = stdout;
2030 if (insn_width == 0 && inf->bytes_per_line != 0)
2031 octets_per_line = inf->bytes_per_line;
a8c62f1c 2032 if (octets < (int) opb)
e07bf1ac 2033 {
6f104306 2034 if (sfile.pos)
e07bf1ac 2035 printf ("%s\n", sfile.buffer);
a8c62f1c
AM
2036 if (octets >= 0)
2037 {
2038 non_fatal (_("disassemble_fn returned length %d"),
2039 octets);
2040 exit_status = 1;
2041 }
e07bf1ac
ILT
2042 break;
2043 }
252b5132
RH
2044 }
2045 else
2046 {
b4c96d0d 2047 bfd_vma j;
252b5132 2048
940b2b78
TW
2049 octets = octets_per_line;
2050 if (addr_offset + octets / opb > stop_offset)
2051 octets = (stop_offset - addr_offset) * opb;
252b5132 2052
940b2b78 2053 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
252b5132 2054 {
3882b010 2055 if (ISPRINT (data[j]))
940b2b78 2056 buf[j - addr_offset * opb] = data[j];
252b5132 2057 else
940b2b78 2058 buf[j - addr_offset * opb] = '.';
252b5132 2059 }
940b2b78 2060 buf[j - addr_offset * opb] = '\0';
252b5132
RH
2061 }
2062
2063 if (prefix_addresses
2064 ? show_raw_insn > 0
2065 : show_raw_insn >= 0)
2066 {
b4c96d0d 2067 bfd_vma j;
252b5132
RH
2068
2069 /* If ! prefix_addresses and ! wide_output, we print
43ac9881 2070 octets_per_line octets per line. */
940b2b78
TW
2071 pb = octets;
2072 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
2073 pb = octets_per_line;
252b5132 2074
91d6fa6a
NC
2075 if (inf->bytes_per_chunk)
2076 bpc = inf->bytes_per_chunk;
252b5132
RH
2077 else
2078 bpc = 1;
2079
940b2b78 2080 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
252b5132 2081 {
ae87f7e7
NC
2082 /* PR 21580: Check for a buffer ending early. */
2083 if (j + bpc <= stop_offset * opb)
252b5132 2084 {
ae87f7e7
NC
2085 int k;
2086
2087 if (inf->display_endian == BFD_ENDIAN_LITTLE)
2088 {
2089 for (k = bpc - 1; k >= 0; k--)
2090 printf ("%02x", (unsigned) data[j + k]);
2091 }
2092 else
2093 {
2094 for (k = 0; k < bpc; k++)
2095 printf ("%02x", (unsigned) data[j + k]);
2096 }
252b5132 2097 }
ae87f7e7 2098 putchar (' ');
252b5132
RH
2099 }
2100
940b2b78 2101 for (; pb < octets_per_line; pb += bpc)
252b5132
RH
2102 {
2103 int k;
2104
2105 for (k = 0; k < bpc; k++)
2106 printf (" ");
2107 putchar (' ');
2108 }
2109
2110 /* Separate raw data from instruction by extra space. */
2111 if (insns)
2112 putchar ('\t');
2113 else
2114 printf (" ");
2115 }
2116
2117 if (! insns)
2118 printf ("%s", buf);
6f104306
NS
2119 else if (sfile.pos)
2120 printf ("%s", sfile.buffer);
252b5132
RH
2121
2122 if (prefix_addresses
2123 ? show_raw_insn > 0
2124 : show_raw_insn >= 0)
2125 {
940b2b78 2126 while (pb < octets)
252b5132 2127 {
b4c96d0d 2128 bfd_vma j;
252b5132
RH
2129 char *s;
2130
2131 putchar ('\n');
940b2b78 2132 j = addr_offset * opb + pb;
252b5132 2133
d8180c76 2134 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
252b5132
RH
2135 for (s = buf + skip_addr_chars; *s == '0'; s++)
2136 *s = ' ';
2137 if (*s == '\0')
2138 *--s = '0';
2139 printf ("%s:\t", buf + skip_addr_chars);
2140
940b2b78
TW
2141 pb += octets_per_line;
2142 if (pb > octets)
2143 pb = octets;
2144 for (; j < addr_offset * opb + pb; j += bpc)
252b5132 2145 {
d16fdddb
NC
2146 /* PR 21619: Check for a buffer ending early. */
2147 if (j + bpc <= stop_offset * opb)
252b5132 2148 {
d16fdddb
NC
2149 int k;
2150
2151 if (inf->display_endian == BFD_ENDIAN_LITTLE)
2152 {
2153 for (k = bpc - 1; k >= 0; k--)
2154 printf ("%02x", (unsigned) data[j + k]);
2155 }
2156 else
2157 {
2158 for (k = 0; k < bpc; k++)
2159 printf ("%02x", (unsigned) data[j + k]);
2160 }
252b5132 2161 }
d16fdddb 2162 putchar (' ');
252b5132
RH
2163 }
2164 }
2165 }
2166
2167 if (!wide_output)
2168 putchar ('\n');
2169 else
b34976b6 2170 need_nl = TRUE;
252b5132
RH
2171 }
2172
fd7bb956
AM
2173 while ((*relppp) < relppend
2174 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
252b5132 2175 {
fd7bb956 2176 if (dump_reloc_info || dump_dynamic_reloc_info)
252b5132
RH
2177 {
2178 arelent *q;
2179
2180 q = **relppp;
2181
2182 if (wide_output)
2183 putchar ('\t');
2184 else
2185 printf ("\t\t\t");
2186
68b3b8dc 2187 objdump_print_value (section->vma - rel_offset + q->address,
91d6fa6a 2188 inf, TRUE);
252b5132 2189
f9ecb0a4
JJ
2190 if (q->howto == NULL)
2191 printf (": *unknown*\t");
2192 else if (q->howto->name)
2193 printf (": %s\t", q->howto->name);
2194 else
2195 printf (": %d\t", q->howto->type);
252b5132
RH
2196
2197 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
2198 printf ("*unknown*");
2199 else
2200 {
2201 const char *sym_name;
2202
2203 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
2204 if (sym_name != NULL && *sym_name != '\0')
91d6fa6a 2205 objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
252b5132
RH
2206 else
2207 {
2208 asection *sym_sec;
2209
2210 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
2211 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
2212 if (sym_name == NULL || *sym_name == '\0')
2213 sym_name = "*unknown*";
12add40e 2214 printf ("%s", sanitize_string (sym_name));
252b5132
RH
2215 }
2216 }
2217
2218 if (q->addend)
2219 {
343dbc36
L
2220 bfd_signed_vma addend = q->addend;
2221 if (addend < 0)
2222 {
2223 printf ("-0x");
2224 addend = -addend;
2225 }
2226 else
2227 printf ("+0x");
2228 objdump_print_value (addend, inf, TRUE);
252b5132
RH
2229 }
2230
2231 printf ("\n");
b34976b6 2232 need_nl = FALSE;
252b5132 2233 }
fd7bb956 2234 ++(*relppp);
252b5132
RH
2235 }
2236
2237 if (need_nl)
2238 printf ("\n");
2239
940b2b78 2240 addr_offset += octets / opb;
252b5132 2241 }
6f104306
NS
2242
2243 free (sfile.buffer);
252b5132
RH
2244}
2245
155e0d23 2246static void
91d6fa6a 2247disassemble_section (bfd *abfd, asection *section, void *inf)
155e0d23 2248{
1b0adfe0
NC
2249 const struct elf_backend_data * bed;
2250 bfd_vma sign_adjust = 0;
91d6fa6a 2251 struct disassemble_info * pinfo = (struct disassemble_info *) inf;
3b9ad1cc 2252 struct objdump_disasm_info * paux;
155e0d23
NC
2253 unsigned int opb = pinfo->octets_per_byte;
2254 bfd_byte * data = NULL;
2255 bfd_size_type datasize = 0;
2256 arelent ** rel_pp = NULL;
2257 arelent ** rel_ppstart = NULL;
2258 arelent ** rel_ppend;
bdc4de1b 2259 bfd_vma stop_offset;
155e0d23
NC
2260 asymbol * sym = NULL;
2261 long place = 0;
2262 long rel_count;
2263 bfd_vma rel_offset;
2264 unsigned long addr_offset;
baae986a
NC
2265 bfd_boolean do_print;
2266 enum loop_control
2267 {
2268 stop_offset_reached,
2269 function_sym,
2270 next_sym
2271 } loop_until;
155e0d23
NC
2272
2273 /* Sections that do not contain machine
2274 code are not normally disassembled. */
2275 if (! disassemble_all
70ecb384 2276 && only_list == NULL
46212538
AM
2277 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
2278 != (SEC_CODE | SEC_HAS_CONTENTS)))
155e0d23
NC
2279 return;
2280
2281 if (! process_section_p (section))
2282 return;
2283
135dfb4a 2284 datasize = bfd_get_section_size (section);
60a02042 2285 if (datasize == 0)
155e0d23
NC
2286 return;
2287
643902a4
AS
2288 if (start_address == (bfd_vma) -1
2289 || start_address < section->vma)
2290 addr_offset = 0;
2291 else
2292 addr_offset = start_address - section->vma;
2293
2294 if (stop_address == (bfd_vma) -1)
2295 stop_offset = datasize / opb;
2296 else
2297 {
2298 if (stop_address < section->vma)
2299 stop_offset = 0;
2300 else
2301 stop_offset = stop_address - section->vma;
2302 if (stop_offset > datasize / opb)
2303 stop_offset = datasize / opb;
2304 }
2305
2306 if (addr_offset >= stop_offset)
2307 return;
2308
155e0d23 2309 /* Decide which set of relocs to use. Load them if necessary. */
3b9ad1cc 2310 paux = (struct objdump_disasm_info *) pinfo->application_data;
a24bb4f0 2311 if (paux->dynrelbuf && dump_dynamic_reloc_info)
155e0d23
NC
2312 {
2313 rel_pp = paux->dynrelbuf;
2314 rel_count = paux->dynrelcount;
2315 /* Dynamic reloc addresses are absolute, non-dynamic are section
50c2245b 2316 relative. REL_OFFSET specifies the reloc address corresponding
155e0d23 2317 to the start of this section. */
68b3b8dc 2318 rel_offset = section->vma;
155e0d23
NC
2319 }
2320 else
2321 {
2322 rel_count = 0;
2323 rel_pp = NULL;
2324 rel_offset = 0;
2325
2326 if ((section->flags & SEC_RELOC) != 0
d99b6465 2327 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
155e0d23
NC
2328 {
2329 long relsize;
2330
2331 relsize = bfd_get_reloc_upper_bound (abfd, section);
2332 if (relsize < 0)
2333 bfd_fatal (bfd_get_filename (abfd));
2334
2335 if (relsize > 0)
2336 {
3f5e193b 2337 rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
155e0d23
NC
2338 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
2339 if (rel_count < 0)
2340 bfd_fatal (bfd_get_filename (abfd));
2341
2342 /* Sort the relocs by address. */
2343 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
2344 }
2345 }
155e0d23
NC
2346 }
2347 rel_ppend = rel_pp + rel_count;
2348
bae7501e 2349 if (!bfd_malloc_and_get_section (abfd, section, &data))
b02cd3e9
AM
2350 {
2351 non_fatal (_("Reading section %s failed because: %s"),
2352 section->name, bfd_errmsg (bfd_get_error ()));
2353 return;
2354 }
155e0d23
NC
2355
2356 paux->sec = section;
2357 pinfo->buffer = data;
2358 pinfo->buffer_vma = section->vma;
2359 pinfo->buffer_length = datasize;
2360 pinfo->section = section;
2361
155e0d23
NC
2362 /* Skip over the relocs belonging to addresses below the
2363 start address. */
2364 while (rel_pp < rel_ppend
2365 && (*rel_pp)->address < rel_offset + addr_offset)
2366 ++rel_pp;
2367
12add40e 2368 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section->name));
155e0d23
NC
2369
2370 /* Find the nearest symbol forwards from our current position. */
3b9ad1cc 2371 paux->require_sec = TRUE;
3f5e193b 2372 sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
91d6fa6a 2373 (struct disassemble_info *) inf,
3f5e193b 2374 &place);
3b9ad1cc 2375 paux->require_sec = FALSE;
155e0d23 2376
46bc35a9
RS
2377 /* PR 9774: If the target used signed addresses then we must make
2378 sure that we sign extend the value that we calculate for 'addr'
2379 in the loop below. */
1b0adfe0
NC
2380 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2381 && (bed = get_elf_backend_data (abfd)) != NULL
2382 && bed->sign_extend_vma)
46bc35a9 2383 sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
1b0adfe0 2384
155e0d23
NC
2385 /* Disassemble a block of instructions up to the address associated with
2386 the symbol we have just found. Then print the symbol and find the
2387 next symbol on. Repeat until we have disassembled the entire section
2388 or we have reached the end of the address range we are interested in. */
baae986a
NC
2389 do_print = paux->symbol == NULL;
2390 loop_until = stop_offset_reached;
2391
155e0d23
NC
2392 while (addr_offset < stop_offset)
2393 {
22a398e1 2394 bfd_vma addr;
155e0d23 2395 asymbol *nextsym;
bdc4de1b 2396 bfd_vma nextstop_offset;
155e0d23
NC
2397 bfd_boolean insns;
2398
22a398e1 2399 addr = section->vma + addr_offset;
095ad3b8 2400 addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
22a398e1
NC
2401
2402 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
155e0d23
NC
2403 {
2404 int x;
2405
2406 for (x = place;
2407 (x < sorted_symcount
22a398e1 2408 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
155e0d23
NC
2409 ++x)
2410 continue;
2411
22a398e1 2412 pinfo->symbols = sorted_syms + place;
155e0d23 2413 pinfo->num_symbols = x - place;
2087ad84 2414 pinfo->symtab_pos = place;
155e0d23
NC
2415 }
2416 else
22a398e1
NC
2417 {
2418 pinfo->symbols = NULL;
2419 pinfo->num_symbols = 0;
2087ad84 2420 pinfo->symtab_pos = -1;
22a398e1 2421 }
155e0d23 2422
baae986a
NC
2423 /* If we are only disassembling from a specific symbol,
2424 check to see if we should start or stop displaying. */
d3def5d7
MY
2425 if (sym && paux->symbol)
2426 {
baae986a
NC
2427 if (do_print)
2428 {
2429 /* See if we should stop printing. */
2430 switch (loop_until)
2431 {
2432 case function_sym:
2433 if (sym->flags & BSF_FUNCTION)
2434 do_print = FALSE;
2435 break;
2436
2437 case stop_offset_reached:
2438 /* Handled by the while loop. */
2439 break;
d3def5d7 2440
baae986a
NC
2441 case next_sym:
2442 /* FIXME: There is an implicit assumption here
2443 that the name of sym is different from
2444 paux->symbol. */
2445 if (! bfd_is_local_label (abfd, sym))
2446 do_print = FALSE;
2447 break;
2448 }
2449 }
2450 else
d3def5d7 2451 {
baae986a
NC
2452 const char * name = bfd_asymbol_name (sym);
2453 char * alloc = NULL;
2454
2455 if (do_demangle && name[0] != '\0')
2456 {
2457 /* Demangle the name. */
2458 alloc = bfd_demangle (abfd, name, demangle_flags);
2459 if (alloc != NULL)
2460 name = alloc;
2461 }
2462
2463 /* We are not currently printing. Check to see
2464 if the current symbol matches the requested symbol. */
2465 if (streq (name, paux->symbol))
2466 {
2467 do_print = TRUE;
2468
2469 if (sym->flags & BSF_FUNCTION)
2470 {
2471 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2472 && ((elf_symbol_type *) sym)->internal_elf_sym.st_size > 0)
2473 {
2474 /* Sym is a function symbol with a size associated
2475 with it. Turn on automatic disassembly for the
2476 next VALUE bytes. */
2477 stop_offset = addr_offset
2478 + ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
2479 loop_until = stop_offset_reached;
2480 }
2481 else
2482 {
2483 /* Otherwise we need to tell the loop heuristic to
2484 loop until the next function symbol is encountered. */
2485 loop_until = function_sym;
2486 }
2487 }
2488 else
2489 {
2490 /* Otherwise loop until the next symbol is encountered. */
2491 loop_until = next_sym;
2492 }
2493 }
2494
2495 free (alloc);
d3def5d7 2496 }
d3def5d7
MY
2497 }
2498
2499 if (! prefix_addresses && do_print)
155e0d23
NC
2500 {
2501 pinfo->fprintf_func (pinfo->stream, "\n");
22a398e1 2502 objdump_print_addr_with_sym (abfd, section, sym, addr,
155e0d23
NC
2503 pinfo, FALSE);
2504 pinfo->fprintf_func (pinfo->stream, ":\n");
2505 }
2506
22a398e1 2507 if (sym != NULL && bfd_asymbol_value (sym) > addr)
155e0d23
NC
2508 nextsym = sym;
2509 else if (sym == NULL)
2510 nextsym = NULL;
2511 else
2512 {
22a398e1 2513#define is_valid_next_sym(SYM) \
39f0547e 2514 (strcmp (bfd_section_name (abfd, (SYM)->section), bfd_section_name (abfd, section)) == 0 \
22a398e1
NC
2515 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2516 && pinfo->symbol_is_valid (SYM, pinfo))
3aade688 2517
155e0d23
NC
2518 /* Search forward for the next appropriate symbol in
2519 SECTION. Note that all the symbols are sorted
2520 together into one big array, and that some sections
2521 may have overlapping addresses. */
2522 while (place < sorted_symcount
22a398e1 2523 && ! is_valid_next_sym (sorted_syms [place]))
155e0d23 2524 ++place;
22a398e1 2525
155e0d23
NC
2526 if (place >= sorted_symcount)
2527 nextsym = NULL;
2528 else
2529 nextsym = sorted_syms[place];
2530 }
2531
22a398e1
NC
2532 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2533 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
155e0d23
NC
2534 else if (nextsym == NULL)
2535 nextstop_offset = stop_offset;
2536 else
22a398e1
NC
2537 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
2538
84d7b001
NC
2539 if (nextstop_offset > stop_offset
2540 || nextstop_offset <= addr_offset)
22a398e1 2541 nextstop_offset = stop_offset;
155e0d23
NC
2542
2543 /* If a symbol is explicitly marked as being an object
2544 rather than a function, just dump the bytes without
2545 disassembling them. */
2546 if (disassemble_all
2547 || sym == NULL
abf71725 2548 || sym->section != section
22a398e1 2549 || bfd_asymbol_value (sym) > addr
155e0d23
NC
2550 || ((sym->flags & BSF_OBJECT) == 0
2551 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
2552 == NULL)
2553 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
2554 == NULL))
2555 || (sym->flags & BSF_FUNCTION) != 0)
2556 insns = TRUE;
2557 else
2558 insns = FALSE;
2559
d3def5d7 2560 if (do_print)
baae986a
NC
2561 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2562 addr_offset, nextstop_offset,
2563 rel_offset, &rel_pp, rel_ppend);
3aade688 2564
155e0d23
NC
2565 addr_offset = nextstop_offset;
2566 sym = nextsym;
2567 }
2568
2569 free (data);
2570
2571 if (rel_ppstart != NULL)
2572 free (rel_ppstart);
2573}
2574
252b5132
RH
2575/* Disassemble the contents of an object file. */
2576
2577static void
46dca2e0 2578disassemble_data (bfd *abfd)
252b5132 2579{
252b5132
RH
2580 struct disassemble_info disasm_info;
2581 struct objdump_disasm_info aux;
4c45e5c9 2582 long i;
252b5132
RH
2583
2584 print_files = NULL;
2585 prev_functionname = NULL;
2586 prev_line = -1;
9b8d1a36 2587 prev_discriminator = 0;
252b5132
RH
2588
2589 /* We make a copy of syms to sort. We don't want to sort syms
2590 because that will screw up the relocs. */
4c45e5c9 2591 sorted_symcount = symcount ? symcount : dynsymcount;
3f5e193b
NC
2592 sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2593 * sizeof (asymbol *));
4c45e5c9
JJ
2594 memcpy (sorted_syms, symcount ? syms : dynsyms,
2595 sorted_symcount * sizeof (asymbol *));
252b5132 2596
4c45e5c9
JJ
2597 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2598
2599 for (i = 0; i < synthcount; ++i)
2600 {
2601 sorted_syms[sorted_symcount] = synthsyms + i;
2602 ++sorted_symcount;
2603 }
252b5132 2604
98a91d6a 2605 /* Sort the symbols into section and symbol order. */
252b5132
RH
2606 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2607
22a398e1 2608 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
98a91d6a 2609
46dca2e0 2610 disasm_info.application_data = (void *) &aux;
252b5132 2611 aux.abfd = abfd;
b34976b6 2612 aux.require_sec = FALSE;
155e0d23
NC
2613 aux.dynrelbuf = NULL;
2614 aux.dynrelcount = 0;
ce04548a 2615 aux.reloc = NULL;
d3def5d7 2616 aux.symbol = disasm_sym;
155e0d23 2617
252b5132
RH
2618 disasm_info.print_address_func = objdump_print_address;
2619 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2620
d3ba0551 2621 if (machine != NULL)
252b5132 2622 {
91d6fa6a 2623 const bfd_arch_info_type *inf = bfd_scan_arch (machine);
98a91d6a 2624
91d6fa6a 2625 if (inf == NULL)
a8c62f1c 2626 fatal (_("can't use supplied machine %s"), machine);
98a91d6a 2627
91d6fa6a 2628 abfd->arch_info = inf;
252b5132
RH
2629 }
2630
2631 if (endian != BFD_ENDIAN_UNKNOWN)
2632 {
2633 struct bfd_target *xvec;
2634
3f5e193b 2635 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
252b5132
RH
2636 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2637 xvec->byteorder = endian;
2638 abfd->xvec = xvec;
2639 }
2640
155e0d23 2641 /* Use libopcodes to locate a suitable disassembler. */
003ca0fd
YQ
2642 aux.disassemble_fn = disassembler (bfd_get_arch (abfd),
2643 bfd_big_endian (abfd),
2644 bfd_get_mach (abfd), abfd);
155e0d23 2645 if (!aux.disassemble_fn)
252b5132 2646 {
a8c62f1c 2647 non_fatal (_("can't disassemble for architecture %s\n"),
37cc8ec1 2648 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
75cd796a 2649 exit_status = 1;
252b5132
RH
2650 return;
2651 }
2652
2653 disasm_info.flavour = bfd_get_flavour (abfd);
2654 disasm_info.arch = bfd_get_arch (abfd);
2655 disasm_info.mach = bfd_get_mach (abfd);
dd92f639 2656 disasm_info.disassembler_options = disassembler_options;
155e0d23 2657 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
0bcb06d2
AS
2658 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2659 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
d99b6465 2660 disasm_info.disassembler_needs_relocs = FALSE;
0af11b59 2661
252b5132 2662 if (bfd_big_endian (abfd))
a8a9050d 2663 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
252b5132 2664 else if (bfd_little_endian (abfd))
a8a9050d 2665 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
252b5132
RH
2666 else
2667 /* ??? Aborting here seems too drastic. We could default to big or little
2668 instead. */
2669 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2670
22a398e1
NC
2671 /* Allow the target to customize the info structure. */
2672 disassemble_init_for_target (& disasm_info);
2673
a24bb4f0 2674 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
fd7bb956
AM
2675 {
2676 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3aade688 2677
a24bb4f0 2678 if (relsize < 0 && dump_dynamic_reloc_info)
fd7bb956
AM
2679 bfd_fatal (bfd_get_filename (abfd));
2680
2681 if (relsize > 0)
2682 {
3f5e193b 2683 aux.dynrelbuf = (arelent **) xmalloc (relsize);
3b9ad1cc
AM
2684 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2685 aux.dynrelbuf,
2686 dynsyms);
155e0d23 2687 if (aux.dynrelcount < 0)
fd7bb956
AM
2688 bfd_fatal (bfd_get_filename (abfd));
2689
2690 /* Sort the relocs by address. */
3b9ad1cc
AM
2691 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2692 compare_relocs);
fd7bb956
AM
2693 }
2694 }
2087ad84
PB
2695 disasm_info.symtab = sorted_syms;
2696 disasm_info.symtab_size = sorted_symcount;
fd7bb956 2697
155e0d23 2698 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
98a91d6a 2699
155e0d23
NC
2700 if (aux.dynrelbuf != NULL)
2701 free (aux.dynrelbuf);
252b5132
RH
2702 free (sorted_syms);
2703}
2704\f
dda8d76d 2705static bfd_boolean
7bcbeb0f
CC
2706load_specific_debug_section (enum dwarf_section_display_enum debug,
2707 asection *sec, void *file)
365544c3
L
2708{
2709 struct dwarf_section *section = &debug_displays [debug].section;
3f5e193b 2710 bfd *abfd = (bfd *) file;
bfec0f11 2711 bfd_byte *contents;
f2023ce7 2712 bfd_size_type amt;
63455780 2713 size_t alloced;
365544c3 2714
365544c3 2715 if (section->start != NULL)
dda8d76d
NC
2716 {
2717 /* If it is already loaded, do nothing. */
2718 if (streq (section->filename, bfd_get_filename (abfd)))
2719 return TRUE;
2720 free (section->start);
2721 }
365544c3 2722
dda8d76d 2723 section->filename = bfd_get_filename (abfd);
d1c4b12b 2724 section->reloc_info = NULL;
3aade688 2725 section->num_relocs = 0;
595330b7 2726 section->address = bfd_get_section_vma (abfd, sec);
11fa9f13 2727 section->user_data = sec;
365544c3 2728 section->size = bfd_get_section_size (sec);
63455780
NC
2729 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2730 alloced = amt = section->size + 1;
2731 if (alloced != amt || alloced == 0)
11fa9f13
NC
2732 {
2733 section->start = NULL;
2734 free_debug_section (debug);
2735 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
12add40e
NC
2736 sanitize_string (section->name),
2737 (unsigned long long) section->size);
11fa9f13
NC
2738 return FALSE;
2739 }
63455780 2740 section->start = contents = malloc (alloced);
11fa9f13 2741 if (section->start == NULL
bfec0f11 2742 || !bfd_get_full_section_contents (abfd, sec, &contents))
365544c3
L
2743 {
2744 free_debug_section (debug);
2745 printf (_("\nCan't get contents for section '%s'.\n"),
12add40e 2746 sanitize_string (section->name));
dda8d76d 2747 return FALSE;
1b315056 2748 }
4f1881b9
AM
2749 /* Ensure any string section has a terminating NUL. */
2750 section->start[section->size] = 0;
1b315056 2751
0acf065b
CC
2752 if (is_relocatable && debug_displays [debug].relocate)
2753 {
dda8d76d
NC
2754 long reloc_size;
2755 bfd_boolean ret;
2756
8a72cc6e 2757 bfd_cache_section_contents (sec, section->start);
0acf065b
CC
2758
2759 ret = bfd_simple_get_relocated_section_contents (abfd,
2760 sec,
2761 section->start,
2762 syms) != NULL;
2763
2764 if (! ret)
2765 {
2766 free_debug_section (debug);
2767 printf (_("\nCan't get contents for section '%s'.\n"),
12add40e 2768 sanitize_string (section->name));
dda8d76d 2769 return FALSE;
0acf065b 2770 }
d1c4b12b 2771
d1c4b12b
NC
2772 reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
2773 if (reloc_size > 0)
2774 {
2775 unsigned long reloc_count;
2776 arelent **relocs;
2777
2778 relocs = (arelent **) xmalloc (reloc_size);
2779
2780 reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, NULL);
2781 if (reloc_count == 0)
2782 free (relocs);
2783 else
2784 {
2785 section->reloc_info = relocs;
2786 section->num_relocs = reloc_count;
2787 }
2788 }
bdc4de1b 2789 }
0acf065b 2790
dda8d76d 2791 return TRUE;
7bcbeb0f
CC
2792}
2793
d1c4b12b
NC
2794bfd_boolean
2795reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
2796{
2797 arelent ** relocs;
2798 arelent * rp;
2799
2800 if (dsec == NULL || dsec->reloc_info == NULL)
2801 return FALSE;
2802
2803 relocs = (arelent **) dsec->reloc_info;
2804
2805 for (; (rp = * relocs) != NULL; ++ relocs)
2806 if (rp->address == offset)
2807 return TRUE;
2808
2809 return FALSE;
2810}
2811
dda8d76d 2812bfd_boolean
7bcbeb0f
CC
2813load_debug_section (enum dwarf_section_display_enum debug, void *file)
2814{
2815 struct dwarf_section *section = &debug_displays [debug].section;
3f5e193b 2816 bfd *abfd = (bfd *) file;
7bcbeb0f
CC
2817 asection *sec;
2818
2819 /* If it is already loaded, do nothing. */
2820 if (section->start != NULL)
dda8d76d
NC
2821 {
2822 if (streq (section->filename, bfd_get_filename (abfd)))
2823 return TRUE;
2824 }
7bcbeb0f
CC
2825
2826 /* Locate the debug section. */
2827 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2828 if (sec != NULL)
2829 section->name = section->uncompressed_name;
2830 else
2831 {
2832 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2833 if (sec != NULL)
2834 section->name = section->compressed_name;
2835 }
2836 if (sec == NULL)
dda8d76d 2837 return FALSE;
7bcbeb0f
CC
2838
2839 return load_specific_debug_section (debug, sec, file);
365544c3
L
2840}
2841
2842void
2843free_debug_section (enum dwarf_section_display_enum debug)
2844{
2845 struct dwarf_section *section = &debug_displays [debug].section;
2846
2847 if (section->start == NULL)
2848 return;
2849
06614111
NC
2850 /* PR 17512: file: 0f67f69d. */
2851 if (section->user_data != NULL)
2852 {
2853 asection * sec = (asection *) section->user_data;
2854
2855 /* If we are freeing contents that are also pointed to by the BFD
2856 library's section structure then make sure to update those pointers
2857 too. Otherwise, the next time we try to load data for this section
2858 we can end up using a stale pointer. */
2859 if (section->start == sec->contents)
2860 {
2861 sec->contents = NULL;
2862 sec->flags &= ~ SEC_IN_MEMORY;
db6b071a 2863 sec->compress_status = COMPRESS_SECTION_NONE;
06614111
NC
2864 }
2865 }
2866
365544c3
L
2867 free ((char *) section->start);
2868 section->start = NULL;
2869 section->address = 0;
2870 section->size = 0;
2871}
2872
dda8d76d
NC
2873void
2874close_debug_file (void * file)
2875{
2876 bfd * abfd = (bfd *) file;
2877
2878 bfd_close (abfd);
2879}
2880
2881void *
2882open_debug_file (const char * pathname)
2883{
2884 bfd * data;
2885
2886 data = bfd_openr (pathname, NULL);
2887 if (data == NULL)
2888 return NULL;
2889
2890 if (! bfd_check_format (data, bfd_object))
2891 return NULL;
2892
2893 return data;
2894}
2895
365544c3
L
2896static void
2897dump_dwarf_section (bfd *abfd, asection *section,
2898 void *arg ATTRIBUTE_UNUSED)
2899{
2900 const char *name = bfd_get_section_name (abfd, section);
2901 const char *match;
3f5e193b 2902 int i;
365544c3 2903
0112cd26 2904 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
365544c3
L
2905 match = ".debug_info";
2906 else
2907 match = name;
2908
2909 for (i = 0; i < max; i++)
4cb93e3b
TG
2910 if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2911 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2912 && debug_displays [i].enabled != NULL
2913 && *debug_displays [i].enabled)
365544c3 2914 {
c8450da8 2915 struct dwarf_section *sec = &debug_displays [i].section;
365544c3 2916
c8450da8
TG
2917 if (strcmp (sec->uncompressed_name, match) == 0)
2918 sec->name = sec->uncompressed_name;
2919 else
2920 sec->name = sec->compressed_name;
3f5e193b
NC
2921 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2922 section, abfd))
c8450da8
TG
2923 {
2924 debug_displays [i].display (sec, abfd);
3aade688 2925
c8450da8 2926 if (i != info && i != abbrev)
3f5e193b 2927 free_debug_section ((enum dwarf_section_display_enum) i);
365544c3
L
2928 }
2929 break;
2930 }
2931}
2932
2933/* Dump the dwarf debugging information. */
2934
2935static void
2936dump_dwarf (bfd *abfd)
2937{
39f0547e
NC
2938 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2939 if (byte_get == NULL)
f41e4712
NC
2940 {
2941 warn (_("File %s does not contain any dwarf debug information\n"),
2942 bfd_get_filename (abfd));
2943 return;
2944 }
365544c3 2945
39f0547e
NC
2946 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2947
2948 eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
2949
b129eb0e 2950 switch (bfd_get_arch (abfd))
2dc4cec1 2951 {
b129eb0e
RH
2952 case bfd_arch_i386:
2953 switch (bfd_get_mach (abfd))
2954 {
2955 case bfd_mach_x86_64:
2956 case bfd_mach_x86_64_intel_syntax:
64b384e1 2957 case bfd_mach_x86_64_nacl:
f24e5a8a
L
2958 case bfd_mach_x64_32:
2959 case bfd_mach_x64_32_intel_syntax:
64b384e1 2960 case bfd_mach_x64_32_nacl:
b129eb0e
RH
2961 init_dwarf_regnames_x86_64 ();
2962 break;
2963
2964 default:
2965 init_dwarf_regnames_i386 ();
2966 break;
2967 }
2968 break;
2969
3d875af5
L
2970 case bfd_arch_iamcu:
2971 init_dwarf_regnames_iamcu ();
2972 break;
2973
4ee22035
RH
2974 case bfd_arch_aarch64:
2975 init_dwarf_regnames_aarch64();
2976 break;
2977
d6bb17b0
AA
2978 case bfd_arch_s390:
2979 init_dwarf_regnames_s390 ();
2980 break;
2981
5bb0830d
AB
2982 case bfd_arch_riscv:
2983 init_dwarf_regnames_riscv ();
2984 break;
2985
8ab159a9
AM
2986 case bfd_arch_s12z:
2987 /* S12Z has a 24 bit address space. But the only known
2988 producer of dwarf_info encodes addresses into 32 bits. */
2989 eh_addr_size = 4;
2990 break;
2991
b129eb0e
RH
2992 default:
2993 break;
2dc4cec1
L
2994 }
2995
365544c3 2996 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
365544c3
L
2997}
2998\f
29ca8dc5
NS
2999/* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3000 it. Return NULL on failure. */
252b5132 3001
bae7501e 3002static bfd_byte *
7d9813f1
NA
3003read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr,
3004 bfd_size_type *entsize_ptr)
252b5132 3005{
29ca8dc5 3006 asection *stabsect;
bae7501e 3007 bfd_byte *contents;
252b5132 3008
29ca8dc5 3009 stabsect = bfd_get_section_by_name (abfd, sect_name);
155e0d23 3010 if (stabsect == NULL)
252b5132 3011 {
12add40e
NC
3012 printf (_("No %s section present\n\n"),
3013 sanitize_string (sect_name));
b34976b6 3014 return FALSE;
252b5132
RH
3015 }
3016
bae7501e 3017 if (!bfd_malloc_and_get_section (abfd, stabsect, &contents))
252b5132 3018 {
a8c62f1c 3019 non_fatal (_("reading %s section of %s failed: %s"),
29ca8dc5 3020 sect_name, bfd_get_filename (abfd),
37cc8ec1 3021 bfd_errmsg (bfd_get_error ()));
75cd796a 3022 exit_status = 1;
a8c62f1c 3023 free (contents);
29ca8dc5 3024 return NULL;
252b5132
RH
3025 }
3026
bae7501e 3027 *size_ptr = bfd_section_size (abfd, stabsect);
7d9813f1
NA
3028 if (entsize_ptr)
3029 *entsize_ptr = stabsect->entsize;
252b5132 3030
29ca8dc5 3031 return contents;
252b5132
RH
3032}
3033
3034/* Stabs entries use a 12 byte format:
3035 4 byte string table index
3036 1 byte stab type
3037 1 byte stab other field
3038 2 byte stab desc field
3039 4 byte stab value
3040 FIXME: This will have to change for a 64 bit object format. */
3041
46dca2e0
NC
3042#define STRDXOFF (0)
3043#define TYPEOFF (4)
3044#define OTHEROFF (5)
3045#define DESCOFF (6)
3046#define VALOFF (8)
252b5132
RH
3047#define STABSIZE (12)
3048
3049/* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3050 using string table section STRSECT_NAME (in `strtab'). */
3051
3052static void
3b9ad1cc
AM
3053print_section_stabs (bfd *abfd,
3054 const char *stabsect_name,
3055 unsigned *string_offset_ptr)
252b5132
RH
3056{
3057 int i;
46dca2e0 3058 unsigned file_string_table_offset = 0;
29ca8dc5 3059 unsigned next_file_string_table_offset = *string_offset_ptr;
252b5132
RH
3060 bfd_byte *stabp, *stabs_end;
3061
3062 stabp = stabs;
3063 stabs_end = stabp + stab_size;
3064
12add40e 3065 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name));
252b5132
RH
3066 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3067
3068 /* Loop through all symbols and print them.
3069
3070 We start the index at -1 because there is a dummy symbol on
3071 the front of stabs-in-{coff,elf} sections that supplies sizes. */
f41e4712 3072 for (i = -1; stabp <= stabs_end - STABSIZE; stabp += STABSIZE, i++)
252b5132
RH
3073 {
3074 const char *name;
3075 unsigned long strx;
3076 unsigned char type, other;
3077 unsigned short desc;
3078 bfd_vma value;
3079
3080 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
3081 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
3082 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
3083 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
3084 value = bfd_h_get_32 (abfd, stabp + VALOFF);
3085
3086 printf ("\n%-6d ", i);
3087 /* Either print the stab name, or, if unnamed, print its number
0af11b59 3088 again (makes consistent formatting for tools like awk). */
252b5132
RH
3089 name = bfd_get_stab_name (type);
3090 if (name != NULL)
12add40e 3091 printf ("%-6s", sanitize_string (name));
252b5132
RH
3092 else if (type == N_UNDF)
3093 printf ("HdrSym");
3094 else
3095 printf ("%-6d", type);
3096 printf (" %-6d %-6d ", other, desc);
d8180c76 3097 bfd_printf_vma (abfd, value);
252b5132
RH
3098 printf (" %-6lu", strx);
3099
3100 /* Symbols with type == 0 (N_UNDF) specify the length of the
3101 string table associated with this file. We use that info
3102 to know how to relocate the *next* file's string table indices. */
252b5132
RH
3103 if (type == N_UNDF)
3104 {
3105 file_string_table_offset = next_file_string_table_offset;
3106 next_file_string_table_offset += value;
3107 }
3108 else
3109 {
f41e4712
NC
3110 bfd_size_type amt = strx + file_string_table_offset;
3111
252b5132
RH
3112 /* Using the (possibly updated) string table offset, print the
3113 string (if any) associated with this symbol. */
f41e4712 3114 if (amt < stabstr_size)
12add40e
NC
3115 /* PR 17512: file: 079-79389-0.001:0.1.
3116 FIXME: May need to sanitize this string before displaying. */
f41e4712 3117 printf (" %.*s", (int)(stabstr_size - amt), strtab + amt);
252b5132
RH
3118 else
3119 printf (" *");
3120 }
3121 }
3122 printf ("\n\n");
29ca8dc5 3123 *string_offset_ptr = next_file_string_table_offset;
252b5132
RH
3124}
3125
155e0d23
NC
3126typedef struct
3127{
3128 const char * section_name;
3129 const char * string_section_name;
29ca8dc5 3130 unsigned string_offset;
155e0d23
NC
3131}
3132stab_section_names;
3133
252b5132 3134static void
155e0d23 3135find_stabs_section (bfd *abfd, asection *section, void *names)
252b5132 3136{
155e0d23
NC
3137 int len;
3138 stab_section_names * sought = (stab_section_names *) names;
252b5132
RH
3139
3140 /* Check for section names for which stabsect_name is a prefix, to
29ca8dc5 3141 handle .stab.N, etc. */
155e0d23
NC
3142 len = strlen (sought->section_name);
3143
3144 /* If the prefix matches, and the files section name ends with a
3145 nul or a digit, then we match. I.e., we want either an exact
3146 match or a section followed by a number. */
3147 if (strncmp (sought->section_name, section->name, len) == 0
3148 && (section->name[len] == 0
29ca8dc5 3149 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
252b5132 3150 {
29ca8dc5
NS
3151 if (strtab == NULL)
3152 strtab = read_section_stabs (abfd, sought->string_section_name,
7d9813f1 3153 &stabstr_size, NULL);
3aade688 3154
29ca8dc5 3155 if (strtab)
252b5132 3156 {
7d9813f1 3157 stabs = read_section_stabs (abfd, section->name, &stab_size, NULL);
29ca8dc5
NS
3158 if (stabs)
3159 print_section_stabs (abfd, section->name, &sought->string_offset);
252b5132
RH
3160 }
3161 }
3162}
98a91d6a 3163
155e0d23
NC
3164static void
3165dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
3166{
3167 stab_section_names s;
3168
3169 s.section_name = stabsect_name;
3170 s.string_section_name = strsect_name;
29ca8dc5
NS
3171 s.string_offset = 0;
3172
155e0d23 3173 bfd_map_over_sections (abfd, find_stabs_section, & s);
29ca8dc5
NS
3174
3175 free (strtab);
3176 strtab = NULL;
155e0d23
NC
3177}
3178
3179/* Dump the any sections containing stabs debugging information. */
3180
3181static void
3182dump_stabs (bfd *abfd)
3183{
3184 dump_stabs_section (abfd, ".stab", ".stabstr");
3185 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
3186 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
62bb81b8
TG
3187
3188 /* For Darwin. */
3189 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3190
155e0d23
NC
3191 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3192}
252b5132
RH
3193\f
3194static void
46dca2e0 3195dump_bfd_header (bfd *abfd)
252b5132
RH
3196{
3197 char *comma = "";
3198
3199 printf (_("architecture: %s, "),
3200 bfd_printable_arch_mach (bfd_get_arch (abfd),
3201 bfd_get_mach (abfd)));
6b6bc957 3202 printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
252b5132
RH
3203
3204#define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3205 PF (HAS_RELOC, "HAS_RELOC");
3206 PF (EXEC_P, "EXEC_P");
3207 PF (HAS_LINENO, "HAS_LINENO");
3208 PF (HAS_DEBUG, "HAS_DEBUG");
3209 PF (HAS_SYMS, "HAS_SYMS");
3210 PF (HAS_LOCALS, "HAS_LOCALS");
3211 PF (DYNAMIC, "DYNAMIC");
3212 PF (WP_TEXT, "WP_TEXT");
3213 PF (D_PAGED, "D_PAGED");
3214 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
3215 printf (_("\nstart address 0x"));
d8180c76 3216 bfd_printf_vma (abfd, abfd->start_address);
252b5132
RH
3217 printf ("\n");
3218}
7d9813f1
NA
3219\f
3220
3221/* Formatting callback function passed to ctf_dump. Returns either the pointer
3222 it is passed, or a pointer to newly-allocated storage, in which case
3223 dump_ctf() will free it when it no longer needs it. */
3224
3225static char *
3226dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
3227 char *s, void *arg)
3228{
63160fc9 3229 const char *blanks = arg;
7d9813f1
NA
3230 char *new_s;
3231
63160fc9 3232 if (asprintf (&new_s, "%s%s", blanks, s) < 0)
7d9813f1
NA
3233 return s;
3234 return new_s;
3235}
3236
3237/* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3238static ctf_sect_t
3239make_ctfsect (const char *name, bfd_byte *data,
3240 bfd_size_type size)
3241{
3242 ctf_sect_t ctfsect;
3243
3244 ctfsect.cts_name = name;
7d9813f1 3245 ctfsect.cts_entsize = 1;
7d9813f1
NA
3246 ctfsect.cts_size = size;
3247 ctfsect.cts_data = data;
3248
3249 return ctfsect;
3250}
3251
3252/* Dump one CTF archive member. */
3253
3254static int
3255dump_ctf_archive_member (ctf_file_t *ctf, const char *name, void *arg)
3256{
3257 ctf_file_t *parent = (ctf_file_t *) arg;
3258 const char *things[] = {"Labels", "Data objects", "Function objects",
3259 "Variables", "Types", "Strings", ""};
3260 const char **thing;
3261 size_t i;
3262
3263 /* Only print out the name of non-default-named archive members.
3264 The name .ctf appears everywhere, even for things that aren't
3265 really archives, so printing it out is liable to be confusing. */
3266 if (strcmp (name, ".ctf") != 0)
3267 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name));
3268
3269 ctf_import (ctf, parent);
3270 for (i = 1, thing = things; *thing[0]; thing++, i++)
3271 {
3272 ctf_dump_state_t *s = NULL;
3273 char *item;
3274
3275 printf ("\n %s:\n", *thing);
3276 while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
3277 (void *) " ")) != NULL)
3278 {
3279 printf ("%s\n", item);
3280 free (item);
3281 }
3282
3283 if (ctf_errno (ctf))
3284 {
3285 non_fatal (_("Iteration failed: %s, %s\n"), *thing,
3286 ctf_errmsg (ctf_errno (ctf)));
3287 break;
3288 }
3289 }
3290 return 0;
3291}
3292
3293/* Dump the CTF debugging information. */
3294
3295static void
3296dump_ctf (bfd *abfd, const char *sect_name, const char *parent_name)
3297{
3298 ctf_archive_t *ctfa, *parenta = NULL;
3299 bfd_byte *ctfdata, *parentdata = NULL;
3300 bfd_size_type ctfsize, parentsize;
3301 ctf_sect_t ctfsect;
3302 ctf_file_t *parent = NULL;
3303 int err;
3304
3305 if ((ctfdata = read_section_stabs (abfd, sect_name, &ctfsize, NULL)) == NULL)
3306 bfd_fatal (bfd_get_filename (abfd));
3307
3308 if (parent_name
3309 && (parentdata = read_section_stabs (abfd, parent_name, &parentsize,
3310 NULL)) == NULL)
3311 bfd_fatal (bfd_get_filename (abfd));
3312
3313 /* Load the CTF file and dump it. */
3314
3315 ctfsect = make_ctfsect (sect_name, ctfdata, ctfsize);
3316 if ((ctfa = ctf_bfdopen_ctfsect (abfd, &ctfsect, &err)) == NULL)
3317 {
3318 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3319 bfd_fatal (bfd_get_filename (abfd));
3320 }
3321
3322 if (parentdata)
3323 {
3324 ctfsect = make_ctfsect (parent_name, parentdata, parentsize);
3325 if ((parenta = ctf_bfdopen_ctfsect (abfd, &ctfsect, &err)) == NULL)
3326 {
3327 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3328 bfd_fatal (bfd_get_filename (abfd));
3329 }
3330
3331 /* Assume that the applicable parent archive member is the default one.
3332 (This is what all known implementations are expected to do, if they
3333 put CTFs and their parents in archives together.) */
3334 if ((parent = ctf_arc_open_by_name (parenta, NULL, &err)) == NULL)
3335 {
3336 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3337 bfd_fatal (bfd_get_filename (abfd));
3338 }
3339 }
3340
3341 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name));
3342
3343 ctf_archive_iter (ctfa, dump_ctf_archive_member, parent);
3344 ctf_file_close (parent);
3345 ctf_close (ctfa);
3346 ctf_close (parenta);
3347 free (parentdata);
3348 free (ctfdata);
3349}
98a91d6a 3350
79b377b3 3351\f
252b5132 3352static void
46dca2e0 3353dump_bfd_private_header (bfd *abfd)
252b5132 3354{
7d272a55
AM
3355 if (!bfd_print_private_bfd_data (abfd, stdout))
3356 non_fatal (_("warning: private headers incomplete: %s"),
3357 bfd_errmsg (bfd_get_error ()));
252b5132
RH
3358}
3359
6abcee90
TG
3360static void
3361dump_target_specific (bfd *abfd)
3362{
3363 const struct objdump_private_desc * const *desc;
3364 struct objdump_private_option *opt;
3365 char *e, *b;
3366
3367 /* Find the desc. */
3368 for (desc = objdump_private_vectors; *desc != NULL; desc++)
3369 if ((*desc)->filter (abfd))
3370 break;
3371
c32d6f7b 3372 if (*desc == NULL)
6abcee90
TG
3373 {
3374 non_fatal (_("option -P/--private not supported by this file"));
3375 return;
3376 }
3377
3378 /* Clear all options. */
3379 for (opt = (*desc)->options; opt->name; opt++)
3380 opt->selected = FALSE;
3381
3382 /* Decode options. */
3383 b = dump_private_options;
3384 do
3385 {
3386 e = strchr (b, ',');
3387
3388 if (e)
3389 *e = 0;
3390
3391 for (opt = (*desc)->options; opt->name; opt++)
3392 if (strcmp (opt->name, b) == 0)
3393 {
3394 opt->selected = TRUE;
3395 break;
3396 }
3397 if (opt->name == NULL)
3398 non_fatal (_("target specific dump '%s' not supported"), b);
3399
3400 if (e)
3401 {
3402 *e = ',';
3403 b = e + 1;
3404 }
3405 }
3406 while (e != NULL);
3407
3408 /* Dump. */
3409 (*desc)->dump (abfd);
3410}
155e0d23
NC
3411\f
3412/* Display a section in hexadecimal format with associated characters.
3413 Each line prefixed by the zero padded address. */
d24de309 3414
252b5132 3415static void
155e0d23 3416dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
252b5132 3417{
cfd14a50 3418 bfd_byte *data = NULL;
155e0d23 3419 bfd_size_type datasize;
bdc4de1b
NC
3420 bfd_vma addr_offset;
3421 bfd_vma start_offset;
3422 bfd_vma stop_offset;
155e0d23
NC
3423 unsigned int opb = bfd_octets_per_byte (abfd);
3424 /* Bytes per line. */
3425 const int onaline = 16;
3426 char buf[64];
3427 int count;
3428 int width;
3429
3430 if ((section->flags & SEC_HAS_CONTENTS) == 0)
3431 return;
3432
3433 if (! process_section_p (section))
3434 return;
3aade688 3435
155e0d23
NC
3436 if ((datasize = bfd_section_size (abfd, section)) == 0)
3437 return;
3438
155e0d23
NC
3439 /* Compute the address range to display. */
3440 if (start_address == (bfd_vma) -1
3441 || start_address < section->vma)
3442 start_offset = 0;
3443 else
3444 start_offset = start_address - section->vma;
3445
3446 if (stop_address == (bfd_vma) -1)
3447 stop_offset = datasize / opb;
3448 else
252b5132 3449 {
155e0d23
NC
3450 if (stop_address < section->vma)
3451 stop_offset = 0;
3452 else
3453 stop_offset = stop_address - section->vma;
252b5132 3454
155e0d23
NC
3455 if (stop_offset > datasize / opb)
3456 stop_offset = datasize / opb;
252b5132
RH
3457 }
3458
32760852
NC
3459 if (start_offset >= stop_offset)
3460 return;
3aade688 3461
12add40e 3462 printf (_("Contents of section %s:"), sanitize_string (section->name));
32760852 3463 if (display_file_offsets)
0af1713e
AM
3464 printf (_(" (Starting at file offset: 0x%lx)"),
3465 (unsigned long) (section->filepos + start_offset));
32760852
NC
3466 printf ("\n");
3467
4a114e3e
L
3468 if (!bfd_get_full_section_contents (abfd, section, &data))
3469 {
0821d5b1
NC
3470 non_fatal (_("Reading section %s failed because: %s"),
3471 section->name, bfd_errmsg (bfd_get_error ()));
4a114e3e
L
3472 return;
3473 }
32760852 3474
155e0d23 3475 width = 4;
026df7c5 3476
155e0d23
NC
3477 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
3478 if (strlen (buf) >= sizeof (buf))
3479 abort ();
026df7c5 3480
155e0d23
NC
3481 count = 0;
3482 while (buf[count] == '0' && buf[count+1] != '\0')
3483 count++;
3484 count = strlen (buf) - count;
3485 if (count > width)
3486 width = count;
252b5132 3487
155e0d23
NC
3488 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
3489 if (strlen (buf) >= sizeof (buf))
3490 abort ();
026df7c5 3491
155e0d23
NC
3492 count = 0;
3493 while (buf[count] == '0' && buf[count+1] != '\0')
3494 count++;
3495 count = strlen (buf) - count;
3496 if (count > width)
3497 width = count;
026df7c5 3498
155e0d23
NC
3499 for (addr_offset = start_offset;
3500 addr_offset < stop_offset; addr_offset += onaline / opb)
d24de309 3501 {
155e0d23 3502 bfd_size_type j;
d24de309 3503
155e0d23
NC
3504 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
3505 count = strlen (buf);
3506 if ((size_t) count >= sizeof (buf))
3507 abort ();
d24de309 3508
155e0d23
NC
3509 putchar (' ');
3510 while (count < width)
252b5132 3511 {
155e0d23
NC
3512 putchar ('0');
3513 count++;
3514 }
3515 fputs (buf + count - width, stdout);
3516 putchar (' ');
252b5132 3517
155e0d23
NC
3518 for (j = addr_offset * opb;
3519 j < addr_offset * opb + onaline; j++)
3520 {
3521 if (j < stop_offset * opb)
3522 printf ("%02x", (unsigned) (data[j]));
3523 else
3524 printf (" ");
3525 if ((j & 3) == 3)
3526 printf (" ");
252b5132
RH
3527 }
3528
155e0d23
NC
3529 printf (" ");
3530 for (j = addr_offset * opb;
3531 j < addr_offset * opb + onaline; j++)
3532 {
3533 if (j >= stop_offset * opb)
3534 printf (" ");
3535 else
3536 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
3537 }
3538 putchar ('\n');
252b5132 3539 }
155e0d23 3540 free (data);
252b5132 3541}
155e0d23 3542
98a91d6a 3543/* Actually display the various requested regions. */
252b5132
RH
3544
3545static void
46dca2e0 3546dump_data (bfd *abfd)
252b5132 3547{
155e0d23 3548 bfd_map_over_sections (abfd, dump_section, NULL);
252b5132
RH
3549}
3550
98a91d6a
NC
3551/* Should perhaps share code and display with nm? */
3552
252b5132 3553static void
46dca2e0 3554dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
252b5132
RH
3555{
3556 asymbol **current;
91d6fa6a 3557 long max_count;
252b5132
RH
3558 long count;
3559
3560 if (dynamic)
3561 {
3562 current = dynsyms;
91d6fa6a 3563 max_count = dynsymcount;
252b5132
RH
3564 printf ("DYNAMIC SYMBOL TABLE:\n");
3565 }
3566 else
3567 {
3568 current = syms;
91d6fa6a 3569 max_count = symcount;
252b5132
RH
3570 printf ("SYMBOL TABLE:\n");
3571 }
3572
91d6fa6a 3573 if (max_count == 0)
a1df01d1
AM
3574 printf (_("no symbols\n"));
3575
91d6fa6a 3576 for (count = 0; count < max_count; count++)
252b5132 3577 {
155e0d23
NC
3578 bfd *cur_bfd;
3579
3580 if (*current == NULL)
83ef0798 3581 printf (_("no information for symbol number %ld\n"), count);
155e0d23
NC
3582
3583 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
83ef0798 3584 printf (_("could not determine the type of symbol number %ld\n"),
155e0d23
NC
3585 count);
3586
661f7c35
NC
3587 else if (process_section_p ((* current)->section)
3588 && (dump_special_syms
3589 || !bfd_is_target_special_symbol (cur_bfd, *current)))
252b5132 3590 {
155e0d23 3591 const char *name = (*current)->name;
252b5132 3592
155e0d23 3593 if (do_demangle && name != NULL && *name != '\0')
252b5132 3594 {
252b5132
RH
3595 char *alloc;
3596
155e0d23
NC
3597 /* If we want to demangle the name, we demangle it
3598 here, and temporarily clobber it while calling
3599 bfd_print_symbol. FIXME: This is a gross hack. */
af03af8f 3600 alloc = bfd_demangle (cur_bfd, name, demangle_flags);
ed180cc5
AM
3601 if (alloc != NULL)
3602 (*current)->name = alloc;
252b5132
RH
3603 bfd_print_symbol (cur_bfd, stdout, *current,
3604 bfd_print_symbol_all);
ed180cc5
AM
3605 if (alloc != NULL)
3606 {
3607 (*current)->name = name;
3608 free (alloc);
3609 }
252b5132 3610 }
252b5132 3611 else
155e0d23
NC
3612 bfd_print_symbol (cur_bfd, stdout, *current,
3613 bfd_print_symbol_all);
83ef0798 3614 printf ("\n");
252b5132 3615 }
661f7c35 3616
155e0d23 3617 current++;
252b5132 3618 }
155e0d23 3619 printf ("\n\n");
252b5132 3620}
155e0d23 3621\f
252b5132 3622static void
46dca2e0 3623dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
252b5132
RH
3624{
3625 arelent **p;
3626 char *last_filename, *last_functionname;
3627 unsigned int last_line;
9b8d1a36 3628 unsigned int last_discriminator;
252b5132
RH
3629
3630 /* Get column headers lined up reasonably. */
3631 {
3632 static int width;
98a91d6a 3633
252b5132
RH
3634 if (width == 0)
3635 {
3636 char buf[30];
155e0d23 3637
d8180c76 3638 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
252b5132
RH
3639 width = strlen (buf) - 7;
3640 }
3641 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
3642 }
3643
3644 last_filename = NULL;
3645 last_functionname = NULL;
3646 last_line = 0;
9b8d1a36 3647 last_discriminator = 0;
252b5132 3648
d3ba0551 3649 for (p = relpp; relcount && *p != NULL; p++, relcount--)
252b5132
RH
3650 {
3651 arelent *q = *p;
3652 const char *filename, *functionname;
91d6fa6a 3653 unsigned int linenumber;
9b8d1a36 3654 unsigned int discriminator;
252b5132
RH
3655 const char *sym_name;
3656 const char *section_name;
bf03e632 3657 bfd_vma addend2 = 0;
252b5132
RH
3658
3659 if (start_address != (bfd_vma) -1
3660 && q->address < start_address)
3661 continue;
3662 if (stop_address != (bfd_vma) -1
3663 && q->address > stop_address)
3664 continue;
3665
3666 if (with_line_numbers
3667 && sec != NULL
9b8d1a36
CC
3668 && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
3669 &filename, &functionname,
3670 &linenumber, &discriminator))
252b5132
RH
3671 {
3672 if (functionname != NULL
3673 && (last_functionname == NULL
3674 || strcmp (functionname, last_functionname) != 0))
3675 {
12add40e 3676 printf ("%s():\n", sanitize_string (functionname));
252b5132
RH
3677 if (last_functionname != NULL)
3678 free (last_functionname);
3679 last_functionname = xstrdup (functionname);
3680 }
98a91d6a 3681
91d6fa6a
NC
3682 if (linenumber > 0
3683 && (linenumber != last_line
252b5132
RH
3684 || (filename != NULL
3685 && last_filename != NULL
9b8d1a36
CC
3686 && filename_cmp (filename, last_filename) != 0)
3687 || (discriminator != last_discriminator)))
252b5132 3688 {
9b8d1a36 3689 if (discriminator > 0)
12add40e
NC
3690 printf ("%s:%u\n", filename == NULL ? "???" :
3691 sanitize_string (filename), linenumber);
9b8d1a36 3692 else
12add40e
NC
3693 printf ("%s:%u (discriminator %u)\n",
3694 filename == NULL ? "???" : sanitize_string (filename),
9b8d1a36 3695 linenumber, discriminator);
91d6fa6a 3696 last_line = linenumber;
9b8d1a36 3697 last_discriminator = discriminator;
252b5132
RH
3698 if (last_filename != NULL)
3699 free (last_filename);
3700 if (filename == NULL)
3701 last_filename = NULL;
3702 else
3703 last_filename = xstrdup (filename);
3704 }
3705 }
3706
3707 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
3708 {
3709 sym_name = (*(q->sym_ptr_ptr))->name;
3710 section_name = (*(q->sym_ptr_ptr))->section->name;
3711 }
3712 else
3713 {
3714 sym_name = NULL;
3715 section_name = NULL;
3716 }
98a91d6a 3717
f9ecb0a4
JJ
3718 bfd_printf_vma (abfd, q->address);
3719 if (q->howto == NULL)
3720 printf (" *unknown* ");
3721 else if (q->howto->name)
bf03e632
DM
3722 {
3723 const char *name = q->howto->name;
3724
3725 /* R_SPARC_OLO10 relocations contain two addends.
3726 But because 'arelent' lacks enough storage to
3727 store them both, the 64-bit ELF Sparc backend
3728 records this as two relocations. One R_SPARC_LO10
3729 and one R_SPARC_13, both pointing to the same
3730 address. This is merely so that we have some
3731 place to store both addend fields.
3732
3733 Undo this transformation, otherwise the output
3734 will be confusing. */
3735 if (abfd->xvec->flavour == bfd_target_elf_flavour
3736 && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
3737 && relcount > 1
3738 && !strcmp (q->howto->name, "R_SPARC_LO10"))
3739 {
3740 arelent *q2 = *(p + 1);
3741 if (q2 != NULL
3742 && q2->howto
3743 && q->address == q2->address
3744 && !strcmp (q2->howto->name, "R_SPARC_13"))
3745 {
3746 name = "R_SPARC_OLO10";
3747 addend2 = q2->addend;
3748 p++;
3749 }
3750 }
3751 printf (" %-16s ", name);
3752 }
f9ecb0a4
JJ
3753 else
3754 printf (" %-16d ", q->howto->type);
171191ba 3755
252b5132 3756 if (sym_name)
171191ba
NC
3757 {
3758 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
171191ba 3759 }
252b5132
RH
3760 else
3761 {
d3ba0551 3762 if (section_name == NULL)
252b5132 3763 section_name = "*unknown*";
12add40e 3764 printf ("[%s]", sanitize_string (section_name));
252b5132 3765 }
98a91d6a 3766
252b5132
RH
3767 if (q->addend)
3768 {
343dbc36
L
3769 bfd_signed_vma addend = q->addend;
3770 if (addend < 0)
3771 {
3772 printf ("-0x");
3773 addend = -addend;
3774 }
3775 else
3776 printf ("+0x");
3777 bfd_printf_vma (abfd, addend);
252b5132 3778 }
bf03e632
DM
3779 if (addend2)
3780 {
3781 printf ("+0x");
3782 bfd_printf_vma (abfd, addend2);
3783 }
98a91d6a 3784
252b5132
RH
3785 printf ("\n");
3786 }
4b41844b
NC
3787
3788 if (last_filename != NULL)
3789 free (last_filename);
3790 if (last_functionname != NULL)
3791 free (last_functionname);
252b5132 3792}
43ac9881 3793
155e0d23 3794static void
3b9ad1cc
AM
3795dump_relocs_in_section (bfd *abfd,
3796 asection *section,
3797 void *dummy ATTRIBUTE_UNUSED)
155e0d23 3798{
e8fba7f6 3799 arelent **relpp = NULL;
155e0d23
NC
3800 long relcount;
3801 long relsize;
3802
3803 if ( bfd_is_abs_section (section)
3804 || bfd_is_und_section (section)
3805 || bfd_is_com_section (section)
3806 || (! process_section_p (section))
3807 || ((section->flags & SEC_RELOC) == 0))
3808 return;
3809
12add40e 3810 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section->name));
155e0d23 3811
7a6e0d89 3812 relsize = bfd_get_reloc_upper_bound (abfd, section);
155e0d23
NC
3813 if (relsize == 0)
3814 {
3815 printf (" (none)\n\n");
3816 return;
3817 }
3818
7a6e0d89
AM
3819 if (relsize < 0)
3820 relcount = relsize;
3821 else
3822 {
3823 relpp = (arelent **) xmalloc (relsize);
3824 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
39ff1b79
NC
3825 }
3826
155e0d23 3827 if (relcount < 0)
5a3f568b
NC
3828 {
3829 printf ("\n");
7a6e0d89
AM
3830 non_fatal (_("failed to read relocs in: %s"),
3831 sanitize_string (bfd_get_filename (abfd)));
5a3f568b
NC
3832 bfd_fatal (_("error message was"));
3833 }
155e0d23
NC
3834 else if (relcount == 0)
3835 printf (" (none)\n\n");
3836 else
3837 {
3838 printf ("\n");
3839 dump_reloc_set (abfd, section, relpp, relcount);
3840 printf ("\n\n");
3841 }
3842 free (relpp);
3843}
3844
3845static void
3846dump_relocs (bfd *abfd)
3847{
3848 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3849}
3850
3851static void
3852dump_dynamic_relocs (bfd *abfd)
3853{
3854 long relsize;
3855 arelent **relpp;
3856 long relcount;
3857
3858 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3859 if (relsize < 0)
3860 bfd_fatal (bfd_get_filename (abfd));
3861
3862 printf ("DYNAMIC RELOCATION RECORDS");
3863
3864 if (relsize == 0)
3865 printf (" (none)\n\n");
3866 else
3867 {
3f5e193b 3868 relpp = (arelent **) xmalloc (relsize);
155e0d23
NC
3869 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3870
3871 if (relcount < 0)
3872 bfd_fatal (bfd_get_filename (abfd));
3873 else if (relcount == 0)
3874 printf (" (none)\n\n");
3875 else
3876 {
3877 printf ("\n");
3878 dump_reloc_set (abfd, NULL, relpp, relcount);
3879 printf ("\n\n");
3880 }
3881 free (relpp);
3882 }
3883}
3884
43ac9881
AM
3885/* Creates a table of paths, to search for source files. */
3886
3887static void
3888add_include_path (const char *path)
3889{
3890 if (path[0] == 0)
3891 return;
3892 include_path_count++;
3f5e193b
NC
3893 include_paths = (const char **)
3894 xrealloc (include_paths, include_path_count * sizeof (*include_paths));
43ac9881
AM
3895#ifdef HAVE_DOS_BASED_FILE_SYSTEM
3896 if (path[1] == ':' && path[2] == 0)
3897 path = concat (path, ".", (const char *) 0);
3898#endif
3899 include_paths[include_path_count - 1] = path;
3900}
155e0d23
NC
3901
3902static void
3b9ad1cc
AM
3903adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3904 asection *section,
bc79cded 3905 void *arg)
155e0d23 3906{
bc79cded
L
3907 if ((section->flags & SEC_DEBUGGING) == 0)
3908 {
3909 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3910 section->vma += adjust_section_vma;
3911 if (*has_reloc_p)
3912 section->lma += adjust_section_vma;
3913 }
155e0d23
NC
3914}
3915
2379f9c4
FS
3916/* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3917
3918static bfd_vma
3919sign_extend_address (bfd *abfd ATTRIBUTE_UNUSED,
3920 bfd_vma vma,
3921 unsigned arch_size)
3922{
3923 bfd_vma mask;
3924 mask = (bfd_vma) 1 << (arch_size - 1);
3925 return (((vma & ((mask << 1) - 1)) ^ mask) - mask);
3926}
3927
155e0d23
NC
3928/* Dump selected contents of ABFD. */
3929
3930static void
39f0547e 3931dump_bfd (bfd *abfd, bfd_boolean is_mainfile)
155e0d23 3932{
2379f9c4
FS
3933 const struct elf_backend_data * bed;
3934
39f0547e
NC
3935 if (bfd_big_endian (abfd))
3936 byte_get = byte_get_big_endian;
3937 else if (bfd_little_endian (abfd))
3938 byte_get = byte_get_little_endian;
3939 else
3940 byte_get = NULL;
3941
3942 /* Load any separate debug information files.
3943 We do this now and without checking do_follow_links because separate
3944 debug info files may contain symbol tables that we will need when
3945 displaying information about the main file. Any memory allocated by
3946 load_separate_debug_files will be released when we call
3947 free_debug_memory below.
3948
3949 The test on is_mainfile is there because the chain of separate debug
3950 info files is a global variable shared by all invocations of dump_bfd. */
3951 if (is_mainfile)
3952 {
3953 load_separate_debug_files (abfd, bfd_get_filename (abfd));
3954
3955 /* If asked to do so, recursively dump the separate files. */
3956 if (do_follow_links)
3957 {
3958 separate_info * i;
3959
3960 for (i = first_separate_info; i != NULL; i = i->next)
3961 dump_bfd (i->handle, FALSE);
3962 }
3963 }
3964
2379f9c4
FS
3965 /* Adjust user-specified start and stop limits for targets that use
3966 signed addresses. */
3967 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
3968 && (bed = get_elf_backend_data (abfd)) != NULL
3969 && bed->sign_extend_vma)
3970 {
3971 start_address = sign_extend_address (abfd, start_address,
3972 bed->s->arch_size);
3973 stop_address = sign_extend_address (abfd, stop_address,
3974 bed->s->arch_size);
3975 }
3976
155e0d23
NC
3977 /* If we are adjusting section VMA's, change them all now. Changing
3978 the BFD information is a hack. However, we must do it, or
3979 bfd_find_nearest_line will not do the right thing. */
3980 if (adjust_section_vma != 0)
bc79cded
L
3981 {
3982 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3983 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3984 }
155e0d23 3985
fd2f0033 3986 if (! dump_debugging_tags && ! suppress_bfd_header)
12add40e
NC
3987 printf (_("\n%s: file format %s\n"),
3988 sanitize_string (bfd_get_filename (abfd)),
155e0d23
NC
3989 abfd->xvec->name);
3990 if (dump_ar_hdrs)
1869e86f 3991 print_arelt_descr (stdout, abfd, TRUE, FALSE);
155e0d23
NC
3992 if (dump_file_header)
3993 dump_bfd_header (abfd);
3994 if (dump_private_headers)
3995 dump_bfd_private_header (abfd);
6abcee90
TG
3996 if (dump_private_options != NULL)
3997 dump_target_specific (abfd);
fd2f0033 3998 if (! dump_debugging_tags && ! suppress_bfd_header)
155e0d23 3999 putchar ('\n');
155e0d23 4000
365544c3
L
4001 if (dump_symtab
4002 || dump_reloc_info
4003 || disassemble
4004 || dump_debugging
4005 || dump_dwarf_section_info)
39f0547e
NC
4006 {
4007 syms = slurp_symtab (abfd);
4008
4009 /* If following links, load any symbol tables from the linked files as well. */
4010 if (do_follow_links && is_mainfile)
4011 {
4012 separate_info * i;
4013
4014 for (i = first_separate_info; i != NULL; i = i->next)
4015 {
4016 asymbol ** extra_syms;
4017 long old_symcount = symcount;
4018
4019 extra_syms = slurp_symtab (i->handle);
4020
4021 if (extra_syms)
4022 {
4023 if (old_symcount == 0)
4024 {
4025 syms = extra_syms;
4026 }
4027 else
4028 {
4029 syms = xrealloc (syms, (symcount + old_symcount) * sizeof (asymbol *));
4030 memcpy (syms + old_symcount,
4031 extra_syms,
4032 symcount * sizeof (asymbol *));
4033 }
4034 }
4035
4036 symcount += old_symcount;
4037 }
4038 }
4039 }
a29a8af8
KT
4040
4041 if (dump_section_headers)
4042 dump_headers (abfd);
4043
4c45e5c9
JJ
4044 if (dump_dynamic_symtab || dump_dynamic_reloc_info
4045 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
155e0d23 4046 dynsyms = slurp_dynamic_symtab (abfd);
39f0547e 4047
90e3cdf2 4048 if (disassemble)
4c45e5c9 4049 {
c9727e01
AM
4050 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
4051 dynsymcount, dynsyms, &synthsyms);
4052 if (synthcount < 0)
4053 synthcount = 0;
4c45e5c9 4054 }
155e0d23
NC
4055
4056 if (dump_symtab)
4057 dump_symbols (abfd, FALSE);
4058 if (dump_dynamic_symtab)
4059 dump_symbols (abfd, TRUE);
365544c3
L
4060 if (dump_dwarf_section_info)
4061 dump_dwarf (abfd);
7d9813f1
NA
4062 if (dump_ctf_section_info)
4063 dump_ctf (abfd, dump_ctf_section_name, dump_ctf_parent_name);
155e0d23
NC
4064 if (dump_stab_section_info)
4065 dump_stabs (abfd);
4066 if (dump_reloc_info && ! disassemble)
4067 dump_relocs (abfd);
4068 if (dump_dynamic_reloc_info && ! disassemble)
4069 dump_dynamic_relocs (abfd);
4070 if (dump_section_contents)
4071 dump_data (abfd);
4072 if (disassemble)
4073 disassemble_data (abfd);
4074
4075 if (dump_debugging)
4076 {
4077 void *dhandle;
4078
b922d590 4079 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
155e0d23
NC
4080 if (dhandle != NULL)
4081 {
ed180cc5
AM
4082 if (!print_debugging_info (stdout, dhandle, abfd, syms,
4083 bfd_demangle,
4084 dump_debugging_tags ? TRUE : FALSE))
155e0d23
NC
4085 {
4086 non_fatal (_("%s: printing debugging information failed"),
4087 bfd_get_filename (abfd));
4088 exit_status = 1;
4089 }
cf0ad5bb
NC
4090
4091 free (dhandle);
155e0d23 4092 }
fdef3943
AM
4093 /* PR 6483: If there was no STABS debug info in the file, try
4094 DWARF instead. */
b922d590
NC
4095 else if (! dump_dwarf_section_info)
4096 {
3aade688 4097 dwarf_select_sections_all ();
b922d590
NC
4098 dump_dwarf (abfd);
4099 }
155e0d23
NC
4100 }
4101
4102 if (syms)
4103 {
4104 free (syms);
4105 syms = NULL;
4106 }
4107
4108 if (dynsyms)
4109 {
4110 free (dynsyms);
4111 dynsyms = NULL;
4112 }
4c45e5c9
JJ
4113
4114 if (synthsyms)
4115 {
4116 free (synthsyms);
4117 synthsyms = NULL;
4118 }
4119
4120 symcount = 0;
4121 dynsymcount = 0;
4122 synthcount = 0;
39f0547e
NC
4123
4124 if (is_mainfile)
4125 free_debug_memory ();
155e0d23
NC
4126}
4127
4128static void
1598539f 4129display_object_bfd (bfd *abfd)
155e0d23
NC
4130{
4131 char **matching;
4132
4133 if (bfd_check_format_matches (abfd, bfd_object, &matching))
4134 {
39f0547e 4135 dump_bfd (abfd, TRUE);
155e0d23
NC
4136 return;
4137 }
4138
4139 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
4140 {
4141 nonfatal (bfd_get_filename (abfd));
4142 list_matching_formats (matching);
4143 free (matching);
4144 return;
4145 }
4146
4147 if (bfd_get_error () != bfd_error_file_not_recognized)
4148 {
4149 nonfatal (bfd_get_filename (abfd));
4150 return;
4151 }
4152
4153 if (bfd_check_format_matches (abfd, bfd_core, &matching))
4154 {
39f0547e 4155 dump_bfd (abfd, TRUE);
155e0d23
NC
4156 return;
4157 }
4158
4159 nonfatal (bfd_get_filename (abfd));
4160
4161 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
4162 {
4163 list_matching_formats (matching);
4164 free (matching);
4165 }
4166}
4167
4168static void
1598539f 4169display_any_bfd (bfd *file, int level)
155e0d23 4170{
4a114e3e
L
4171 /* Decompress sections unless dumping the section contents. */
4172 if (!dump_section_contents)
4173 file->flags |= BFD_DECOMPRESS;
4174
155e0d23
NC
4175 /* If the file is an archive, process all of its elements. */
4176 if (bfd_check_format (file, bfd_archive))
4177 {
1598539f 4178 bfd *arfile = NULL;
155e0d23 4179 bfd *last_arfile = NULL;
bdc4de1b 4180
1598539f 4181 if (level == 0)
12add40e 4182 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file)));
c88f5b8e
NC
4183 else if (level > 100)
4184 {
4185 /* Prevent corrupted files from spinning us into an
4186 infinite loop. 100 is an arbitrary heuristic. */
64d29018 4187 fatal (_("Archive nesting is too deep"));
c88f5b8e
NC
4188 return;
4189 }
1598539f 4190 else
12add40e
NC
4191 printf (_("In nested archive %s:\n"),
4192 sanitize_string (bfd_get_filename (file)));
1598539f 4193
155e0d23
NC
4194 for (;;)
4195 {
4196 bfd_set_error (bfd_error_no_error);
4197
4198 arfile = bfd_openr_next_archived_file (file, arfile);
4199 if (arfile == NULL)
4200 {
4201 if (bfd_get_error () != bfd_error_no_more_archived_files)
4202 nonfatal (bfd_get_filename (file));
4203 break;
4204 }
4205
1598539f 4206 display_any_bfd (arfile, level + 1);
155e0d23
NC
4207
4208 if (last_arfile != NULL)
f64e188b
NC
4209 {
4210 bfd_close (last_arfile);
4211 /* PR 17512: file: ac585d01. */
4212 if (arfile == last_arfile)
4213 {
4214 last_arfile = NULL;
4215 break;
4216 }
4217 }
155e0d23
NC
4218 last_arfile = arfile;
4219 }
4220
4221 if (last_arfile != NULL)
4222 bfd_close (last_arfile);
4223 }
4224 else
1598539f
TG
4225 display_object_bfd (file);
4226}
4227
4228static void
cd6581da 4229display_file (char *filename, char *target, bfd_boolean last_file)
1598539f
TG
4230{
4231 bfd *file;
4232
4233 if (get_file_size (filename) < 1)
4234 {
4235 exit_status = 1;
4236 return;
4237 }
4238
4239 file = bfd_openr (filename, target);
4240 if (file == NULL)
4241 {
4242 nonfatal (filename);
4243 return;
4244 }
4245
4246 display_any_bfd (file, 0);
155e0d23 4247
cd6581da
NC
4248 /* This is an optimization to improve the speed of objdump, especially when
4249 dumping a file with lots of associated debug informatiom. Calling
4250 bfd_close on such a file can take a non-trivial amount of time as there
4251 are lots of lists to walk and buffers to free. This is only really
4252 necessary however if we are about to load another file and we need the
4253 memory back. Otherwise, if we are about to exit, then we can save (a lot
4254 of) time by only doing a quick close, and allowing the OS to reclaim the
4255 memory for us. */
4256 if (! last_file)
4257 bfd_close (file);
4258 else
4259 bfd_close_all_done (file);
155e0d23 4260}
252b5132 4261\f
252b5132 4262int
46dca2e0 4263main (int argc, char **argv)
252b5132
RH
4264{
4265 int c;
4266 char *target = default_target;
b34976b6 4267 bfd_boolean seenflag = FALSE;
252b5132 4268
155e0d23
NC
4269#if defined (HAVE_SETLOCALE)
4270#if defined (HAVE_LC_MESSAGES)
252b5132 4271 setlocale (LC_MESSAGES, "");
3882b010 4272#endif
3882b010 4273 setlocale (LC_CTYPE, "");
252b5132 4274#endif
155e0d23 4275
252b5132
RH
4276 bindtextdomain (PACKAGE, LOCALEDIR);
4277 textdomain (PACKAGE);
4278
4279 program_name = *argv;
4280 xmalloc_set_program_name (program_name);
86eafac0 4281 bfd_set_error_program_name (program_name);
252b5132
RH
4282
4283 START_PROGRESS (program_name, 0);
4284
869b9d07
MM
4285 expandargv (&argc, &argv);
4286
bf2dd8d7
AM
4287 if (bfd_init () != BFD_INIT_MAGIC)
4288 fatal (_("fatal error: libbfd ABI mismatch"));
252b5132
RH
4289 set_default_bfd_target ();
4290
4cb93e3b 4291 while ((c = getopt_long (argc, argv,
6abcee90 4292 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
252b5132
RH
4293 long_options, (int *) 0))
4294 != EOF)
4295 {
252b5132
RH
4296 switch (c)
4297 {
4298 case 0:
8b53311e 4299 break; /* We've been given a long option. */
252b5132
RH
4300 case 'm':
4301 machine = optarg;
4302 break;
dd92f639 4303 case 'M':
65b48a81
PB
4304 {
4305 char *options;
4306 if (disassembler_options)
4307 /* Ignore potential memory leak for now. */
4308 options = concat (disassembler_options, ",",
4309 optarg, (const char *) NULL);
4310 else
4311 options = optarg;
4312 disassembler_options = remove_whitespace_and_extra_commas (options);
4313 }
dd92f639 4314 break;
252b5132 4315 case 'j':
70ecb384 4316 add_only (optarg);
252b5132 4317 break;
98ec6e72
NC
4318 case 'F':
4319 display_file_offsets = TRUE;
4320 break;
252b5132 4321 case 'l':
b34976b6 4322 with_line_numbers = TRUE;
252b5132
RH
4323 break;
4324 case 'b':
4325 target = optarg;
4326 break;
1dada9c5 4327 case 'C':
b34976b6 4328 do_demangle = TRUE;
28c309a2
NC
4329 if (optarg != NULL)
4330 {
4331 enum demangling_styles style;
8b53311e 4332
28c309a2 4333 style = cplus_demangle_name_to_style (optarg);
0af11b59 4334 if (style == unknown_demangling)
28c309a2
NC
4335 fatal (_("unknown demangling style `%s'"),
4336 optarg);
8b53311e 4337
28c309a2 4338 cplus_demangle_set_style (style);
0af11b59 4339 }
1dada9c5 4340 break;
af03af8f
NC
4341 case OPTION_RECURSE_LIMIT:
4342 demangle_flags &= ~ DMGL_NO_RECURSE_LIMIT;
4343 break;
4344 case OPTION_NO_RECURSE_LIMIT:
4345 demangle_flags |= DMGL_NO_RECURSE_LIMIT;
4346 break;
1dada9c5 4347 case 'w':
7b5d4822 4348 do_wide = wide_output = TRUE;
1dada9c5
NC
4349 break;
4350 case OPTION_ADJUST_VMA:
4351 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
4352 break;
4353 case OPTION_START_ADDRESS:
4354 start_address = parse_vma (optarg, "--start-address");
98ec6e72
NC
4355 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
4356 fatal (_("error: the start address should be before the end address"));
1dada9c5
NC
4357 break;
4358 case OPTION_STOP_ADDRESS:
4359 stop_address = parse_vma (optarg, "--stop-address");
98ec6e72
NC
4360 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
4361 fatal (_("error: the stop address should be after the start address"));
1dada9c5 4362 break;
0dafdf3f
L
4363 case OPTION_PREFIX:
4364 prefix = optarg;
4365 prefix_length = strlen (prefix);
4366 /* Remove an unnecessary trailing '/' */
4367 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
4368 prefix_length--;
4369 break;
4370 case OPTION_PREFIX_STRIP:
4371 prefix_strip = atoi (optarg);
4372 if (prefix_strip < 0)
4373 fatal (_("error: prefix strip must be non-negative"));
4374 break;
3dcb3fcb
L
4375 case OPTION_INSN_WIDTH:
4376 insn_width = strtoul (optarg, NULL, 0);
4377 if (insn_width <= 0)
4378 fatal (_("error: instruction width must be positive"));
4379 break;
4a14e306
AK
4380 case OPTION_INLINES:
4381 unwind_inlines = TRUE;
4382 break;
1dada9c5
NC
4383 case 'E':
4384 if (strcmp (optarg, "B") == 0)
4385 endian = BFD_ENDIAN_BIG;
4386 else if (strcmp (optarg, "L") == 0)
4387 endian = BFD_ENDIAN_LITTLE;
4388 else
4389 {
a8c62f1c 4390 nonfatal (_("unrecognized -E option"));
1dada9c5
NC
4391 usage (stderr, 1);
4392 }
4393 break;
4394 case OPTION_ENDIAN:
4395 if (strncmp (optarg, "big", strlen (optarg)) == 0)
4396 endian = BFD_ENDIAN_BIG;
4397 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
4398 endian = BFD_ENDIAN_LITTLE;
4399 else
4400 {
37cc8ec1 4401 non_fatal (_("unrecognized --endian type `%s'"), optarg);
a8c62f1c 4402 exit_status = 1;
1dada9c5
NC
4403 usage (stderr, 1);
4404 }
4405 break;
8b53311e 4406
252b5132 4407 case 'f':
b34976b6
AM
4408 dump_file_header = TRUE;
4409 seenflag = TRUE;
252b5132
RH
4410 break;
4411 case 'i':
b34976b6
AM
4412 formats_info = TRUE;
4413 seenflag = TRUE;
252b5132 4414 break;
43ac9881
AM
4415 case 'I':
4416 add_include_path (optarg);
4417 break;
252b5132 4418 case 'p':
b34976b6
AM
4419 dump_private_headers = TRUE;
4420 seenflag = TRUE;
252b5132 4421 break;
6abcee90
TG
4422 case 'P':
4423 dump_private_options = optarg;
4424 seenflag = TRUE;
4425 break;
252b5132 4426 case 'x':
b34976b6
AM
4427 dump_private_headers = TRUE;
4428 dump_symtab = TRUE;
4429 dump_reloc_info = TRUE;
4430 dump_file_header = TRUE;
4431 dump_ar_hdrs = TRUE;
4432 dump_section_headers = TRUE;
4433 seenflag = TRUE;
252b5132
RH
4434 break;
4435 case 't':
b34976b6
AM
4436 dump_symtab = TRUE;
4437 seenflag = TRUE;
252b5132
RH
4438 break;
4439 case 'T':
b34976b6
AM
4440 dump_dynamic_symtab = TRUE;
4441 seenflag = TRUE;
252b5132
RH
4442 break;
4443 case 'd':
b34976b6
AM
4444 disassemble = TRUE;
4445 seenflag = TRUE;
d3def5d7 4446 disasm_sym = optarg;
1dada9c5
NC
4447 break;
4448 case 'z':
b34976b6 4449 disassemble_zeroes = TRUE;
252b5132
RH
4450 break;
4451 case 'D':
b34976b6
AM
4452 disassemble = TRUE;
4453 disassemble_all = TRUE;
4454 seenflag = TRUE;
252b5132
RH
4455 break;
4456 case 'S':
b34976b6
AM
4457 disassemble = TRUE;
4458 with_source_code = TRUE;
4459 seenflag = TRUE;
1dada9c5
NC
4460 break;
4461 case 'g':
4462 dump_debugging = 1;
b34976b6 4463 seenflag = TRUE;
1dada9c5 4464 break;
51cdc6e0
NC
4465 case 'e':
4466 dump_debugging = 1;
4467 dump_debugging_tags = 1;
4468 do_demangle = TRUE;
4469 seenflag = TRUE;
4470 break;
365544c3
L
4471 case 'W':
4472 dump_dwarf_section_info = TRUE;
4473 seenflag = TRUE;
4cb93e3b
TG
4474 if (optarg)
4475 dwarf_select_sections_by_letters (optarg);
4476 else
4477 dwarf_select_sections_all ();
4478 break;
4479 case OPTION_DWARF:
4480 dump_dwarf_section_info = TRUE;
4481 seenflag = TRUE;
4482 if (optarg)
4483 dwarf_select_sections_by_names (optarg);
4484 else
4485 dwarf_select_sections_all ();
365544c3 4486 break;
fd2f0033
TT
4487 case OPTION_DWARF_DEPTH:
4488 {
4489 char *cp;
4490 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4491 }
4492 break;
4493 case OPTION_DWARF_START:
4494 {
4495 char *cp;
4496 dwarf_start_die = strtoul (optarg, & cp, 0);
4497 suppress_bfd_header = 1;
4498 }
4499 break;
4723351a
CC
4500 case OPTION_DWARF_CHECK:
4501 dwarf_check = TRUE;
4502 break;
7d9813f1
NA
4503 case OPTION_CTF:
4504 dump_ctf_section_info = TRUE;
4505 dump_ctf_section_name = xstrdup (optarg);
4506 seenflag = TRUE;
4507 break;
4508 case OPTION_CTF_PARENT:
4509 dump_ctf_parent_name = xstrdup (optarg);
4510 break;
1dada9c5 4511 case 'G':
b34976b6
AM
4512 dump_stab_section_info = TRUE;
4513 seenflag = TRUE;
252b5132
RH
4514 break;
4515 case 's':
b34976b6
AM
4516 dump_section_contents = TRUE;
4517 seenflag = TRUE;
252b5132
RH
4518 break;
4519 case 'r':
b34976b6
AM
4520 dump_reloc_info = TRUE;
4521 seenflag = TRUE;
252b5132
RH
4522 break;
4523 case 'R':
b34976b6
AM
4524 dump_dynamic_reloc_info = TRUE;
4525 seenflag = TRUE;
252b5132
RH
4526 break;
4527 case 'a':
b34976b6
AM
4528 dump_ar_hdrs = TRUE;
4529 seenflag = TRUE;
252b5132
RH
4530 break;
4531 case 'h':
b34976b6
AM
4532 dump_section_headers = TRUE;
4533 seenflag = TRUE;
252b5132 4534 break;
8b53311e 4535 case 'v':
252b5132 4536 case 'V':
b34976b6
AM
4537 show_version = TRUE;
4538 seenflag = TRUE;
252b5132 4539 break;
0af11b59 4540
aebcf7b7
NC
4541 case 'H':
4542 usage (stdout, 0);
4543 /* No need to set seenflag or to break - usage() does not return. */
252b5132
RH
4544 default:
4545 usage (stderr, 1);
4546 }
4547 }
4548
4549 if (show_version)
4550 print_version ("objdump");
4551
b34976b6 4552 if (!seenflag)
1dada9c5 4553 usage (stderr, 2);
252b5132
RH
4554
4555 if (formats_info)
06d86cf7 4556 exit_status = display_info ();
252b5132
RH
4557 else
4558 {
4559 if (optind == argc)
cd6581da 4560 display_file ("a.out", target, TRUE);
252b5132
RH
4561 else
4562 for (; optind < argc;)
cd6581da
NC
4563 {
4564 display_file (argv[optind], target, optind == argc - 1);
4565 optind++;
4566 }
252b5132
RH
4567 }
4568
70ecb384 4569 free_only_list ();
7d9813f1
NA
4570 free (dump_ctf_section_name);
4571 free (dump_ctf_parent_name);
79b377b3 4572
252b5132
RH
4573 END_PROGRESS (program_name);
4574
75cd796a 4575 return exit_status;
252b5132 4576}
This page took 1.121749 seconds and 4 git commands to generate.