contrib/binutils/bfd/doc/targets.texi

   1 @section Targets
   2
   3
   4 @strong{Description}@*
   5 Each port of BFD to a different machine requries the creation
   6 of a target back end. All the back end provides to the root
   7 part of BFD is a structure containing pointers to functions
   8 which perform certain low level operations on files. BFD
   9 translates the applications's requests through a pointer into
  10 calls to the back end routines.
  11
  12 When a file is opened with @code{bfd_openr}, its format and
  13 target are unknown. BFD uses various mechanisms to determine
  14 how to interpret the file. The operations performed are:
  15
  16 @itemize @bullet
  17
  18 @item
  19 Create a BFD by calling the internal routine
  20 @code{_bfd_new_bfd}, then call @code{bfd_find_target} with the
  21 target string supplied to @code{bfd_openr} and the new BFD pointer.
  22
  23 @item
  24 If a null target string was provided to @code{bfd_find_target},
  25 look up the environment variable @code{GNUTARGET} and use
  26 that as the target string.
  27
  28 @item
  29 If the target string is still @code{NULL}, or the target string is
  30 @code{default}, then use the first item in the target vector
  31 as the target type, and set @code{target_defaulted} in the BFD to
  32 cause @code{bfd_check_format} to loop through all the targets.
  33 @xref{bfd_target}.  @xref{Formats}.
  34
  35 @item
  36 Otherwise, inspect the elements in the target vector
  37 one by one, until a match on target name is found. When found,
  38 use it.
  39
  40 @item
  41 Otherwise return the error @code{bfd_error_invalid_target} to
  42 @code{bfd_openr}.
  43
  44 @item
  45 @code{bfd_openr} attempts to open the file using
  46 @code{bfd_open_file}, and returns the BFD.
  47 @end itemize
  48 Once the BFD has been opened and the target selected, the file
  49 format may be determined. This is done by calling
  50 @code{bfd_check_format} on the BFD with a suggested format.
  51 If @code{target_defaulted} has been set, each possible target
  52 type is tried to see if it recognizes the specified format.
  53 @code{bfd_check_format} returns @code{true} when the caller guesses right.
  54 @menu
  55 * bfd_target::
  56 @end menu
  57
  58 @node bfd_target,  , Targets, Targets
  59
  60 @subsection bfd_target
  61
  62
  63 @strong{Description}@*
  64 This structure contains everything that BFD knows about a
  65 target. It includes things like its byte order, name, and which
  66 routines to call to do various operations.
  67
  68 Every BFD points to a target structure with its @code{xvec}
  69 member.
  70
  71 The macros below are used to dispatch to functions through the
  72 @code{bfd_target} vector. They are used in a number of macros further
  73 down in @file{bfd.h}, and are also used when calling various
  74 routines by hand inside the BFD implementation.  The @var{arglist}
  75 argument must be parenthesized; it contains all the arguments
  76 to the called function.
  77
  78 They make the documentation (more) unpleasant to read, so if
  79 someone wants to fix this and not break the above, please do.
  80 @example
  81 #define BFD_SEND(bfd, message, arglist) \
  82                ((*((bfd)->xvec->message)) arglist)
  83
  84 #ifdef DEBUG_BFD_SEND
  85 #undef BFD_SEND
  86 #define BFD_SEND(bfd, message, arglist) \
  87   (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
  88     ((*((bfd)->xvec->message)) arglist) : \
  89     (bfd_assert (__FILE__,__LINE__), NULL))
  90 #endif
  91 @end example
  92 For operations which index on the BFD format:
  93 @example
  94 #define BFD_SEND_FMT(bfd, message, arglist) \
  95             (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist)
  96
  97 #ifdef DEBUG_BFD_SEND
  98 #undef BFD_SEND_FMT
  99 #define BFD_SEND_FMT(bfd, message, arglist) \
 100   (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
 101    (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) : \
 102    (bfd_assert (__FILE__,__LINE__), NULL))
 103 #endif
 104
 105 @end example
 106 This is the structure which defines the type of BFD this is.  The
 107 @code{xvec} member of the struct @code{bfd} itself points here.  Each
 108 module that implements access to a different target under BFD,
 109 defines one of these.
 110
 111 FIXME, these names should be rationalised with the names of
 112 the entry points which call them. Too bad we can't have one
 113 macro to define them both!
 114 @example
 115 enum bfd_flavour
 116 @{
 117   bfd_target_unknown_flavour,
 118   bfd_target_aout_flavour,
 119   bfd_target_coff_flavour,
 120   bfd_target_ecoff_flavour,
 121   bfd_target_xcoff_flavour,
 122   bfd_target_elf_flavour,
 123   bfd_target_ieee_flavour,
 124   bfd_target_nlm_flavour,
 125   bfd_target_oasys_flavour,
 126   bfd_target_tekhex_flavour,
 127   bfd_target_srec_flavour,
 128   bfd_target_ihex_flavour,
 129   bfd_target_som_flavour,
 130   bfd_target_os9k_flavour,
 131   bfd_target_versados_flavour,
 132   bfd_target_msdos_flavour,
 133   bfd_target_ovax_flavour,
 134   bfd_target_evax_flavour,
 135   bfd_target_mmo_flavour
 136 @};
 137
 138 enum bfd_endian @{ BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN @};
 139
 140 /* Forward declaration.  */
 141 typedef struct bfd_link_info _bfd_link_info;
 142
 143 typedef struct bfd_target
 144 @{
 145   /* Identifies the kind of target, e.g., SunOS4, Ultrix, etc.  */
 146   char *name;
 147
 148  /* The "flavour" of a back end is a general indication about
 149     the contents of a file.  */
 150   enum bfd_flavour flavour;
 151
 152   /* The order of bytes within the data area of a file.  */
 153   enum bfd_endian byteorder;
 154
 155  /* The order of bytes within the header parts of a file.  */
 156   enum bfd_endian header_byteorder;
 157
 158   /* A mask of all the flags which an executable may have set -
 159      from the set @code{BFD_NO_FLAGS}, @code{HAS_RELOC}, ...@code{D_PAGED}.  */
 160   flagword object_flags;
 161
 162  /* A mask of all the flags which a section may have set - from
 163     the set @code{SEC_NO_FLAGS}, @code{SEC_ALLOC}, ...@code{SET_NEVER_LOAD}.  */
 164   flagword section_flags;
 165
 166  /* The character normally found at the front of a symbol.
 167     (if any), perhaps `_'.  */
 168   char symbol_leading_char;
 169
 170  /* The pad character for file names within an archive header.  */
 171   char ar_pad_char;
 172
 173   /* The maximum number of characters in an archive header.  */
 174   unsigned short ar_max_namelen;
 175
 176   /* Entries for byte swapping for data. These are different from the
 177      other entry points, since they don't take a BFD asthe first argument.
 178      Certain other handlers could do the same.  */
 179   bfd_vma        (*bfd_getx64) PARAMS ((const bfd_byte *));
 180   bfd_signed_vma (*bfd_getx_signed_64) PARAMS ((const bfd_byte *));
 181   void           (*bfd_putx64) PARAMS ((bfd_vma, bfd_byte *));
 182   bfd_vma        (*bfd_getx32) PARAMS ((const bfd_byte *));
 183   bfd_signed_vma (*bfd_getx_signed_32) PARAMS ((const bfd_byte *));
 184   void           (*bfd_putx32) PARAMS ((bfd_vma, bfd_byte *));
 185   bfd_vma        (*bfd_getx16) PARAMS ((const bfd_byte *));
 186   bfd_signed_vma (*bfd_getx_signed_16) PARAMS ((const bfd_byte *));
 187   void           (*bfd_putx16) PARAMS ((bfd_vma, bfd_byte *));
 188
 189   /* Byte swapping for the headers.  */
 190   bfd_vma        (*bfd_h_getx64) PARAMS ((const bfd_byte *));
 191   bfd_signed_vma (*bfd_h_getx_signed_64) PARAMS ((const bfd_byte *));
 192   void           (*bfd_h_putx64) PARAMS ((bfd_vma, bfd_byte *));
 193   bfd_vma        (*bfd_h_getx32) PARAMS ((const bfd_byte *));
 194   bfd_signed_vma (*bfd_h_getx_signed_32) PARAMS ((const bfd_byte *));
 195   void           (*bfd_h_putx32) PARAMS ((bfd_vma, bfd_byte *));
 196   bfd_vma        (*bfd_h_getx16) PARAMS ((const bfd_byte *));
 197   bfd_signed_vma (*bfd_h_getx_signed_16) PARAMS ((const bfd_byte *));
 198   void           (*bfd_h_putx16) PARAMS ((bfd_vma, bfd_byte *));
 199
 200   /* Format dependent routines: these are vectors of entry points
 201      within the target vector structure, one for each format to check.  */
 202
 203   /* Check the format of a file being read.  Return a @code{bfd_target *} or zero.  */
 204   const struct bfd_target *(*_bfd_check_format[bfd_type_end]) PARAMS ((bfd *));
 205
 206   /* Set the format of a file being written.  */
 207   boolean  (*_bfd_set_format[bfd_type_end]) PARAMS ((bfd *));
 208
 209   /* Write cached information into a file being written, at @code{bfd_close}.  */
 210   boolean  (*_bfd_write_contents[bfd_type_end]) PARAMS ((bfd *));
 211
 212 @end example
 213 The general target vector.  These vectors are initialized using the
 214 BFD_JUMP_TABLE macros.
 215 @example
 216
 217   /* Generic entry points.  */
 218 @end example
 219 Do not "beautify" the CONCAT* macro args.  Traditional C will not
 220 remove whitespace added here, and thus will fail to concatenate
 221 the tokens.
 222 @example
 223 #define BFD_JUMP_TABLE_GENERIC(NAME) \
 224 CONCAT2 (NAME,_close_and_cleanup), \
 225 CONCAT2 (NAME,_bfd_free_cached_info), \
 226 CONCAT2 (NAME,_new_section_hook), \
 227 CONCAT2 (NAME,_get_section_contents), \
 228 CONCAT2 (NAME,_get_section_contents_in_window)
 229
 230   /* Called when the BFD is being closed to do any necessary cleanup.  */
 231   boolean  (*_close_and_cleanup) PARAMS ((bfd *));
 232   /* Ask the BFD to free all cached information.  */
 233   boolean  (*_bfd_free_cached_info) PARAMS ((bfd *));
 234   /* Called when a new section is created.  */
 235   boolean  (*_new_section_hook) PARAMS ((bfd *, sec_ptr));
 236   /* Read the contents of a section.  */
 237   boolean  (*_bfd_get_section_contents) PARAMS ((bfd *, sec_ptr, PTR,
 238                                                  file_ptr, bfd_size_type));
 239   boolean  (*_bfd_get_section_contents_in_window)
 240     PARAMS ((bfd *, sec_ptr, bfd_window *, file_ptr, bfd_size_type));
 241
 242   /* Entry points to copy private data.  */
 243 #define BFD_JUMP_TABLE_COPY(NAME) \
 244 CONCAT2 (NAME,_bfd_copy_private_bfd_data), \
 245 CONCAT2 (NAME,_bfd_merge_private_bfd_data), \
 246 CONCAT2 (NAME,_bfd_copy_private_section_data), \
 247 CONCAT2 (NAME,_bfd_copy_private_symbol_data), \
 248 CONCAT2 (NAME,_bfd_set_private_flags), \
 249 CONCAT2 (NAME,_bfd_print_private_bfd_data) \
 250   /* Called to copy BFD general private data from one object file
 251      to another.  */
 252   boolean  (*_bfd_copy_private_bfd_data) PARAMS ((bfd *, bfd *));
 253   /* Called to merge BFD general private data from one object file
 254      to a common output file when linking.  */
 255   boolean  (*_bfd_merge_private_bfd_data) PARAMS ((bfd *, bfd *));
 256   /* Called to copy BFD private section data from one object file
 257      to another.  */
 258   boolean  (*_bfd_copy_private_section_data) PARAMS ((bfd *, sec_ptr,
 259                                                       bfd *, sec_ptr));
 260   /* Called to copy BFD private symbol data from one symbol
 261      to another.  */
 262   boolean  (*_bfd_copy_private_symbol_data) PARAMS ((bfd *, asymbol *,
 263                                                      bfd *, asymbol *));
 264   /* Called to set private backend flags.  */
 265   boolean  (*_bfd_set_private_flags) PARAMS ((bfd *, flagword));
 266
 267   /* Called to print private BFD data.  */
 268   boolean  (*_bfd_print_private_bfd_data) PARAMS ((bfd *, PTR));
 269
 270   /* Core file entry points.  */
 271 #define BFD_JUMP_TABLE_CORE(NAME) \
 272 CONCAT2 (NAME,_core_file_failing_command), \
 273 CONCAT2 (NAME,_core_file_failing_signal), \
 274 CONCAT2 (NAME,_core_file_matches_executable_p)
 275   char *   (*_core_file_failing_command) PARAMS ((bfd *));
 276   int      (*_core_file_failing_signal) PARAMS ((bfd *));
 277   boolean  (*_core_file_matches_executable_p) PARAMS ((bfd *, bfd *));
 278
 279   /* Archive entry points.  */
 280 #define BFD_JUMP_TABLE_ARCHIVE(NAME) \
 281 CONCAT2 (NAME,_slurp_armap), \
 282 CONCAT2 (NAME,_slurp_extended_name_table), \
 283 CONCAT2 (NAME,_construct_extended_name_table), \
 284 CONCAT2 (NAME,_truncate_arname), \
 285 CONCAT2 (NAME,_write_armap), \
 286 CONCAT2 (NAME,_read_ar_hdr), \
 287 CONCAT2 (NAME,_openr_next_archived_file), \
 288 CONCAT2 (NAME,_get_elt_at_index), \
 289 CONCAT2 (NAME,_generic_stat_arch_elt), \
 290 CONCAT2 (NAME,_update_armap_timestamp)
 291   boolean  (*_bfd_slurp_armap) PARAMS ((bfd *));
 292   boolean  (*_bfd_slurp_extended_name_table) PARAMS ((bfd *));
 293   boolean  (*_bfd_construct_extended_name_table)
 294     PARAMS ((bfd *, char **, bfd_size_type *, const char **));
 295   void     (*_bfd_truncate_arname) PARAMS ((bfd *, const char *, char *));
 296   boolean  (*write_armap)
 297     PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int));
 298   PTR      (*_bfd_read_ar_hdr_fn) PARAMS ((bfd *));
 299   bfd *    (*openr_next_archived_file) PARAMS ((bfd *, bfd *));
 300 #define bfd_get_elt_at_index(b,i) BFD_SEND(b, _bfd_get_elt_at_index, (b,i))
 301   bfd *    (*_bfd_get_elt_at_index) PARAMS ((bfd *, symindex));
 302   int      (*_bfd_stat_arch_elt) PARAMS ((bfd *, struct stat *));
 303   boolean  (*_bfd_update_armap_timestamp) PARAMS ((bfd *));
 304
 305   /* Entry points used for symbols.  */
 306 #define BFD_JUMP_TABLE_SYMBOLS(NAME) \
 307 CONCAT2 (NAME,_get_symtab_upper_bound), \
 308 CONCAT2 (NAME,_get_symtab), \
 309 CONCAT2 (NAME,_make_empty_symbol), \
 310 CONCAT2 (NAME,_print_symbol), \
 311 CONCAT2 (NAME,_get_symbol_info), \
 312 CONCAT2 (NAME,_bfd_is_local_label_name), \
 313 CONCAT2 (NAME,_get_lineno), \
 314 CONCAT2 (NAME,_find_nearest_line), \
 315 CONCAT2 (NAME,_bfd_make_debug_symbol), \
 316 CONCAT2 (NAME,_read_minisymbols), \
 317 CONCAT2 (NAME,_minisymbol_to_symbol)
 318   long     (*_bfd_get_symtab_upper_bound) PARAMS ((bfd *));
 319   long     (*_bfd_canonicalize_symtab) PARAMS ((bfd *,
 320                                                 struct symbol_cache_entry **));
 321   struct symbol_cache_entry *
 322            (*_bfd_make_empty_symbol) PARAMS ((bfd *));
 323   void     (*_bfd_print_symbol) PARAMS ((bfd *, PTR,
 324                                          struct symbol_cache_entry *,
 325                                          bfd_print_symbol_type));
 326 #define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e))
 327   void     (*_bfd_get_symbol_info) PARAMS ((bfd *,
 328                                             struct symbol_cache_entry *,
 329                                             symbol_info *));
 330 #define bfd_get_symbol_info(b,p,e) BFD_SEND(b, _bfd_get_symbol_info, (b,p,e))
 331   boolean  (*_bfd_is_local_label_name) PARAMS ((bfd *, const char *));
 332
 333   alent *  (*_get_lineno) PARAMS ((bfd *, struct symbol_cache_entry *));
 334   boolean  (*_bfd_find_nearest_line)
 335     PARAMS ((bfd *, struct sec *, struct symbol_cache_entry **, bfd_vma,
 336              const char **, const char **, unsigned int *));
 337  /* Back-door to allow format-aware applications to create debug symbols
 338     while using BFD for everything else.  Currently used by the assembler
 339     when creating COFF files.  */
 340   asymbol *(*_bfd_make_debug_symbol) PARAMS ((bfd *, void *,
 341                                               unsigned long size));
 342 #define bfd_read_minisymbols(b, d, m, s) \
 343   BFD_SEND (b, _read_minisymbols, (b, d, m, s))
 344   long     (*_read_minisymbols) PARAMS ((bfd *, boolean, PTR *,
 345                                          unsigned int *));
 346 #define bfd_minisymbol_to_symbol(b, d, m, f) \
 347   BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f))
 348   asymbol *(*_minisymbol_to_symbol) PARAMS ((bfd *, boolean, const PTR,
 349                                              asymbol *));
 350
 351   /* Routines for relocs.  */
 352 #define BFD_JUMP_TABLE_RELOCS(NAME) \
 353 CONCAT2 (NAME,_get_reloc_upper_bound), \
 354 CONCAT2 (NAME,_canonicalize_reloc), \
 355 CONCAT2 (NAME,_bfd_reloc_type_lookup)
 356   long     (*_get_reloc_upper_bound) PARAMS ((bfd *, sec_ptr));
 357   long     (*_bfd_canonicalize_reloc) PARAMS ((bfd *, sec_ptr, arelent **,
 358                                                struct symbol_cache_entry **));
 359   /* See documentation on reloc types.  */
 360   reloc_howto_type *
 361            (*reloc_type_lookup) PARAMS ((bfd *, bfd_reloc_code_real_type));
 362
 363   /* Routines used when writing an object file.  */
 364 #define BFD_JUMP_TABLE_WRITE(NAME) \
 365 CONCAT2 (NAME,_set_arch_mach), \
 366 CONCAT2 (NAME,_set_section_contents)
 367   boolean  (*_bfd_set_arch_mach) PARAMS ((bfd *, enum bfd_architecture,
 368                                           unsigned long));
 369   boolean  (*_bfd_set_section_contents) PARAMS ((bfd *, sec_ptr, PTR,
 370                                                  file_ptr, bfd_size_type));
 371
 372   /* Routines used by the linker.  */
 373 #define BFD_JUMP_TABLE_LINK(NAME) \
 374 CONCAT2 (NAME,_sizeof_headers), \
 375 CONCAT2 (NAME,_bfd_get_relocated_section_contents), \
 376 CONCAT2 (NAME,_bfd_relax_section), \
 377 CONCAT2 (NAME,_bfd_link_hash_table_create), \
 378 CONCAT2 (NAME,_bfd_link_add_symbols), \
 379 CONCAT2 (NAME,_bfd_final_link), \
 380 CONCAT2 (NAME,_bfd_link_split_section), \
 381 CONCAT2 (NAME,_bfd_gc_sections), \
 382 CONCAT2 (NAME,_bfd_merge_sections)
 383   int      (*_bfd_sizeof_headers) PARAMS ((bfd *, boolean));
 384   bfd_byte *(*_bfd_get_relocated_section_contents)
 385     PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
 386              bfd_byte *, boolean, struct symbol_cache_entry **));
 387
 388   boolean  (*_bfd_relax_section)
 389     PARAMS ((bfd *, struct sec *, struct bfd_link_info *, boolean *));
 390
 391   /* Create a hash table for the linker.  Different backends store
 392      different information in this table.  */
 393   struct bfd_link_hash_table *(*_bfd_link_hash_table_create) PARAMS ((bfd *));
 394
 395   /* Add symbols from this object file into the hash table.  */
 396   boolean  (*_bfd_link_add_symbols) PARAMS ((bfd *, struct bfd_link_info *));
 397
 398   /* Do a link based on the link_order structures attached to each
 399      section of the BFD.  */
 400   boolean  (*_bfd_final_link) PARAMS ((bfd *, struct bfd_link_info *));
 401
 402   /* Should this section be split up into smaller pieces during linking.  */
 403   boolean  (*_bfd_link_split_section) PARAMS ((bfd *, struct sec *));
 404
 405   /* Remove sections that are not referenced from the output.  */
 406   boolean  (*_bfd_gc_sections) PARAMS ((bfd *, struct bfd_link_info *));
 407
 408   /* Attempt to merge SEC_MERGE sections.  */
 409   boolean  (*_bfd_merge_sections) PARAMS ((bfd *, struct bfd_link_info *));
 410
 411   /* Routines to handle dynamic symbols and relocs.  */
 412 #define BFD_JUMP_TABLE_DYNAMIC(NAME) \
 413 CONCAT2 (NAME,_get_dynamic_symtab_upper_bound), \
 414 CONCAT2 (NAME,_canonicalize_dynamic_symtab), \
 415 CONCAT2 (NAME,_get_dynamic_reloc_upper_bound), \
 416 CONCAT2 (NAME,_canonicalize_dynamic_reloc)
 417   /* Get the amount of memory required to hold the dynamic symbols.  */
 418   long     (*_bfd_get_dynamic_symtab_upper_bound) PARAMS ((bfd *));
 419   /* Read in the dynamic symbols.  */
 420   long     (*_bfd_canonicalize_dynamic_symtab)
 421     PARAMS ((bfd *, struct symbol_cache_entry **));
 422   /* Get the amount of memory required to hold the dynamic relocs.  */
 423   long     (*_bfd_get_dynamic_reloc_upper_bound) PARAMS ((bfd *));
 424   /* Read in the dynamic relocs.  */
 425   long     (*_bfd_canonicalize_dynamic_reloc)
 426     PARAMS ((bfd *, arelent **, struct symbol_cache_entry **));
 427
 428 @end example
 429 A pointer to an alternative bfd_target in case the current one is not
 430 satisfactory.  This can happen when the target cpu supports both big
 431 and little endian code, and target chosen by the linker has the wrong
 432 endianness.  The function open_output() in ld/ldlang.c uses this field
 433 to find an alternative output format that is suitable.
 434 @example
 435   /* Opposite endian version of this target.  */
 436   const struct bfd_target * alternative_target;
 437
 438   /* Data for use by back-end routines, which isn't
 439      generic enough to belong in this structure.  */
 440   PTR backend_data;
 441
 442 @} bfd_target;
 443
 444 @end example
 445
 446 @findex bfd_set_default_target
 447 @subsubsection @code{bfd_set_default_target}
 448 @strong{Synopsis}
 449 @example
 450 boolean bfd_set_default_target (const char *name);
 451 @end example
 452 @strong{Description}@*
 453 Set the default target vector to use when recognizing a BFD.
 454 This takes the name of the target, which may be a BFD target
 455 name or a configuration triplet.
 456
 457 @findex bfd_find_target
 458 @subsubsection @code{bfd_find_target}
 459 @strong{Synopsis}
 460 @example
 461 const bfd_target *bfd_find_target(const char *target_name, bfd *abfd);
 462 @end example
 463 @strong{Description}@*
 464 Return a pointer to the transfer vector for the object target
 465 named @var{target_name}.  If @var{target_name} is @code{NULL}, choose the
 466 one in the environment variable @code{GNUTARGET}; if that is null or not
 467 defined, then choose the first entry in the target list.
 468 Passing in the string "default" or setting the environment
 469 variable to "default" will cause the first entry in the target
 470 list to be returned, and "target_defaulted" will be set in the
 471 BFD.  This causes @code{bfd_check_format} to loop over all the
 472 targets to find the one that matches the file being read.
 473
 474 @findex bfd_target_list
 475 @subsubsection @code{bfd_target_list}
 476 @strong{Synopsis}
 477 @example
 478 const char **bfd_target_list(void);
 479 @end example
 480 @strong{Description}@*
 481 Return a freshly malloced NULL-terminated
 482 vector of the names of all the valid BFD targets. Do not
 483 modify the names.
 484
 485 @findex bfd_seach_for_target
 486 @subsubsection @code{bfd_seach_for_target}
 487 @strong{Synopsis}
 488 @example
 489 const bfd_target * bfd_search_for_target (int (* search_func) (const bfd_target *, void *), void *);
 490 @end example
 491 @strong{Description}@*
 492 Return a pointer to the first transfer vector in the list of
 493 transfer vectors maintained by BFD that produces a non-zero
 494 result when passed to the function @var{search_func}.  The
 495 parameter @var{data} is passed, unexamined, to the search
 496 function.
 497