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