bfd/libbfd-in.h

   1 /* libbfd.h -- Declarations used by bfd library *implementation*.
   2    (This include file is not for users of the library.)
   3    Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   4    Written by Cygnus Support.
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21
  22 /* Use builtin alloca for gcc.  */
  23 #ifdef __GNUC__
  24 #ifndef alloca
  25 #define alloca __builtin_alloca
  26 #endif
  27 #endif
  28
  29 /* Align an address upward to a boundary, expressed as a number of bytes.
  30    E.g. align to an 8-byte boundary with argument of 8.  */
  31 #define BFD_ALIGN(this, boundary) \
  32   ((( (this) + ((boundary) -1)) & (~((boundary)-1))))
  33
  34 /* If you want to read and write large blocks, you might want to do it
  35    in quanta of this amount */
  36 #define DEFAULT_BUFFERSIZE 8192
  37
  38 /* Set a tdata field.  Can't use the other macros for this, since they
  39    do casts, and casting to the left of assignment isn't portable.  */
  40 #define set_tdata(bfd, v) ((bfd)->tdata.any = (PTR) (v))
  41
  42 /* tdata for an archive.  For an input archive, cache
  43    needs to be free()'d.  For an output archive, symdefs do.  */
  44
  45 struct artdata {
  46   file_ptr first_file_filepos;
  47   /* Speed up searching the armap */
  48   struct ar_cache *cache;
  49   bfd *archive_head;            /* Only interesting in output routines */
  50   carsym *symdefs;              /* the symdef entries */
  51   symindex symdef_count;             /* how many there are */
  52   char *extended_names;         /* clever intel extension */
  53   /* when more compilers are standard C, this can be a time_t */
  54   long  armap_timestamp;        /* Timestamp value written into armap.
  55                                    This is used for BSD archives to check
  56                                    that the timestamp is recent enough
  57                                    for the BSD linker to not complain,
  58                                    just before we finish writing an
  59                                    archive.  */
  60   file_ptr armap_datepos;       /* Position within archive to seek to
  61                                    rewrite the date field.  */
  62   PTR tdata;                    /* Backend specific information.  */
  63 };
  64
  65 #define bfd_ardata(bfd) ((bfd)->tdata.aout_ar_data)
  66
  67 /* Goes in bfd's arelt_data slot */
  68 struct areltdata {
  69   char * arch_header;                        /* it's actually a string */
  70   unsigned int parsed_size;     /* octets of filesize not including ar_hdr */
  71   char *filename;                            /* null-terminated */
  72 };
  73
  74 #define arelt_size(bfd) (((struct areltdata *)((bfd)->arelt_data))->parsed_size)
  75
  76 /* There is major inconsistency in how running out of memory is handled.
  77    Some routines return a NULL, and set bfd_error to no_memory.
  78    However, obstack routines can't do this ... */
  79
  80 char *bfd_zmalloc PARAMS ((bfd_size_type size));
  81 /* From libiberty.  */
  82 extern PTR xmalloc PARAMS ((size_t));
  83 /* SIZE is bfd_size_type.  */
  84 #define bfd_xmalloc(size) xmalloc ((size_t) size)
  85 /* Defined without an argument so its address can be used.  */
  86 #define bfd_xmalloc_by_size_t xmalloc
  87
  88 /* These routines allocate and free things on the BFD's obstack.  Note
  89    that realloc can never occur in place.  */
  90
  91 PTR     bfd_alloc PARAMS ((bfd *abfd, size_t size));
  92 PTR     bfd_zalloc PARAMS ((bfd *abfd, size_t size));
  93 PTR     bfd_realloc PARAMS ((bfd *abfd, PTR orig, size_t new));
  94 void    bfd_alloc_grow PARAMS ((bfd *abfd, PTR thing, size_t size));
  95 PTR     bfd_alloc_finish PARAMS ((bfd *abfd));
  96 PTR     bfd_alloc_by_size_t PARAMS ((bfd *abfd, size_t wanted));
  97
  98 #define bfd_release(x,y) (void) obstack_free(&(x->memory),y)
  99
 100
 101 bfd_size_type   bfd_read  PARAMS ((PTR ptr, bfd_size_type size,
 102                                    bfd_size_type nitems, bfd *abfd));
 103 bfd_size_type   bfd_write PARAMS ((CONST PTR ptr, bfd_size_type size,
 104                                    bfd_size_type nitems, bfd *abfd));
 105 int             bfd_seek  PARAMS ((bfd* CONST abfd, CONST file_ptr fp,
 106                                    CONST int direction));
 107 long            bfd_tell  PARAMS ((bfd *abfd));
 108
 109 int             bfd_flush PARAMS ((bfd *abfd));
 110 int             bfd_stat  PARAMS ((bfd *abfd, struct stat *));
 111
 112 bfd *   _bfd_create_empty_archive_element_shell PARAMS ((bfd *obfd));
 113 bfd *   _bfd_look_for_bfd_in_cache PARAMS ((bfd *arch_bfd, file_ptr index));
 114 boolean _bfd_add_bfd_to_archive_cache PARAMS ((bfd *, file_ptr, bfd *));
 115 boolean _bfd_generic_mkarchive PARAMS ((bfd *abfd));
 116 struct areltdata *      _bfd_snarf_ar_hdr PARAMS ((bfd *abfd));
 117 bfd_target *            bfd_generic_archive_p PARAMS ((bfd *abfd));
 118 boolean bfd_slurp_armap PARAMS ((bfd *abfd));
 119 boolean bfd_slurp_bsd_armap_f2 PARAMS ((bfd *abfd));
 120 #define bfd_slurp_bsd_armap bfd_slurp_armap
 121 #define bfd_slurp_coff_armap bfd_slurp_armap
 122 boolean _bfd_slurp_extended_name_table PARAMS ((bfd *abfd));
 123 boolean _bfd_write_archive_contents PARAMS ((bfd *abfd));
 124 bfd *_bfd_get_elt_at_filepos PARAMS ((bfd *archive, file_ptr filepos));
 125 bfd * _bfd_new_bfd PARAMS ((void));
 126
 127 #define DEFAULT_STRING_SPACE_SIZE 0x2000
 128 boolean bfd_add_to_string_table PARAMS ((char **table, char *new_string,
 129                                          unsigned int *table_length,
 130                                          char **free_ptr));
 131
 132 boolean bfd_false PARAMS ((bfd *ignore));
 133 boolean bfd_true PARAMS ((bfd *ignore));
 134 PTR     bfd_nullvoidptr PARAMS ((bfd *ignore));
 135 int     bfd_0 PARAMS ((bfd *ignore));
 136 unsigned int    bfd_0u PARAMS ((bfd *ignore));
 137 void    bfd_void PARAMS ((bfd *ignore));
 138
 139 bfd *   _bfd_new_bfd_contained_in PARAMS ((bfd *));
 140 boolean  _bfd_dummy_new_section_hook PARAMS ((bfd *ignore, asection *newsect));
 141 char *   _bfd_dummy_core_file_failing_command PARAMS ((bfd *abfd));
 142 int      _bfd_dummy_core_file_failing_signal PARAMS ((bfd *abfd));
 143 boolean  _bfd_dummy_core_file_matches_executable_p PARAMS ((bfd *core_bfd,
 144                                                             bfd *exec_bfd));
 145 bfd_target *    _bfd_dummy_target PARAMS ((bfd *abfd));
 146
 147 void    bfd_dont_truncate_arname PARAMS ((bfd *abfd, CONST char *filename,
 148                                         char *hdr));
 149 void    bfd_bsd_truncate_arname PARAMS ((bfd *abfd, CONST char *filename,
 150                                         char *hdr));
 151 void    bfd_gnu_truncate_arname PARAMS ((bfd *abfd, CONST char *filename,
 152                                         char *hdr));
 153
 154 boolean bsd_write_armap PARAMS ((bfd *arch, unsigned int elength,
 155                                   struct orl *map, unsigned int orl_count, int stridx));
 156
 157 boolean coff_write_armap PARAMS ((bfd *arch, unsigned int elength,
 158                                    struct orl *map, unsigned int orl_count, int stridx));
 159
 160 bfd *   bfd_generic_openr_next_archived_file PARAMS ((bfd *archive,
 161                                                      bfd *last_file));
 162
 163 int     bfd_generic_stat_arch_elt PARAMS ((bfd *, struct stat *));
 164
 165 boolean bfd_generic_get_section_contents PARAMS ((bfd *abfd, sec_ptr section,
 166                                                   PTR location, file_ptr offset,
 167                                                   bfd_size_type count));
 168
 169 boolean bfd_generic_set_section_contents PARAMS ((bfd *abfd, sec_ptr section,
 170                                                   PTR location, file_ptr offset,
 171                                                   bfd_size_type count));
 172 \f
 173 /* A routine to create entries for a bfd_link_hash_table.  */
 174 extern struct bfd_hash_entry *_bfd_link_hash_newfunc
 175   PARAMS ((struct bfd_hash_entry *entry,
 176            struct bfd_hash_table *table,
 177            const char *string));
 178
 179 /* Initialize a bfd_link_hash_table.  */
 180 extern boolean _bfd_link_hash_table_init
 181   PARAMS ((struct bfd_link_hash_table *, bfd *,
 182            struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
 183                                        struct bfd_hash_table *,
 184                                        const char *)));
 185
 186 /* Generic link hash table creation routine.  */
 187 extern struct bfd_link_hash_table *_bfd_generic_link_hash_table_create
 188   PARAMS ((bfd *));
 189
 190 /* Generic add symbol routine.  */
 191 extern boolean _bfd_generic_link_add_symbols
 192   PARAMS ((bfd *, struct bfd_link_info *));
 193
 194 /* Generic archive add symbol routine.  */
 195 extern boolean _bfd_generic_link_add_archive_symbols
 196   PARAMS ((bfd *, struct bfd_link_info *,
 197            boolean (*checkfn) (bfd *, struct bfd_link_info *, boolean *)));
 198
 199 /* Forward declaration to avoid prototype errors.  */
 200 typedef struct bfd_link_hash_entry _bfd_link_hash_entry;
 201
 202 /* Generic routine to add a single symbol.  */
 203 extern boolean _bfd_generic_link_add_one_symbol
 204   PARAMS ((struct bfd_link_info *, bfd *, const char *name, flagword,
 205            asection *, bfd_vma, const char *, boolean copy,
 206            boolean constructor, unsigned int bitsize,
 207            struct bfd_link_hash_entry **));
 208
 209 /* Generic link routine.  */
 210 extern boolean _bfd_generic_final_link
 211   PARAMS ((bfd *, struct bfd_link_info *));
 212
 213 /* Default link order processing routine.  */
 214 extern boolean _bfd_default_link_order
 215   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 216            struct bfd_link_order *));
 217
 218 /* Final link relocation routine.  */
 219 extern bfd_reloc_status_type _bfd_final_link_relocate
 220   PARAMS ((const reloc_howto_type *, bfd *, asection *, bfd_byte *,
 221            bfd_vma address, bfd_vma value, bfd_vma addend));
 222
 223 /* Relocate a particular location by a howto and a value.  */
 224 extern bfd_reloc_status_type _bfd_relocate_contents
 225   PARAMS ((const reloc_howto_type *, bfd *, bfd_vma, bfd_byte *));
 226 \f
 227 /* Macros to tell if bfds are read or write enabled.
 228
 229    Note that bfds open for read may be scribbled into if the fd passed
 230    to bfd_fdopenr is actually open both for read and write
 231    simultaneously.  However an output bfd will never be open for
 232    read.  Therefore sometimes you want to check bfd_read_p or
 233    !bfd_read_p, and only sometimes bfd_write_p.
 234 */
 235
 236 #define bfd_read_p(abfd) ((abfd)->direction == read_direction || (abfd)->direction == both_direction)
 237 #define bfd_write_p(abfd) ((abfd)->direction == write_direction || (abfd)->direction == both_direction)
 238
 239 void    bfd_assert PARAMS ((char*,int));
 240
 241 #define BFD_ASSERT(x) \
 242 { if (!(x)) bfd_assert(__FILE__,__LINE__); }
 243
 244 #define BFD_FAIL() \
 245 { bfd_assert(__FILE__,__LINE__); }
 246
 247 FILE *  bfd_cache_lookup_worker PARAMS ((bfd *));
 248
 249 extern bfd *bfd_last_cache;
 250
 251 /* Now Steve, what's the story here? */
 252 #ifdef lint
 253 #define itos(x) "l"
 254 #define stoi(x) 1
 255 #else
 256 #define itos(x) ((char*)(x))
 257 #define stoi(x) ((int)(x))
 258 #endif
 259
 260 /* Generic routine for close_and_cleanup is really just bfd_true.  */
 261 #define bfd_generic_close_and_cleanup   bfd_true
 262
 263 /* List of supported target vectors, and the default vector (if
 264    bfd_default_vector[0] is NULL, there is no default).  */
 265 extern bfd_target *bfd_target_vector[];
 266 extern bfd_target *bfd_default_vector[];
 267
 268 /* And more follows */
 269