Changeset 609 for branches/GNU/src/binutils/bfd/doc/bfd.info-4

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/bfd/doc/bfd.info-4 (modified) (5 diffs, 1 prop)

branches/GNU/src/binutils/bfd/doc/bfd.info-4

@@ -1 @@
-This is bfd.info, produced by makeinfo version 4.0 from bfd.texinfo.
+This is bfd.info, produced by makeinfo version 4. from bfd.texinfo.
 
 START-INFO-DIR-ENTRY
@@ -7 +7 @@
    This file documents the BFD library.
 
-   Copyright (C) 1991, 2000 Free Software Foundation, Inc.
+   Copyright (C) 1991, 2000 Free Software Foundation, Inc.
 
    Permission is granted to copy, distribute and/or modify this document
@@ -17 +17 @@
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 File: bfd.info,  Node: Targets,  Next: Architectures,  Prev: Core Files,  Up: BFD front end
 
@@ -59 +1596 @@
 the BFD with a suggested format.  If `target_defaulted' has been set,
 each possible target type is tried to see if it recognizes the
-specified format.  `bfd_check_format' returns `true' when the caller
+specified format.  `bfd_check_format' returns `' when the caller
 guesses right.
 
@@ -66 +1603 @@
 * bfd_target::
 
-
-File: bfd.info,  Node: bfd_target,  Prev: Targets,  Up: Targets
-
-bfd_target
-----------
-
-   *Description*
-This structure contains everything that BFD knows about a target. It
-includes things like its byte order, name, and which routines to call
-to do various operations.
-
-   Every BFD points to a target structure with its `xvec' member.
-
-   The macros below are used to dispatch to functions through the
-`bfd_target' vector. They are used in a number of macros further down
-in `bfd.h', and are also used when calling various routines by hand
-inside the BFD implementation.  The ARGLIST argument must be
-parenthesized; it contains all the arguments to the called function.
-
-   They make the documentation (more) unpleasant to read, so if someone
-wants to fix this and not break the above, please do.
-     #define BFD_SEND(bfd, message, arglist) \
-                    ((*((bfd)->xvec->message)) arglist)
-     
-     #ifdef DEBUG_BFD_SEND
-     #undef BFD_SEND
-     #define BFD_SEND(bfd, message, arglist) \
-       (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
-         ((*((bfd)->xvec->message)) arglist) : \
-         (bfd_assert (__FILE__,__LINE__), NULL))
-     #endif
-   For operations which index on the BFD format:
-     #define BFD_SEND_FMT(bfd, message, arglist) \
-                 (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist)
-     
-     #ifdef DEBUG_BFD_SEND
-     #undef BFD_SEND_FMT
-     #define BFD_SEND_FMT(bfd, message, arglist) \
-       (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
-        (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) : \
-        (bfd_assert (__FILE__,__LINE__), NULL))
-     #endif
-   This is the structure which defines the type of BFD this is.  The
-`xvec' member of the struct `bfd' itself points here.  Each module that
-implements access to a different target under BFD, defines one of these.
-
-   FIXME, these names should be rationalised with the names of the
-entry points which call them. Too bad we can't have one macro to define
-them both!
-     enum bfd_flavour {
-       bfd_target_unknown_flavour,
-       bfd_target_aout_flavour,
-       bfd_target_coff_flavour,
-       bfd_target_ecoff_flavour,
-       bfd_target_xcoff_flavour,
-       bfd_target_elf_flavour,
-       bfd_target_ieee_flavour,
-       bfd_target_nlm_flavour,
-       bfd_target_oasys_flavour,
-       bfd_target_tekhex_flavour,
-       bfd_target_srec_flavour,
-       bfd_target_ihex_flavour,
-       bfd_target_som_flavour,
-       bfd_target_os9k_flavour,
-       bfd_target_versados_flavour,
-       bfd_target_msdos_flavour,
-       bfd_target_ovax_flavour,
-       bfd_target_evax_flavour
-     };
-     
-     enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN };
-     
-     /* Forward declaration.  */
-     typedef struct bfd_link_info _bfd_link_info;
-     
-     typedef struct bfd_target
-     {
-   Identifies the kind of target, e.g., SunOS4, Ultrix, etc.
-       char *name;
-   The "flavour" of a back end is a general indication about the
-contents of a file.
-       enum bfd_flavour flavour;
-   The order of bytes within the data area of a file.
-       enum bfd_endian byteorder;
-   The order of bytes within the header parts of a file.
-       enum bfd_endian header_byteorder;
-   A mask of all the flags which an executable may have set - from the
-set `BFD_NO_FLAGS', `HAS_RELOC', ...`D_PAGED'.
-       flagword object_flags;
-   A mask of all the flags which a section may have set - from the set
-`SEC_NO_FLAGS', `SEC_ALLOC', ...`SET_NEVER_LOAD'.
-       flagword section_flags;
-   The character normally found at the front of a symbol (if any),
-perhaps `_'.
-       char symbol_leading_char;
-   The pad character for file names within an archive header.
-       char ar_pad_char;
-   The maximum number of characters in an archive header.
-       unsigned short ar_max_namelen;
-   Entries for byte swapping for data. These are different from the
-other entry points, since they don't take a BFD asthe first argument.
-Certain other handlers could do the same.
-       bfd_vma      (*bfd_getx64) PARAMS ((const bfd_byte *));
-       bfd_signed_vma (*bfd_getx_signed_64) PARAMS ((const bfd_byte *));
-       void         (*bfd_putx64) PARAMS ((bfd_vma, bfd_byte *));
-       bfd_vma      (*bfd_getx32) PARAMS ((const bfd_byte *));
-       bfd_signed_vma (*bfd_getx_signed_32) PARAMS ((const bfd_byte *));
-       void         (*bfd_putx32) PARAMS ((bfd_vma, bfd_byte *));
-       bfd_vma      (*bfd_getx16) PARAMS ((const bfd_byte *));
-       bfd_signed_vma (*bfd_getx_signed_16) PARAMS ((const bfd_byte *));
-       void         (*bfd_putx16) PARAMS ((bfd_vma, bfd_byte *));
-   Byte swapping for the headers
-       bfd_vma      (*bfd_h_getx64) PARAMS ((const bfd_byte *));
-       bfd_signed_vma (*bfd_h_getx_signed_64) PARAMS ((const bfd_byte *));
-       void         (*bfd_h_putx64) PARAMS ((bfd_vma, bfd_byte *));
-       bfd_vma      (*bfd_h_getx32) PARAMS ((const bfd_byte *));
-       bfd_signed_vma (*bfd_h_getx_signed_32) PARAMS ((const bfd_byte *));
-       void         (*bfd_h_putx32) PARAMS ((bfd_vma, bfd_byte *));
-       bfd_vma      (*bfd_h_getx16) PARAMS ((const bfd_byte *));
-       bfd_signed_vma (*bfd_h_getx_signed_16) PARAMS ((const bfd_byte *));
-       void         (*bfd_h_putx16) PARAMS ((bfd_vma, bfd_byte *));
-   Format dependent routines: these are vectors of entry points within
-the target vector structure, one for each format to check.
-
-   Check the format of a file being read.  Return a `bfd_target *' or
-zero.
-       const struct bfd_target *(*_bfd_check_format[bfd_type_end]) PARAMS ((bfd *));
-   Set the format of a file being written.
-       boolean             (*_bfd_set_format[bfd_type_end]) PARAMS ((bfd *));
-   Write cached information into a file being written, at `bfd_close'.
-       boolean             (*_bfd_write_contents[bfd_type_end]) PARAMS ((bfd *));
-   The general target vector.  These vectors are initialized using the
-BFD_JUMP_TABLE macros.
-
-       /* Generic entry points.  */
-     #define BFD_JUMP_TABLE_GENERIC(NAME)\
-     CAT(NAME,_close_and_cleanup),\
-     CAT(NAME,_bfd_free_cached_info),\
-     CAT(NAME,_new_section_hook),\
-     CAT(NAME,_get_section_contents),\
-     CAT(NAME,_get_section_contents_in_window)
-     
-       /* Called when the BFD is being closed to do any necessary cleanup.  */
-       boolean       (*_close_and_cleanup) PARAMS ((bfd *));
-       /* Ask the BFD to free all cached information.  */
-       boolean (*_bfd_free_cached_info) PARAMS ((bfd *));
-       /* Called when a new section is created.  */
-       boolean       (*_new_section_hook) PARAMS ((bfd *, sec_ptr));
-       /* Read the contents of a section.  */
-       boolean       (*_bfd_get_section_contents) PARAMS ((bfd *, sec_ptr, PTR,
-                                                 file_ptr, bfd_size_type));
-       boolean       (*_bfd_get_section_contents_in_window)
-                               PARAMS ((bfd *, sec_ptr, bfd_window *,
-                                        file_ptr, bfd_size_type));
-     
-       /* Entry points to copy private data.  */
-     #define BFD_JUMP_TABLE_COPY(NAME)\
-     CAT(NAME,_bfd_copy_private_bfd_data),\
-     CAT(NAME,_bfd_merge_private_bfd_data),\
-     CAT(NAME,_bfd_copy_private_section_data),\
-     CAT(NAME,_bfd_copy_private_symbol_data),\
-     CAT(NAME,_bfd_set_private_flags),\
-     CAT(NAME,_bfd_print_private_bfd_data)\
-       /* Called to copy BFD general private data from one object file
-          to another.  */
-       boolean       (*_bfd_copy_private_bfd_data) PARAMS ((bfd *, bfd *));
-       /* Called to merge BFD general private data from one object file
-          to a common output file when linking.  */
-       boolean       (*_bfd_merge_private_bfd_data) PARAMS ((bfd *, bfd *));
-       /* Called to copy BFD private section data from one object file
-          to another.  */
-       boolean       (*_bfd_copy_private_section_data) PARAMS ((bfd *, sec_ptr,
-                                                            bfd *, sec_ptr));
-       /* Called to copy BFD private symbol data from one symbol
-          to another.  */
-       boolean       (*_bfd_copy_private_symbol_data) PARAMS ((bfd *, asymbol *,
-                                                               bfd *, asymbol *));
-       /* Called to set private backend flags */
-       boolean       (*_bfd_set_private_flags) PARAMS ((bfd *, flagword));
-     
-       /* Called to print private BFD data */
-       boolean       (*_bfd_print_private_bfd_data) PARAMS ((bfd *, PTR));
-     
-       /* Core file entry points.  */
-     #define BFD_JUMP_TABLE_CORE(NAME)\
-     CAT(NAME,_core_file_failing_command),\
-     CAT(NAME,_core_file_failing_signal),\
-     CAT(NAME,_core_file_matches_executable_p)
-       char *   (*_core_file_failing_command) PARAMS ((bfd *));
-       int      (*_core_file_failing_signal) PARAMS ((bfd *));
-       boolean  (*_core_file_matches_executable_p) PARAMS ((bfd *, bfd *));
-     
-       /* Archive entry points.  */
-     #define BFD_JUMP_TABLE_ARCHIVE(NAME)\
-     CAT(NAME,_slurp_armap),\
-     CAT(NAME,_slurp_extended_name_table),\
-     CAT(NAME,_construct_extended_name_table),\
-     CAT(NAME,_truncate_arname),\
-     CAT(NAME,_write_armap),\
-     CAT(NAME,_read_ar_hdr),\
-     CAT(NAME,_openr_next_archived_file),\
-     CAT(NAME,_get_elt_at_index),\
-     CAT(NAME,_generic_stat_arch_elt),\
-     CAT(NAME,_update_armap_timestamp)
-       boolean  (*_bfd_slurp_armap) PARAMS ((bfd *));
-       boolean  (*_bfd_slurp_extended_name_table) PARAMS ((bfd *));
-       boolean  (*_bfd_construct_extended_name_table)
-                  PARAMS ((bfd *, char **, bfd_size_type *, const char **));
-       void     (*_bfd_truncate_arname) PARAMS ((bfd *, CONST char *, char *));
-       boolean  (*write_armap) PARAMS ((bfd *arch,
-                                   unsigned int elength,
-                                   struct orl *map,
-                                   unsigned int orl_count,
-                                   int stridx));
-       PTR (*_bfd_read_ar_hdr_fn) PARAMS ((bfd *));
-       bfd *    (*openr_next_archived_file) PARAMS ((bfd *arch, bfd *prev));
-     #define bfd_get_elt_at_index(b,i) BFD_SEND(b, _bfd_get_elt_at_index, (b,i))
-       bfd *    (*_bfd_get_elt_at_index) PARAMS ((bfd *, symindex));
-       int      (*_bfd_stat_arch_elt) PARAMS ((bfd *, struct stat *));
-       boolean  (*_bfd_update_armap_timestamp) PARAMS ((bfd *));
-     
-       /* Entry points used for symbols.  */
-     #define BFD_JUMP_TABLE_SYMBOLS(NAME)\
-     CAT(NAME,_get_symtab_upper_bound),\
-     CAT(NAME,_get_symtab),\
-     CAT(NAME,_make_empty_symbol),\
-     CAT(NAME,_print_symbol),\
-     CAT(NAME,_get_symbol_info),\
-     CAT(NAME,_bfd_is_local_label_name),\
-     CAT(NAME,_get_lineno),\
-     CAT(NAME,_find_nearest_line),\
-     CAT(NAME,_bfd_make_debug_symbol),\
-     CAT(NAME,_read_minisymbols),\
-     CAT(NAME,_minisymbol_to_symbol)
-       long  (*_bfd_get_symtab_upper_bound) PARAMS ((bfd *));
-       long  (*_bfd_canonicalize_symtab) PARAMS ((bfd *,
-                                                  struct symbol_cache_entry **));
-       struct symbol_cache_entry  *
-                     (*_bfd_make_empty_symbol) PARAMS ((bfd *));
-       void          (*_bfd_print_symbol) PARAMS ((bfd *, PTR,
-                                           struct symbol_cache_entry *,
-                                           bfd_print_symbol_type));
-     #define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e))
-       void          (*_bfd_get_symbol_info) PARAMS ((bfd *,
-                                           struct symbol_cache_entry *,
-                                           symbol_info *));
-     #define bfd_get_symbol_info(b,p,e) BFD_SEND(b, _bfd_get_symbol_info, (b,p,e))
-       boolean       (*_bfd_is_local_label_name) PARAMS ((bfd *, const char *));
-     
-       alent *    (*_get_lineno) PARAMS ((bfd *, struct symbol_cache_entry *));
-       boolean    (*_bfd_find_nearest_line) PARAMS ((bfd *abfd,
-                         struct sec *section, struct symbol_cache_entry **symbols,
-                         bfd_vma offset, CONST char **file, CONST char **func,
-                         unsigned int *line));
-      /* Back-door to allow format-aware applications to create debug symbols
-         while using BFD for everything else.  Currently used by the assembler
-         when creating COFF files.  */
-       asymbol *  (*_bfd_make_debug_symbol) PARAMS ((
-            bfd *abfd,
-            void *ptr,
-            unsigned long size));
-     #define bfd_read_minisymbols(b, d, m, s) \
-       BFD_SEND (b, _read_minisymbols, (b, d, m, s))
-       long  (*_read_minisymbols) PARAMS ((bfd *, boolean, PTR *,
-                                           unsigned int *));
-     #define bfd_minisymbol_to_symbol(b, d, m, f) \
-       BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f))
-       asymbol *(*_minisymbol_to_symbol) PARAMS ((bfd *, boolean, const PTR,
-                                                  asymbol *));
-     
-       /* Routines for relocs.  */
-     #define BFD_JUMP_TABLE_RELOCS(NAME)\
-     CAT(NAME,_get_reloc_upper_bound),\
-     CAT(NAME,_canonicalize_reloc),\
-     CAT(NAME,_bfd_reloc_type_lookup)
-       long  (*_get_reloc_upper_bound) PARAMS ((bfd *, sec_ptr));
-       long  (*_bfd_canonicalize_reloc) PARAMS ((bfd *, sec_ptr, arelent **,
-                                                 struct symbol_cache_entry **));
-       /* See documentation on reloc types.  */
-       reloc_howto_type *
-            (*reloc_type_lookup) PARAMS ((bfd *abfd,
-                                          bfd_reloc_code_real_type code));
-     
-       /* Routines used when writing an object file.  */
-     #define BFD_JUMP_TABLE_WRITE(NAME)\
-     CAT(NAME,_set_arch_mach),\
-     CAT(NAME,_set_section_contents)
-       boolean    (*_bfd_set_arch_mach) PARAMS ((bfd *, enum bfd_architecture,
-                         unsigned long));
-       boolean       (*_bfd_set_section_contents) PARAMS ((bfd *, sec_ptr, PTR,
-                                                 file_ptr, bfd_size_type));
-     
-       /* Routines used by the linker.  */
-     #define BFD_JUMP_TABLE_LINK(NAME)\
-     CAT(NAME,_sizeof_headers),\
-     CAT(NAME,_bfd_get_relocated_section_contents),\
-     CAT(NAME,_bfd_relax_section),\
-     CAT(NAME,_bfd_link_hash_table_create),\
-     CAT(NAME,_bfd_link_add_symbols),\
-     CAT(NAME,_bfd_final_link),\
-     CAT(NAME,_bfd_link_split_section),\
-     CAT(NAME,_bfd_gc_sections)
-       int        (*_bfd_sizeof_headers) PARAMS ((bfd *, boolean));
-       bfd_byte * (*_bfd_get_relocated_section_contents) PARAMS ((bfd *,
-                         struct bfd_link_info *, struct bfd_link_order *,
-                         bfd_byte *data, boolean relocateable,
-                         struct symbol_cache_entry **));
-     
-       boolean    (*_bfd_relax_section) PARAMS ((bfd *, struct sec *,
-                         struct bfd_link_info *, boolean *again));
-     
-       /* Create a hash table for the linker.  Different backends store
-          different information in this table.  */
-       struct bfd_link_hash_table *(*_bfd_link_hash_table_create) PARAMS ((bfd *));
-     
-       /* Add symbols from this object file into the hash table.  */
-       boolean (*_bfd_link_add_symbols) PARAMS ((bfd *, struct bfd_link_info *));
-     
-       /* Do a link based on the link_order structures attached to each
-          section of the BFD.  */
-       boolean (*_bfd_final_link) PARAMS ((bfd *, struct bfd_link_info *));
-     
-       /* Should this section be split up into smaller pieces during linking.  */
-       boolean (*_bfd_link_split_section) PARAMS ((bfd *, struct sec *));
-     
-       /* Remove sections that are not referenced from the output.  */
-       boolean (*_bfd_gc_sections) PARAMS ((bfd *, struct bfd_link_info *));
-     
-       /* Routines to handle dynamic symbols and relocs.  */
-     #define BFD_JUMP_TABLE_DYNAMIC(NAME)\
-     CAT(NAME,_get_dynamic_symtab_upper_bound),\
-     CAT(NAME,_canonicalize_dynamic_symtab),\
-     CAT(NAME,_get_dynamic_reloc_upper_bound),\
-     CAT(NAME,_canonicalize_dynamic_reloc)
-       /* Get the amount of memory required to hold the dynamic symbols. */
-       long  (*_bfd_get_dynamic_symtab_upper_bound) PARAMS ((bfd *));
-       /* Read in the dynamic symbols.  */
-       long  (*_bfd_canonicalize_dynamic_symtab)
-         PARAMS ((bfd *, struct symbol_cache_entry **));
-       /* Get the amount of memory required to hold the dynamic relocs.  */
-       long  (*_bfd_get_dynamic_reloc_upper_bound) PARAMS ((bfd *));
-       /* Read in the dynamic relocs.  */
-       long  (*_bfd_canonicalize_dynamic_reloc)
-         PARAMS ((bfd *, arelent **, struct symbol_cache_entry **));
-   A pointer to an alternative bfd_target in case the current one is not
-satisfactory.  This can happen when the target cpu supports both big
-and little endian code, and target chosen by the linker has the wrong
-endianness.  The function open_output() in ld/ldlang.c uses this field
-to find an alternative output format that is suitable.
-      /* Opposite endian version of this target.  */
-      const struct bfd_target * alternative_target;
-   Data for use by back-end routines, which isn't generic enough to
-belong in this structure.
-      PTR backend_data;
-     
-     } bfd_target;
-
-`bfd_set_default_target'
-........................
-
-   *Synopsis*
-     boolean bfd_set_default_target (const char *name);
-   *Description*
-Set the default target vector to use when recognizing a BFD.  This
-takes the name of the target, which may be a BFD target name or a
-configuration triplet.
-
-`bfd_find_target'
-.................
-
-   *Synopsis*
-     const bfd_target *bfd_find_target(CONST char *target_name, bfd *abfd);
-   *Description*
-Return a pointer to the transfer vector for the object target named
-TARGET_NAME.  If TARGET_NAME is `NULL', choose the one in the
-environment variable `GNUTARGET'; if that is null or not defined, then
-choose the first entry in the target list.  Passing in the string
-"default" or setting the environment variable to "default" will cause
-the first entry in the target list to be returned, and
-"target_defaulted" will be set in the BFD.  This causes
-`bfd_check_format' to loop over all the targets to find the one that
-matches the file being read.
-
-`bfd_target_list'
-.................
-
-   *Synopsis*
-     const char **bfd_target_list(void);
-   *Description*
-Return a freshly malloced NULL-terminated vector of the names of all
-the valid BFD targets. Do not modify the names.
-
-`bfd_seach_for_target'
-......................
-
-   *Synopsis*
-     const bfd_target * bfd_search_for_target (int (* search_func) (const bfd_target *, void *), void *);
-   *Description*
-Return a pointer to the first transfer vector in the list of transfer
-vectors maintained by BFD that produces a non-zero result when passed
-to the function SEARCH_FUNC.  The parameter DATA is passed, unexamined,
-to the search function.
-
-
-File: bfd.info,  Node: Architectures,  Next: Opening and Closing,  Prev: Targets,  Up: BFD front end
-
-Architectures
-=============
-
-   BFD keeps one atom in a BFD describing the architecture of the data
-attached to the BFD: a pointer to a `bfd_arch_info_type'.
-
-   Pointers to structures can be requested independently of a BFD so
-that an architecture's information can be interrogated without access
-to an open BFD.
-
-   The architecture information is provided by each architecture
-package.  The set of default architectures is selected by the macro
-`SELECT_ARCHITECTURES'.  This is normally set up in the
-`config/TARGET.mt' file of your choice.  If the name is not defined,
-then all the architectures supported are included.
-
-   When BFD starts up, all the architectures are called with an
-initialize method.  It is up to the architecture back end to insert as
-many items into the list of architectures as it wants to; generally
-this would be one for each machine and one for the default case (an
-item with a machine field of 0).
-
-   BFD's idea of an architecture is implemented in `archures.c'.
-
-bfd_architecture
-----------------
-
-   *Description*
-This enum gives the object file's CPU architecture, in a global
-sense--i.e., what processor family does it belong to?  Another field
-indicates which processor within the family is in use.  The machine
-gives a number which distinguishes different versions of the
-architecture, containing, for example, 2 and 3 for Intel i960 KA and
-i960 KB, and 68020 and 68030 for Motorola 68020 and 68030.
-     enum bfd_architecture
-     {
-       bfd_arch_unknown,   /* File arch not known */
-       bfd_arch_obscure,   /* Arch known, not one of these */
-       bfd_arch_m68k,      /* Motorola 68xxx */
-     #define bfd_mach_m68000 1
-     #define bfd_mach_m68008 2
-     #define bfd_mach_m68010 3
-     #define bfd_mach_m68020 4
-     #define bfd_mach_m68030 5
-     #define bfd_mach_m68040 6
-     #define bfd_mach_m68060 7
-     #define bfd_mach_cpu32  8
-     #define bfd_mach_mcf5200  9
-     #define bfd_mach_mcf5206e 10
-     #define bfd_mach_mcf5307  11
-     #define bfd_mach_mcf5407  12
-       bfd_arch_vax,       /* DEC Vax */
-       bfd_arch_i960,      /* Intel 960 */
-         /* The order of the following is important.
-            lower number indicates a machine type that
-            only accepts a subset of the instructions
-            available to machines with higher numbers.
-            The exception is the "ca", which is
-            incompatible with all other machines except
-            "core". */
-     
-     #define bfd_mach_i960_core      1
-     #define bfd_mach_i960_ka_sa     2
-     #define bfd_mach_i960_kb_sb     3
-     #define bfd_mach_i960_mc        4
-     #define bfd_mach_i960_xa        5
-     #define bfd_mach_i960_ca        6
-     #define bfd_mach_i960_jx        7
-     #define bfd_mach_i960_hx        8
-     
-       bfd_arch_a29k,      /* AMD 29000 */
-       bfd_arch_sparc,     /* SPARC */
-     #define bfd_mach_sparc                 1
-     /* The difference between v8plus and v9 is that v9 is a true 64 bit env.  */
-     #define bfd_mach_sparc_sparclet        2
-     #define bfd_mach_sparc_sparclite       3
-     #define bfd_mach_sparc_v8plus          4
-     #define bfd_mach_sparc_v8plusa         5 /* with ultrasparc add'ns */
-     #define bfd_mach_sparc_sparclite_le    6
-     #define bfd_mach_sparc_v9              7
-     #define bfd_mach_sparc_v9a             8 /* with ultrasparc add'ns */
-     #define bfd_mach_sparc_v8plusb         9 /* with cheetah add'ns */
-     #define bfd_mach_sparc_v9b             10 /* with cheetah add'ns */
-     /* Nonzero if MACH has the v9 instruction set.  */
-     #define bfd_mach_sparc_v9_p(mach) \
-       ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9b \
-        && (mach) != bfd_mach_sparc_sparclite_le)
-       bfd_arch_mips,      /* MIPS Rxxxx */
-     #define bfd_mach_mips3000              3000
-     #define bfd_mach_mips3900              3900
-     #define bfd_mach_mips4000              4000
-     #define bfd_mach_mips4010              4010
-     #define bfd_mach_mips4100              4100
-     #define bfd_mach_mips4111              4111
-     #define bfd_mach_mips4300              4300
-     #define bfd_mach_mips4400              4400
-     #define bfd_mach_mips4600              4600
-     #define bfd_mach_mips4650              4650
-     #define bfd_mach_mips5000              5000
-     #define bfd_mach_mips6000              6000
-     #define bfd_mach_mips8000              8000
-     #define bfd_mach_mips10000             10000
-     #define bfd_mach_mips12000             12000
-     #define bfd_mach_mips16                16
-     #define bfd_mach_mips32                32
-     #define bfd_mach_mips32_4k             3204113 /* 32, 04, octal 'K' */
-     #define bfd_mach_mips5                 5
-     #define bfd_mach_mips64                64
-     #define bfd_mach_mips_sb1              12310201 /* octal 'SB', 01 */
-       bfd_arch_i386,      /* Intel 386 */
-     #define bfd_mach_i386_i386 0
-     #define bfd_mach_i386_i8086 1
-     #define bfd_mach_i386_i386_intel_syntax 2
-     #define bfd_mach_x86_64 3
-     #define bfd_mach_x86_64_intel_syntax 4
-       bfd_arch_we32k,     /* AT&T WE32xxx */
-       bfd_arch_tahoe,     /* CCI/Harris Tahoe */
-       bfd_arch_i860,      /* Intel 860 */
-       bfd_arch_i370,      /* IBM 360/370 Mainframes */
-       bfd_arch_romp,      /* IBM ROMP PC/RT */
-       bfd_arch_alliant,   /* Alliant */
-       bfd_arch_convex,    /* Convex */
-       bfd_arch_m88k,      /* Motorola 88xxx */
-       bfd_arch_pyramid,   /* Pyramid Technology */
-       bfd_arch_h8300,     /* Hitachi H8/300 */
-     #define bfd_mach_h8300   1
-     #define bfd_mach_h8300h  2
-     #define bfd_mach_h8300s  3
-       bfd_arch_powerpc,   /* PowerPC */
-     #define bfd_mach_ppc           0
-     #define bfd_mach_ppc_403       403
-     #define bfd_mach_ppc_403gc     4030
-     #define bfd_mach_ppc_505       505
-     #define bfd_mach_ppc_601       601
-     #define bfd_mach_ppc_602       602
-     #define bfd_mach_ppc_603       603
-     #define bfd_mach_ppc_ec603e    6031
-     #define bfd_mach_ppc_604       604
-     #define bfd_mach_ppc_620       620
-     #define bfd_mach_ppc_630       630
-     #define bfd_mach_ppc_750       750
-     #define bfd_mach_ppc_860       860
-     #define bfd_mach_ppc_a35       35
-     #define bfd_mach_ppc_rs64ii    642
-     #define bfd_mach_ppc_rs64iii   643
-     #define bfd_mach_ppc_7400      7400
-       bfd_arch_rs6000,    /* IBM RS/6000 */
-     #define bfd_mach_rs6k          0
-     #define bfd_mach_rs6k_rs1      6001
-     #define bfd_mach_rs6k_rsc      6003
-     #define bfd_mach_rs6k_rs2      6002
-       bfd_arch_hppa,      /* HP PA RISC */
-       bfd_arch_d10v,      /* Mitsubishi D10V */
-     #define bfd_mach_d10v          0
-     #define bfd_mach_d10v_ts2      2
-     #define bfd_mach_d10v_ts3      3
-       bfd_arch_d30v,      /* Mitsubishi D30V */
-       bfd_arch_m68hc11,   /* Motorola 68HC11 */
-       bfd_arch_m68hc12,   /* Motorola 68HC12 */
-       bfd_arch_z8k,       /* Zilog Z8000 */
-     #define bfd_mach_z8001         1
-     #define bfd_mach_z8002         2
-       bfd_arch_h8500,     /* Hitachi H8/500 */
-       bfd_arch_sh,        /* Hitachi SH */
-     #define bfd_mach_sh            0
-     #define bfd_mach_sh2        0x20
-     #define bfd_mach_sh_dsp     0x2d
-     #define bfd_mach_sh3        0x30
-     #define bfd_mach_sh3_dsp    0x3d
-     #define bfd_mach_sh3e       0x3e
-     #define bfd_mach_sh4        0x40
-       bfd_arch_alpha,     /* Dec Alpha */
-     #define bfd_mach_alpha_ev4  0x10
-     #define bfd_mach_alpha_ev5  0x20
-     #define bfd_mach_alpha_ev6  0x30
-       bfd_arch_arm,       /* Advanced Risc Machines ARM */
-     #define bfd_mach_arm_2         1
-     #define bfd_mach_arm_2a        2
-     #define bfd_mach_arm_3         3
-     #define bfd_mach_arm_3M        4
-     #define bfd_mach_arm_4         5
-     #define bfd_mach_arm_4T        6
-     #define bfd_mach_arm_5         7
-     #define bfd_mach_arm_5T        8
-     #define bfd_mach_arm_5TE       9
-     #define bfd_mach_arm_XScale    10
-       bfd_arch_ns32k,     /* National Semiconductors ns32000 */
-       bfd_arch_w65,       /* WDC 65816 */
-       bfd_arch_tic30,     /* Texas Instruments TMS320C30 */
-       bfd_arch_tic54x,    /* Texas Instruments TMS320C54X */
-       bfd_arch_tic80,     /* TI TMS320c80 (MVP) */
-       bfd_arch_v850,      /* NEC V850 */
-     #define bfd_mach_v850          0
-     #define bfd_mach_v850e         'E'
-     #define bfd_mach_v850ea        'A'
-       bfd_arch_arc,       /* ARC Cores */
-     #define bfd_mach_arc_5         0
-     #define bfd_mach_arc_6         1
-     #define bfd_mach_arc_7         2
-     #define bfd_mach_arc_8         3
-       bfd_arch_m32r,      /* Mitsubishi M32R/D */
-     #define bfd_mach_m32r          0 /* backwards compatibility */
-     #define bfd_mach_m32rx         'x'
-       bfd_arch_mn10200,   /* Matsushita MN10200 */
-       bfd_arch_mn10300,   /* Matsushita MN10300 */
-     #define bfd_mach_mn10300               300
-     #define bfd_mach_am33          330
-       bfd_arch_fr30,
-     #define bfd_mach_fr30          0x46523330
-       bfd_arch_mcore,
-       bfd_arch_ia64,      /* HP/Intel ia64 */
-     #define bfd_mach_ia64_elf64    0
-     #define bfd_mach_ia64_elf32    1
-       bfd_arch_pj,
-       bfd_arch_avr,       /* Atmel AVR microcontrollers */
-     #define bfd_mach_avr1          1
-     #define bfd_mach_avr2          2
-     #define bfd_mach_avr3          3
-     #define bfd_mach_avr4          4
-     #define bfd_mach_avr5          5
-       bfd_arch_cris,      /* Axis CRIS */
-       bfd_arch_last
-       };
-
-bfd_arch_info
--------------
-
-   *Description*
-This structure contains information on architectures for use within BFD.
-
-     typedef struct bfd_arch_info
-     {
-       int bits_per_word;
-       int bits_per_address;
-       int bits_per_byte;
-       enum bfd_architecture arch;
-       unsigned long mach;
-       const char *arch_name;
-       const char *printable_name;
-       unsigned int section_align_power;
-       /* True if this is the default machine for the architecture.  */
-       boolean the_default;
-       const struct bfd_arch_info * (*compatible)
-            PARAMS ((const struct bfd_arch_info *a,
-                     const struct bfd_arch_info *b));
-     
-       boolean (*scan) PARAMS ((const struct bfd_arch_info *, const char *));
-     
-       const struct bfd_arch_info *next;
-     } bfd_arch_info_type;
-
-`bfd_printable_name'
-....................
-
-   *Synopsis*
-     const char *bfd_printable_name(bfd *abfd);
-   *Description*
-Return a printable string representing the architecture and machine
-from the pointer to the architecture info structure.
-
-`bfd_scan_arch'
-...............
-
-   *Synopsis*
-     const bfd_arch_info_type *bfd_scan_arch(const char *string);
-   *Description*
-Figure out if BFD supports any cpu which could be described with the
-name STRING.  Return a pointer to an `arch_info' structure if a machine
-is found, otherwise NULL.
-
-`bfd_arch_list'
-...............
-
-   *Synopsis*
-     const char **bfd_arch_list(void);
-   *Description*
-Return a freshly malloced NULL-terminated vector of the names of all
-the valid BFD architectures.  Do not modify the names.
-
-`bfd_arch_get_compatible'
-.........................
-
-   *Synopsis*
-     const bfd_arch_info_type *bfd_arch_get_compatible(
-         const bfd *abfd,
-         const bfd *bbfd);
-   *Description*
-Determine whether two BFDs' architectures and machine types are
-compatible.  Calculates the lowest common denominator between the two
-architectures and machine types implied by the BFDs and returns a
-pointer to an `arch_info' structure describing the compatible machine.
-
-`bfd_default_arch_struct'
-.........................
-
-   *Description*
-The `bfd_default_arch_struct' is an item of `bfd_arch_info_type' which
-has been initialized to a fairly generic state.  A BFD starts life by
-pointing to this structure, until the correct back end has determined
-the real architecture of the file.
-     extern const bfd_arch_info_type bfd_default_arch_struct;
-
-`bfd_set_arch_info'
-...................
-
-   *Synopsis*
-     void bfd_set_arch_info(bfd *abfd, const bfd_arch_info_type *arg);
-   *Description*
-Set the architecture info of ABFD to ARG.
-
-`bfd_default_set_arch_mach'
-...........................
-
-   *Synopsis*
-     boolean bfd_default_set_arch_mach(bfd *abfd,
-         enum bfd_architecture arch,
-         unsigned long mach);
-   *Description*
-Set the architecture and machine type in BFD ABFD to ARCH and MACH.
-Find the correct pointer to a structure and insert it into the
-`arch_info' pointer.
-
-`bfd_get_arch'
-..............
-
-   *Synopsis*
-     enum bfd_architecture bfd_get_arch(bfd *abfd);
-   *Description*
-Return the enumerated type which describes the BFD ABFD's architecture.
-
-`bfd_get_mach'
-..............
-
-   *Synopsis*
-     unsigned long bfd_get_mach(bfd *abfd);
-   *Description*
-Return the long type which describes the BFD ABFD's machine.
-
-`bfd_arch_bits_per_byte'
-........................
-
-   *Synopsis*
-     unsigned int bfd_arch_bits_per_byte(bfd *abfd);
-   *Description*
-Return the number of bits in one of the BFD ABFD's architecture's bytes.
-
-`bfd_arch_bits_per_address'
-...........................
-
-   *Synopsis*
-     unsigned int bfd_arch_bits_per_address(bfd *abfd);
-   *Description*
-Return the number of bits in one of the BFD ABFD's architecture's
-addresses.
-
-`bfd_default_compatible'
-........................
-
-   *Synopsis*
-     const bfd_arch_info_type *bfd_default_compatible
-        (const bfd_arch_info_type *a,
-         const bfd_arch_info_type *b);
-   *Description*
-The default function for testing for compatibility.
-
-`bfd_default_scan'
-..................
-
-   *Synopsis*
-     boolean bfd_default_scan(const struct bfd_arch_info *info, const char *string);
-   *Description*
-The default function for working out whether this is an architecture
-hit and a machine hit.
-
-`bfd_get_arch_info'
-...................
-
-   *Synopsis*
-     const bfd_arch_info_type * bfd_get_arch_info(bfd *abfd);
-   *Description*
-Return the architecture info struct in ABFD.
-
-`bfd_lookup_arch'
-.................
-
-   *Synopsis*
-     const bfd_arch_info_type *bfd_lookup_arch
-        (enum bfd_architecture
-         arch,
-         unsigned long machine);
-   *Description*
-Look for the architecure info structure which matches the arguments
-ARCH and MACHINE. A machine of 0 matches the machine/architecture
-structure which marks itself as the default.
-
-`bfd_printable_arch_mach'
-.........................
-
-   *Synopsis*
-     const char *bfd_printable_arch_mach
-        (enum bfd_architecture arch, unsigned long machine);
-   *Description*
-Return a printable string representing the architecture and machine
-type.
-
-   This routine is depreciated.
-
-`bfd_octets_per_byte'
-.....................
-
-   *Synopsis*
-     unsigned int bfd_octets_per_byte(bfd *abfd);
-   *Description*
-Return the number of octets (8-bit quantities) per target byte (minimum
-addressable unit).  In most cases, this will be one, but some DSP
-targets have 16, 32, or even 48 bits per byte.
-
-`bfd_arch_mach_octets_per_byte'
-...............................
-
-   *Synopsis*
-     unsigned int bfd_arch_mach_octets_per_byte(enum bfd_architecture arch,
-         unsigned long machine);
-   *Description*
-See bfd_octets_per_byte.
-
-   This routine is provided for those cases where a bfd * is not
-available
-
-
-File: bfd.info,  Node: Opening and Closing,  Next: Internal,  Prev: Architectures,  Up: BFD front end
-
-Opening and closing BFDs
-========================
-
-`bfd_openr'
-...........
-
-   *Synopsis*
-     bfd *bfd_openr(CONST char *filename, CONST char *target);
-   *Description*
-Open the file FILENAME (using `fopen') with the target TARGET.  Return
-a pointer to the created BFD.
-
-   Calls `bfd_find_target', so TARGET is interpreted as by that
-function.
-
-   If `NULL' is returned then an error has occured.   Possible errors
-are `bfd_error_no_memory', `bfd_error_invalid_target' or `system_call'
-error.
-
-`bfd_fdopenr'
-.............
-
-   *Synopsis*
-     bfd *bfd_fdopenr(CONST char *filename, CONST char *target, int fd);
-   *Description*
-`bfd_fdopenr' is to `bfd_fopenr' much like `fdopen' is to `fopen'.  It
-opens a BFD on a file already described by the FD supplied.
-
-   When the file is later `bfd_close'd, the file descriptor will be
-closed.
-
-   If the caller desires that this file descriptor be cached by BFD
-(opened as needed, closed as needed to free descriptors for other
-opens), with the supplied FD used as an initial file descriptor (but
-subject to closure at any time), call bfd_set_cacheable(bfd, 1) on the
-returned BFD.  The default is to assume no cacheing; the file
-descriptor will remain open until `bfd_close', and will not be affected
-by BFD operations on other files.
-
-   Possible errors are `bfd_error_no_memory',
-`bfd_error_invalid_target' and `bfd_error_system_call'.
-
-`bfd_openstreamr'
-.................
-
-   *Synopsis*
-     bfd *bfd_openstreamr(const char *, const char *, PTR);
-   *Description*
-Open a BFD for read access on an existing stdio stream.  When the BFD
-is passed to `bfd_close', the stream will be closed.
-
-`bfd_openw'
-...........
-
-   *Synopsis*
-     bfd *bfd_openw(CONST char *filename, CONST char *target);
-   *Description*
-Create a BFD, associated with file FILENAME, using the file format
-TARGET, and return a pointer to it.
-
-   Possible errors are `bfd_error_system_call', `bfd_error_no_memory',
-`bfd_error_invalid_target'.
-
-`bfd_close'
-...........
-
-   *Synopsis*
-     boolean bfd_close(bfd *abfd);
-   *Description*
-Close a BFD. If the BFD was open for writing, then pending operations
-are completed and the file written out and closed. If the created file
-is executable, then `chmod' is called to mark it as such.
-
-   All memory attached to the BFD is released.
-
-   The file descriptor associated with the BFD is closed (even if it
-was passed in to BFD by `bfd_fdopenr').
-
-   *Returns*
-`true' is returned if all is ok, otherwise `false'.
-
-`bfd_close_all_done'
-....................
-
-   *Synopsis*
-     boolean bfd_close_all_done(bfd *);
-   *Description*
-Close a BFD.  Differs from `bfd_close' since it does not complete any
-pending operations.  This routine would be used if the application had
-just used BFD for swapping and didn't want to use any of the writing
-code.
-
-   If the created file is executable, then `chmod' is called to mark it
-as such.
-
-   All memory attached to the BFD is released.
-
-   *Returns*
-`true' is returned if all is ok, otherwise `false'.
-
-`bfd_create'
-............
-
-   *Synopsis*
-     bfd *bfd_create(CONST char *filename, bfd *templ);
-   *Description*
-Create a new BFD in the manner of `bfd_openw', but without opening a
-file. The new BFD takes the target from the target used by TEMPLATE. The
-format is always set to `bfd_object'.
-
-`bfd_make_writable'
-...................
-
-   *Synopsis*
-     boolean bfd_make_writable(bfd *abfd);
-   *Description*
-Takes a BFD as created by `bfd_create' and converts it into one like as
-returned by `bfd_openw'.  It does this by converting the BFD to
-BFD_IN_MEMORY.  It's assumed that you will call `bfd_make_readable' on
-this bfd later.
-
-   *Returns*
-`true' is returned if all is ok, otherwise `false'.
-
-`bfd_make_readable'
-...................
-
-   *Synopsis*
-     boolean bfd_make_readable(bfd *abfd);
-   *Description*
-Takes a BFD as created by `bfd_create' and `bfd_make_writable' and
-converts it into one like as returned by `bfd_openr'.  It does this by
-writing the contents out to the memory buffer, then reversing the
-direction.
-
-   *Returns*
-`true' is returned if all is ok, otherwise `false'.
-
-`bfd_alloc'
-...........
-
-   *Synopsis*
-     PTR bfd_alloc (bfd *abfd, size_t wanted);
-   *Description*
-Allocate a block of WANTED bytes of memory attached to `abfd' and
-return a pointer to it.
-
-
-File: bfd.info,  Node: Internal,  Next: File Caching,  Prev: Opening and Closing,  Up: BFD front end
-
-Internal functions
-==================
-
-   *Description*
-These routines are used within BFD.  They are not intended for export,
-but are documented here for completeness.
-
-`bfd_write_bigendian_4byte_int'
-...............................
-
-   *Synopsis*
-     void bfd_write_bigendian_4byte_int(bfd *abfd,  int i);
-   *Description*
-Write a 4 byte integer I to the output BFD ABFD, in big endian order
-regardless of what else is going on.  This is useful in archives.
-
-`bfd_put_size'
-..............
-
-`bfd_get_size'
-..............
-
-   *Description*
-These macros as used for reading and writing raw data in sections; each
-access (except for bytes) is vectored through the target format of the
-BFD and mangled accordingly. The mangling performs any necessary endian
-translations and removes alignment restrictions.  Note that types
-accepted and returned by these macros are identical so they can be
-swapped around in macros--for example, `libaout.h' defines `GET_WORD'
-to either `bfd_get_32' or `bfd_get_64'.
-
-   In the put routines, VAL must be a `bfd_vma'.  If we are on a system
-without prototypes, the caller is responsible for making sure that is
-true, with a cast if necessary.  We don't cast them in the macro
-definitions because that would prevent `lint' or `gcc -Wall' from
-detecting sins such as passing a pointer.  To detect calling these with
-less than a `bfd_vma', use `gcc -Wconversion' on a host with 64 bit
-`bfd_vma''s.
-
-     /* Byte swapping macros for user section data.  */
-     
-     #define bfd_put_8(abfd, val, ptr) \
-                     ((void) (*((unsigned char *) (ptr)) = (unsigned char) (val)))
-     #define bfd_put_signed_8 \
-                    bfd_put_8
-     #define bfd_get_8(abfd, ptr) \
-                     (*(unsigned char *) (ptr))
-     #define bfd_get_signed_8(abfd, ptr) \
-                    ((*(unsigned char *) (ptr) ^ 0x80) - 0x80)
-     
-     #define bfd_put_16(abfd, val, ptr) \
-                     BFD_SEND(abfd, bfd_putx16, ((val),(ptr)))
-     #define bfd_put_signed_16 \
-                     bfd_put_16
-     #define bfd_get_16(abfd, ptr) \
-                     BFD_SEND(abfd, bfd_getx16, (ptr))
-     #define bfd_get_signed_16(abfd, ptr) \
-                     BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
-     
-     #define bfd_put_32(abfd, val, ptr) \
-                     BFD_SEND(abfd, bfd_putx32, ((val),(ptr)))
-     #define bfd_put_signed_32 \
-                     bfd_put_32
-     #define bfd_get_32(abfd, ptr) \
-                     BFD_SEND(abfd, bfd_getx32, (ptr))
-     #define bfd_get_signed_32(abfd, ptr) \
-                     BFD_SEND(abfd, bfd_getx_signed_32, (ptr))
-     
-     #define bfd_put_64(abfd, val, ptr) \
-                     BFD_SEND(abfd, bfd_putx64, ((val), (ptr)))
-     #define bfd_put_signed_64 \
-                     bfd_put_64
-     #define bfd_get_64(abfd, ptr) \
-                     BFD_SEND(abfd, bfd_getx64, (ptr))
-     #define bfd_get_signed_64(abfd, ptr) \
-                     BFD_SEND(abfd, bfd_getx_signed_64, (ptr))
-     
-     #define bfd_get(bits, abfd, ptr)                               \
-                     ((bits) == 8 ? bfd_get_8 (abfd, ptr)           \
-                     : (bits) == 16 ? bfd_get_16 (abfd, ptr)        \
-                     : (bits) == 32 ? bfd_get_32 (abfd, ptr)        \
-                     : (bits) == 64 ? bfd_get_64 (abfd, ptr)        \
-                     : (abort (), (bfd_vma) - 1))
-     
-     #define bfd_put(bits, abfd, val, ptr)                          \
-                     ((bits) == 8 ? bfd_put_8 (abfd, val, ptr)      \
-                     : (bits) == 16 ? bfd_put_16 (abfd, val, ptr)   \
-                     : (bits) == 32 ? bfd_put_32 (abfd, val, ptr)   \
-                     : (bits) == 64 ? bfd_put_64 (abfd, val, ptr)   \
-                     : (abort (), (void) 0))
-
-`bfd_h_put_size'
-................
-
-   *Description*
-These macros have the same function as their `bfd_get_x' bretheren,
-except that they are used for removing information for the header
-records of object files. Believe it or not, some object files keep
-their header records in big endian order and their data in little
-endian order.
-
-     /* Byte swapping macros for file header data.  */
-     
-     #define bfd_h_put_8(abfd, val, ptr) \
-                    bfd_put_8 (abfd, val, ptr)
-     #define bfd_h_put_signed_8(abfd, val, ptr) \
-                    bfd_put_8 (abfd, val, ptr)
-     #define bfd_h_get_8(abfd, ptr) \
-                    bfd_get_8 (abfd, ptr)
-     #define bfd_h_get_signed_8(abfd, ptr) \
-                    bfd_get_signed_8 (abfd, ptr)
-     
-     #define bfd_h_put_16(abfd, val, ptr) \
-                     BFD_SEND(abfd, bfd_h_putx16,(val,ptr))
-     #define bfd_h_put_signed_16 \
-                     bfd_h_put_16
-     #define bfd_h_get_16(abfd, ptr) \
-                     BFD_SEND(abfd, bfd_h_getx16,(ptr))
-     #define bfd_h_get_signed_16(abfd, ptr) \
-                     BFD_SEND(abfd, bfd_h_getx_signed_16, (ptr))
-     
-     #define bfd_h_put_32(abfd, val, ptr) \
-                     BFD_SEND(abfd, bfd_h_putx32,(val,ptr))
-     #define bfd_h_put_signed_32 \
-                     bfd_h_put_32
-     #define bfd_h_get_32(abfd, ptr) \
-                     BFD_SEND(abfd, bfd_h_getx32,(ptr))
-     #define bfd_h_get_signed_32(abfd, ptr) \
-                     BFD_SEND(abfd, bfd_h_getx_signed_32, (ptr))
-     
-     #define bfd_h_put_64(abfd, val, ptr) \
-                     BFD_SEND(abfd, bfd_h_putx64,(val, ptr))
-     #define bfd_h_put_signed_64 \
-                     bfd_h_put_64
-     #define bfd_h_get_64(abfd, ptr) \
-                     BFD_SEND(abfd, bfd_h_getx64,(ptr))
-     #define bfd_h_get_signed_64(abfd, ptr) \
-                     BFD_SEND(abfd, bfd_h_getx_signed_64, (ptr))
-
-`bfd_log2'
-..........
-
-   *Synopsis*
-     unsigned int bfd_log2(bfd_vma x);
-   *Description*
-Return the log base 2 of the value supplied, rounded up.  E.g., an X of
-1025 returns 11.
-
-
-File: bfd.info,  Node: File Caching,  Next: Linker Functions,  Prev: Internal,  Up: BFD front end
-
-File caching
-============
-
-   The file caching mechanism is embedded within BFD and allows the
-application to open as many BFDs as it wants without regard to the
-underlying operating system's file descriptor limit (often as low as 20
-open files).  The module in `cache.c' maintains a least recently used
-list of `BFD_CACHE_MAX_OPEN' files, and exports the name
-`bfd_cache_lookup', which runs around and makes sure that the required
-BFD is open. If not, then it chooses a file to close, closes it and
-opens the one wanted, returning its file handle.
-
-`BFD_CACHE_MAX_OPEN macro'
-..........................
-
-   *Description*
-The maximum number of files which the cache will keep open at one time.
-     #define BFD_CACHE_MAX_OPEN 10
-
-`bfd_last_cache'
-................
-
-   *Synopsis*
-     extern bfd *bfd_last_cache;
-   *Description*
-Zero, or a pointer to the topmost BFD on the chain.  This is used by
-the `bfd_cache_lookup' macro in `libbfd.h' to determine when it can
-avoid a function call.
-
-`bfd_cache_lookup'
-..................
-
-   *Description*
-Check to see if the required BFD is the same as the last one looked up.
-If so, then it can use the stream in the BFD with impunity, since it
-can't have changed since the last lookup; otherwise, it has to perform
-the complicated lookup function.
-     #define bfd_cache_lookup(x) \
-         ((x)==bfd_last_cache? \
-           (FILE*) (bfd_last_cache->iostream): \
-            bfd_cache_lookup_worker(x))
-
-`bfd_cache_init'
-................
-
-   *Synopsis*
-     boolean bfd_cache_init (bfd *abfd);
-   *Description*
-Add a newly opened BFD to the cache.
-
-`bfd_cache_close'
-.................
-
-   *Synopsis*
-     boolean bfd_cache_close (bfd *abfd);
-   *Description*
-Remove the BFD ABFD from the cache. If the attached file is open, then
-close it too.
-
-   *Returns*
-`false' is returned if closing the file fails, `true' is returned if
-all is well.
-
-`bfd_open_file'
-...............
-
-   *Synopsis*
-     FILE* bfd_open_file(bfd *abfd);
-   *Description*
-Call the OS to open a file for ABFD.  Return the `FILE *' (possibly
-`NULL') that results from this operation.  Set up the BFD so that
-future accesses know the file is open. If the `FILE *' returned is
-`NULL', then it won't have been put in the cache, so it won't have to
-be removed from it.
-
-`bfd_cache_lookup_worker'
-.........................
-
-   *Synopsis*
-     FILE *bfd_cache_lookup_worker(bfd *abfd);
-   *Description*
-Called when the macro `bfd_cache_lookup' fails to find a quick answer.
-Find a file descriptor for ABFD.  If necessary, it open it.  If there
-are already more than `BFD_CACHE_MAX_OPEN' files open, it tries to
-close one first, to avoid running out of file descriptors.
-