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