Commit | Line | Data |
---|---|---|
2fa0b342 DHW |
1 | /*** objdump.c -- dump information about an object file. */ |
2 | ||
3 | /* Copyright (C) 1990, 1991 Free Software Foundation, Inc. | |
4 | ||
5 | This file is part of BFD, the Binary File Diddler. | |
6 | ||
7 | BFD is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 1, or (at your option) | |
10 | any later version. | |
11 | ||
12 | BFD is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with BFD; see the file COPYING. If not, write to | |
19 | the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
20 | ||
21 | /* | |
22 | $Id$ | |
2fa0b342 DHW |
23 | */ |
24 | /* | |
25 | * Until there is other documentation, refer to the manual page dump(1) in | |
26 | * the system 5 program's reference manual | |
27 | */ | |
28 | ||
29 | #include "sysdep.h" | |
30 | #include "bfd.h" | |
31 | #include "getopt.h" | |
32 | #include <stdio.h> | |
33 | #include <ctype.h> | |
34 | ||
bf661056 SC |
35 | |
36 | ||
2fa0b342 DHW |
37 | char *xmalloc(); |
38 | ||
39 | char *default_target = NULL; /* default at runtime */ | |
40 | ||
41 | char *program_name = NULL; | |
42 | ||
43 | int dump_section_contents; /* -s */ | |
44 | int dump_section_headers; /* -h */ | |
45 | boolean dump_file_header; /* -f */ | |
46 | int dump_symtab; /* -t */ | |
47 | int dump_reloc_info; /* -r */ | |
48 | int dump_ar_hdrs; /* -a */ | |
49 | int with_line_numbers; /* -l */ | |
50 | boolean disassemble; /* -d */ | |
9872a49c | 51 | boolean info; /* -i */ |
2fa0b342 DHW |
52 | char *only; |
53 | ||
54 | PROTO (void, display_file, (char *filename, char *target)); | |
55 | PROTO (void, dump_data, (bfd *abfd)); | |
56 | PROTO (void, dump_relocs, (bfd *abfd)); | |
57 | PROTO (void, dump_symbols, (bfd *abfd)); | |
58 | PROTO (void, print_arelt_descr, (bfd *abfd, boolean verbose)); | |
59 | ||
60 | ||
61 | ||
62 | ||
63 | ||
64 | ||
65 | \f | |
66 | char *machine = (char *)NULL; | |
67 | asymbol **syms; | |
68 | asymbol **syms2; | |
69 | ||
70 | ||
71 | unsigned int storage; | |
72 | ||
73 | unsigned int symcount = 0; | |
74 | ||
75 | void | |
76 | usage () | |
77 | { | |
78 | fprintf (stderr, | |
9872a49c | 79 | "usage: %s [-ahifdrtxsl] [-m machine] [-j section_name] obj ...\n", |
2fa0b342 DHW |
80 | program_name); |
81 | exit (1); | |
82 | } | |
83 | ||
84 | static struct option long_options[] = | |
85 | {{"syms", 0, &dump_symtab, 1}, | |
86 | {"reloc", 0, &dump_reloc_info, 1}, | |
87 | {"header", 0, &dump_section_headers, 1}, | |
88 | {0, 0, 0, 0}}; | |
89 | ||
90 | ||
91 | ||
92 | static void | |
93 | dump_headers(abfd) | |
94 | bfd *abfd; | |
95 | { | |
96 | asection *section; | |
97 | for (section = abfd->sections; | |
98 | section != (asection *) NULL; | |
99 | section = section->next) | |
100 | { | |
101 | char *comma = ""; | |
102 | #define PF(x,y) \ | |
103 | if (section->flags & x) { printf("%s%s",comma,y); comma = ", "; } | |
104 | ||
105 | printf("SECTION %d [%s]\t: size %08x", | |
106 | section->index, | |
107 | section->name, | |
108 | (unsigned) section->size); | |
109 | printf(" vma %08lx align 2**%2u\n ", | |
110 | section->vma, | |
111 | section->alignment_power); | |
112 | PF(SEC_ALLOC,"ALLOC"); | |
113 | PF(SEC_LOAD,"LOAD"); | |
114 | PF(SEC_RELOC,"RELOC"); | |
115 | PF(SEC_BALIGN,"BALIGN"); | |
116 | PF(SEC_READONLY,"READONLY"); | |
117 | PF(SEC_CODE,"CODE"); | |
118 | PF(SEC_DATA,"DATA"); | |
119 | PF(SEC_ROM,"ROM"); | |
120 | printf("\n"); | |
121 | #undef PF | |
122 | } | |
123 | } | |
124 | ||
125 | static asymbol ** | |
126 | slurp_symtab(abfd) | |
127 | bfd *abfd; | |
128 | { | |
129 | asymbol **sy; | |
130 | if (!(bfd_get_file_flags (abfd) & HAS_SYMS)) { | |
131 | (void) printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd)); | |
132 | return(NULL); | |
133 | } | |
134 | ||
135 | storage = get_symtab_upper_bound (abfd); | |
136 | if (storage) { | |
137 | sy = (asymbol **) malloc (storage); | |
138 | if (sy == NULL) { | |
139 | fprintf (stderr, "%s: out of memory.\n", program_name); | |
140 | exit (1); | |
141 | } | |
142 | } | |
143 | symcount = bfd_canonicalize_symtab (abfd, sy); | |
144 | return sy; | |
145 | } | |
146 | /* Sort symbols into value order */ | |
147 | static int comp(ap,bp) | |
148 | asymbol **ap; | |
149 | asymbol **bp; | |
150 | { | |
151 | asymbol *a = *ap; | |
152 | asymbol *b = *bp; | |
153 | int diff; | |
154 | ||
155 | if ( a->name== (char *)NULL || (a->flags &( BSF_DEBUGGING| BSF_UNDEFINED) )) | |
156 | a->the_bfd = 0; | |
157 | if ( b->name== (char *)NULL || (b->flags &( BSF_DEBUGGING|BSF_UNDEFINED))) | |
158 | b->the_bfd =0; | |
159 | ||
160 | diff = a->the_bfd - b->the_bfd; | |
161 | if (diff) { | |
162 | return -diff; | |
163 | } | |
164 | diff = a->value - b->value; | |
165 | if (diff) { | |
166 | return diff; | |
167 | } | |
168 | return a->section - b->section; | |
169 | } | |
170 | ||
171 | /* Print the supplied address symbolically if possible */ | |
172 | void | |
173 | print_address(vma, stream) | |
174 | bfd_vma vma; | |
175 | FILE *stream; | |
176 | { | |
177 | /* Perform a binary search looking for the closest symbol to | |
178 | the required value */ | |
179 | ||
180 | unsigned int min = 0; | |
181 | unsigned int max = symcount; | |
182 | ||
183 | unsigned int thisplace = 1; | |
184 | unsigned int oldthisplace ; | |
185 | ||
186 | int vardiff; | |
187 | if (symcount == 0) | |
188 | fprintf(stream,"%08lx", vma); | |
189 | else { | |
190 | while (true) { | |
191 | oldthisplace = thisplace; | |
192 | thisplace = (max + min )/2 ; | |
193 | if (thisplace == oldthisplace) break; | |
194 | ||
195 | ||
196 | vardiff = syms[thisplace]->value - vma; | |
197 | ||
198 | if (vardiff) { | |
199 | if (vardiff > 0) { | |
200 | max = thisplace; | |
201 | } | |
202 | else { | |
203 | min = thisplace; | |
204 | } | |
205 | } | |
206 | else { | |
207 | /* Totally awesome! the exact right symbol */ | |
208 | fprintf(stream,"%08lx (%s)", vma, syms[thisplace]->name); | |
209 | return; | |
210 | } | |
211 | } | |
212 | /* We've run out of places to look, print the symbol before this one */ | |
213 | /* see if this or the symbol before describes this location the best */ | |
214 | ||
215 | if (thisplace != 0) { | |
216 | if (syms[thisplace-1]->value - vma > | |
217 | syms[thisplace]->value-vma) { | |
218 | /* Previous symbol is in correct section and is closer */ | |
219 | thisplace --; | |
220 | } | |
221 | } | |
222 | ||
bf661056 | 223 | |
2fa0b342 DHW |
224 | if (syms[thisplace]->value > vma) { |
225 | fprintf(stream,"%08lx (%s-%lx)", vma, syms[thisplace]->name, | |
226 | syms[thisplace]->value - vma); | |
227 | ||
228 | } | |
229 | else { | |
230 | fprintf(stream,"%08lx (%s+%lx)", vma, | |
231 | syms[thisplace]->name, | |
232 | vma - syms[thisplace]->value); | |
233 | } | |
234 | } | |
235 | } | |
236 | ||
237 | void | |
238 | disassemble_data(abfd) | |
239 | bfd *abfd; | |
240 | { | |
241 | bfd_byte *data = NULL; | |
242 | unsigned int datasize = 0; | |
243 | unsigned int i; | |
244 | int (*print)() ; | |
245 | int print_insn_m68k(); | |
246 | int print_insn_i960(); | |
247 | int print_insn_sparc(); | |
248 | enum bfd_architecture a; | |
249 | unsigned long m; | |
250 | asection *section; | |
251 | /* Replace symbol section relative values with abs values */ | |
252 | ||
253 | ||
254 | for (i = 0; i < symcount; i++) { | |
255 | if (syms[i]->section != (asection *)NULL) { | |
256 | syms[i]->value += syms[i]->section->vma; | |
257 | } | |
258 | } | |
259 | ||
260 | /* We keep a copy of the symbols in the original order */ | |
261 | syms2 = slurp_symtab(abfd); | |
262 | ||
263 | /* Sort the symbols into section and symbol order */ | |
264 | (void) qsort(syms, symcount, sizeof(asymbol *), comp); | |
265 | ||
266 | /* Find the first useless symbol */ | |
267 | { unsigned int i; | |
268 | for (i =0; i < symcount; i++) { | |
269 | if (syms[i]->the_bfd == 0) { | |
270 | symcount =i; | |
271 | break; | |
272 | } | |
273 | } | |
274 | } | |
275 | ||
276 | ||
277 | if (machine!= (char *)NULL) { | |
278 | if (bfd_scan_arch_mach(machine, &a, &m) == false) { | |
279 | fprintf(stderr,"%s: Can't use supplied machine %s\n", | |
280 | program_name, | |
281 | machine); | |
282 | exit(1); | |
283 | } | |
284 | } | |
285 | else { | |
286 | a = bfd_get_architecture(abfd); | |
287 | } | |
288 | switch (a) { | |
289 | ||
290 | case bfd_arch_sparc: | |
291 | print = print_insn_sparc; | |
292 | break; | |
293 | case bfd_arch_m68k: | |
294 | print = print_insn_m68k; | |
295 | break; | |
296 | case bfd_arch_i960: | |
297 | print = print_insn_i960; | |
298 | break; | |
299 | default: | |
300 | fprintf(stderr,"%s: Can't disassemble for architecture %s\n", | |
301 | program_name, | |
302 | bfd_printable_arch_mach(bfd_get_architecture(abfd),0)); | |
303 | exit(1); | |
304 | } | |
305 | ||
306 | ||
307 | for (section = abfd->sections; | |
308 | section != (asection *)NULL; | |
309 | section = section->next) { | |
310 | ||
311 | if (only == (char *)NULL || strcmp(only,section->name) == 0){ | |
312 | printf("Disassembly of section %s:\n", section->name); | |
313 | ||
314 | if (section->size == 0) continue; | |
315 | ||
316 | data = (bfd_byte *)malloc(section->size); | |
317 | ||
318 | if (data == (bfd_byte *)NULL) { | |
319 | fprintf (stderr, "%s: memory exhausted.\n", program_name); | |
320 | exit (1); | |
321 | } | |
322 | datasize = section->size; | |
323 | ||
324 | ||
325 | bfd_get_section_contents (abfd, section, data, 0, section->size); | |
326 | ||
327 | i = 0; | |
328 | while ((size_t)i <section->size) { | |
329 | if (with_line_numbers) { | |
330 | static prevline; | |
331 | char *filename; | |
332 | char *functionname; | |
333 | int line; | |
334 | bfd_find_nearest_line(abfd, | |
335 | section, | |
336 | syms, | |
337 | section->vma + i, | |
338 | &filename, | |
339 | &functionname, | |
340 | &line); | |
341 | ||
342 | if (filename && functionname && line && line != prevline) { | |
343 | printf("%s:%d\n", filename, line); | |
344 | prevline = line; | |
345 | } | |
346 | } | |
347 | print_address(section->vma + i, stdout); | |
348 | printf(" "); | |
349 | ||
350 | i += print(section->vma + i, | |
351 | data + i, | |
352 | stdout); | |
353 | putchar ('\n') ; | |
354 | } | |
355 | ||
356 | ||
357 | ||
358 | ||
359 | free(data); | |
360 | } | |
361 | } | |
362 | } | |
363 | ||
364 | void | |
365 | display_bfd (abfd) | |
366 | bfd *abfd; | |
367 | { | |
368 | ||
369 | if (!bfd_check_format (abfd, bfd_object)) { | |
370 | fprintf (stderr,"%s: %s not an object file\n", program_name, | |
371 | abfd->filename); | |
372 | return; | |
373 | } | |
374 | printf ("\n%s: file format %s\n", abfd->filename, abfd->xvec->name); | |
375 | if (dump_ar_hdrs) print_arelt_descr (abfd, true); | |
376 | ||
377 | if (dump_file_header) { | |
378 | char *comma = ""; | |
379 | ||
380 | printf("architecture: %s, ", | |
381 | bfd_printable_arch_mach (bfd_get_architecture (abfd), | |
382 | bfd_get_machine (abfd))); | |
383 | printf("flags 0x%08x:\n", abfd->flags); | |
384 | ||
385 | #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";} | |
386 | PF(HAS_RELOC, "HAS_RELOC"); | |
387 | PF(EXEC_P, "EXEC_P"); | |
388 | PF(HAS_LINENO, "HAS_LINENO"); | |
389 | PF(HAS_DEBUG, "HAS_DEBUG"); | |
390 | PF(HAS_SYMS, "HAS_SYMS"); | |
391 | PF(HAS_LOCALS, "HAS_LOCALS"); | |
392 | PF(DYNAMIC, "DYNAMIC"); | |
393 | PF(WP_TEXT, "WP_TEXT"); | |
394 | PF(D_PAGED, "D_PAGED"); | |
395 | printf("\nstart address 0x%08lx", abfd->start_address); | |
396 | } | |
397 | printf("\n"); | |
398 | ||
399 | if (dump_section_headers) | |
400 | dump_headers(abfd); | |
401 | if (dump_symtab || dump_reloc_info || disassemble) { | |
402 | syms = slurp_symtab(abfd); | |
403 | } | |
404 | if (dump_symtab) dump_symbols (abfd); | |
405 | if (dump_reloc_info) dump_relocs(abfd); | |
406 | if (dump_section_contents) dump_data (abfd); | |
407 | if (disassemble) disassemble_data(abfd); | |
408 | } | |
409 | ||
410 | void | |
411 | display_file (filename, target) | |
412 | char *filename; | |
413 | char *target; | |
414 | { | |
415 | bfd *file, *arfile = (bfd *) NULL; | |
416 | ||
417 | file = bfd_openr (filename, target); | |
418 | if (file == NULL) { | |
419 | bfd_perror (filename); | |
420 | return; | |
421 | } | |
422 | ||
423 | if (bfd_check_format (file, bfd_archive) == true) { | |
424 | printf ("In archive %s:\n", bfd_get_filename (file)); | |
425 | for(;;) { | |
426 | bfd_error = no_error; | |
427 | ||
428 | arfile = bfd_openr_next_archived_file (file, arfile); | |
429 | if (arfile == NULL) { | |
430 | if (bfd_error != no_more_archived_files) | |
431 | bfd_perror (bfd_get_filename(file)); | |
432 | return; | |
433 | } | |
434 | ||
435 | display_bfd (arfile); | |
436 | /* Don't close the archive elements; we need them for next_archive */ | |
437 | } | |
438 | } | |
439 | else | |
440 | display_bfd(file); | |
441 | ||
442 | bfd_close(file); | |
443 | } | |
444 | \f | |
445 | /* Actually display the various requested regions */ | |
446 | ||
447 | ||
448 | ||
449 | ||
450 | ||
451 | ||
452 | ||
453 | ||
454 | ||
455 | ||
456 | void | |
457 | dump_data (abfd) | |
458 | bfd *abfd; | |
459 | { | |
460 | asection *section; | |
461 | bfd_byte *data ; | |
462 | unsigned int datasize = 0; | |
463 | size_t i; | |
464 | ||
465 | for (section = abfd->sections; section != NULL; section = | |
466 | section->next) { | |
467 | int onaline = 16; | |
468 | ||
469 | if (only == (char *)NULL || | |
470 | strcmp(only,section->name) == 0){ | |
471 | ||
472 | ||
473 | ||
474 | printf("Contents of section %s:\n", section->name); | |
475 | ||
476 | if (section->size == 0) continue; | |
477 | data = (bfd_byte *)malloc(section->size); | |
478 | if (data == (bfd_byte *)NULL) { | |
479 | fprintf (stderr, "%s: memory exhausted.\n", program_name); | |
480 | exit (1); | |
481 | } | |
482 | datasize = section->size; | |
483 | ||
484 | ||
485 | bfd_get_section_contents (abfd, section, data, 0, section->size); | |
486 | ||
487 | for (i= 0; i < section->size; i += onaline) { | |
488 | size_t j; | |
489 | printf(" %04lx ", i + section->vma); | |
490 | for (j = i; j < i+ onaline; j++) { | |
491 | if (j < section->size) | |
492 | printf("%02x", (unsigned)(data[j])); | |
493 | else | |
494 | printf(" "); | |
495 | if ((j & 3 ) == 3) printf(" "); | |
496 | } | |
497 | ||
498 | printf(" "); | |
499 | for (j = i; j < i+onaline ; j++) { | |
500 | if (j >= section->size) | |
501 | printf(" "); | |
502 | else | |
503 | printf("%c", isprint(data[j]) ?data[j] : '.'); | |
504 | } | |
505 | putchar ('\n'); | |
506 | } | |
507 | } | |
508 | ||
509 | free (data); | |
510 | } | |
511 | } | |
512 | ||
513 | ||
514 | ||
515 | /* Should perhaps share code and display with nm? */ | |
516 | void | |
517 | dump_symbols (abfd) | |
518 | bfd *abfd; | |
519 | { | |
520 | ||
521 | unsigned int count; | |
522 | asymbol **current = syms; | |
523 | printf("SYMBOL TABLE:\n"); | |
524 | ||
525 | for (count = 0; count < symcount; count++) { | |
526 | if ((*current)->the_bfd) { | |
527 | bfd_print_symbol((*current)->the_bfd, | |
528 | stdout, | |
529 | *current, bfd_print_symbol_all_enum); | |
530 | ||
531 | printf("\n"); | |
532 | } | |
533 | current++; | |
534 | } | |
535 | printf("\n"); | |
536 | printf("\n"); | |
537 | } | |
538 | ||
539 | ||
540 | void | |
541 | dump_relocs(abfd) | |
542 | bfd *abfd; | |
543 | { | |
544 | arelent **relpp; | |
545 | unsigned int relcount; | |
546 | asection *a; | |
547 | for (a = abfd->sections; a != (asection *)NULL; a = a->next) { | |
548 | printf("RELOCATION RECORDS FOR [%s]:",a->name); | |
549 | ||
550 | if (get_reloc_upper_bound(abfd, a) == 0) { | |
551 | printf(" (none)\n\n"); | |
552 | } | |
553 | else { | |
554 | arelent **p; | |
555 | ||
556 | relpp = (arelent **) xmalloc( get_reloc_upper_bound(abfd,a) ); | |
557 | relcount = bfd_canonicalize_reloc(abfd,a,relpp, syms); | |
558 | if (relcount == 0) { | |
559 | printf(" (none)\n\n"); | |
560 | } | |
561 | else { | |
562 | printf("\n"); | |
563 | printf("OFFSET TYPE VALUE \n"); | |
564 | ||
565 | for (p =relpp; *p != (arelent *)NULL; p++) { | |
566 | arelent *q = *p; | |
bf661056 SC |
567 | CONST char *sym_name; |
568 | CONST char *section_name = q->section == (asection *)NULL ? "*abs" : | |
2fa0b342 DHW |
569 | q->section->name; |
570 | if (q->sym_ptr_ptr && *q->sym_ptr_ptr) { | |
571 | sym_name = (*(q->sym_ptr_ptr))->name ; | |
572 | } | |
573 | else { | |
574 | sym_name = 0; | |
575 | } | |
576 | if (sym_name) { | |
577 | printf("%08lx %-8s %s", | |
578 | q->address, | |
579 | q->howto->name, | |
580 | sym_name); | |
581 | } | |
582 | else { | |
583 | printf("%08lx %-8s [%s]", | |
584 | q->address, | |
585 | q->howto->name, | |
586 | section_name); | |
587 | } | |
588 | if (q->addend) { | |
589 | printf("+0x%lx(%ld)", q->addend, (long) q->addend); | |
590 | } | |
591 | printf("\n"); | |
592 | } | |
593 | printf("\n\n"); | |
594 | free(relpp); | |
595 | } | |
596 | } | |
597 | ||
598 | } | |
599 | } | |
600 | ||
9872a49c SC |
601 | static void |
602 | DEFUN_VOID(display_info) | |
603 | { | |
604 | unsigned int i; | |
605 | extern bfd_target *target_vector[]; | |
606 | ||
607 | enum bfd_architecture j; | |
608 | i = 0; | |
609 | printf("BFD header file version %s\n", BFD_VERSION); | |
610 | while (target_vector[i] != (bfd_target *)NULL) | |
611 | { | |
612 | bfd_target *p = target_vector[i]; | |
613 | bfd *abfd = bfd_openw("##dummy",p->name); | |
614 | printf("%s\n (header %s, data %s)\n", p->name, | |
615 | p->header_byteorder_big_p ? "big endian" : "little endian", | |
616 | p->byteorder_big_p ? "big endian" : "little endian" ); | |
617 | { | |
618 | enum bfd_architecture j; | |
619 | for (j = bfd_arch_obscure +1; j < bfd_arch_last; j++) | |
620 | { | |
621 | if (bfd_set_arch_mach(abfd, j, 0)) | |
622 | { | |
623 | printf(" %s\n", bfd_printable_arch_mach(j,0)); | |
624 | } | |
625 | } | |
2fa0b342 | 626 | |
9872a49c SC |
627 | } |
628 | i++; | |
629 | } | |
630 | /* Again as a table */ | |
631 | printf("%12s"," "); | |
632 | for (i = 0; target_vector[i]; i++) { | |
633 | printf("%s ",target_vector[i]->name); | |
634 | } | |
635 | printf("\n"); | |
636 | for (j = bfd_arch_obscure +1; j < bfd_arch_last; j++) { | |
637 | printf("%11s ", bfd_printable_arch_mach(j,0)); | |
638 | for (i = 0; target_vector[i]; i++) { | |
639 | { | |
640 | bfd_target *p = target_vector[i]; | |
641 | bfd *abfd = bfd_openw("##dummy",p->name); | |
642 | int l = strlen(p->name); | |
643 | int ok = bfd_set_arch_mach(abfd, j, 0); | |
644 | if (ok) { | |
645 | printf("%s ", p->name); | |
646 | } | |
647 | else { | |
648 | while (l--) { | |
649 | printf("%c",ok?'*':'-'); | |
650 | } | |
651 | printf(" "); | |
652 | } | |
653 | ||
654 | } | |
655 | } | |
656 | ||
657 | printf("\n"); | |
658 | } | |
659 | } | |
2fa0b342 DHW |
660 | /** main and like trivia */ |
661 | int | |
662 | main (argc, argv) | |
663 | int argc; | |
664 | char **argv; | |
665 | { | |
666 | int c; | |
667 | extern int optind; | |
668 | extern char *optarg; | |
669 | char *target = default_target; | |
670 | boolean seenflag = false; | |
671 | int ind = 0; | |
672 | ||
673 | program_name = *argv; | |
674 | ||
9872a49c | 675 | while ((c = getopt_long (argc, argv, "ib:m:dlfahrtxsj:", long_options, &ind)) |
2fa0b342 DHW |
676 | != EOF) { |
677 | seenflag = true; | |
678 | switch (c) { | |
679 | case 'm': | |
680 | machine = optarg; | |
681 | break; | |
682 | case 'j': | |
683 | only = optarg; | |
684 | break; | |
685 | case 'l': | |
686 | with_line_numbers = 1; | |
687 | break; | |
688 | case 'b': | |
689 | target = optarg; | |
690 | break; | |
691 | case 'f': | |
692 | dump_file_header = true; | |
693 | break; | |
9872a49c SC |
694 | case 'i': |
695 | info = true; | |
696 | break; | |
2fa0b342 DHW |
697 | case 'x': |
698 | dump_symtab = 1; | |
699 | dump_reloc_info = 1; | |
700 | dump_file_header = true; | |
701 | dump_ar_hdrs = 1; | |
702 | dump_section_headers = 1; | |
703 | break; | |
704 | case 0 : break; /* we've been given a long option */ | |
705 | case 't': dump_symtab = 1; break; | |
706 | case 'd': disassemble = true ; break; | |
707 | case 's': dump_section_contents = 1; break; | |
708 | case 'r': dump_reloc_info = 1; break; | |
709 | case 'a': dump_ar_hdrs = 1; break; | |
710 | case 'h': dump_section_headers = 1; break; | |
711 | default: | |
712 | usage (); | |
713 | } | |
714 | } | |
715 | ||
716 | if (seenflag == false) | |
717 | usage (); | |
718 | ||
9872a49c SC |
719 | if (info) { |
720 | display_info(); | |
721 | } | |
722 | else { | |
2fa0b342 DHW |
723 | if (optind == argc) |
724 | display_file ("a.out", target); | |
725 | else | |
726 | for (; optind < argc;) | |
727 | display_file (argv[optind++], target); | |
9872a49c | 728 | } |
2fa0b342 DHW |
729 | return 0; |
730 | } |