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_zalloc
 862
 863 SYNOPSIS
 864         void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
 865
 866 DESCRIPTION
 867         Allocate a block of @var{wanted} bytes of zeroed memory
 868         attached to <<abfd>> and return a pointer to it.
 869 */
 870
 871 void *
 872 bfd_zalloc (bfd *abfd, bfd_size_type size)
 873 {
 874   void *res;
 875
 876   res = bfd_alloc (abfd, size);
 877   if (res)
 878     memset (res, 0, (size_t) size);
 879   return res;
 880 }
 881
 882 /* Free a block allocated for a BFD.
 883    Note:  Also frees all more recently allocated blocks!  */
 884
 885 void
 886 bfd_release (bfd *abfd, void *block)
 887 {
 888   objalloc_free_block ((struct objalloc *) abfd->memory, block);
 889 }
 890
 891
 892 /*
 893    GNU Extension: separate debug-info files
 894
 895    The idea here is that a special section called .gnu_debuglink might be
 896    embedded in a binary file, which indicates that some *other* file
 897    contains the real debugging information. This special section contains a
 898    filename and CRC32 checksum, which we read and resolve to another file,
 899    if it exists.
 900
 901    This facilitates "optional" provision of debugging information, without
 902    having to provide two complete copies of every binary object (with and
 903    without debug symbols).
 904 */
 905
 906 #define GNU_DEBUGLINK   ".gnu_debuglink"
 907 /*
 908 FUNCTION
 909         bfd_calc_gnu_debuglink_crc32
 910
 911 SYNOPSIS
 912         unsigned long bfd_calc_gnu_debuglink_crc32
 913           (unsigned long crc, const unsigned char *buf, bfd_size_type len);
 914
 915 DESCRIPTION
 916         Computes a CRC value as used in the .gnu_debuglink section.
 917         Advances the previously computed @var{crc} value by computing
 918         and adding in the crc32 for @var{len} bytes of @var{buf}.
 919
 920 RETURNS
 921         Return the updated CRC32 value.
 922 */
 923
 924 unsigned long
 925 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
 926                               const unsigned char *buf,
 927                               bfd_size_type len)
 928 {
 929   static const unsigned long crc32_table[256] =
 930     {
 931       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
 932       0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
 933       0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
 934       0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
 935       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
 936       0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
 937       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
 938       0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
 939       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
 940       0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
 941       0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
 942       0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
 943       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
 944       0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
 945       0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
 946       0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
 947       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
 948       0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
 949       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
 950       0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
 951       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
 952       0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
 953       0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
 954       0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
 955       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
 956       0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
 957       0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
 958       0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
 959       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
 960       0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
 961       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
 962       0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
 963       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
 964       0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
 965       0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
 966       0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
 967       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
 968       0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
 969       0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
 970       0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
 971       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
 972       0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
 973       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
 974       0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
 975       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
 976       0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
 977       0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
 978       0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
 979       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
 980       0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
 981       0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
 982       0x2d02ef8d
 983     };
 984   const unsigned char *end;
 985
 986   crc = ~crc & 0xffffffff;
 987   for (end = buf + len; buf < end; ++ buf)
 988     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
 989   return ~crc & 0xffffffff;;
 990 }
 991
 992
 993 /*
 994 INTERNAL_FUNCTION
 995         get_debug_link_info
 996
 997 SYNOPSIS
 998         char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
 999
1000 DESCRIPTION
1001         fetch the filename and CRC32 value for any separate debuginfo
1002         associated with @var{abfd}. Return NULL if no such info found,
1003         otherwise return filename and update @var{crc32_out}.
1004 */
1005
1006 static char *
1007 get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1008 {
1009   asection *sect;
1010   unsigned long crc32;
1011   bfd_byte *contents;
1012   int crc_offset;
1013   char *name;
1014
1015   BFD_ASSERT (abfd);
1016   BFD_ASSERT (crc32_out);
1017
1018   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1019
1020   if (sect == NULL)
1021     return NULL;
1022
1023   if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1024     {
1025       if (contents != NULL)
1026         free (contents);
1027       return NULL;
1028     }
1029
1030   /* Crc value is stored after the filename, aligned up to 4 bytes.  */
1031   name = (char *) contents;
1032   crc_offset = strlen (name) + 1;
1033   crc_offset = (crc_offset + 3) & ~3;
1034
1035   crc32 = bfd_get_32 (abfd, contents + crc_offset);
1036
1037   *crc32_out = crc32;
1038   return name;
1039 }
1040
1041 /*
1042 INTERNAL_FUNCTION
1043         separate_debug_file_exists
1044
1045 SYNOPSIS
1046         bfd_boolean separate_debug_file_exists
1047           (char *name, unsigned long crc32);
1048
1049 DESCRIPTION
1050         Checks to see if @var{name} is a file and if its contents
1051         match @var{crc32}.
1052 */
1053
1054 static bfd_boolean
1055 separate_debug_file_exists (const char *name, const unsigned long crc)
1056 {
1057   static unsigned char buffer [8 * 1024];
1058   unsigned long file_crc = 0;
1059   int fd;
1060   bfd_size_type count;
1061
1062   BFD_ASSERT (name);
1063
1064   fd = open (name, O_RDONLY);
1065   if (fd < 0)
1066     return FALSE;
1067
1068   while ((count = read (fd, buffer, sizeof (buffer))) > 0)
1069     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1070
1071   close (fd);
1072
1073   return crc == file_crc;
1074 }
1075
1076
1077 /*
1078 INTERNAL_FUNCTION
1079         find_separate_debug_file
1080
1081 SYNOPSIS
1082         char *find_separate_debug_file (bfd *abfd);
1083
1084 DESCRIPTION
1085         Searches @var{abfd} for a reference to separate debugging
1086         information, scans various locations in the filesystem, including
1087         the file tree rooted at @var{debug_file_directory}, and returns a
1088         filename of such debugging information if the file is found and has
1089         matching CRC32.  Returns NULL if no reference to debugging file
1090         exists, or file cannot be found.
1091 */
1092
1093 static char *
1094 find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1095 {
1096   char *basename;
1097   char *dir;
1098   char *debugfile;
1099   unsigned long crc32;
1100   int i;
1101
1102   BFD_ASSERT (abfd);
1103   if (debug_file_directory == NULL)
1104     debug_file_directory = ".";
1105
1106   /* BFD may have been opened from a stream.  */
1107   if (! abfd->filename)
1108     return NULL;
1109
1110   basename = get_debug_link_info (abfd, & crc32);
1111   if (basename == NULL)
1112     return NULL;
1113
1114   if (strlen (basename) < 1)
1115     {
1116       free (basename);
1117       return NULL;
1118     }
1119
1120   dir = strdup (abfd->filename);
1121   if (dir == NULL)
1122     {
1123       free (basename);
1124       return NULL;
1125     }
1126   BFD_ASSERT (strlen (dir) != 0);
1127
1128   /* Strip off filename part.  */
1129   for (i = strlen (dir) - 1; i >= 0; i--)
1130     if (IS_DIR_SEPARATOR (dir[i]))
1131       break;
1132
1133   dir[i + 1] = '\0';
1134   BFD_ASSERT (dir[i] == '/' || dir[0] == '\0');
1135
1136   debugfile = malloc (strlen (debug_file_directory) + 1
1137                       + strlen (dir)
1138                       + strlen (".debug/")
1139                       + strlen (basename)
1140                       + 1);
1141   if (debugfile == NULL)
1142     {
1143       free (basename);
1144       free (dir);
1145       return NULL;
1146     }
1147
1148   /* First try in the same directory as the original file:  */
1149   strcpy (debugfile, dir);
1150   strcat (debugfile, basename);
1151
1152   if (separate_debug_file_exists (debugfile, crc32))
1153     {
1154       free (basename);
1155       free (dir);
1156       return debugfile;
1157     }
1158
1159   /* Then try in a subdirectory called .debug.  */
1160   strcpy (debugfile, dir);
1161   strcat (debugfile, ".debug/");
1162   strcat (debugfile, basename);
1163
1164   if (separate_debug_file_exists (debugfile, crc32))
1165     {
1166       free (basename);
1167       free (dir);
1168       return debugfile;
1169     }
1170
1171   /* Then try in the global debugfile directory.  */
1172   strcpy (debugfile, debug_file_directory);
1173   i = strlen (debug_file_directory) - 1;
1174   if (i > 0
1175       && debug_file_directory[i] != '/'
1176       && dir[0] != '/')
1177     strcat (debugfile, "/");
1178   strcat (debugfile, dir);
1179   strcat (debugfile, basename);
1180
1181   if (separate_debug_file_exists (debugfile, crc32))
1182     {
1183       free (basename);
1184       free (dir);
1185       return debugfile;
1186     }
1187
1188   free (debugfile);
1189   free (basename);
1190   free (dir);
1191   return NULL;
1192 }
1193
1194
1195 /*
1196 FUNCTION
1197         bfd_follow_gnu_debuglink
1198
1199 SYNOPSIS
1200         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1201
1202 DESCRIPTION
1203
1204         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1205         section is found, it examines the section for the name and checksum
1206         of a '.debug' file containing auxiliary debugging information.  It
1207         then searches the filesystem for this .debug file in some standard
1208         locations, including the directory tree rooted at @var{dir}, and if
1209         found returns the full filename.
1210
1211         If @var{dir} is NULL, it will search a default path configured into
1212         libbfd at build time.  [XXX this feature is not currently
1213         implemented].
1214
1215 RETURNS
1216         <<NULL>> on any errors or failure to locate the .debug file,
1217         otherwise a pointer to a heap-allocated string containing the
1218         filename.  The caller is responsible for freeing this string.
1219 */
1220
1221 char *
1222 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1223 {
1224   return find_separate_debug_file (abfd, dir);
1225 }
1226
1227 /*
1228 FUNCTION
1229         bfd_create_gnu_debuglink_section
1230
1231 SYNOPSIS
1232         struct bfd_section *bfd_create_gnu_debuglink_section
1233           (bfd *abfd, const char *filename);
1234
1235 DESCRIPTION
1236
1237         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The section is sized
1238         to be big enough to contain a link to the specified @var{filename}.
1239
1240 RETURNS
1241         A pointer to the new section is returned if all is ok.  Otherwise <<NULL>> is
1242         returned and bfd_error is set.
1243 */
1244
1245 asection *
1246 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1247 {
1248   asection *sect;
1249   bfd_size_type debuglink_size;
1250
1251   if (abfd == NULL || filename == NULL)
1252     {
1253       bfd_set_error (bfd_error_invalid_operation);
1254       return NULL;
1255     }
1256
1257   /* Strip off any path components in filename.  */
1258   filename = lbasename (filename);
1259
1260   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1261   if (sect)
1262     {
1263       /* Section already exists.  */
1264       bfd_set_error (bfd_error_invalid_operation);
1265       return NULL;
1266     }
1267
1268   sect = bfd_make_section (abfd, GNU_DEBUGLINK);
1269   if (sect == NULL)
1270     return NULL;
1271
1272   if (! bfd_set_section_flags (abfd, sect,
1273                                SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING))
1274     /* XXX Should we delete the section from the bfd ?  */
1275     return NULL;
1276
1277
1278   debuglink_size = strlen (filename) + 1;
1279   debuglink_size += 3;
1280   debuglink_size &= ~3;
1281   debuglink_size += 4;
1282
1283   if (! bfd_set_section_size (abfd, sect, debuglink_size))
1284     /* XXX Should we delete the section from the bfd ?  */
1285     return NULL;
1286
1287   return sect;
1288 }
1289
1290
1291 /*
1292 FUNCTION
1293         bfd_fill_in_gnu_debuglink_section
1294
1295 SYNOPSIS
1296         bfd_boolean bfd_fill_in_gnu_debuglink_section
1297           (bfd *abfd, struct bfd_section *sect, const char *filename);
1298
1299 DESCRIPTION
1300
1301         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1302         and fills in the contents of the section to contain a link to the
1303         specified @var{filename}.  The filename should be relative to the
1304         current directory.
1305
1306 RETURNS
1307         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1308         and bfd_error is set.
1309 */
1310
1311 bfd_boolean
1312 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1313                                    struct bfd_section *sect,
1314                                    const char *filename)
1315 {
1316   bfd_size_type debuglink_size;
1317   unsigned long crc32;
1318   char * contents;
1319   bfd_size_type crc_offset;
1320   FILE * handle;
1321   static unsigned char buffer[8 * 1024];
1322   size_t count;
1323
1324   if (abfd == NULL || sect == NULL || filename == NULL)
1325     {
1326       bfd_set_error (bfd_error_invalid_operation);
1327       return FALSE;
1328     }
1329
1330   /* Make sure that we can read the file.
1331      XXX - Should we attempt to locate the debug info file using the same
1332      algorithm as gdb ?  At the moment, since we are creating the
1333      .gnu_debuglink section, we insist upon the user providing us with a
1334      correct-for-section-creation-time path, but this need not conform to
1335      the gdb location algorithm.  */
1336   handle = fopen (filename, FOPEN_RB);
1337   if (handle == NULL)
1338     {
1339       bfd_set_error (bfd_error_system_call);
1340       return FALSE;
1341     }
1342
1343   crc32 = 0;
1344   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1345     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1346   fclose (handle);
1347
1348   /* Strip off any path components in filename,
1349      now that we no longer need them.  */
1350   filename = lbasename (filename);
1351
1352   debuglink_size = strlen (filename) + 1;
1353   debuglink_size += 3;
1354   debuglink_size &= ~3;
1355   debuglink_size += 4;
1356
1357   contents = malloc (debuglink_size);
1358   if (contents == NULL)
1359     {
1360       /* XXX Should we delete the section from the bfd ?  */
1361       bfd_set_error (bfd_error_no_memory);
1362       return FALSE;
1363     }
1364
1365   strcpy (contents, filename);
1366   crc_offset = debuglink_size - 4;
1367
1368   bfd_put_32 (abfd, crc32, contents + crc_offset);
1369
1370   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1371     {
1372       /* XXX Should we delete the section from the bfd ?  */
1373       free (contents);
1374       return FALSE;
1375     }
1376
1377   return TRUE;
1378 }