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