1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Diddler.
6 BFD is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 BFD is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with BFD; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 * Until there is other documentation, refer to the manual page dump(1) in
22 * the system 5 program's reference manual
32 #define ELF_STAB_DISPLAY /* This code works, but uses internal
33 bfd and elf stuff. Flip this define
34 off if you need to just use generic
37 #ifdef ELF_STAB_DISPLAY
38 /* Internal headers for the ELF .stab-dump code - sorry. */
39 #define BYTES_IN_WORD 32
40 #include "aout/aout64.h"
41 #include "elf/internal.h"
42 extern Elf_Internal_Shdr
*bfd_elf_find_section();
43 #endif /* ELF_STAB_DISPLAY */
45 extern char *xmalloc ();
46 extern int fprintf ();
48 char *default_target
= NULL
; /* default at runtime */
50 extern *program_version
;
51 char *program_name
= NULL
;
53 int show_version
= 0; /* show the version number */
54 int dump_section_contents
; /* -s */
55 int dump_section_headers
; /* -h */
56 boolean dump_file_header
; /* -f */
57 int dump_symtab
; /* -t */
58 int dump_reloc_info
; /* -r */
59 int dump_ar_hdrs
; /* -a */
60 int with_line_numbers
; /* -l */
61 int dump_stab_section_info
; /* -stabs */
62 boolean disassemble
; /* -d */
63 boolean info
; /* -i */
66 char *machine
= (char *) NULL
;
72 unsigned int symcount
= 0;
74 /* Forward declarations. */
77 display_file
PARAMS ((char *filename
, char *target
));
80 dump_data
PARAMS ((bfd
*abfd
));
83 dump_relocs
PARAMS ((bfd
*abfd
));
86 dump_symbols
PARAMS ((bfd
*abfd
));
92 usage: %s [-ahifdrtxsl] [-m machine] [-j section_name]\n\
93 [--syms] [--reloc] [--header] [--version] obj ...\n",
98 static struct option long_options
[]=
100 {"syms", no_argument
, &dump_symtab
, 1},
101 {"reloc", no_argument
, &dump_reloc_info
, 1},
102 {"header", no_argument
, &dump_section_headers
, 1},
103 {"version", no_argument
, &show_version
, 1},
104 #ifdef ELF_STAB_DISPLAY
105 {"stabs", no_argument
, &dump_stab_section_info
, 1},
107 {0, no_argument
, 0, 0}};
116 for (section
= abfd
->sections
;
117 section
!= (asection
*) NULL
;
118 section
= section
->next
)
123 if (section->flags & x) { printf("%s%s",comma,y); comma = ", "; }
126 printf ("SECTION %d [%s]\t: size %08x",
129 (unsigned) bfd_get_section_size_before_reloc (section
));
131 printf_vma (section
->vma
);
132 printf (" align 2**%u\n ",
133 section
->alignment_power
);
134 PF (SEC_ALLOC
, "ALLOC");
135 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
136 PF (SEC_CONSTRUCTOR_TEXT
, "CONSTRUCTOR TEXT");
137 PF (SEC_CONSTRUCTOR_DATA
, "CONSTRUCTOR DATA");
138 PF (SEC_CONSTRUCTOR_BSS
, "CONSTRUCTOR BSS");
139 PF (SEC_LOAD
, "LOAD");
140 PF (SEC_RELOC
, "RELOC");
141 PF (SEC_BALIGN
, "BALIGN");
142 PF (SEC_READONLY
, "READONLY");
143 PF (SEC_CODE
, "CODE");
144 PF (SEC_DATA
, "DATA");
152 DEFUN (slurp_symtab
, (abfd
),
155 asymbol
**sy
= (asymbol
**) NULL
;
157 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
159 (void) printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd
));
163 storage
= get_symtab_upper_bound (abfd
);
166 sy
= (asymbol
**) malloc (storage
);
169 fprintf (stderr
, "%s: out of memory.\n", program_name
);
173 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
177 /* Sort symbols into value order */
183 asymbol
*a
= *(asymbol
**)ap
;
184 asymbol
*b
= *(asymbol
**)bp
;
188 if (a
->name
== (char *) NULL
|| (a
->flags
& (BSF_DEBUGGING
)))
191 a_bfd
= bfd_asymbol_bfd(a
);
192 if (b
->name
== (char *) NULL
|| (b
->flags
& (BSF_DEBUGGING
)))
195 b_bfd
= bfd_asymbol_bfd(b
);
197 diff
= a_bfd
- b_bfd
;
202 diff
= a
->value
- b
->value
;
207 return a
->section
- b
->section
;
210 /* Print the supplied address symbolically if possible */
212 print_address (vma
, stream
)
216 /* Perform a binary search looking for the closest symbol to
217 the required value */
219 unsigned int min
= 0;
220 unsigned int max
= symcount
;
222 unsigned int thisplace
= 1;
223 unsigned int oldthisplace
;
229 fprintf_vma (stream
, vma
);
235 oldthisplace
= thisplace
;
236 thisplace
= (max
+ min
) / 2;
237 if (thisplace
== oldthisplace
)
239 vardiff
= syms
[thisplace
]->value
- vma
;
242 /* Check that the value isn't merely a coincidence.
243 (if not checked, we might print some undefined symbol
244 for the address 0 rather than "main", for example. */
245 || !(syms
[thisplace
]->flags
& (BSF_GLOBAL
|BSF_LOCAL
)))
258 /* Totally awesome! the exact right symbol */
259 CONST
char *match_name
= syms
[thisplace
]->name
;
260 int sym_len
= strlen (match_name
);
262 /* Avoid "filename.o" as a match */
264 && match_name
[sym_len
- 2] == '.'
265 && match_name
[sym_len
- 1] == 'o'
266 && thisplace
+ 1 < symcount
267 && syms
[thisplace
+ 1]->value
== vma
)
268 match_name
= syms
[thisplace
+ 1]->name
;
269 /* Totally awesome! the exact right symbol */
270 fprintf_vma (stream
, vma
);
271 fprintf (stream
, " (%s+)0000", syms
[thisplace
]->name
);
275 /* We've run out of places to look, print the symbol before this one
276 see if this or the symbol before describes this location the best */
280 if (syms
[thisplace
- 1]->value
- vma
>
281 syms
[thisplace
]->value
- vma
)
283 /* Previous symbol is in correct section and is closer */
288 fprintf_vma (stream
, vma
);
289 if (syms
[thisplace
]->value
> vma
)
291 fprintf (stream
, " (%s-)", syms
[thisplace
]->name
);
292 fprintf (stream
, "%04x", syms
[thisplace
]->value
- vma
);
296 fprintf (stream
, " (%s+)", syms
[thisplace
]->name
);
297 fprintf (stream
, "%04x", vma
- syms
[thisplace
]->value
);
303 disassemble_data (abfd
)
306 bfd_byte
*data
= NULL
;
307 bfd_arch_info_type
*info
;
308 bfd_size_type datasize
= 0;
310 unsigned int (*print
) ()= 0; /* Old style */
311 disassembler_ftype disassemble
= 0; /* New style */
312 unsigned int print_insn_a29k ();
313 unsigned int print_insn_i960 ();
314 unsigned int print_insn_sparc ();
315 unsigned int print_insn_h8300 ();
316 enum bfd_architecture a
;
317 struct disassemble_info disasm_info
;
320 CONST
char *prev_function
= "";
324 /* Replace symbol section relative values with abs values */
325 boolean done_dot
= false;
327 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
);
329 for (i
= 0; i
< symcount
; i
++)
331 syms
[i
]->value
+= syms
[i
]->section
->vma
;
334 /* We keep a copy of the symbols in the original order */
335 syms2
= slurp_symtab (abfd
);
337 /* Sort the symbols into section and symbol order */
338 (void) qsort (syms
, symcount
, sizeof (asymbol
*), comp
);
340 /* Find the first useless symbol */
344 for (i
= 0; i
< symcount
; i
++)
346 if (syms
[i
]->name
== (char *) NULL
347 || (syms
[i
]->flags
& BSF_DEBUGGING
) != 0)
356 if (machine
!= (char *) NULL
)
358 info
= bfd_scan_arch (machine
);
361 fprintf (stderr
, "%s: Can't use supplied machine %s\n",
366 abfd
->arch_info
= info
;
369 /* See if we can disassemble using bfd */
371 if (abfd
->arch_info
->disassemble
)
373 print
= abfd
->arch_info
->disassemble
;
377 a
= bfd_get_arch (abfd
);
381 print
= print_insn_sparc
;
384 if (bfd_get_mach(abfd
) == bfd_mach_z8001
)
385 disassemble
= print_insn_z8001
;
387 disassemble
= print_insn_z8002
;
390 disassemble
= print_insn_i386
;
393 disassemble
= print_insn_m68k
;
396 print
= print_insn_a29k
;
399 print
= print_insn_i960
;
402 if (abfd
->xvec
->byteorder_big_p
)
403 disassemble
= print_insn_big_mips
;
405 disassemble
= print_insn_little_mips
;
408 fprintf (stderr
, "%s: Can't disassemble for architecture %s\n",
410 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
416 for (section
= abfd
->sections
;
417 section
!= (asection
*) NULL
;
418 section
= section
->next
)
421 if ((section
->flags
& SEC_LOAD
)
422 && (only
== (char *) NULL
|| strcmp (only
, section
->name
) == 0))
424 printf ("Disassembly of section %s:\n", section
->name
);
426 if (bfd_get_section_size_before_reloc (section
) == 0)
429 data
= (bfd_byte
*) malloc (bfd_get_section_size_before_reloc (section
));
431 if (data
== (bfd_byte
*) NULL
)
433 fprintf (stderr
, "%s: memory exhausted.\n", program_name
);
436 datasize
= bfd_get_section_size_before_reloc (section
);
438 bfd_get_section_contents (abfd
, section
, data
, 0, bfd_get_section_size_before_reloc (section
));
441 while (i
< bfd_get_section_size_before_reloc (section
))
443 if (data
[i
] == 0 && data
[i
+ 1] == 0 && data
[i
+ 2] == 0 &&
446 if (done_dot
== false)
456 if (with_line_numbers
)
458 CONST
char *filename
;
459 CONST
char *functionname
;
462 if (bfd_find_nearest_line (abfd
,
470 if (functionname
&& *functionname
471 && strcmp(functionname
, prev_function
))
473 printf ("%s():\n", functionname
);
474 prev_function
= functionname
;
478 if (line
&& line
!= prevline
)
480 printf ("%s:%u\n", filename
, line
);
485 print_address (section
->vma
+ i
, stdout
);
488 if (disassemble
) /* New style */
489 i
+= (*disassemble
)(section
->vma
+ i
,
493 i
+= print (section
->vma
+ i
,
504 #ifdef ELF_STAB_DISPLAY
506 /* Define a table of stab values and print-strings. We wish the initializer
507 could be a direct-mapped table, but instead we build one the first
510 #define STAB_STRING_LENGTH 6
512 char stab_name
[256][STAB_STRING_LENGTH
];
516 char string
[STAB_STRING_LENGTH
];
519 struct stab_print stab_print
[] = {
520 #define __define_stab(NAME, CODE, STRING) {CODE, STRING},
521 #include "aout/stab.def"
526 void dump_elf_stabs_1 ();
528 /* This is a kludge for dumping the stabs section from an ELF file that
529 uses Sun stabs encoding. It has to use some hooks into BFD because
530 string table sections are not normally visible to BFD callers. */
533 dump_elf_stabs (abfd
)
538 /* Initialize stab name array if first time. */
539 if (stab_name
[0][0] == 0)
541 /* Fill in numeric values for all possible strings. */
542 for (i
= 0; i
< 256; i
++)
544 sprintf (stab_name
[i
], "%d", i
);
546 for (i
= 0; stab_print
[i
].string
[0]; i
++)
547 strcpy (stab_name
[stab_print
[i
].value
], stab_print
[i
].string
);
550 if (0 != strncmp ("elf", abfd
->xvec
->name
, 3))
552 fprintf (stderr
, "%s: %s is not in ELF format.\n", program_name
,
557 dump_elf_stabs_1 (abfd
, ".stab", ".stabstr");
558 dump_elf_stabs_1 (abfd
, ".stab.excl", ".stab.exclstr");
559 dump_elf_stabs_1 (abfd
, ".stab.index", ".stab.indexstr");
563 dump_elf_stabs_1 (abfd
, name1
, name2
)
565 char *name1
; /* Section name of .stab */
566 char *name2
; /* Section name of its string section */
568 Elf_Internal_Shdr
*stab_hdr
, *stabstr_hdr
;
570 struct internal_nlist
*stabs
, *stabs_end
;
572 unsigned file_string_table_offset
, next_file_string_table_offset
;
574 stab_hdr
= bfd_elf_find_section (abfd
, name1
);
577 printf ("Contents of %s section: none.\n\n", name1
);
581 stabstr_hdr
= bfd_elf_find_section (abfd
, name2
);
582 if (0 == stabstr_hdr
)
584 fprintf (stderr
, "%s: %s has no %s section.\n", program_name
,
585 abfd
->filename
, name2
);
589 stabs
= (struct internal_nlist
*) xmalloc (stab_hdr
->sh_size
);
590 strtab
= (char *) xmalloc (stabstr_hdr
->sh_size
);
591 stabs_end
= (struct internal_nlist
*) (stab_hdr
->sh_size
+ (char *)stabs
);
593 if (bfd_seek (abfd
, stab_hdr
->sh_offset
, SEEK_SET
) < 0 ||
594 stab_hdr
->sh_size
!= bfd_read ((PTR
)stabs
, stab_hdr
->sh_size
, 1, abfd
))
596 fprintf (stderr
, "%s: reading %s section of %s failed.\n",
602 if (bfd_seek (abfd
, stabstr_hdr
->sh_offset
, SEEK_SET
) < 0 ||
603 stabstr_hdr
->sh_size
!= bfd_read ((PTR
)strtab
, stabstr_hdr
->sh_size
,
606 fprintf (stderr
, "%s: reading %s section of %s failed.\n",
612 #define SWAP_SYMBOL(symp, abfd) \
614 (symp)->n_strx = bfd_h_get_32(abfd, \
615 (unsigned char *)&(symp)->n_strx); \
616 (symp)->n_desc = bfd_h_get_16 (abfd, \
617 (unsigned char *)&(symp)->n_desc); \
618 (symp)->n_value = bfd_h_get_32 (abfd, \
619 (unsigned char *)&(symp)->n_value); \
622 printf ("Contents of %s section:\n\n", name1
);
623 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
625 file_string_table_offset
= 0;
626 next_file_string_table_offset
= 0;
628 /* Loop through all symbols and print them.
630 We start the index at -1 because there is a dummy symbol on
631 the front of Sun's stabs-in-elf sections. */
633 for (i
= -1; stabs
< stabs_end
; stabs
++, i
++)
635 SWAP_SYMBOL (stabs
, abfd
);
636 printf ("\n%-6d %-6s %-6d %-6d %08x %-6d", i
,
637 stab_name
[stabs
->n_type
],
638 stabs
->n_other
, stabs
->n_desc
, stabs
->n_value
,
641 /* Symbols with type == 0 (N_UNDF) specify the length of the
642 string table associated with this file. We use that info
643 to know how to relocate the *next* file's string table indices. */
645 if (stabs
->n_type
== N_UNDF
)
647 file_string_table_offset
= next_file_string_table_offset
;
648 next_file_string_table_offset
+= stabs
->n_value
;
651 /* Now, using the possibly updated string table offset, print the
652 string (if any) associated with this symbol. */
654 if ((stabs
->n_strx
+ file_string_table_offset
) < stabstr_hdr
->sh_size
)
655 printf (" %s", &strtab
[stabs
->n_strx
+ file_string_table_offset
]);
661 #endif /* ELF_STAB_DISPLAY */
667 if (!bfd_check_format (abfd
, bfd_object
))
669 fprintf (stderr
, "%s: %s not an object file\n", program_name
,
673 printf ("\n%s: file format %s\n", abfd
->filename
, abfd
->xvec
->name
);
675 print_arelt_descr (stdout
, abfd
, true);
677 if (dump_file_header
)
681 printf ("architecture: %s, ",
682 bfd_printable_arch_mach (bfd_get_arch (abfd
),
683 bfd_get_mach (abfd
)));
684 printf ("flags 0x%08x:\n", abfd
->flags
);
686 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
687 PF (HAS_RELOC
, "HAS_RELOC");
688 PF (EXEC_P
, "EXEC_P");
689 PF (HAS_LINENO
, "HAS_LINENO");
690 PF (HAS_DEBUG
, "HAS_DEBUG");
691 PF (HAS_SYMS
, "HAS_SYMS");
692 PF (HAS_LOCALS
, "HAS_LOCALS");
693 PF (DYNAMIC
, "DYNAMIC");
694 PF (WP_TEXT
, "WP_TEXT");
695 PF (D_PAGED
, "D_PAGED");
696 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
697 printf ("\nstart address 0x");
698 printf_vma (abfd
->start_address
);
702 if (dump_section_headers
)
704 if (dump_symtab
|| dump_reloc_info
|| disassemble
)
706 syms
= slurp_symtab (abfd
);
710 #ifdef ELF_STAB_DISPLAY
711 if (dump_stab_section_info
)
712 dump_elf_stabs (abfd
);
716 if (dump_section_contents
)
719 disassemble_data (abfd
);
723 display_file (filename
, target
)
727 bfd
*file
, *arfile
= (bfd
*) NULL
;
729 file
= bfd_openr (filename
, target
);
732 bfd_perror (filename
);
736 if (bfd_check_format (file
, bfd_archive
) == true)
738 printf ("In archive %s:\n", bfd_get_filename (file
));
741 bfd_error
= no_error
;
743 arfile
= bfd_openr_next_archived_file (file
, arfile
);
746 if (bfd_error
!= no_more_archived_files
)
747 bfd_perror (bfd_get_filename (file
));
751 display_bfd (arfile
);
752 /* Don't close the archive elements; we need them for next_archive */
761 /* Actually display the various requested regions */
769 bfd_size_type datasize
= 0;
772 for (section
= abfd
->sections
; section
!= NULL
; section
=
777 if (only
== (char *) NULL
||
778 strcmp (only
, section
->name
) == 0)
780 if (section
->flags
& SEC_HAS_CONTENTS
)
782 printf ("Contents of section %s:\n", section
->name
);
784 if (bfd_get_section_size_before_reloc (section
) == 0)
786 data
= (bfd_byte
*) malloc (bfd_get_section_size_before_reloc (section
));
787 if (data
== (bfd_byte
*) NULL
)
789 fprintf (stderr
, "%s: memory exhausted.\n", program_name
);
792 datasize
= bfd_get_section_size_before_reloc (section
);
795 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_get_section_size_before_reloc (section
));
797 for (i
= 0; i
< bfd_get_section_size_before_reloc (section
); i
+= onaline
)
801 printf (" %04lx ", (unsigned long int) (i
+ section
->vma
));
802 for (j
= i
; j
< i
+ onaline
; j
++)
804 if (j
< bfd_get_section_size_before_reloc (section
))
805 printf ("%02x", (unsigned) (data
[j
]));
813 for (j
= i
; j
< i
+ onaline
; j
++)
815 if (j
>= bfd_get_section_size_before_reloc (section
))
818 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
828 /* Should perhaps share code and display with nm? */
835 asymbol
**current
= syms
;
837 printf ("SYMBOL TABLE:\n");
839 for (count
= 0; count
< symcount
; count
++)
844 bfd
*cur_bfd
= bfd_asymbol_bfd(*current
);
847 bfd_print_symbol (cur_bfd
,
849 *current
, bfd_print_symbol_all
);
865 unsigned int relcount
;
868 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
870 if (a
== &bfd_abs_section
)
872 if (a
== &bfd_und_section
)
874 if (bfd_is_com_section (a
))
877 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
879 if (bfd_get_reloc_upper_bound (abfd
, a
) == 0)
881 printf (" (none)\n\n");
887 relpp
= (arelent
**) xmalloc (bfd_get_reloc_upper_bound (abfd
, a
));
888 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
891 printf (" (none)\n\n");
896 printf ("OFFSET TYPE VALUE \n");
898 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++,
902 CONST
char *sym_name
;
904 /* CONST char *section_name = q->section == (asection *)NULL ? "*abs" :*/
905 /* q->section->name;*/
906 CONST
char *section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
908 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
910 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
918 printf_vma (q
->address
);
925 printf_vma (q
->address
);
926 printf (" %-8s [%s]",
933 printf_vma (q
->addend
);
946 #define _DUMMY_NAME_ "/dev/null"
948 #define _DUMMY_NAME_ "##dummy"
951 DEFUN (display_info_table
, (first
, last
),
952 int first AND
int last
)
955 extern bfd_target
*target_vector
[];
957 printf ("\n%12s", " ");
958 for (i
= first
; i
++ < last
&& target_vector
[i
];)
959 printf ("%s ", target_vector
[i
]->name
);
962 for (j
= (int) bfd_arch_obscure
+ 1; (int) j
< (int) bfd_arch_last
; j
++)
963 if (strcmp (bfd_printable_arch_mach (j
, 0), "UNKNOWN!") != 0)
965 printf ("%11s ", bfd_printable_arch_mach (j
, 0));
966 for (i
= first
; i
++ < last
&& target_vector
[i
];)
968 bfd_target
*p
= target_vector
[i
];
969 bfd
*abfd
= bfd_openw (_DUMMY_NAME_
, p
->name
);
970 int l
= strlen (p
->name
);
972 bfd_set_format (abfd
, bfd_object
);
973 ok
= bfd_set_arch_mach (abfd
, j
, 0);
976 printf ("%s ", p
->name
);
980 printf ("%c", ok
? '*' : '-');
989 DEFUN_VOID (display_info
)
992 unsigned int i
, j
, columns
;
993 extern bfd_target
*target_vector
[];
994 extern char *getenv ();
996 printf ("BFD header file version %s\n", BFD_VERSION
);
997 for (i
= 0; target_vector
[i
]; i
++)
999 bfd_target
*p
= target_vector
[i
];
1000 bfd
*abfd
= bfd_openw (_DUMMY_NAME_
, p
->name
);
1001 bfd_set_format (abfd
, bfd_object
);
1002 printf ("%s\n (header %s, data %s)\n", p
->name
,
1003 p
->header_byteorder_big_p
? "big endian" : "little endian",
1004 p
->byteorder_big_p
? "big endian" : "little endian");
1005 for (j
= (int) bfd_arch_obscure
+ 1; j
< (int) bfd_arch_last
; j
++)
1006 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) j
, 0))
1008 bfd_printable_arch_mach ((enum bfd_architecture
) j
, 0));
1011 if (colum
= getenv ("COLUMNS"))
1012 columns
= atoi (colum
);
1015 for (i
= 0; target_vector
[i
];)
1019 for (j
= 12; target_vector
[i
] && j
< columns
; i
++)
1020 j
+= strlen (target_vector
[i
]->name
) + 1;
1024 display_info_table (old
, i
);
1028 /** main and like trivia */
1036 extern char *optarg
;
1037 char *target
= default_target
;
1038 boolean seenflag
= false;
1042 program_name
= *argv
;
1044 while ((c
= getopt_long (argc
, argv
, "ib:m:Vdlfahrtxsj:", long_options
, &ind
))
1057 with_line_numbers
= 1;
1063 dump_file_header
= true;
1070 dump_reloc_info
= 1;
1071 dump_file_header
= true;
1073 dump_section_headers
= 1;
1076 break; /* we've been given a long option */
1084 dump_section_contents
= 1;
1087 dump_reloc_info
= 1;
1093 dump_section_headers
= 1;
1104 printf ("%s version %s\n", program_name
, program_version
);
1106 if (seenflag
== false)
1116 display_file ("a.out", target
);
1118 for (; optind
< argc
;)
1119 display_file (argv
[optind
++], target
);