Automatic date update in version.in
[binutils-gdb.git] / bfd / format.c
blob443fc6dbde02650b223d56babf635b68c9406d5e
1 /* Generic BFD support for file formats.
2 Copyright (C) 1990-2024 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program 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 3 of the License, or
10 (at your option) any later version.
12 This program 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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
24 SECTION
25 File formats
27 A format is a BFD concept of high level file contents type. The
28 formats supported by BFD are:
30 o <<bfd_object>>
32 The BFD may contain data, symbols, relocations and debug info.
34 o <<bfd_archive>>
36 The BFD contains other BFDs and an optional index.
38 o <<bfd_core>>
40 The BFD contains the result of an executable core dump.
42 SUBSECTION
43 File format functions
46 #include "sysdep.h"
47 #include "bfd.h"
48 #include "libbfd.h"
50 /* IMPORT from targets.c. */
51 extern const size_t _bfd_target_vector_entries;
54 FUNCTION
55 bfd_check_format
57 SYNOPSIS
58 bool bfd_check_format (bfd *abfd, bfd_format format);
60 DESCRIPTION
61 Verify if the file attached to the BFD @var{abfd} is compatible
62 with the format @var{format} (i.e., one of <<bfd_object>>,
63 <<bfd_archive>> or <<bfd_core>>).
65 If the BFD has been set to a specific target before the
66 call, only the named target and format combination is
67 checked. If the target has not been set, or has been set to
68 <<default>>, then all the known target backends is
69 interrogated to determine a match. If the default target
70 matches, it is used. If not, exactly one target must recognize
71 the file, or an error results.
73 The function returns <<TRUE>> on success, otherwise <<FALSE>>
74 with one of the following error codes:
76 o <<bfd_error_invalid_operation>> -
77 if <<format>> is not one of <<bfd_object>>, <<bfd_archive>> or
78 <<bfd_core>>.
80 o <<bfd_error_system_call>> -
81 if an error occured during a read - even some file mismatches
82 can cause bfd_error_system_calls.
84 o <<file_not_recognised>> -
85 none of the backends recognised the file format.
87 o <<bfd_error_file_ambiguously_recognized>> -
88 more than one backend recognised the file format.
90 When calling bfd_check_format (or bfd_check_format_matches),
91 any underlying file descriptor will be kept open for the
92 duration of the call. This is done to avoid races when
93 another thread calls bfd_cache_close_all. In this scenario,
94 the thread calling bfd_check_format must call bfd_cache_close
95 itself.
98 bool
99 bfd_check_format (bfd *abfd, bfd_format format)
101 return bfd_check_format_matches (abfd, format, NULL);
104 struct bfd_preserve
106 void *marker;
107 void *tdata;
108 flagword flags;
109 const struct bfd_iovec *iovec;
110 void *iostream;
111 const struct bfd_arch_info *arch_info;
112 const struct bfd_build_id *build_id;
113 bfd_cleanup cleanup;
114 struct bfd_section *sections;
115 struct bfd_section *section_last;
116 unsigned int section_count;
117 unsigned int section_id;
118 unsigned int symcount;
119 bool read_only;
120 bfd_vma start_address;
121 struct bfd_hash_table section_htab;
124 /* When testing an object for compatibility with a particular target
125 back-end, the back-end object_p function needs to set up certain
126 fields in the bfd on successfully recognizing the object. This
127 typically happens in a piecemeal fashion, with failures possible at
128 many points. On failure, the bfd is supposed to be restored to its
129 initial state, which is virtually impossible. However, restoring a
130 subset of the bfd state works in practice. This function stores
131 the subset. */
133 static bool
134 bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve,
135 bfd_cleanup cleanup)
137 preserve->tdata = abfd->tdata.any;
138 preserve->arch_info = abfd->arch_info;
139 preserve->flags = abfd->flags;
140 preserve->iovec = abfd->iovec;
141 preserve->iostream = abfd->iostream;
142 preserve->sections = abfd->sections;
143 preserve->section_last = abfd->section_last;
144 preserve->section_count = abfd->section_count;
145 preserve->section_id = _bfd_section_id;
146 preserve->symcount = abfd->symcount;
147 preserve->read_only = abfd->read_only;
148 preserve->start_address = abfd->start_address;
149 preserve->section_htab = abfd->section_htab;
150 preserve->marker = bfd_alloc (abfd, 1);
151 preserve->build_id = abfd->build_id;
152 preserve->cleanup = cleanup;
153 if (preserve->marker == NULL)
154 return false;
156 return bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,
157 sizeof (struct section_hash_entry));
160 /* A back-end object_p function may flip a bfd from file backed to
161 in-memory, eg. pe_ILF_object_p. In that case to restore the
162 original IO state we need to reopen the file. Conversely, if we
163 are restoring a previously matched pe ILF format and have been
164 checking further target matches using file IO then we need to close
165 the file and detach the bfd from the cache lru list. */
167 static void
168 io_reinit (bfd *abfd, struct bfd_preserve *preserve)
170 if (abfd->iovec != preserve->iovec)
172 /* Handle file backed to in-memory transition. bfd_cache_close
173 won't do anything unless abfd->iovec is the cache_iovec.
174 Don't be tempted to call iovec->bclose here. We don't want
175 to call memory_bclose, which would free the bim. The bim
176 must be kept if bfd_check_format_matches is going to decide
177 later that the PE format needing it is in fact the correct
178 target match. */
179 bfd_cache_close (abfd);
180 abfd->iovec = preserve->iovec;
181 abfd->iostream = preserve->iostream;
183 /* Handle in-memory to file backed transition. */
184 if ((abfd->flags & BFD_CLOSED_BY_CACHE) != 0
185 && (abfd->flags & BFD_IN_MEMORY) != 0
186 && (preserve->flags & BFD_CLOSED_BY_CACHE) == 0
187 && (preserve->flags & BFD_IN_MEMORY) == 0)
188 bfd_open_file (abfd);
190 abfd->flags = preserve->flags;
193 /* Clear out a subset of BFD state. */
195 static void
196 bfd_reinit (bfd *abfd, unsigned int section_id,
197 struct bfd_preserve *preserve, bfd_cleanup cleanup)
199 _bfd_section_id = section_id;
200 if (cleanup)
201 cleanup (abfd);
202 abfd->tdata.any = NULL;
203 abfd->arch_info = &bfd_default_arch_struct;
204 io_reinit (abfd, preserve);
205 abfd->symcount = 0;
206 abfd->read_only = 0;
207 abfd->start_address = 0;
208 abfd->build_id = NULL;
209 bfd_section_list_clear (abfd);
212 /* Restores bfd state saved by bfd_preserve_save. */
214 static bfd_cleanup
215 bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
217 bfd_hash_table_free (&abfd->section_htab);
219 abfd->tdata.any = preserve->tdata;
220 abfd->arch_info = preserve->arch_info;
221 io_reinit (abfd, preserve);
222 abfd->section_htab = preserve->section_htab;
223 abfd->sections = preserve->sections;
224 abfd->section_last = preserve->section_last;
225 abfd->section_count = preserve->section_count;
226 _bfd_section_id = preserve->section_id;
227 abfd->symcount = preserve->symcount;
228 abfd->read_only = preserve->read_only;
229 abfd->start_address = preserve->start_address;
230 abfd->build_id = preserve->build_id;
232 /* bfd_release frees all memory more recently bfd_alloc'd than
233 its arg, as well as its arg. */
234 bfd_release (abfd, preserve->marker);
235 preserve->marker = NULL;
236 return preserve->cleanup;
239 /* Called when the bfd state saved by bfd_preserve_save is no longer
240 needed. */
242 static void
243 bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
245 if (preserve->cleanup)
247 /* Run the cleanup, assuming that all it will need is the
248 tdata at the time the cleanup was returned. */
249 void *tdata = abfd->tdata.any;
250 abfd->tdata.any = preserve->tdata;
251 preserve->cleanup (abfd);
252 abfd->tdata.any = tdata;
254 /* It would be nice to be able to free more memory here, eg. old
255 tdata, but that's not possible since these blocks are sitting
256 inside bfd_alloc'd memory. The section hash is on a separate
257 objalloc. */
258 bfd_hash_table_free (&preserve->section_htab);
259 preserve->marker = NULL;
262 static void
263 print_warnmsg (struct per_xvec_message **list)
265 for (struct per_xvec_message *warn = *list; warn; warn = warn->next)
266 _bfd_error_handler ("%s", warn->message);
269 static void
270 clear_warnmsg (struct per_xvec_message **list)
272 struct per_xvec_message *warn = *list;
273 while (warn)
275 struct per_xvec_message *next = warn->next;
276 free (warn);
277 warn = next;
279 *list = NULL;
282 /* Free all the storage in LIST. Note that the first element of LIST
283 is special and is assumed to be stack-allocated. TARG is used for
284 re-issuing warning messages. If TARG is PER_XVEC_NO_TARGET, then
285 it acts like a sort of wildcard -- messages are only reissued if
286 they are all associated with a single BFD target, regardless of
287 which one it is. If TARG is anything else, then only messages
288 associated with TARG are emitted. */
290 static void
291 print_and_clear_messages (struct per_xvec_messages *list,
292 const bfd_target *targ)
294 struct per_xvec_messages *iter = list;
296 if (targ == PER_XVEC_NO_TARGET && list->next == NULL)
297 print_warnmsg (&list->messages);
299 while (iter != NULL)
301 struct per_xvec_messages *next = iter->next;
303 if (iter->targ == targ)
304 print_warnmsg (&iter->messages);
305 clear_warnmsg (&iter->messages);
306 if (iter != list)
307 free (iter);
308 iter = next;
312 /* This a copy of lto_section defined in GCC (lto-streamer.h). */
314 struct lto_section
316 int16_t major_version;
317 int16_t minor_version;
318 unsigned char slim_object;
320 /* Flags is a private field that is not defined publicly. */
321 uint16_t flags;
324 /* Set lto_type in ABFD. */
326 static void
327 bfd_set_lto_type (bfd *abfd ATTRIBUTE_UNUSED)
329 #if BFD_SUPPORTS_PLUGINS
330 if (abfd->format == bfd_object
331 && abfd->lto_type == lto_non_object
332 && (abfd->flags & (DYNAMIC | EXEC_P)) == 0)
334 asection *sec;
335 enum bfd_lto_object_type type = lto_non_ir_object;
336 struct lto_section lsection;
337 /* GCC uses .gnu.lto_.lto.<some_hash> as a LTO bytecode information
338 section. */
339 for (sec = abfd->sections; sec != NULL; sec = sec->next)
340 if (startswith (sec->name, ".gnu.lto_.lto.")
341 && bfd_get_section_contents (abfd, sec, &lsection, 0,
342 sizeof (struct lto_section)))
344 if (lsection.slim_object)
345 type = lto_slim_ir_object;
346 else
347 type = lto_fat_ir_object;
348 break;
351 abfd->lto_type = type;
353 #endif
357 FUNCTION
358 bfd_check_format_matches
360 SYNOPSIS
361 bool bfd_check_format_matches
362 (bfd *abfd, bfd_format format, char ***matching);
364 DESCRIPTION
365 Like <<bfd_check_format>>, except when it returns FALSE with
366 <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>. In that
367 case, if @var{matching} is not NULL, it will be filled in with
368 a NULL-terminated list of the names of the formats that matched,
369 allocated with <<malloc>>.
370 Then the user may choose a format and try again.
372 When done with the list that @var{matching} points to, the caller
373 should free it.
376 bool
377 bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
379 extern const bfd_target binary_vec;
380 #if BFD_SUPPORTS_PLUGINS
381 extern const bfd_target plugin_vec;
382 #endif
383 const bfd_target * const *target;
384 const bfd_target **matching_vector = NULL;
385 const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ;
386 int match_count, best_count, best_match;
387 int ar_match_index;
388 unsigned int initial_section_id = _bfd_section_id;
389 struct bfd_preserve preserve, preserve_match;
390 bfd_cleanup cleanup = NULL;
391 struct per_xvec_messages messages = { abfd, PER_XVEC_NO_TARGET, NULL, NULL };
392 struct per_xvec_messages *orig_messages;
393 bool old_in_format_matches;
395 if (matching != NULL)
396 *matching = NULL;
398 if (!bfd_read_p (abfd)
399 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
401 bfd_set_error (bfd_error_invalid_operation);
402 return false;
405 if (abfd->format != bfd_unknown)
407 bfd_set_lto_type (abfd);
408 return abfd->format == format;
411 if (matching != NULL || *bfd_associated_vector != NULL)
413 size_t amt;
415 amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;
416 matching_vector = (const bfd_target **) bfd_malloc (amt);
417 if (!matching_vector)
418 return false;
421 /* Avoid clashes with bfd_cache_close_all running in another
422 thread. */
423 if (!bfd_cache_set_uncloseable (abfd, true, &old_in_format_matches))
424 return false;
426 /* Presume the answer is yes. */
427 abfd->format = format;
428 save_targ = abfd->xvec;
430 /* Don't report errors on recursive calls checking the first element
431 of an archive. */
432 orig_messages = _bfd_set_error_handler_caching (&messages);
434 preserve_match.marker = NULL;
435 if (!bfd_preserve_save (abfd, &preserve, NULL))
436 goto err_ret;
438 /* If the target type was explicitly specified, just check that target. */
439 if (!abfd->target_defaulted)
441 if (bfd_seek (abfd, 0, SEEK_SET) != 0) /* rewind! */
442 goto err_ret;
444 cleanup = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
446 if (cleanup)
447 goto ok_ret;
449 /* For a long time the code has dropped through to check all
450 targets if the specified target was wrong. I don't know why,
451 and I'm reluctant to change it. However, in the case of an
452 archive, it can cause problems. If the specified target does
453 not permit archives (e.g., the binary target), then we should
454 not allow some other target to recognize it as an archive, but
455 should instead allow the specified target to recognize it as an
456 object. When I first made this change, it broke the PE target,
457 because the specified pei-i386 target did not recognize the
458 actual pe-i386 archive. Since there may be other problems of
459 this sort, I changed this test to check only for the binary
460 target. */
461 if (format == bfd_archive && save_targ == &binary_vec)
462 goto err_unrecog;
465 /* Since the target type was defaulted, check them all in the hope
466 that one will be uniquely recognized. */
467 right_targ = NULL;
468 ar_right_targ = NULL;
469 match_targ = NULL;
470 best_match = 256;
471 best_count = 0;
472 match_count = 0;
473 ar_match_index = _bfd_target_vector_entries;
475 for (target = bfd_target_vector; *target != NULL; target++)
477 void **high_water;
479 /* The binary target matches anything, so don't return it when
480 searching. Don't match the plugin target if we have another
481 alternative since we want to properly set the input format
482 before allowing a plugin to claim the file. Also, don't
483 check the default target twice. */
484 if (*target == &binary_vec
485 #if BFD_SUPPORTS_PLUGINS
486 || (match_count != 0 && *target == &plugin_vec)
487 #endif
488 || (!abfd->target_defaulted && *target == save_targ))
489 continue;
491 /* If we already tried a match, the bfd is modified and may
492 have sections attached, which will confuse the next
493 _bfd_check_format call. */
494 bfd_reinit (abfd, initial_section_id, &preserve, cleanup);
495 /* Free bfd_alloc memory too. If we have matched and preserved
496 a target then the high water mark is that much higher. */
497 if (preserve_match.marker)
498 high_water = &preserve_match.marker;
499 else
500 high_water = &preserve.marker;
501 bfd_release (abfd, *high_water);
502 *high_water = bfd_alloc (abfd, 1);
504 /* Change BFD's target temporarily. */
505 abfd->xvec = *target;
507 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
508 goto err_ret;
510 cleanup = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
511 if (cleanup)
513 int match_priority = abfd->xvec->match_priority;
514 #if BFD_SUPPORTS_PLUGINS
515 /* If this object can be handled by a plugin, give that the
516 lowest priority; objects both handled by a plugin and
517 with an underlying object format will be claimed
518 separately by the plugin. */
519 if (*target == &plugin_vec)
520 match_priority = (*target)->match_priority;
521 #endif
523 if (abfd->format != bfd_archive
524 || (bfd_has_map (abfd)
525 && bfd_get_error () != bfd_error_wrong_object_format))
527 /* If this is the default target, accept it, even if
528 other targets might match. People who want those
529 other targets have to set the GNUTARGET variable. */
530 if (abfd->xvec == bfd_default_vector[0])
531 goto ok_ret;
533 if (matching_vector)
534 matching_vector[match_count] = abfd->xvec;
535 match_count++;
537 if (match_priority < best_match)
539 best_match = match_priority;
540 best_count = 0;
542 if (match_priority <= best_match)
544 /* This format checks out as ok! */
545 right_targ = abfd->xvec;
546 best_count++;
549 else
551 /* An archive with no armap or objects of the wrong
552 type. We want this target to match if we get no
553 better matches. */
554 if (ar_right_targ != bfd_default_vector[0])
555 ar_right_targ = *target;
556 if (matching_vector)
557 matching_vector[ar_match_index] = *target;
558 ar_match_index++;
561 if (preserve_match.marker == NULL)
563 match_targ = abfd->xvec;
564 if (!bfd_preserve_save (abfd, &preserve_match, cleanup))
565 goto err_ret;
566 cleanup = NULL;
571 if (best_count == 1)
572 match_count = 1;
574 if (match_count == 0)
576 /* Try partial matches. */
577 right_targ = ar_right_targ;
579 if (right_targ == bfd_default_vector[0])
581 match_count = 1;
583 else
585 match_count = ar_match_index - _bfd_target_vector_entries;
587 if (matching_vector && match_count > 1)
588 memcpy (matching_vector,
589 matching_vector + _bfd_target_vector_entries,
590 sizeof (*matching_vector) * match_count);
594 /* We have more than one equally good match. If any of the best
595 matches is a target in config.bfd targ_defvec or targ_selvecs,
596 choose it. */
597 if (match_count > 1)
599 const bfd_target * const *assoc = bfd_associated_vector;
601 while ((right_targ = *assoc++) != NULL)
603 int i = match_count;
605 while (--i >= 0)
606 if (matching_vector[i] == right_targ
607 && right_targ->match_priority <= best_match)
608 break;
610 if (i >= 0)
612 match_count = 1;
613 break;
618 /* We still have more than one equally good match, and at least some
619 of the targets support match priority. Choose the first of the
620 best matches. */
621 if (matching_vector && match_count > 1 && best_count != match_count)
623 int i;
625 for (i = 0; i < match_count; i++)
627 right_targ = matching_vector[i];
628 if (right_targ->match_priority <= best_match)
629 break;
631 match_count = 1;
634 /* There is way too much undoing of half-known state here. We
635 really shouldn't iterate on live bfd's. Note that saving the
636 whole bfd and restoring it would be even worse; the first thing
637 you notice is that the cached bfd file position gets out of sync. */
638 if (preserve_match.marker != NULL)
639 cleanup = bfd_preserve_restore (abfd, &preserve_match);
641 if (match_count == 1)
643 abfd->xvec = right_targ;
644 /* If we come out of the loop knowing that the last target that
645 matched is the one we want, then ABFD should still be in a usable
646 state (except possibly for XVEC). This is not just an
647 optimisation. In the case of plugins a match against the
648 plugin target can result in the bfd being changed such that
649 it no longer matches the plugin target, nor will it match
650 RIGHT_TARG again. */
651 if (match_targ != right_targ)
653 bfd_reinit (abfd, initial_section_id, &preserve, cleanup);
654 bfd_release (abfd, preserve.marker);
655 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
656 goto err_ret;
657 cleanup = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
658 BFD_ASSERT (cleanup != NULL);
661 ok_ret:
662 /* If the file was opened for update, then `output_has_begun'
663 some time ago when the file was created. Do not recompute
664 sections sizes or alignments in _bfd_set_section_contents.
665 We can not set this flag until after checking the format,
666 because it will interfere with creation of BFD sections. */
667 if (abfd->direction == both_direction)
668 abfd->output_has_begun = true;
670 free (matching_vector);
671 if (preserve_match.marker != NULL)
672 bfd_preserve_finish (abfd, &preserve_match);
673 bfd_preserve_finish (abfd, &preserve);
674 _bfd_restore_error_handler_caching (orig_messages);
676 print_and_clear_messages (&messages, abfd->xvec);
678 bfd_set_lto_type (abfd);
680 /* File position has moved, BTW. */
681 return bfd_cache_set_uncloseable (abfd, old_in_format_matches, NULL);
684 if (match_count == 0)
686 err_unrecog:
687 bfd_set_error (bfd_error_file_not_recognized);
688 err_ret:
689 if (cleanup)
690 cleanup (abfd);
691 abfd->xvec = save_targ;
692 abfd->format = bfd_unknown;
693 free (matching_vector);
694 goto out;
697 /* Restore original target type and format. */
698 abfd->xvec = save_targ;
699 abfd->format = bfd_unknown;
700 bfd_set_error (bfd_error_file_ambiguously_recognized);
702 if (matching)
704 *matching = (char **) matching_vector;
705 matching_vector[match_count] = NULL;
706 /* Return target names. This is a little nasty. Maybe we
707 should do another bfd_malloc? */
708 while (--match_count >= 0)
710 const char *name = matching_vector[match_count]->name;
711 *(const char **) &matching_vector[match_count] = name;
714 else
715 free (matching_vector);
716 if (cleanup)
717 cleanup (abfd);
718 out:
719 if (preserve_match.marker != NULL)
720 bfd_preserve_finish (abfd, &preserve_match);
721 bfd_preserve_restore (abfd, &preserve);
722 _bfd_restore_error_handler_caching (orig_messages);
723 print_and_clear_messages (&messages, PER_XVEC_NO_TARGET);
724 bfd_cache_set_uncloseable (abfd, old_in_format_matches, NULL);
725 return false;
729 FUNCTION
730 bfd_set_format
732 SYNOPSIS
733 bool bfd_set_format (bfd *abfd, bfd_format format);
735 DESCRIPTION
736 This function sets the file format of the BFD @var{abfd} to the
737 format @var{format}. If the target set in the BFD does not
738 support the format requested, the format is invalid, or the BFD
739 is not open for writing, then an error occurs.
742 bool
743 bfd_set_format (bfd *abfd, bfd_format format)
745 if (bfd_read_p (abfd)
746 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
748 bfd_set_error (bfd_error_invalid_operation);
749 return false;
752 if (abfd->format != bfd_unknown)
753 return abfd->format == format;
755 /* Presume the answer is yes. */
756 abfd->format = format;
758 if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
760 abfd->format = bfd_unknown;
761 return false;
764 return true;
768 FUNCTION
769 bfd_format_string
771 SYNOPSIS
772 const char *bfd_format_string (bfd_format format);
774 DESCRIPTION
775 Return a pointer to a const string
776 <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
777 depending upon the value of @var{format}.
780 const char *
781 bfd_format_string (bfd_format format)
783 if (((int) format < (int) bfd_unknown)
784 || ((int) format >= (int) bfd_type_end))
785 return "invalid";
787 switch (format)
789 case bfd_object:
790 return "object"; /* Linker/assembler/compiler output. */
791 case bfd_archive:
792 return "archive"; /* Object archive file. */
793 case bfd_core:
794 return "core"; /* Core dump. */
795 default:
796 return "unknown";