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