bfd/opncls.c

   1 /* opncls.c -- open and close a BFD.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
   3    2001, 2002, 2003
   4    Free Software Foundation, Inc.
   5
   6    Written by Cygnus Support.
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  23
  24 #include "bfd.h"
  25 #include "sysdep.h"
  26 #include "objalloc.h"
  27 #include "libbfd.h"
  28 #include "libiberty.h"
  29
  30 #ifndef S_IXUSR
  31 #define S_IXUSR 0100    /* Execute by owner.  */
  32 #endif
  33 #ifndef S_IXGRP
  34 #define S_IXGRP 0010    /* Execute by group.  */
  35 #endif
  36 #ifndef S_IXOTH
  37 #define S_IXOTH 0001    /* Execute by others.  */
  38 #endif
  39
  40 /* Counter used to initialize the bfd identifier.  */
  41
  42 static unsigned int _bfd_id_counter = 0;
  43
  44 /* fdopen is a loser -- we should use stdio exclusively.  Unfortunately
  45    if we do that we can't use fcntl.  */
  46
  47 /* Return a new BFD.  All BFD's are allocated through this routine.  */
  48
  49 bfd *
  50 _bfd_new_bfd (void)
  51 {
  52   bfd *nbfd;
  53
  54   nbfd = bfd_zmalloc (sizeof (bfd));
  55   if (nbfd == NULL)
  56     return NULL;
  57
  58   nbfd->id = _bfd_id_counter++;
  59
  60   nbfd->memory = objalloc_create ();
  61   if (nbfd->memory == NULL)
  62     {
  63       bfd_set_error (bfd_error_no_memory);
  64       free (nbfd);
  65       return NULL;
  66     }
  67
  68   nbfd->arch_info = &bfd_default_arch_struct;
  69
  70   nbfd->direction = no_direction;
  71   nbfd->iostream = NULL;
  72   nbfd->where = 0;
  73   if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
  74                               251))
  75     {
  76       free (nbfd);
  77       return NULL;
  78     }
  79   nbfd->sections = NULL;
  80   nbfd->section_tail = &nbfd->sections;
  81   nbfd->format = bfd_unknown;
  82   nbfd->my_archive = NULL;
  83   nbfd->origin = 0;
  84   nbfd->opened_once = FALSE;
  85   nbfd->output_has_begun = FALSE;
  86   nbfd->section_count = 0;
  87   nbfd->usrdata = NULL;
  88   nbfd->cacheable = FALSE;
  89   nbfd->flags = BFD_NO_FLAGS;
  90   nbfd->mtime_set = FALSE;
  91
  92   return nbfd;
  93 }
  94
  95 /* Allocate a new BFD as a member of archive OBFD.  */
  96
  97 bfd *
  98 _bfd_new_bfd_contained_in (bfd *obfd)
  99 {
 100   bfd *nbfd;
 101
 102   nbfd = _bfd_new_bfd ();
 103   if (nbfd == NULL)
 104     return NULL;
 105   nbfd->xvec = obfd->xvec;
 106   nbfd->iovec = obfd->iovec;
 107   nbfd->my_archive = obfd;
 108   nbfd->direction = read_direction;
 109   nbfd->target_defaulted = obfd->target_defaulted;
 110   return nbfd;
 111 }
 112
 113 /* Delete a BFD.  */
 114
 115 void
 116 _bfd_delete_bfd (bfd *abfd)
 117 {
 118   bfd_hash_table_free (&abfd->section_htab);
 119   objalloc_free ((struct objalloc *) abfd->memory);
 120   free (abfd);
 121 }
 122
 123 /*
 124 SECTION
 125         Opening and closing BFDs
 126
 127 */
 128
 129 /*
 130 FUNCTION
 131         bfd_openr
 132
 133 SYNOPSIS
 134         bfd *bfd_openr (const char *filename, const char *target);
 135
 136 DESCRIPTION
 137         Open the file @var{filename} (using <<fopen>>) with the target
 138         @var{target}.  Return a pointer to the created BFD.
 139
 140         Calls <<bfd_find_target>>, so @var{target} is interpreted as by
 141         that function.
 142
 143         If <<NULL>> is returned then an error has occured.   Possible errors
 144         are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
 145         <<system_call>> error.
 146 */
 147
 148 bfd *
 149 bfd_openr (const char *filename, const char *target)
 150 {
 151   bfd *nbfd;
 152   const bfd_target *target_vec;
 153
 154   nbfd = _bfd_new_bfd ();
 155   if (nbfd == NULL)
 156     return NULL;
 157
 158   target_vec = bfd_find_target (target, nbfd);
 159   if (target_vec == NULL)
 160     {
 161       _bfd_delete_bfd (nbfd);
 162       return NULL;
 163     }
 164
 165   nbfd->filename = filename;
 166   nbfd->direction = read_direction;
 167
 168   if (bfd_open_file (nbfd) == NULL)
 169     {
 170       /* File didn't exist, or some such.  */
 171       bfd_set_error (bfd_error_system_call);
 172       _bfd_delete_bfd (nbfd);
 173       return NULL;
 174     }
 175
 176   return nbfd;
 177 }
 178
 179 /* Don't try to `optimize' this function:
 180
 181    o - We lock using stack space so that interrupting the locking
 182        won't cause a storage leak.
 183    o - We open the file stream last, since we don't want to have to
 184        close it if anything goes wrong.  Closing the stream means closing
 185        the file descriptor too, even though we didn't open it.  */
 186 /*
 187 FUNCTION
 188         bfd_fdopenr
 189
 190 SYNOPSIS
 191         bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
 192
 193 DESCRIPTION
 194         <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
 195         <<fopen>>.  It opens a BFD on a file already described by the
 196         @var{fd} supplied.
 197
 198         When the file is later <<bfd_close>>d, the file descriptor will
 199         be closed.  If the caller desires that this file descriptor be
 200         cached by BFD (opened as needed, closed as needed to free
 201         descriptors for other opens), with the supplied @var{fd} used as
 202         an initial file descriptor (but subject to closure at any time),
 203         call bfd_set_cacheable(bfd, 1) on the returned BFD.  The default
 204         is to assume no caching; the file descriptor will remain open
 205         until <<bfd_close>>, and will not be affected by BFD operations
 206         on other files.
 207
 208         Possible errors are <<bfd_error_no_memory>>,
 209         <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
 210 */
 211
 212 bfd *
 213 bfd_fdopenr (const char *filename, const char *target, int fd)
 214 {
 215   bfd *nbfd;
 216   const bfd_target *target_vec;
 217   int fdflags;
 218
 219   bfd_set_error (bfd_error_system_call);
 220 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
 221   fdflags = O_RDWR;                     /* Assume full access.  */
 222 #else
 223   fdflags = fcntl (fd, F_GETFL, NULL);
 224 #endif
 225   if (fdflags == -1)
 226     return NULL;
 227
 228   nbfd = _bfd_new_bfd ();
 229   if (nbfd == NULL)
 230     return NULL;
 231
 232   target_vec = bfd_find_target (target, nbfd);
 233   if (target_vec == NULL)
 234     {
 235       _bfd_delete_bfd (nbfd);
 236       return NULL;
 237     }
 238
 239 #ifndef HAVE_FDOPEN
 240   nbfd->iostream = fopen (filename, FOPEN_RB);
 241 #else
 242   /* (O_ACCMODE) parens are to avoid Ultrix header file bug.  */
 243   switch (fdflags & (O_ACCMODE))
 244     {
 245     case O_RDONLY: nbfd->iostream = fdopen (fd, FOPEN_RB);   break;
 246     case O_WRONLY: nbfd->iostream = fdopen (fd, FOPEN_RUB);  break;
 247     case O_RDWR:   nbfd->iostream = fdopen (fd, FOPEN_RUB);  break;
 248     default: abort ();
 249     }
 250 #endif
 251
 252   if (nbfd->iostream == NULL)
 253     {
 254       _bfd_delete_bfd (nbfd);
 255       return NULL;
 256     }
 257
 258   /* OK, put everything where it belongs.  */
 259   nbfd->filename = filename;
 260
 261   /* As a special case we allow a FD open for read/write to
 262      be written through, although doing so requires that we end
 263      the previous clause with a preposition.  */
 264   /* (O_ACCMODE) parens are to avoid Ultrix header file bug.  */
 265   switch (fdflags & (O_ACCMODE))
 266     {
 267     case O_RDONLY: nbfd->direction = read_direction; break;
 268     case O_WRONLY: nbfd->direction = write_direction; break;
 269     case O_RDWR: nbfd->direction = both_direction; break;
 270     default: abort ();
 271     }
 272
 273   if (! bfd_cache_init (nbfd))
 274     {
 275       _bfd_delete_bfd (nbfd);
 276       return NULL;
 277     }
 278   nbfd->opened_once = TRUE;
 279
 280   return nbfd;
 281 }
 282
 283 /*
 284 FUNCTION
 285         bfd_openstreamr
 286
 287 SYNOPSIS
 288         bfd *bfd_openstreamr (const char *, const char *, void *);
 289
 290 DESCRIPTION
 291
 292         Open a BFD for read access on an existing stdio stream.  When
 293         the BFD is passed to <<bfd_close>>, the stream will be closed.
 294 */
 295
 296 bfd *
 297 bfd_openstreamr (const char *filename, const char *target, void *streamarg)
 298 {
 299   FILE *stream = streamarg;
 300   bfd *nbfd;
 301   const bfd_target *target_vec;
 302
 303   nbfd = _bfd_new_bfd ();
 304   if (nbfd == NULL)
 305     return NULL;
 306
 307   target_vec = bfd_find_target (target, nbfd);
 308   if (target_vec == NULL)
 309     {
 310       _bfd_delete_bfd (nbfd);
 311       return NULL;
 312     }
 313
 314   nbfd->iostream = stream;
 315   nbfd->filename = filename;
 316   nbfd->direction = read_direction;
 317
 318   if (! bfd_cache_init (nbfd))
 319     {
 320       _bfd_delete_bfd (nbfd);
 321       return NULL;
 322     }
 323
 324   return nbfd;
 325 }
 326
 327 /*
 328 FUNCTION
 329         bfd_openr_iovec
 330
 331 SYNOPSIS
 332         bfd *bfd_openr_iovec (const char *filename, const char *target,
 333                               void *(*open) (struct bfd *nbfd,
 334                                              void *open_closure),
 335                               void *open_closure,
 336                               file_ptr (*pread) (struct bfd *nbfd,
 337                                                  void *stream,
 338                                                  void *buf,
 339                                                  file_ptr nbytes,
 340                                                  file_ptr offset),
 341                               int (*close) (struct bfd *nbfd,
 342                                             void *stream));
 343
 344 DESCRIPTION
 345
 346         Create and return a BFD backed by a read-only @var{stream}.
 347         The @var{stream} is created using @var{open}, accessed using
 348         @var{pread} and destroyed using @var{close}.
 349
 350         Calls <<bfd_find_target>>, so @var{target} is interpreted as by
 351         that function.
 352
 353         Calls @var{open} (which can call <<bfd_zalloc>> and
 354         <<bfd_get_filename>>) to obtain the read-only stream backing
 355         the BFD.  @var{open} either succeeds returning the
 356         non-<<NULL>> @var{stream}, or fails returning <<NULL>>
 357         (setting <<bfd_error>>).
 358
 359         Calls @var{pread} to request @var{nbytes} of data from
 360         @var{stream} starting at @var{offset} (e.g., via a call to
 361         <<bfd_read>>).  @var{pread} either succeeds returning the
 362         number of bytes read (which can be less than @var{nbytes} when
 363         end-of-file), or fails returning -1 (setting <<bfd_error>>).
 364
 365         Calls @var{close} when the BFD is later closed using
 366         <<bfd_close>>.  @var{close} either succeeds returning 0, or
 367         fails returning -1 (setting <<bfd_error>>).
 368
 369         If <<bfd_openr_iovec>> returns <<NULL>> then an error has
 370         occurred.  Possible errors are <<bfd_error_no_memory>>,
 371         <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
 372
 373 */
 374
 375 struct opncls
 376 {
 377   void *stream;
 378   file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,
 379                      file_ptr nbytes, file_ptr offset);
 380   int (*close) (struct bfd *abfd, void *stream);
 381   file_ptr where;
 382 };
 383
 384 static file_ptr
 385 opncls_btell (struct bfd *abfd)
 386 {
 387   struct opncls *vec = abfd->iostream;
 388   return vec->where;
 389 }
 390
 391 static int
 392 opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)
 393 {
 394   struct opncls *vec = abfd->iostream;
 395   switch (whence)
 396     {
 397     case SEEK_SET: vec->where = offset; break;
 398     case SEEK_CUR: vec->where += offset; break;
 399     case SEEK_END: return -1;
 400     }
 401   return 0;
 402 }
 403
 404 static file_ptr
 405 opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
 406 {
 407   struct opncls *vec = abfd->iostream;
 408   file_ptr nread = vec->pread (abfd, vec->stream, buf, nbytes, vec->where);
 409   if (nread < 0)
 410     return nread;
 411   vec->where += nread;
 412   return nread;
 413 }
 414
 415 static file_ptr
 416 opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
 417               const void *where ATTRIBUTE_UNUSED,
 418               file_ptr nbytes ATTRIBUTE_UNUSED)
 419 {
 420   return -1;
 421 }
 422
 423 static int
 424 opncls_bclose (struct bfd *abfd)
 425 {
 426   struct opncls *vec = abfd->iostream;
 427   /* Since the VEC's memory is bound to the bfd deleting the bfd will
 428      free it.  */
 429   int status = 0;
 430   if (vec->close != NULL)
 431     status = vec->close (abfd, vec->stream);
 432   abfd->iostream = NULL;
 433   return status;
 434 }
 435
 436 static int
 437 opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
 438 {
 439   return 0;
 440 }
 441
 442 static int
 443 opncls_bstat (struct bfd *abfd ATTRIBUTE_UNUSED, struct stat *sb)
 444 {
 445   memset (sb, 0, sizeof (*sb));
 446   return 0;
 447 }
 448
 449 static const struct bfd_iovec opncls_iovec = {
 450   &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
 451   &opncls_bclose, &opncls_bflush, &opncls_bstat
 452 };
 453
 454 bfd *
 455 bfd_openr_iovec (const char *filename, const char *target,
 456                  void *(*open) (struct bfd *nbfd,
 457                                 void *open_closure),
 458                  void *open_closure,
 459                  file_ptr (*pread) (struct bfd *abfd,
 460                                     void *stream,
 461                                     void *buf,
 462                                     file_ptr nbytes,
 463                                     file_ptr offset),
 464                  int (*close) (struct bfd *nbfd,
 465                                void *stream))
 466 {
 467   bfd *nbfd;
 468   const bfd_target *target_vec;
 469   struct opncls *vec;
 470   void *stream;
 471
 472   nbfd = _bfd_new_bfd ();
 473   if (nbfd == NULL)
 474     return NULL;
 475
 476   target_vec = bfd_find_target (target, nbfd);
 477   if (target_vec == NULL)
 478     {
 479       _bfd_delete_bfd (nbfd);
 480       return NULL;
 481     }
 482
 483   nbfd->filename = filename;
 484   nbfd->direction = read_direction;
 485
 486   stream = open (nbfd, open_closure);
 487   if (stream == NULL)
 488     {
 489       _bfd_delete_bfd (nbfd);
 490       return NULL;
 491     }
 492
 493   vec = bfd_zalloc (nbfd, sizeof (struct opncls));
 494   vec->stream = stream;
 495   vec->pread = pread;
 496   vec->close = close;
 497
 498   nbfd->iovec = &opncls_iovec;
 499   nbfd->iostream = vec;
 500
 501   return nbfd;
 502 }
 503 \f
 504 /* bfd_openw -- open for writing.
 505    Returns a pointer to a freshly-allocated BFD on success, or NULL.
 506
 507    See comment by bfd_fdopenr before you try to modify this function.  */
 508
 509 /*
 510 FUNCTION
 511         bfd_openw
 512
 513 SYNOPSIS
 514         bfd *bfd_openw (const char *filename, const char *target);
 515
 516 DESCRIPTION
 517         Create a BFD, associated with file @var{filename}, using the
 518         file format @var{target}, and return a pointer to it.
 519
 520         Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
 521         <<bfd_error_invalid_target>>.
 522 */
 523
 524 bfd *
 525 bfd_openw (const char *filename, const char *target)
 526 {
 527   bfd *nbfd;
 528   const bfd_target *target_vec;
 529
 530   /* nbfd has to point to head of malloc'ed block so that bfd_close may
 531      reclaim it correctly.  */
 532   nbfd = _bfd_new_bfd ();
 533   if (nbfd == NULL)
 534     return NULL;
 535
 536   target_vec = bfd_find_target (target, nbfd);
 537   if (target_vec == NULL)
 538     {
 539       _bfd_delete_bfd (nbfd);
 540       return NULL;
 541     }
 542
 543   nbfd->filename = filename;
 544   nbfd->direction = write_direction;
 545
 546   if (bfd_open_file (nbfd) == NULL)
 547     {
 548       /* File not writeable, etc.  */
 549       bfd_set_error (bfd_error_system_call);
 550       _bfd_delete_bfd (nbfd);
 551       return NULL;
 552   }
 553
 554   return nbfd;
 555 }
 556
 557 /*
 558
 559 FUNCTION
 560         bfd_close
 561
 562 SYNOPSIS
 563         bfd_boolean bfd_close (bfd *abfd);
 564
 565 DESCRIPTION
 566
 567         Close a BFD. If the BFD was open for writing, then pending
 568         operations are completed and the file written out and closed.
 569         If the created file is executable, then <<chmod>> is called
 570         to mark it as such.
 571
 572         All memory attached to the BFD is released.
 573
 574         The file descriptor associated with the BFD is closed (even
 575         if it was passed in to BFD by <<bfd_fdopenr>>).
 576
 577 RETURNS
 578         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 579 */
 580
 581
 582 bfd_boolean
 583 bfd_close (bfd *abfd)
 584 {
 585   bfd_boolean ret;
 586
 587   if (bfd_write_p (abfd))
 588     {
 589       if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 590         return FALSE;
 591     }
 592
 593   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 594     return FALSE;
 595
 596   /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io
 597      vector.  */
 598   if (!(abfd->flags & BFD_IN_MEMORY))
 599     ret = abfd->iovec->bclose (abfd);
 600   else
 601     ret = 0;
 602
 603   /* If the file was open for writing and is now executable,
 604      make it so.  */
 605   if (ret
 606       && abfd->direction == write_direction
 607       && abfd->flags & EXEC_P)
 608     {
 609       struct stat buf;
 610
 611       if (stat (abfd->filename, &buf) == 0)
 612         {
 613           unsigned int mask = umask (0);
 614
 615           umask (mask);
 616           chmod (abfd->filename,
 617                  (0777
 618                   & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
 619         }
 620     }
 621
 622   _bfd_delete_bfd (abfd);
 623
 624   return ret;
 625 }
 626
 627 /*
 628 FUNCTION
 629         bfd_close_all_done
 630
 631 SYNOPSIS
 632         bfd_boolean bfd_close_all_done (bfd *);
 633
 634 DESCRIPTION
 635         Close a BFD.  Differs from <<bfd_close>> since it does not
 636         complete any pending operations.  This routine would be used
 637         if the application had just used BFD for swapping and didn't
 638         want to use any of the writing code.
 639
 640         If the created file is executable, then <<chmod>> is called
 641         to mark it as such.
 642
 643         All memory attached to the BFD is released.
 644
 645 RETURNS
 646         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 647 */
 648
 649 bfd_boolean
 650 bfd_close_all_done (bfd *abfd)
 651 {
 652   bfd_boolean ret;
 653
 654   ret = bfd_cache_close (abfd);
 655
 656   /* If the file was open for writing and is now executable,
 657      make it so.  */
 658   if (ret
 659       && abfd->direction == write_direction
 660       && abfd->flags & EXEC_P)
 661     {
 662       struct stat buf;
 663
 664       if (stat (abfd->filename, &buf) == 0)
 665         {
 666           unsigned int mask = umask (0);
 667
 668           umask (mask);
 669           chmod (abfd->filename,
 670                  (0777
 671                   & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
 672         }
 673     }
 674
 675   _bfd_delete_bfd (abfd);
 676
 677   return ret;
 678 }
 679
 680 /*
 681 FUNCTION
 682         bfd_create
 683
 684 SYNOPSIS
 685         bfd *bfd_create (const char *filename, bfd *templ);
 686
 687 DESCRIPTION
 688         Create a new BFD in the manner of <<bfd_openw>>, but without
 689         opening a file. The new BFD takes the target from the target
 690         used by @var{template}. The format is always set to <<bfd_object>>.
 691 */
 692
 693 bfd *
 694 bfd_create (const char *filename, bfd *templ)
 695 {
 696   bfd *nbfd;
 697
 698   nbfd = _bfd_new_bfd ();
 699   if (nbfd == NULL)
 700     return NULL;
 701   nbfd->filename = filename;
 702   if (templ)
 703     nbfd->xvec = templ->xvec;
 704   nbfd->direction = no_direction;
 705   bfd_set_format (nbfd, bfd_object);
 706
 707   return nbfd;
 708 }
 709
 710 /*
 711 FUNCTION
 712         bfd_make_writable
 713
 714 SYNOPSIS
 715         bfd_boolean bfd_make_writable (bfd *abfd);
 716
 717 DESCRIPTION
 718         Takes a BFD as created by <<bfd_create>> and converts it
 719         into one like as returned by <<bfd_openw>>.  It does this
 720         by converting the BFD to BFD_IN_MEMORY.  It's assumed that
 721         you will call <<bfd_make_readable>> on this bfd later.
 722
 723 RETURNS
 724         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 725 */
 726
 727 bfd_boolean
 728 bfd_make_writable (bfd *abfd)
 729 {
 730   struct bfd_in_memory *bim;
 731
 732   if (abfd->direction != no_direction)
 733     {
 734       bfd_set_error (bfd_error_invalid_operation);
 735       return FALSE;
 736     }
 737
 738   bim = bfd_malloc (sizeof (struct bfd_in_memory));
 739   abfd->iostream = bim;
 740   /* bfd_bwrite will grow these as needed.  */
 741   bim->size = 0;
 742   bim->buffer = 0;
 743
 744   abfd->flags |= BFD_IN_MEMORY;
 745   abfd->direction = write_direction;
 746   abfd->where = 0;
 747
 748   return TRUE;
 749 }
 750
 751 /*
 752 FUNCTION
 753         bfd_make_readable
 754
 755 SYNOPSIS
 756         bfd_boolean bfd_make_readable (bfd *abfd);
 757
 758 DESCRIPTION
 759         Takes a BFD as created by <<bfd_create>> and
 760         <<bfd_make_writable>> and converts it into one like as
 761         returned by <<bfd_openr>>.  It does this by writing the
 762         contents out to the memory buffer, then reversing the
 763         direction.
 764
 765 RETURNS
 766         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
 767
 768 bfd_boolean
 769 bfd_make_readable (bfd *abfd)
 770 {
 771   if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
 772     {
 773       bfd_set_error (bfd_error_invalid_operation);
 774       return FALSE;
 775     }
 776
 777   if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 778     return FALSE;
 779
 780   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 781     return FALSE;
 782
 783
 784   abfd->arch_info = &bfd_default_arch_struct;
 785
 786   abfd->where = 0;
 787   abfd->format = bfd_unknown;
 788   abfd->my_archive = NULL;
 789   abfd->origin = 0;
 790   abfd->opened_once = FALSE;
 791   abfd->output_has_begun = FALSE;
 792   abfd->section_count = 0;
 793   abfd->usrdata = NULL;
 794   abfd->cacheable = FALSE;
 795   abfd->flags = BFD_IN_MEMORY;
 796   abfd->mtime_set = FALSE;
 797
 798   abfd->target_defaulted = TRUE;
 799   abfd->direction = read_direction;
 800   abfd->sections = 0;
 801   abfd->symcount = 0;
 802   abfd->outsymbols = 0;
 803   abfd->tdata.any = 0;
 804
 805   bfd_section_list_clear (abfd);
 806   bfd_check_format (abfd, bfd_object);
 807
 808   return TRUE;
 809 }
 810
 811 /*
 812 INTERNAL_FUNCTION
 813         bfd_alloc
 814
 815 SYNOPSIS
 816         void *bfd_alloc (bfd *abfd, size_t wanted);
 817
 818 DESCRIPTION
 819         Allocate a block of @var{wanted} bytes of memory attached to
 820         <<abfd>> and return a pointer to it.
 821 */
 822
 823
 824 void *
 825 bfd_alloc (bfd *abfd, bfd_size_type size)
 826 {
 827   void *ret;
 828
 829   if (size != (unsigned long) size)
 830     {
 831       bfd_set_error (bfd_error_no_memory);
 832       return NULL;
 833     }
 834
 835   ret = objalloc_alloc (abfd->memory, (unsigned long) size);
 836   if (ret == NULL)
 837     bfd_set_error (bfd_error_no_memory);
 838   return ret;
 839 }
 840
 841 void *
 842 bfd_zalloc (bfd *abfd, bfd_size_type size)
 843 {
 844   void *res;
 845
 846   res = bfd_alloc (abfd, size);
 847   if (res)
 848     memset (res, 0, (size_t) size);
 849   return res;
 850 }
 851
 852 /* Free a block allocated for a BFD.
 853    Note:  Also frees all more recently allocated blocks!  */
 854
 855 void
 856 bfd_release (bfd *abfd, void *block)
 857 {
 858   objalloc_free_block ((struct objalloc *) abfd->memory, block);
 859 }
 860
 861
 862 /*
 863    GNU Extension: separate debug-info files
 864
 865    The idea here is that a special section called .gnu_debuglink might be
 866    embedded in a binary file, which indicates that some *other* file
 867    contains the real debugging information. This special section contains a
 868    filename and CRC32 checksum, which we read and resolve to another file,
 869    if it exists.
 870
 871    This facilitates "optional" provision of debugging information, without
 872    having to provide two complete copies of every binary object (with and
 873    without debug symbols).
 874 */
 875
 876 #define GNU_DEBUGLINK   ".gnu_debuglink"
 877 /*
 878 FUNCTION
 879         bfd_calc_gnu_debuglink_crc32
 880
 881 SYNOPSIS
 882         unsigned long bfd_calc_gnu_debuglink_crc32
 883           (unsigned long crc, const unsigned char *buf, bfd_size_type len);
 884
 885 DESCRIPTION
 886         Computes a CRC value as used in the .gnu_debuglink section.
 887         Advances the previously computed @var{crc} value by computing
 888         and adding in the crc32 for @var{len} bytes of @var{buf}.
 889
 890 RETURNS
 891         Return the updated CRC32 value.
 892 */
 893
 894 unsigned long
 895 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
 896                               const unsigned char *buf,
 897                               bfd_size_type len)
 898 {
 899   static const unsigned long crc32_table[256] =
 900     {
 901       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
 902       0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
 903       0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
 904       0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
 905       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
 906       0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
 907       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
 908       0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
 909       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
 910       0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
 911       0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
 912       0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
 913       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
 914       0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
 915       0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
 916       0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
 917       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
 918       0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
 919       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
 920       0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
 921       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
 922       0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
 923       0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
 924       0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
 925       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
 926       0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
 927       0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
 928       0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
 929       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
 930       0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
 931       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
 932       0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
 933       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
 934       0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
 935       0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
 936       0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
 937       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
 938       0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
 939       0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
 940       0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
 941       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
 942       0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
 943       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
 944       0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
 945       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
 946       0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
 947       0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
 948       0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
 949       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
 950       0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
 951       0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
 952       0x2d02ef8d
 953     };
 954   const unsigned char *end;
 955
 956   crc = ~crc & 0xffffffff;
 957   for (end = buf + len; buf < end; ++ buf)
 958     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
 959   return ~crc & 0xffffffff;;
 960 }
 961
 962
 963 /*
 964 INTERNAL_FUNCTION
 965         get_debug_link_info
 966
 967 SYNOPSIS
 968         char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
 969
 970 DESCRIPTION
 971         fetch the filename and CRC32 value for any separate debuginfo
 972         associated with @var{abfd}. Return NULL if no such info found,
 973         otherwise return filename and update @var{crc32_out}.
 974 */
 975
 976 static char *
 977 get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
 978 {
 979   asection * sect;
 980   bfd_size_type debuglink_size;
 981   unsigned long crc32;
 982   char * contents;
 983   int crc_offset;
 984   bfd_boolean ret;
 985
 986   BFD_ASSERT (abfd);
 987   BFD_ASSERT (crc32_out);
 988
 989   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
 990
 991   if (sect == NULL)
 992     return NULL;
 993
 994   debuglink_size = bfd_section_size (abfd, sect);
 995
 996   contents = malloc (debuglink_size);
 997   if (contents == NULL)
 998     return NULL;
 999
1000   ret = bfd_get_section_contents (abfd, sect, contents, 0, debuglink_size);
1001   if (! ret)
1002     {
1003       free (contents);
1004       return NULL;
1005     }
1006
1007   /* Crc value is stored after the filename, aligned up to 4 bytes.  */
1008   crc_offset = strlen (contents) + 1;
1009   crc_offset = (crc_offset + 3) & ~3;
1010
1011   crc32 = bfd_get_32 (abfd, contents + crc_offset);
1012
1013   *crc32_out = crc32;
1014   return contents;
1015 }
1016
1017 /*
1018 INTERNAL_FUNCTION
1019         separate_debug_file_exists
1020
1021 SYNOPSIS
1022         bfd_boolean separate_debug_file_exists
1023           (char *name, unsigned long crc32);
1024
1025 DESCRIPTION
1026         Checks to see if @var{name} is a file and if its contents
1027         match @var{crc32}.
1028 */
1029
1030 static bfd_boolean
1031 separate_debug_file_exists (const char *name, const unsigned long crc)
1032 {
1033   static char buffer [8 * 1024];
1034   unsigned long file_crc = 0;
1035   int fd;
1036   bfd_size_type count;
1037
1038   BFD_ASSERT (name);
1039
1040   fd = open (name, O_RDONLY);
1041   if (fd < 0)
1042     return FALSE;
1043
1044   while ((count = read (fd, buffer, sizeof (buffer))) > 0)
1045     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1046
1047   close (fd);
1048
1049   return crc == file_crc;
1050 }
1051
1052
1053 /*
1054 INTERNAL_FUNCTION
1055         find_separate_debug_file
1056
1057 SYNOPSIS
1058         char *find_separate_debug_file (bfd *abfd);
1059
1060 DESCRIPTION
1061         Searches @var{abfd} for a reference to separate debugging
1062         information, scans various locations in the filesystem, including
1063         the file tree rooted at @var{debug_file_directory}, and returns a
1064         filename of such debugging information if the file is found and has
1065         matching CRC32.  Returns NULL if no reference to debugging file
1066         exists, or file cannot be found.
1067 */
1068
1069 static char *
1070 find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1071 {
1072   char *basename;
1073   char *dir;
1074   char *debugfile;
1075   unsigned long crc32;
1076   int i;
1077
1078   BFD_ASSERT (abfd);
1079   if (debug_file_directory == NULL)
1080     debug_file_directory = ".";
1081
1082   /* BFD may have been opened from a stream.  */
1083   if (! abfd->filename)
1084     return NULL;
1085
1086   basename = get_debug_link_info (abfd, & crc32);
1087   if (basename == NULL)
1088     return NULL;
1089
1090   if (strlen (basename) < 1)
1091     {
1092       free (basename);
1093       return NULL;
1094     }
1095
1096   dir = strdup (abfd->filename);
1097   if (dir == NULL)
1098     {
1099       free (basename);
1100       return NULL;
1101     }
1102   BFD_ASSERT (strlen (dir) != 0);
1103
1104   /* Strip off filename part.  */
1105   for (i = strlen (dir) - 1; i >= 0; i--)
1106     if (IS_DIR_SEPARATOR (dir[i]))
1107       break;
1108
1109   dir[i + 1] = '\0';
1110   BFD_ASSERT (dir[i] == '/' || dir[0] == '\0')
1111
1112   debugfile = malloc (strlen (debug_file_directory) + 1
1113                       + strlen (dir)
1114                       + strlen (".debug/")
1115                       + strlen (basename)
1116                       + 1);
1117   if (debugfile == NULL)
1118     {
1119       free (basename);
1120       free (dir);
1121       return NULL;
1122     }
1123
1124   /* First try in the same directory as the original file:  */
1125   strcpy (debugfile, dir);
1126   strcat (debugfile, basename);
1127
1128   if (separate_debug_file_exists (debugfile, crc32))
1129     {
1130       free (basename);
1131       free (dir);
1132       return debugfile;
1133     }
1134
1135   /* Then try in a subdirectory called .debug.  */
1136   strcpy (debugfile, dir);
1137   strcat (debugfile, ".debug/");
1138   strcat (debugfile, basename);
1139
1140   if (separate_debug_file_exists (debugfile, crc32))
1141     {
1142       free (basename);
1143       free (dir);
1144       return debugfile;
1145     }
1146
1147   /* Then try in the global debugfile directory.  */
1148   strcpy (debugfile, debug_file_directory);
1149   i = strlen (debug_file_directory) - 1;
1150   if (i > 0
1151       && debug_file_directory[i] != '/'
1152       && dir[0] != '/')
1153     strcat (debugfile, "/");
1154   strcat (debugfile, dir);
1155   strcat (debugfile, basename);
1156
1157   if (separate_debug_file_exists (debugfile, crc32))
1158     {
1159       free (basename);
1160       free (dir);
1161       return debugfile;
1162     }
1163
1164   free (debugfile);
1165   free (basename);
1166   free (dir);
1167   return NULL;
1168 }
1169
1170
1171 /*
1172 FUNCTION
1173         bfd_follow_gnu_debuglink
1174
1175 SYNOPSIS
1176         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1177
1178 DESCRIPTION
1179
1180         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1181         section is found, it examines the section for the name and checksum
1182         of a '.debug' file containing auxiliary debugging information.  It
1183         then searches the filesystem for this .debug file in some standard
1184         locations, including the directory tree rooted at @var{dir}, and if
1185         found returns the full filename.
1186
1187         If @var{dir} is NULL, it will search a default path configured into
1188         libbfd at build time.  [XXX this feature is not currently
1189         implemented].
1190
1191 RETURNS
1192         <<NULL>> on any errors or failure to locate the .debug file,
1193         otherwise a pointer to a heap-allocated string containing the
1194         filename.  The caller is responsible for freeing this string.
1195 */
1196
1197 char *
1198 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1199 {
1200 #if 0 /* Disabled until DEBUGDIR can be defined by configure.in.  */
1201   if (dir == NULL)
1202     dir = DEBUGDIR;
1203 #endif
1204   return find_separate_debug_file (abfd, dir);
1205 }
1206
1207 /*
1208 FUNCTION
1209         bfd_create_gnu_debuglink_section
1210
1211 SYNOPSIS
1212         struct bfd_section *bfd_create_gnu_debuglink_section
1213           (bfd *abfd, const char *filename);
1214
1215 DESCRIPTION
1216
1217         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The section is sized
1218         to be big enough to contain a link to the specified @var{filename}.
1219
1220 RETURNS
1221         A pointer to the new section is returned if all is ok.  Otherwise <<NULL>> is
1222         returned and bfd_error is set.
1223 */
1224
1225 asection *
1226 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1227 {
1228   asection *sect;
1229   bfd_size_type debuglink_size;
1230
1231   if (abfd == NULL || filename == NULL)
1232     {
1233       bfd_set_error (bfd_error_invalid_operation);
1234       return NULL;
1235     }
1236
1237   /* Strip off any path components in filename.  */
1238   filename = lbasename (filename);
1239
1240   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1241   if (sect)
1242     {
1243       /* Section already exists.  */
1244       bfd_set_error (bfd_error_invalid_operation);
1245       return NULL;
1246     }
1247
1248   sect = bfd_make_section (abfd, GNU_DEBUGLINK);
1249   if (sect == NULL)
1250     return NULL;
1251
1252   if (! bfd_set_section_flags (abfd, sect,
1253                                SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING))
1254     /* XXX Should we delete the section from the bfd ?  */
1255     return NULL;
1256
1257
1258   debuglink_size = strlen (filename) + 1;
1259   debuglink_size += 3;
1260   debuglink_size &= ~3;
1261   debuglink_size += 4;
1262
1263   if (! bfd_set_section_size (abfd, sect, debuglink_size))
1264     /* XXX Should we delete the section from the bfd ?  */
1265     return NULL;
1266
1267   return sect;
1268 }
1269
1270
1271 /*
1272 FUNCTION
1273         bfd_fill_in_gnu_debuglink_section
1274
1275 SYNOPSIS
1276         bfd_boolean bfd_fill_in_gnu_debuglink_section
1277           (bfd *abfd, struct bfd_section *sect, const char *filename);
1278
1279 DESCRIPTION
1280
1281         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1282         and fills in the contents of the section to contain a link to the
1283         specified @var{filename}.  The filename should be relative to the
1284         current directory.
1285
1286 RETURNS
1287         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1288         and bfd_error is set.
1289 */
1290
1291 bfd_boolean
1292 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1293                                    struct bfd_section *sect,
1294                                    const char *filename)
1295 {
1296   bfd_size_type debuglink_size;
1297   unsigned long crc32;
1298   char * contents;
1299   bfd_size_type crc_offset;
1300   FILE * handle;
1301   static char buffer[8 * 1024];
1302   size_t count;
1303
1304   if (abfd == NULL || sect == NULL || filename == NULL)
1305     {
1306       bfd_set_error (bfd_error_invalid_operation);
1307       return FALSE;
1308     }
1309
1310   /* Make sure that we can read the file.
1311      XXX - Should we attempt to locate the debug info file using the same
1312      algorithm as gdb ?  At the moment, since we are creating the
1313      .gnu_debuglink section, we insist upon the user providing us with a
1314      correct-for-section-creation-time path, but this need not conform to
1315      the gdb location algorithm.  */
1316   handle = fopen (filename, FOPEN_RB);
1317   if (handle == NULL)
1318     {
1319       bfd_set_error (bfd_error_system_call);
1320       return FALSE;
1321     }
1322
1323   crc32 = 0;
1324   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1325     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1326   fclose (handle);
1327
1328   /* Strip off any path components in filename,
1329      now that we no longer need them.  */
1330   filename = lbasename (filename);
1331
1332   debuglink_size = strlen (filename) + 1;
1333   debuglink_size += 3;
1334   debuglink_size &= ~3;
1335   debuglink_size += 4;
1336
1337   contents = malloc (debuglink_size);
1338   if (contents == NULL)
1339     {
1340       /* XXX Should we delete the section from the bfd ?  */
1341       bfd_set_error (bfd_error_no_memory);
1342       return FALSE;
1343     }
1344
1345   strcpy (contents, filename);
1346   crc_offset = debuglink_size - 4;
1347
1348   bfd_put_32 (abfd, crc32, contents + crc_offset);
1349
1350   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1351     {
1352       /* XXX Should we delete the section from the bfd ?  */
1353       free (contents);
1354       return FALSE;
1355     }
1356
1357   return TRUE;
1358 }