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