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