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