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