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
PARAMS ((FILE *, CONST
char *, ...));
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_h8300 ();
315 enum bfd_architecture a
;
316 struct disassemble_info disasm_info
;
319 CONST
char *prev_function
= "";
323 /* Replace symbol section relative values with abs values */
324 boolean done_dot
= false;
326 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
);
328 for (i
= 0; i
< symcount
; i
++)
330 syms
[i
]->value
+= syms
[i
]->section
->vma
;
333 /* We keep a copy of the symbols in the original order */
334 syms2
= slurp_symtab (abfd
);
336 /* Sort the symbols into section and symbol order */
337 (void) qsort (syms
, symcount
, sizeof (asymbol
*), comp
);
339 /* Find the first useless symbol */
343 for (i
= 0; i
< symcount
; i
++)
345 if (syms
[i
]->name
== (char *) NULL
346 || (syms
[i
]->flags
& BSF_DEBUGGING
) != 0)
355 if (machine
!= (char *) NULL
)
357 info
= bfd_scan_arch (machine
);
360 fprintf (stderr
, "%s: Can't use supplied machine %s\n",
365 abfd
->arch_info
= info
;
368 /* See if we can disassemble using bfd */
370 if (abfd
->arch_info
->disassemble
)
372 print
= abfd
->arch_info
->disassemble
;
376 a
= bfd_get_arch (abfd
);
380 disassemble
= print_insn_sparc
;
383 if (bfd_get_mach(abfd
) == bfd_mach_z8001
)
384 disassemble
= print_insn_z8001
;
386 disassemble
= print_insn_z8002
;
389 disassemble
= print_insn_i386
;
392 disassemble
= print_insn_h8500
;
395 disassemble
= print_insn_m68k
;
398 print
= print_insn_a29k
;
401 print
= print_insn_i960
;
404 if (abfd
->xvec
->byteorder_big_p
)
405 disassemble
= print_insn_big_mips
;
407 disassemble
= print_insn_little_mips
;
410 fprintf (stderr
, "%s: Can't disassemble for architecture %s\n",
412 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
418 for (section
= abfd
->sections
;
419 section
!= (asection
*) NULL
;
420 section
= section
->next
)
423 if ((section
->flags
& SEC_LOAD
)
424 && (only
== (char *) NULL
|| strcmp (only
, section
->name
) == 0))
426 printf ("Disassembly of section %s:\n", section
->name
);
428 if (bfd_get_section_size_before_reloc (section
) == 0)
431 data
= (bfd_byte
*) malloc (bfd_get_section_size_before_reloc (section
));
433 if (data
== (bfd_byte
*) NULL
)
435 fprintf (stderr
, "%s: memory exhausted.\n", program_name
);
438 datasize
= bfd_get_section_size_before_reloc (section
);
440 bfd_get_section_contents (abfd
, section
, data
, 0, bfd_get_section_size_before_reloc (section
));
442 disasm_info
.buffer
= data
;
443 disasm_info
.buffer_vma
= section
->vma
;
444 disasm_info
.buffer_length
=
445 bfd_get_section_size_before_reloc (section
);
447 while (i
< disasm_info
.buffer_length
)
449 if (data
[i
] == 0 && data
[i
+ 1] == 0 && data
[i
+ 2] == 0 &&
452 if (done_dot
== false)
462 if (with_line_numbers
)
464 CONST
char *filename
;
465 CONST
char *functionname
;
468 if (bfd_find_nearest_line (abfd
,
476 if (functionname
&& *functionname
477 && strcmp(functionname
, prev_function
))
479 printf ("%s():\n", functionname
);
480 prev_function
= functionname
;
484 if (line
&& line
!= prevline
)
486 printf ("%s:%u\n", filename
, line
);
491 print_address (section
->vma
+ i
, stdout
);
494 if (disassemble
) /* New style */
496 int bytes
= (*disassemble
)(section
->vma
+ i
,
503 i
+= print (section
->vma
+ i
,
514 #ifdef ELF_STAB_DISPLAY
516 /* Define a table of stab values and print-strings. We wish the initializer
517 could be a direct-mapped table, but instead we build one the first
520 #define STAB_STRING_LENGTH 6
522 char stab_name
[256][STAB_STRING_LENGTH
];
526 char string
[STAB_STRING_LENGTH
];
529 struct stab_print stab_print
[] = {
530 #define __define_stab(NAME, CODE, STRING) {CODE, STRING},
531 #include "aout/stab.def"
536 void dump_elf_stabs_1 ();
538 /* This is a kludge for dumping the stabs section from an ELF file that
539 uses Sun stabs encoding. It has to use some hooks into BFD because
540 string table sections are not normally visible to BFD callers. */
543 dump_elf_stabs (abfd
)
548 /* Initialize stab name array if first time. */
549 if (stab_name
[0][0] == 0)
551 /* Fill in numeric values for all possible strings. */
552 for (i
= 0; i
< 256; i
++)
554 sprintf (stab_name
[i
], "%d", i
);
556 for (i
= 0; stab_print
[i
].string
[0]; i
++)
557 strcpy (stab_name
[stab_print
[i
].value
], stab_print
[i
].string
);
560 if (0 != strncmp ("elf", abfd
->xvec
->name
, 3))
562 fprintf (stderr
, "%s: %s is not in ELF format.\n", program_name
,
567 dump_elf_stabs_1 (abfd
, ".stab", ".stabstr");
568 dump_elf_stabs_1 (abfd
, ".stab.excl", ".stab.exclstr");
569 dump_elf_stabs_1 (abfd
, ".stab.index", ".stab.indexstr");
573 dump_elf_stabs_1 (abfd
, name1
, name2
)
575 char *name1
; /* Section name of .stab */
576 char *name2
; /* Section name of its string section */
578 Elf_Internal_Shdr
*stab_hdr
, *stabstr_hdr
;
580 struct internal_nlist
*stabs
, *stabs_end
;
582 unsigned file_string_table_offset
, next_file_string_table_offset
;
584 stab_hdr
= bfd_elf_find_section (abfd
, name1
);
587 printf ("Contents of %s section: none.\n\n", name1
);
591 stabstr_hdr
= bfd_elf_find_section (abfd
, name2
);
592 if (0 == stabstr_hdr
)
594 fprintf (stderr
, "%s: %s has no %s section.\n", program_name
,
595 abfd
->filename
, name2
);
599 stabs
= (struct internal_nlist
*) xmalloc (stab_hdr
->sh_size
);
600 strtab
= (char *) xmalloc (stabstr_hdr
->sh_size
);
601 stabs_end
= (struct internal_nlist
*) (stab_hdr
->sh_size
+ (char *)stabs
);
603 if (bfd_seek (abfd
, stab_hdr
->sh_offset
, SEEK_SET
) < 0 ||
604 stab_hdr
->sh_size
!= bfd_read ((PTR
)stabs
, stab_hdr
->sh_size
, 1, abfd
))
606 fprintf (stderr
, "%s: reading %s section of %s failed.\n",
612 if (bfd_seek (abfd
, stabstr_hdr
->sh_offset
, SEEK_SET
) < 0 ||
613 stabstr_hdr
->sh_size
!= bfd_read ((PTR
)strtab
, stabstr_hdr
->sh_size
,
616 fprintf (stderr
, "%s: reading %s section of %s failed.\n",
622 #define SWAP_SYMBOL(symp, abfd) \
624 (symp)->n_strx = bfd_h_get_32(abfd, \
625 (unsigned char *)&(symp)->n_strx); \
626 (symp)->n_desc = bfd_h_get_16 (abfd, \
627 (unsigned char *)&(symp)->n_desc); \
628 (symp)->n_value = bfd_h_get_32 (abfd, \
629 (unsigned char *)&(symp)->n_value); \
632 printf ("Contents of %s section:\n\n", name1
);
633 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
635 file_string_table_offset
= 0;
636 next_file_string_table_offset
= 0;
638 /* Loop through all symbols and print them.
640 We start the index at -1 because there is a dummy symbol on
641 the front of Sun's stabs-in-elf sections. */
643 for (i
= -1; stabs
< stabs_end
; stabs
++, i
++)
645 SWAP_SYMBOL (stabs
, abfd
);
646 printf ("\n%-6d %-6s %-6d %-6d %08x %-6d", i
,
647 stab_name
[stabs
->n_type
],
648 stabs
->n_other
, stabs
->n_desc
, stabs
->n_value
,
651 /* Symbols with type == 0 (N_UNDF) specify the length of the
652 string table associated with this file. We use that info
653 to know how to relocate the *next* file's string table indices. */
655 if (stabs
->n_type
== N_UNDF
)
657 file_string_table_offset
= next_file_string_table_offset
;
658 next_file_string_table_offset
+= stabs
->n_value
;
661 /* Now, using the possibly updated string table offset, print the
662 string (if any) associated with this symbol. */
664 if ((stabs
->n_strx
+ file_string_table_offset
) < stabstr_hdr
->sh_size
)
665 printf (" %s", &strtab
[stabs
->n_strx
+ file_string_table_offset
]);
671 #endif /* ELF_STAB_DISPLAY */
677 if (!bfd_check_format (abfd
, bfd_object
))
679 fprintf (stderr
, "%s: %s not an object file\n", program_name
,
683 printf ("\n%s: file format %s\n", abfd
->filename
, abfd
->xvec
->name
);
685 print_arelt_descr (stdout
, abfd
, true);
687 if (dump_file_header
)
691 printf ("architecture: %s, ",
692 bfd_printable_arch_mach (bfd_get_arch (abfd
),
693 bfd_get_mach (abfd
)));
694 printf ("flags 0x%08x:\n", abfd
->flags
);
696 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
697 PF (HAS_RELOC
, "HAS_RELOC");
698 PF (EXEC_P
, "EXEC_P");
699 PF (HAS_LINENO
, "HAS_LINENO");
700 PF (HAS_DEBUG
, "HAS_DEBUG");
701 PF (HAS_SYMS
, "HAS_SYMS");
702 PF (HAS_LOCALS
, "HAS_LOCALS");
703 PF (DYNAMIC
, "DYNAMIC");
704 PF (WP_TEXT
, "WP_TEXT");
705 PF (D_PAGED
, "D_PAGED");
706 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
707 printf ("\nstart address 0x");
708 printf_vma (abfd
->start_address
);
712 if (dump_section_headers
)
714 if (dump_symtab
|| dump_reloc_info
|| disassemble
)
716 syms
= slurp_symtab (abfd
);
720 #ifdef ELF_STAB_DISPLAY
721 if (dump_stab_section_info
)
722 dump_elf_stabs (abfd
);
726 if (dump_section_contents
)
729 disassemble_data (abfd
);
733 display_file (filename
, target
)
737 bfd
*file
, *arfile
= (bfd
*) NULL
;
739 file
= bfd_openr (filename
, target
);
742 bfd_perror (filename
);
746 if (bfd_check_format (file
, bfd_archive
) == true)
748 printf ("In archive %s:\n", bfd_get_filename (file
));
751 bfd_error
= no_error
;
753 arfile
= bfd_openr_next_archived_file (file
, arfile
);
756 if (bfd_error
!= no_more_archived_files
)
757 bfd_perror (bfd_get_filename (file
));
761 display_bfd (arfile
);
762 /* Don't close the archive elements; we need them for next_archive */
771 /* Actually display the various requested regions */
779 bfd_size_type datasize
= 0;
782 for (section
= abfd
->sections
; section
!= NULL
; section
=
787 if (only
== (char *) NULL
||
788 strcmp (only
, section
->name
) == 0)
790 if (section
->flags
& SEC_HAS_CONTENTS
)
792 printf ("Contents of section %s:\n", section
->name
);
794 if (bfd_get_section_size_before_reloc (section
) == 0)
796 data
= (bfd_byte
*) malloc (bfd_get_section_size_before_reloc (section
));
797 if (data
== (bfd_byte
*) NULL
)
799 fprintf (stderr
, "%s: memory exhausted.\n", program_name
);
802 datasize
= bfd_get_section_size_before_reloc (section
);
805 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_get_section_size_before_reloc (section
));
807 for (i
= 0; i
< bfd_get_section_size_before_reloc (section
); i
+= onaline
)
811 printf (" %04lx ", (unsigned long int) (i
+ section
->vma
));
812 for (j
= i
; j
< i
+ onaline
; j
++)
814 if (j
< bfd_get_section_size_before_reloc (section
))
815 printf ("%02x", (unsigned) (data
[j
]));
823 for (j
= i
; j
< i
+ onaline
; j
++)
825 if (j
>= bfd_get_section_size_before_reloc (section
))
828 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
838 /* Should perhaps share code and display with nm? */
845 asymbol
**current
= syms
;
847 printf ("SYMBOL TABLE:\n");
849 for (count
= 0; count
< symcount
; count
++)
854 bfd
*cur_bfd
= bfd_asymbol_bfd(*current
);
857 bfd_print_symbol (cur_bfd
,
859 *current
, bfd_print_symbol_all
);
875 unsigned int relcount
;
878 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
880 if (a
== &bfd_abs_section
)
882 if (a
== &bfd_und_section
)
884 if (bfd_is_com_section (a
))
887 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
889 if (bfd_get_reloc_upper_bound (abfd
, a
) == 0)
891 printf (" (none)\n\n");
897 relpp
= (arelent
**) xmalloc (bfd_get_reloc_upper_bound (abfd
, a
));
898 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
901 printf (" (none)\n\n");
906 printf ("OFFSET TYPE VALUE \n");
908 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++,
912 CONST
char *sym_name
;
914 /* CONST char *section_name = q->section == (asection *)NULL ? "*abs" :*/
915 /* q->section->name;*/
916 CONST
char *section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
918 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
920 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
928 printf_vma (q
->address
);
935 printf_vma (q
->address
);
936 printf (" %-8s [%s]",
943 printf_vma (q
->addend
);
956 #define _DUMMY_NAME_ "/dev/null"
958 #define _DUMMY_NAME_ "##dummy"
961 DEFUN (display_info_table
, (first
, last
),
962 int first AND
int last
)
965 extern bfd_target
*target_vector
[];
967 printf ("\n%12s", " ");
968 for (i
= first
; i
++ < last
&& target_vector
[i
];)
969 printf ("%s ", target_vector
[i
]->name
);
972 for (j
= (int) bfd_arch_obscure
+ 1; (int) j
< (int) bfd_arch_last
; j
++)
973 if (strcmp (bfd_printable_arch_mach (j
, 0), "UNKNOWN!") != 0)
975 printf ("%11s ", bfd_printable_arch_mach (j
, 0));
976 for (i
= first
; i
++ < last
&& target_vector
[i
];)
978 bfd_target
*p
= target_vector
[i
];
979 bfd
*abfd
= bfd_openw (_DUMMY_NAME_
, p
->name
);
980 int l
= strlen (p
->name
);
982 bfd_set_format (abfd
, bfd_object
);
983 ok
= bfd_set_arch_mach (abfd
, j
, 0);
986 printf ("%s ", p
->name
);
990 printf ("%c", ok
? '*' : '-');
999 DEFUN_VOID (display_info
)
1002 unsigned int i
, j
, columns
;
1003 extern bfd_target
*target_vector
[];
1004 extern char *getenv ();
1006 printf ("BFD header file version %s\n", BFD_VERSION
);
1007 for (i
= 0; target_vector
[i
]; i
++)
1009 bfd_target
*p
= target_vector
[i
];
1010 bfd
*abfd
= bfd_openw (_DUMMY_NAME_
, p
->name
);
1011 bfd_set_format (abfd
, bfd_object
);
1012 printf ("%s\n (header %s, data %s)\n", p
->name
,
1013 p
->header_byteorder_big_p
? "big endian" : "little endian",
1014 p
->byteorder_big_p
? "big endian" : "little endian");
1015 for (j
= (int) bfd_arch_obscure
+ 1; j
< (int) bfd_arch_last
; j
++)
1016 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) j
, 0))
1018 bfd_printable_arch_mach ((enum bfd_architecture
) j
, 0));
1021 if (colum
= getenv ("COLUMNS"))
1022 columns
= atoi (colum
);
1025 for (i
= 0; target_vector
[i
];)
1029 for (j
= 12; target_vector
[i
] && j
< columns
; i
++)
1030 j
+= strlen (target_vector
[i
]->name
) + 1;
1034 display_info_table (old
, i
);
1038 /** main and like trivia */
1046 extern char *optarg
;
1047 char *target
= default_target
;
1048 boolean seenflag
= false;
1052 program_name
= *argv
;
1054 while ((c
= getopt_long (argc
, argv
, "ib:m:Vdlfahrtxsj:", long_options
, &ind
))
1067 with_line_numbers
= 1;
1073 dump_file_header
= true;
1080 dump_reloc_info
= 1;
1081 dump_file_header
= true;
1083 dump_section_headers
= 1;
1086 break; /* we've been given a long option */
1094 dump_section_contents
= 1;
1097 dump_reloc_info
= 1;
1103 dump_section_headers
= 1;
1114 printf ("%s version %s\n", program_name
, program_version
);
1116 if (seenflag
== false)
1126 display_file ("a.out", target
);
1128 for (; optind
< argc
;)
1129 display_file (argv
[optind
++], target
);