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