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