| This is bfd.info, produced by makeinfo version 4.0 from bfd.texinfo. |
| |
| START-INFO-DIR-ENTRY |
| * Bfd: (bfd). The Binary File Descriptor library. |
| END-INFO-DIR-ENTRY |
| |
| This file documents the BFD library. |
| |
| Copyright (C) 1991, 2000 Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.1 |
| or any later version published by the Free Software Foundation; |
| with no Invariant Sections, with no Front-Cover Texts, and with no |
| Back-Cover Texts. A copy of the license is included in the |
| section entitled "GNU Free Documentation License". |
| |
| |
| File: bfd.info, Node: Targets, Next: Architectures, Prev: Core Files, Up: BFD front end |
| |
| Targets |
| ======= |
| |
| *Description* |
| Each port of BFD to a different machine requries the creation of a |
| target back end. All the back end provides to the root part of BFD is a |
| structure containing pointers to functions which perform certain low |
| level operations on files. BFD translates the applications's requests |
| through a pointer into calls to the back end routines. |
| |
| When a file is opened with `bfd_openr', its format and target are |
| unknown. BFD uses various mechanisms to determine how to interpret the |
| file. The operations performed are: |
| |
| * Create a BFD by calling the internal routine `_bfd_new_bfd', then |
| call `bfd_find_target' with the target string supplied to |
| `bfd_openr' and the new BFD pointer. |
| |
| * If a null target string was provided to `bfd_find_target', look up |
| the environment variable `GNUTARGET' and use that as the target |
| string. |
| |
| * If the target string is still `NULL', or the target string is |
| `default', then use the first item in the target vector as the |
| target type, and set `target_defaulted' in the BFD to cause |
| `bfd_check_format' to loop through all the targets. *Note |
| bfd_target::. *Note Formats::. |
| |
| * Otherwise, inspect the elements in the target vector one by one, |
| until a match on target name is found. When found, use it. |
| |
| * Otherwise return the error `bfd_error_invalid_target' to |
| `bfd_openr'. |
| |
| * `bfd_openr' attempts to open the file using `bfd_open_file', and |
| returns the BFD. |
| Once the BFD has been opened and the target selected, the file |
| format may be determined. This is done by calling `bfd_check_format' on |
| 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 |
| guesses right. |
| |
| * Menu: |
| |
| * 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. |
| |
