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