bfd/libbfd.h

   1
   2 /* libbfd.h -- Declarations used by bfd library *implementation*.
   3    (This include file is not for users of the library.)
   4    Copyright (C) 1990-1991 Free Software Foundation, Inc.
   5    Written by Cygnus Support.
   6
   7 This file is part of BFD, the Binary File Descriptor library.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  22
  23
  24 /* Align an address upward to a boundary, expressed as a number of bytes.
  25    E.g. align to an 8-byte boundary with argument of 8.  */
  26 #define ALIGN(this, boundary) \
  27   ((( (this) + ((boundary) -1)) & (~((boundary)-1))))
  28
  29 /* If you want to read and write large blocks, you might want to do it
  30    in quanta of this amount */
  31 #define DEFAULT_BUFFERSIZE 8192
  32
  33 /* Set a tdata field.  Can't use the other macros for this, since they
  34    do casts, and casting to the left of assignment isn't portable.  */
  35 #define set_tdata(bfd, v) ((bfd)->tdata = (PTR) (v))
  36
  37 /* tdata for an archive.  For an input archive, cache
  38    needs to be free()'d.  For an output archive, symdefs do.  */
  39
  40 struct artdata {
  41   file_ptr first_file_filepos;
  42   /* Speed up searching the armap */
  43   struct ar_cache *cache;
  44   bfd *archive_head;            /* Only interesting in output routines */
  45   carsym *symdefs;              /* the symdef entries */
  46   symindex symdef_count;             /* how many there are */
  47   char *extended_names;         /* clever intel extension */
  48 };
  49
  50 #define bfd_ardata(bfd) ((struct artdata *) ((bfd)->tdata))
  51
  52 /* Goes in bfd's arelt_data slot */
  53 struct areltdata {
  54   char * arch_header;                        /* it's actually a string */
  55   unsigned int parsed_size;     /* octets of filesize not including ar_hdr */
  56   char *filename;                            /* null-terminated */
  57 };
  58
  59 #define arelt_size(bfd) (((struct areltdata *)((bfd)->arelt_data))->parsed_size)
  60
  61 /* FIXME -- a lot of my code allocates a large block and subdivides it.
  62    This can't always work, because of alignment restrictions.  We should change
  63    it before it becomes a problem -- Gumby */
  64
  65 PROTO (char *, zalloc, (bfd_size_type size));
  66
  67 /* These routines allocate and free things on the BFD's obstack.  Note
  68    that realloc can never occur in place.  */
  69
  70 PROTO(PTR, bfd_alloc, (bfd *abfd, bfd_size_type size));
  71 PROTO(PTR, bfd_zalloc,(bfd *abfd, bfd_size_type size));
  72 PROTO(PTR, bfd_realloc,(bfd *abfd, PTR orig, bfd_size_type new));
  73 PROTO(void, bfd_alloc_grow,(bfd *abfd, PTR thing, bfd_size_type size));
  74 PROTO(PTR, bfd_alloc_finish,(bfd *abfd));
  75
  76 #define bfd_release(x,y) (void) obstack_free(&(x->memory),y)
  77
  78
  79 PROTO (bfd_size_type, bfd_read, (PTR ptr, bfd_size_type size, bfd_size_type nitems, bfd *abfd));
  80 PROTO (bfd_size_type, bfd_write, (CONST PTR ptr, bfd_size_type size, bfd_size_type nitems, bfd *abfd));
  81
  82
  83
  84 PROTO (int, bfd_seek,(bfd* abfd, file_ptr fp , int direction));
  85 PROTO (long, bfd_tell, (bfd *abfd));
  86 PROTO (bfd *, _bfd_create_empty_archive_element_shell, (bfd *obfd));
  87 PROTO (bfd *, look_for_bfd_in_cache, (bfd *arch_bfd, file_ptr index));
  88 PROTO (boolean, _bfd_generic_mkarchive, (bfd *abfd));
  89 PROTO (struct areltdata *, snarf_ar_hdr, (bfd *abfd));
  90 PROTO (bfd_target *, bfd_generic_archive_p, (bfd *abfd));
  91 PROTO (boolean, bfd_slurp_bsd_armap, (bfd *abfd));
  92 PROTO (boolean, bfd_slurp_coff_armap, (bfd *abfd));
  93 PROTO (boolean, _bfd_slurp_extended_name_table, (bfd *abfd));
  94 PROTO (boolean, _bfd_write_archive_contents, (bfd *abfd));
  95 PROTO (bfd *, new_bfd, ());
  96
  97 #define DEFAULT_STRING_SPACE_SIZE 0x2000
  98 PROTO (boolean, bfd_add_to_string_table, (char **table, char *new_string,
  99                                           unsigned int *table_length,
 100                                           char **free_ptr));
 101 PROTO (bfd_vma, _do_getb64, (unsigned char *addr));
 102 PROTO (bfd_vma, _do_getl64, (unsigned char *addr));
 103 PROTO (bfd_vma, _do_getb32, (unsigned char *addr));
 104 PROTO (bfd_vma, _do_getl32, (unsigned char *addr));
 105 PROTO (bfd_vma, _do_getb16, (unsigned char *addr));
 106 PROTO (bfd_vma, _do_getl16, (unsigned char *addr));
 107 PROTO (void, _do_putb64, (bfd_vma data, unsigned char *addr));
 108 PROTO (void, _do_putl64, (bfd_vma data, unsigned char *addr));
 109 PROTO (void, _do_putb32, (bfd_vma data, unsigned char *addr));
 110 PROTO (void, _do_putl32, (bfd_vma data, unsigned char *addr));
 111 PROTO (void, _do_putb16, (bfd_vma data, unsigned char *addr));
 112 PROTO (void, _do_putl16, (bfd_vma data, unsigned char *addr));
 113
 114 PROTO (boolean, bfd_false, (bfd *ignore));
 115 PROTO (boolean, bfd_true, (bfd *ignore));
 116 PROTO (PTR, bfd_nullvoidptr, (bfd *ignore));
 117 PROTO (int, bfd_0, (bfd *ignore));
 118 PROTO (unsigned int, bfd_0u, (bfd *ignore));
 119 PROTO (void, bfd_void, (bfd *ignore));
 120
 121 PROTO (bfd *,new_bfd_contained_in,(bfd *));
 122 PROTO (boolean, _bfd_dummy_new_section_hook, (bfd *ignore, asection *newsect));
 123 PROTO (char *, _bfd_dummy_core_file_failing_command, (bfd *abfd));
 124 PROTO (int, _bfd_dummy_core_file_failing_signal, (bfd *abfd));
 125 PROTO (boolean, _bfd_dummy_core_file_matches_executable_p, (bfd *core_bfd,
 126                                                             bfd *exec_bfd));
 127 PROTO (bfd_target *, _bfd_dummy_target, (bfd *abfd));
 128
 129 PROTO (void, bfd_dont_truncate_arname, (bfd *abfd, CONST char *filename,
 130                                         char *hdr));
 131 PROTO (void, bfd_bsd_truncate_arname, (bfd *abfd, CONST char *filename,
 132                                         char *hdr));
 133 PROTO (void, bfd_gnu_truncate_arname, (bfd *abfd, CONST char *filename,
 134                                         char *hdr));
 135
 136 PROTO (boolean, bsd_write_armap, (bfd *arch, unsigned int elength,
 137                                   struct orl *map, unsigned int orl_count, int stridx));
 138
 139 PROTO (boolean, coff_write_armap, (bfd *arch, unsigned int elength,
 140                                    struct orl *map, unsigned int orl_count, int stridx));
 141
 142 PROTO (bfd *, bfd_generic_openr_next_archived_file, (bfd *archive,
 143                                                      bfd *last_file));
 144
 145 PROTO(int, bfd_generic_stat_arch_elt, (bfd *, struct stat *));
 146
 147 PROTO(boolean, bfd_generic_get_section_contents,
 148       (bfd *abfd, sec_ptr section, PTR location, file_ptr offset,
 149        bfd_size_type count));
 150
 151 PROTO(boolean, bfd_generic_set_section_contents,
 152       (bfd *abfd, sec_ptr section, PTR location, file_ptr offset,
 153        bfd_size_type count));
 154
 155 /* Macros to tell if bfds are read or write enabled.
 156
 157    Note that bfds open for read may be scribbled into if the fd passed
 158    to bfd_fdopenr is actually open both for read and write
 159    simultaneously.  However an output bfd will never be open for
 160    read.  Therefore sometimes you want to check bfd_read_p or
 161    !bfd_read_p, and only sometimes bfd_write_p.
 162 */
 163
 164 #define bfd_read_p(abfd) ((abfd)->direction == read_direction || (abfd)->direction == both_direction)
 165 #define bfd_write_p(abfd) ((abfd)->direction == write_direction || (abfd)->direction == both_direction)
 166
 167 PROTO (void, bfd_assert,(char*,int));
 168 #define BFD_ASSERT(x) \
 169 { if (!(x)) bfd_assert(__FILE__,__LINE__); }
 170
 171 #define BFD_FAIL() \
 172 { bfd_assert(__FILE__,__LINE__); }
 173
 174 PROTO (FILE *, bfd_cache_lookup_worker, (bfd *));
 175
 176 extern bfd *bfd_last_cache;
 177
 178 /* Now Steve, what's the story here? */
 179 #ifdef lint
 180 #define itos(x) "l"
 181 #define stoi(x) 1
 182 #else
 183 #define itos(x) ((char*)(x))
 184 #define stoi(x) ((int)(x))
 185 #endif
 186
 187 /* Generic routine for close_and_cleanup is really just bfd_true.  */
 188 #define bfd_generic_close_and_cleanup   bfd_true
 189
 190 /* THE FOLLOWING IS EXTRACTED FROM THE SOURCE*/
 191
 192 /*:init.c*/
 193 /* bfd_check_init
 194
 195 This routine is called before any other bfd function using initialized
 196 data is used to ensure that the structures have been initialized.
 197 Soon this function will go away, and the bfd library will assume that
 198 bfd_init has been called.
 199 */
 200
 201  void EXFUN(bfd_check_init,(void));
 202
 203 /*
 204 */
 205
 206 /*:libbfd.c*/
 207 /* bfd_write_bigendian_4byte_int
 208 */
 209
 210  PROTO(void, bfd_write_bigendian_4byte_int,( bfd *abfd,  int i));
 211
 212 /*
 213
 214 *i bfd_log2
 215 Return the log base 2 of the value supplied, rounded up. eg an arg
 216 of 1025 would return 11.
 217 */
 218  PROTO(bfd_vma, bfd_log2,(bfd_vma x));
 219
 220 /*
 221 */
 222
 223 /*:cache.c*/
 224 /* BFD_CACHE_MAX_OPEN
 225 The maxiumum number of files which the cache will keep open at one
 226 time.
 227 */
 228 #define BFD_CACHE_MAX_OPEN 10
 229
 230 /*
 231
 232   bfd_last_cache
 233 Zero, or a pointer to the topmost BFD on the chain.  This is used by
 234 the @code{bfd_cache_lookup} macro in @file{libbfd.h} to determine when
 235 it can avoid a function call.
 236 */
 237 extern bfd *bfd_last_cache;
 238
 239 /*
 240
 241   bfd_cache_lookup
 242 Checks to see if the required BFD is the same as the last one looked
 243 up. If so then it can use the iostream in the BFD with impunity, since
 244 it can't have changed since the last lookup, otherwise it has to
 245 perform the complicated lookup function
 246 */
 247 #define bfd_cache_lookup(x) \
 248      ((x)==bfd_last_cache? \
 249         (FILE*)(bfd_last_cache->iostream): \
 250          bfd_cache_lookup_worker(x))
 251
 252 /*
 253
 254 *i bfd_cache_init
 255 Initialize a BFD by putting it on the cache LRU.
 256 */
 257  PROTO(void, bfd_cache_init, (bfd *));
 258
 259 /*
 260
 261 *i bfd_cache_close
 262 Remove the BFD from the cache. If the attached file is open, then close it too.
 263 */
 264  PROTO(void, bfd_cache_close, (bfd *));
 265
 266 /*
 267
 268 *i bfd_open_file
 269 Call the OS to open a file for this BFD.  Returns the FILE *
 270 (possibly null) that results from this operation.  Sets up the
 271 BFD so that future accesses know the file is open. If the FILE *
 272 returned is null, then there is won't have been put in the cache, so
 273 it won't have to be removed from it.
 274 */
 275  PROTO(FILE *, bfd_open_file, (bfd *));
 276
 277 /*
 278
 279 *i bfd_cache_lookup_worker
 280 Called when the macro @code{bfd_cache_lookup} fails to find a quick
 281 answer. Finds a file descriptor for this BFD.  If necessary, it open it.
 282 If there are already more than BFD_CACHE_MAX_OPEN files open, it trys to close
 283 one first, to avoid running out of file descriptors.
 284 */
 285  PROTO(FILE *, bfd_cache_lookup_worker, (bfd *));
 286
 287 /*
 288 */
 289
 290
 291 /*:reloc.c*/
 292
 293 /*:cpu-h8300.c*/
 294
 295 /*:cpu-i960.c*/
 296
 297 /*:cpu-empty.c*/
 298
 299 /*:archures.c*/
 300 /* bfd_default_arch_struct
 301
 302 What bfds are seeded with
 303 */
 304
 305 extern bfd_arch_info_type bfd_default_arch_struct;
 306
 307 /*
 308  bfd_default_set_arch_mach
 309
 310 Set the architecture and machine type in a bfd. This finds the correct
 311 pointer to structure and inserts it into the arch_info pointer.
 312 */
 313
 314   boolean EXFUN(bfd_default_set_arch_mach,(bfd *abfd,
 315           enum bfd_architecture arch,
 316          unsigned long mach));
 317
 318 /*
 319
 320 This routine initializes the architecture dispatch table by calling
 321 all installed architecture packages and getting them to poke around.
 322 */
 323
 324  PROTO(void, bfd_arch_init,(void));
 325
 326 /*
 327
 328  bfd_arch_linkin
 329
 330 Link the provided arch info structure into the list
 331 */
 332
 333  void EXFUN(bfd_arch_linkin,(bfd_arch_info_type *));
 334
 335 /*
 336
 337  bfd_default_compatible
 338
 339 The default function for testing for compatibility
 340 */
 341
 342  CONST bfd_arch_info_type *EXFUN(bfd_default_compatible,
 343      (CONST bfd_arch_info_type *a,
 344      CONST bfd_arch_info_type *b));
 345
 346 /*
 347
 348  bfd_default_scan
 349 The default function for working out whether this is an architecture
 350 hit and a machine hit
 351 */
 352
 353  boolean EXFUN(bfd_default_scan,(CONST struct bfd_arch_info *, CONST char *));
 354
 355 /*
 356 */
 357
 358