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 void *
 509 opncls_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
 510               void *addr ATTRIBUTE_UNUSED,
 511               bfd_size_type len ATTRIBUTE_UNUSED,
 512               int prot ATTRIBUTE_UNUSED,
 513               int flags ATTRIBUTE_UNUSED,
 514               file_ptr offset ATTRIBUTE_UNUSED)
 515 {
 516   return (void *) -1;
 517 }
 518
 519 static const struct bfd_iovec opncls_iovec = {
 520   &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
 521   &opncls_bclose, &opncls_bflush, &opncls_bstat, &opncls_bmmap
 522 };
 523
 524 bfd *
 525 bfd_openr_iovec (const char *filename, const char *target,
 526                  void *(*open) (struct bfd *nbfd,
 527                                 void *open_closure),
 528                  void *open_closure,
 529                  file_ptr (*pread) (struct bfd *abfd,
 530                                     void *stream,
 531                                     void *buf,
 532                                     file_ptr nbytes,
 533                                     file_ptr offset),
 534                  int (*close) (struct bfd *nbfd,
 535                                void *stream),
 536                  int (*stat) (struct bfd *abfd,
 537                               void *stream,
 538                               struct stat *sb))
 539 {
 540   bfd *nbfd;
 541   const bfd_target *target_vec;
 542   struct opncls *vec;
 543   void *stream;
 544
 545   nbfd = _bfd_new_bfd ();
 546   if (nbfd == NULL)
 547     return NULL;
 548
 549   target_vec = bfd_find_target (target, nbfd);
 550   if (target_vec == NULL)
 551     {
 552       _bfd_delete_bfd (nbfd);
 553       return NULL;
 554     }
 555
 556   nbfd->filename = filename;
 557   nbfd->direction = read_direction;
 558
 559   /* `open (...)' would get expanded by an the open(2) syscall macro.  */
 560   stream = (*open) (nbfd, open_closure);
 561   if (stream == NULL)
 562     {
 563       _bfd_delete_bfd (nbfd);
 564       return NULL;
 565     }
 566
 567   vec = bfd_zalloc (nbfd, sizeof (struct opncls));
 568   vec->stream = stream;
 569   vec->pread = pread;
 570   vec->close = close;
 571   vec->stat = stat;
 572
 573   nbfd->iovec = &opncls_iovec;
 574   nbfd->iostream = vec;
 575
 576   return nbfd;
 577 }
 578 \f
 579 /* bfd_openw -- open for writing.
 580    Returns a pointer to a freshly-allocated BFD on success, or NULL.
 581
 582    See comment by bfd_fdopenr before you try to modify this function.  */
 583
 584 /*
 585 FUNCTION
 586         bfd_openw
 587
 588 SYNOPSIS
 589         bfd *bfd_openw (const char *filename, const char *target);
 590
 591 DESCRIPTION
 592         Create a BFD, associated with file @var{filename}, using the
 593         file format @var{target}, and return a pointer to it.
 594
 595         Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
 596         <<bfd_error_invalid_target>>.
 597 */
 598
 599 bfd *
 600 bfd_openw (const char *filename, const char *target)
 601 {
 602   bfd *nbfd;
 603   const bfd_target *target_vec;
 604
 605   /* nbfd has to point to head of malloc'ed block so that bfd_close may
 606      reclaim it correctly.  */
 607   nbfd = _bfd_new_bfd ();
 608   if (nbfd == NULL)
 609     return NULL;
 610
 611   target_vec = bfd_find_target (target, nbfd);
 612   if (target_vec == NULL)
 613     {
 614       _bfd_delete_bfd (nbfd);
 615       return NULL;
 616     }
 617
 618   nbfd->filename = filename;
 619   nbfd->direction = write_direction;
 620
 621   if (bfd_open_file (nbfd) == NULL)
 622     {
 623       /* File not writeable, etc.  */
 624       bfd_set_error (bfd_error_system_call);
 625       _bfd_delete_bfd (nbfd);
 626       return NULL;
 627   }
 628
 629   return nbfd;
 630 }
 631
 632 /*
 633
 634 FUNCTION
 635         bfd_close
 636
 637 SYNOPSIS
 638         bfd_boolean bfd_close (bfd *abfd);
 639
 640 DESCRIPTION
 641
 642         Close a BFD. If the BFD was open for writing, then pending
 643         operations are completed and the file written out and closed.
 644         If the created file is executable, then <<chmod>> is called
 645         to mark it as such.
 646
 647         All memory attached to the BFD is released.
 648
 649         The file descriptor associated with the BFD is closed (even
 650         if it was passed in to BFD by <<bfd_fdopenr>>).
 651
 652 RETURNS
 653         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 654 */
 655
 656
 657 bfd_boolean
 658 bfd_close (bfd *abfd)
 659 {
 660   bfd_boolean ret;
 661   bfd *nbfd;
 662   bfd *next;
 663
 664   if (bfd_write_p (abfd))
 665     {
 666       if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 667         return FALSE;
 668     }
 669
 670   /* Close nested archives (if this bfd is a thin archive).  */
 671   for (nbfd = abfd->nested_archives; nbfd; nbfd = next)
 672     {
 673       next = nbfd->archive_next;
 674       bfd_close (nbfd);
 675     }
 676
 677   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 678     return FALSE;
 679
 680   /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io
 681      vector.  */
 682   if (!(abfd->flags & BFD_IN_MEMORY))
 683     ret = abfd->iovec->bclose (abfd);
 684   else
 685     ret = TRUE;
 686
 687   /* If the file was open for writing and is now executable,
 688      make it so.  */
 689   if (ret
 690       && abfd->direction == write_direction
 691       && abfd->flags & EXEC_P)
 692     {
 693       struct stat buf;
 694
 695       if (stat (abfd->filename, &buf) == 0)
 696         {
 697           unsigned int mask = umask (0);
 698
 699           umask (mask);
 700           chmod (abfd->filename,
 701                  (0777
 702                   & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
 703         }
 704     }
 705
 706   _bfd_delete_bfd (abfd);
 707
 708   return ret;
 709 }
 710
 711 /*
 712 FUNCTION
 713         bfd_close_all_done
 714
 715 SYNOPSIS
 716         bfd_boolean bfd_close_all_done (bfd *);
 717
 718 DESCRIPTION
 719         Close a BFD.  Differs from <<bfd_close>> since it does not
 720         complete any pending operations.  This routine would be used
 721         if the application had just used BFD for swapping and didn't
 722         want to use any of the writing code.
 723
 724         If the created file is executable, then <<chmod>> is called
 725         to mark it as such.
 726
 727         All memory attached to the BFD is released.
 728
 729 RETURNS
 730         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 731 */
 732
 733 bfd_boolean
 734 bfd_close_all_done (bfd *abfd)
 735 {
 736   bfd_boolean ret;
 737
 738   ret = bfd_cache_close (abfd);
 739
 740   /* If the file was open for writing and is now executable,
 741      make it so.  */
 742   if (ret
 743       && abfd->direction == write_direction
 744       && abfd->flags & EXEC_P)
 745     {
 746       struct stat buf;
 747
 748       if (stat (abfd->filename, &buf) == 0)
 749         {
 750           unsigned int mask = umask (0);
 751
 752           umask (mask);
 753           chmod (abfd->filename,
 754                  (0777
 755                   & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
 756         }
 757     }
 758
 759   _bfd_delete_bfd (abfd);
 760
 761   return ret;
 762 }
 763
 764 /*
 765 FUNCTION
 766         bfd_create
 767
 768 SYNOPSIS
 769         bfd *bfd_create (const char *filename, bfd *templ);
 770
 771 DESCRIPTION
 772         Create a new BFD in the manner of <<bfd_openw>>, but without
 773         opening a file. The new BFD takes the target from the target
 774         used by @var{template}. The format is always set to <<bfd_object>>.
 775 */
 776
 777 bfd *
 778 bfd_create (const char *filename, bfd *templ)
 779 {
 780   bfd *nbfd;
 781
 782   nbfd = _bfd_new_bfd ();
 783   if (nbfd == NULL)
 784     return NULL;
 785   nbfd->filename = filename;
 786   if (templ)
 787     nbfd->xvec = templ->xvec;
 788   nbfd->direction = no_direction;
 789   bfd_set_format (nbfd, bfd_object);
 790
 791   return nbfd;
 792 }
 793
 794 /*
 795 FUNCTION
 796         bfd_make_writable
 797
 798 SYNOPSIS
 799         bfd_boolean bfd_make_writable (bfd *abfd);
 800
 801 DESCRIPTION
 802         Takes a BFD as created by <<bfd_create>> and converts it
 803         into one like as returned by <<bfd_openw>>.  It does this
 804         by converting the BFD to BFD_IN_MEMORY.  It's assumed that
 805         you will call <<bfd_make_readable>> on this bfd later.
 806
 807 RETURNS
 808         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 809 */
 810
 811 bfd_boolean
 812 bfd_make_writable (bfd *abfd)
 813 {
 814   struct bfd_in_memory *bim;
 815
 816   if (abfd->direction != no_direction)
 817     {
 818       bfd_set_error (bfd_error_invalid_operation);
 819       return FALSE;
 820     }
 821
 822   bim = bfd_malloc (sizeof (struct bfd_in_memory));
 823   if (bim == NULL)
 824     return FALSE;       /* bfd_error already set.  */
 825   abfd->iostream = bim;
 826   /* bfd_bwrite will grow these as needed.  */
 827   bim->size = 0;
 828   bim->buffer = 0;
 829
 830   abfd->flags |= BFD_IN_MEMORY;
 831   abfd->direction = write_direction;
 832   abfd->where = 0;
 833
 834   return TRUE;
 835 }
 836
 837 /*
 838 FUNCTION
 839         bfd_make_readable
 840
 841 SYNOPSIS
 842         bfd_boolean bfd_make_readable (bfd *abfd);
 843
 844 DESCRIPTION
 845         Takes a BFD as created by <<bfd_create>> and
 846         <<bfd_make_writable>> and converts it into one like as
 847         returned by <<bfd_openr>>.  It does this by writing the
 848         contents out to the memory buffer, then reversing the
 849         direction.
 850
 851 RETURNS
 852         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
 853
 854 bfd_boolean
 855 bfd_make_readable (bfd *abfd)
 856 {
 857   if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
 858     {
 859       bfd_set_error (bfd_error_invalid_operation);
 860       return FALSE;
 861     }
 862
 863   if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 864     return FALSE;
 865
 866   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 867     return FALSE;
 868
 869
 870   abfd->arch_info = &bfd_default_arch_struct;
 871
 872   abfd->where = 0;
 873   abfd->format = bfd_unknown;
 874   abfd->my_archive = NULL;
 875   abfd->origin = 0;
 876   abfd->opened_once = FALSE;
 877   abfd->output_has_begun = FALSE;
 878   abfd->section_count = 0;
 879   abfd->usrdata = NULL;
 880   abfd->cacheable = FALSE;
 881   abfd->flags = BFD_IN_MEMORY;
 882   abfd->mtime_set = FALSE;
 883
 884   abfd->target_defaulted = TRUE;
 885   abfd->direction = read_direction;
 886   abfd->sections = 0;
 887   abfd->symcount = 0;
 888   abfd->outsymbols = 0;
 889   abfd->tdata.any = 0;
 890
 891   bfd_section_list_clear (abfd);
 892   bfd_check_format (abfd, bfd_object);
 893
 894   return TRUE;
 895 }
 896
 897 /*
 898 INTERNAL_FUNCTION
 899         bfd_alloc
 900
 901 SYNOPSIS
 902         void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
 903
 904 DESCRIPTION
 905         Allocate a block of @var{wanted} bytes of memory attached to
 906         <<abfd>> and return a pointer to it.
 907 */
 908
 909 void *
 910 bfd_alloc (bfd *abfd, bfd_size_type size)
 911 {
 912   void *ret;
 913
 914   if (size != (unsigned long) size)
 915     {
 916       bfd_set_error (bfd_error_no_memory);
 917       return NULL;
 918     }
 919
 920   ret = objalloc_alloc (abfd->memory, (unsigned long) size);
 921   if (ret == NULL)
 922     bfd_set_error (bfd_error_no_memory);
 923   return ret;
 924 }
 925
 926 /*
 927 INTERNAL_FUNCTION
 928         bfd_alloc2
 929
 930 SYNOPSIS
 931         void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
 932
 933 DESCRIPTION
 934         Allocate a block of @var{nmemb} elements of @var{size} bytes each
 935         of memory attached to <<abfd>> and return a pointer to it.
 936 */
 937
 938 void *
 939 bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
 940 {
 941   void *ret;
 942
 943   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
 944       && size != 0
 945       && nmemb > ~(bfd_size_type) 0 / size)
 946     {
 947       bfd_set_error (bfd_error_no_memory);
 948       return NULL;
 949     }
 950
 951   size *= nmemb;
 952
 953   if (size != (unsigned long) size)
 954     {
 955       bfd_set_error (bfd_error_no_memory);
 956       return NULL;
 957     }
 958
 959   ret = objalloc_alloc (abfd->memory, (unsigned long) size);
 960   if (ret == NULL)
 961     bfd_set_error (bfd_error_no_memory);
 962   return ret;
 963 }
 964
 965 /*
 966 INTERNAL_FUNCTION
 967         bfd_zalloc
 968
 969 SYNOPSIS
 970         void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
 971
 972 DESCRIPTION
 973         Allocate a block of @var{wanted} bytes of zeroed memory
 974         attached to <<abfd>> and return a pointer to it.
 975 */
 976
 977 void *
 978 bfd_zalloc (bfd *abfd, bfd_size_type size)
 979 {
 980   void *res;
 981
 982   res = bfd_alloc (abfd, size);
 983   if (res)
 984     memset (res, 0, (size_t) size);
 985   return res;
 986 }
 987
 988 /*
 989 INTERNAL_FUNCTION
 990         bfd_zalloc2
 991
 992 SYNOPSIS
 993         void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
 994
 995 DESCRIPTION
 996         Allocate a block of @var{nmemb} elements of @var{size} bytes each
 997         of zeroed memory attached to <<abfd>> and return a pointer to it.
 998 */
 999
1000 void *
1001 bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
1002 {
1003   void *res;
1004
1005   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
1006       && size != 0
1007       && nmemb > ~(bfd_size_type) 0 / size)
1008     {
1009       bfd_set_error (bfd_error_no_memory);
1010       return NULL;
1011     }
1012
1013   size *= nmemb;
1014
1015   res = bfd_alloc (abfd, size);
1016   if (res)
1017     memset (res, 0, (size_t) size);
1018   return res;
1019 }
1020
1021 /* Free a block allocated for a BFD.
1022    Note:  Also frees all more recently allocated blocks!  */
1023
1024 void
1025 bfd_release (bfd *abfd, void *block)
1026 {
1027   objalloc_free_block ((struct objalloc *) abfd->memory, block);
1028 }
1029
1030
1031 /*
1032    GNU Extension: separate debug-info files
1033
1034    The idea here is that a special section called .gnu_debuglink might be
1035    embedded in a binary file, which indicates that some *other* file
1036    contains the real debugging information. This special section contains a
1037    filename and CRC32 checksum, which we read and resolve to another file,
1038    if it exists.
1039
1040    This facilitates "optional" provision of debugging information, without
1041    having to provide two complete copies of every binary object (with and
1042    without debug symbols).
1043 */
1044
1045 #define GNU_DEBUGLINK   ".gnu_debuglink"
1046 /*
1047 FUNCTION
1048         bfd_calc_gnu_debuglink_crc32
1049
1050 SYNOPSIS
1051         unsigned long bfd_calc_gnu_debuglink_crc32
1052           (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1053
1054 DESCRIPTION
1055         Computes a CRC value as used in the .gnu_debuglink section.
1056         Advances the previously computed @var{crc} value by computing
1057         and adding in the crc32 for @var{len} bytes of @var{buf}.
1058
1059 RETURNS
1060         Return the updated CRC32 value.
1061 */
1062
1063 unsigned long
1064 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1065                               const unsigned char *buf,
1066                               bfd_size_type len)
1067 {
1068   static const unsigned long crc32_table[256] =
1069     {
1070       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1071       0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1072       0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1073       0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1074       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1075       0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1076       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1077       0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1078       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1079       0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1080       0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1081       0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1082       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1083       0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1084       0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1085       0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1086       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1087       0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1088       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1089       0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1090       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1091       0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1092       0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1093       0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1094       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1095       0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1096       0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1097       0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1098       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1099       0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1100       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1101       0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1102       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1103       0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1104       0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1105       0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1106       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1107       0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1108       0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1109       0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1110       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1111       0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1112       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1113       0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1114       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1115       0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1116       0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1117       0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1118       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1119       0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1120       0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1121       0x2d02ef8d
1122     };
1123   const unsigned char *end;
1124
1125   crc = ~crc & 0xffffffff;
1126   for (end = buf + len; buf < end; ++ buf)
1127     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1128   return ~crc & 0xffffffff;;
1129 }
1130
1131
1132 /*
1133 INTERNAL_FUNCTION
1134         get_debug_link_info
1135
1136 SYNOPSIS
1137         char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1138
1139 DESCRIPTION
1140         fetch the filename and CRC32 value for any separate debuginfo
1141         associated with @var{abfd}. Return NULL if no such info found,
1142         otherwise return filename and update @var{crc32_out}.
1143 */
1144
1145 static char *
1146 get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1147 {
1148   asection *sect;
1149   unsigned long crc32;
1150   bfd_byte *contents;
1151   int crc_offset;
1152   char *name;
1153
1154   BFD_ASSERT (abfd);
1155   BFD_ASSERT (crc32_out);
1156
1157   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1158
1159   if (sect == NULL)
1160     return NULL;
1161
1162   if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1163     {
1164       if (contents != NULL)
1165         free (contents);
1166       return NULL;
1167     }
1168
1169   /* Crc value is stored after the filename, aligned up to 4 bytes.  */
1170   name = (char *) contents;
1171   crc_offset = strlen (name) + 1;
1172   crc_offset = (crc_offset + 3) & ~3;
1173
1174   crc32 = bfd_get_32 (abfd, contents + crc_offset);
1175
1176   *crc32_out = crc32;
1177   return name;
1178 }
1179
1180 /*
1181 INTERNAL_FUNCTION
1182         separate_debug_file_exists
1183
1184 SYNOPSIS
1185         bfd_boolean separate_debug_file_exists
1186           (char *name, unsigned long crc32);
1187
1188 DESCRIPTION
1189         Checks to see if @var{name} is a file and if its contents
1190         match @var{crc32}.
1191 */
1192
1193 static bfd_boolean
1194 separate_debug_file_exists (const char *name, const unsigned long crc)
1195 {
1196   static unsigned char buffer [8 * 1024];
1197   unsigned long file_crc = 0;
1198   FILE *f;
1199   bfd_size_type count;
1200
1201   BFD_ASSERT (name);
1202
1203   f = real_fopen (name, FOPEN_RB);
1204   if (f == NULL)
1205     return FALSE;
1206
1207   while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1208     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1209
1210   fclose (f);
1211
1212   return crc == file_crc;
1213 }
1214
1215
1216 /*
1217 INTERNAL_FUNCTION
1218         find_separate_debug_file
1219
1220 SYNOPSIS
1221         char *find_separate_debug_file (bfd *abfd);
1222
1223 DESCRIPTION
1224         Searches @var{abfd} for a reference to separate debugging
1225         information, scans various locations in the filesystem, including
1226         the file tree rooted at @var{debug_file_directory}, and returns a
1227         filename of such debugging information if the file is found and has
1228         matching CRC32.  Returns NULL if no reference to debugging file
1229         exists, or file cannot be found.
1230 */
1231
1232 static char *
1233 find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1234 {
1235   char *basename;
1236   char *dir;
1237   char *debugfile;
1238   char *canon_dir;
1239   unsigned long crc32;
1240   size_t dirlen;
1241   size_t canon_dirlen;
1242
1243   BFD_ASSERT (abfd);
1244   if (debug_file_directory == NULL)
1245     debug_file_directory = ".";
1246
1247   /* BFD may have been opened from a stream.  */
1248   if (abfd->filename == NULL)
1249     {
1250       bfd_set_error (bfd_error_invalid_operation);
1251       return NULL;
1252     }
1253
1254   basename = get_debug_link_info (abfd, & crc32);
1255   if (basename == NULL)
1256     return NULL;
1257
1258   if (basename[0] == '\0')
1259     {
1260       free (basename);
1261       bfd_set_error (bfd_error_no_debug_section);
1262       return NULL;
1263     }
1264
1265   for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--)
1266     if (IS_DIR_SEPARATOR (abfd->filename[dirlen - 1]))
1267       break;
1268
1269   dir = bfd_malloc (dirlen + 1);
1270   if (dir == NULL)
1271     {
1272       free (basename);
1273       return NULL;
1274     }
1275   memcpy (dir, abfd->filename, dirlen);
1276   dir[dirlen] = '\0';
1277
1278   /* Compute the canonical name of the bfd object with all symbolic links
1279      resolved, for use in the global debugfile directory.  */
1280   canon_dir = lrealpath (abfd->filename);
1281   for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1282     if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1283       break;
1284   canon_dir[canon_dirlen] = '\0';
1285
1286   debugfile = bfd_malloc (strlen (debug_file_directory) + 1
1287                           + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1288                           + strlen (".debug/")
1289                           + strlen (basename)
1290                           + 1);
1291   if (debugfile == NULL)
1292     {
1293       free (basename);
1294       free (dir);
1295       free (canon_dir);
1296       return NULL;
1297     }
1298
1299   /* First try in the same directory as the original file:  */
1300   strcpy (debugfile, dir);
1301   strcat (debugfile, basename);
1302
1303   if (separate_debug_file_exists (debugfile, crc32))
1304     {
1305       free (basename);
1306       free (dir);
1307       free (canon_dir);
1308       return debugfile;
1309     }
1310
1311   /* Then try in a subdirectory called .debug.  */
1312   strcpy (debugfile, dir);
1313   strcat (debugfile, ".debug/");
1314   strcat (debugfile, basename);
1315
1316   if (separate_debug_file_exists (debugfile, crc32))
1317     {
1318       free (basename);
1319       free (dir);
1320       free (canon_dir);
1321       return debugfile;
1322     }
1323
1324   /* Then try in the global debugfile directory.  */
1325   strcpy (debugfile, debug_file_directory);
1326   dirlen = strlen (debug_file_directory) - 1;
1327   if (dirlen > 0
1328       && debug_file_directory[dirlen] != '/'
1329       && canon_dir[0] != '/')
1330     strcat (debugfile, "/");
1331   strcat (debugfile, canon_dir);
1332   strcat (debugfile, basename);
1333
1334   if (separate_debug_file_exists (debugfile, crc32))
1335     {
1336       free (basename);
1337       free (dir);
1338       free (canon_dir);
1339       return debugfile;
1340     }
1341
1342   free (debugfile);
1343   free (basename);
1344   free (dir);
1345   free (canon_dir);
1346   return NULL;
1347 }
1348
1349
1350 /*
1351 FUNCTION
1352         bfd_follow_gnu_debuglink
1353
1354 SYNOPSIS
1355         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1356
1357 DESCRIPTION
1358
1359         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1360         section is found, it examines the section for the name and checksum
1361         of a '.debug' file containing auxiliary debugging information.  It
1362         then searches the filesystem for this .debug file in some standard
1363         locations, including the directory tree rooted at @var{dir}, and if
1364         found returns the full filename.
1365
1366         If @var{dir} is NULL, it will search a default path configured into
1367         libbfd at build time.  [XXX this feature is not currently
1368         implemented].
1369
1370 RETURNS
1371         <<NULL>> on any errors or failure to locate the .debug file,
1372         otherwise a pointer to a heap-allocated string containing the
1373         filename.  The caller is responsible for freeing this string.
1374 */
1375
1376 char *
1377 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1378 {
1379   return find_separate_debug_file (abfd, dir);
1380 }
1381
1382 /*
1383 FUNCTION
1384         bfd_create_gnu_debuglink_section
1385
1386 SYNOPSIS
1387         struct bfd_section *bfd_create_gnu_debuglink_section
1388           (bfd *abfd, const char *filename);
1389
1390 DESCRIPTION
1391
1392         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The section is sized
1393         to be big enough to contain a link to the specified @var{filename}.
1394
1395 RETURNS
1396         A pointer to the new section is returned if all is ok.  Otherwise <<NULL>> is
1397         returned and bfd_error is set.
1398 */
1399
1400 asection *
1401 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1402 {
1403   asection *sect;
1404   bfd_size_type debuglink_size;
1405   flagword flags;
1406
1407   if (abfd == NULL || filename == NULL)
1408     {
1409       bfd_set_error (bfd_error_invalid_operation);
1410       return NULL;
1411     }
1412
1413   /* Strip off any path components in filename.  */
1414   filename = lbasename (filename);
1415
1416   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1417   if (sect)
1418     {
1419       /* Section already exists.  */
1420       bfd_set_error (bfd_error_invalid_operation);
1421       return NULL;
1422     }
1423
1424   flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1425   sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1426   if (sect == NULL)
1427     return NULL;
1428
1429   debuglink_size = strlen (filename) + 1;
1430   debuglink_size += 3;
1431   debuglink_size &= ~3;
1432   debuglink_size += 4;
1433
1434   if (! bfd_set_section_size (abfd, sect, debuglink_size))
1435     /* XXX Should we delete the section from the bfd ?  */
1436     return NULL;
1437
1438   return sect;
1439 }
1440
1441
1442 /*
1443 FUNCTION
1444         bfd_fill_in_gnu_debuglink_section
1445
1446 SYNOPSIS
1447         bfd_boolean bfd_fill_in_gnu_debuglink_section
1448           (bfd *abfd, struct bfd_section *sect, const char *filename);
1449
1450 DESCRIPTION
1451
1452         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1453         and fills in the contents of the section to contain a link to the
1454         specified @var{filename}.  The filename should be relative to the
1455         current directory.
1456
1457 RETURNS
1458         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1459         and bfd_error is set.
1460 */
1461
1462 bfd_boolean
1463 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1464                                    struct bfd_section *sect,
1465                                    const char *filename)
1466 {
1467   bfd_size_type debuglink_size;
1468   unsigned long crc32;
1469   char * contents;
1470   bfd_size_type crc_offset;
1471   FILE * handle;
1472   static unsigned char buffer[8 * 1024];
1473   size_t count;
1474   size_t filelen;
1475
1476   if (abfd == NULL || sect == NULL || filename == NULL)
1477     {
1478       bfd_set_error (bfd_error_invalid_operation);
1479       return FALSE;
1480     }
1481
1482   /* Make sure that we can read the file.
1483      XXX - Should we attempt to locate the debug info file using the same
1484      algorithm as gdb ?  At the moment, since we are creating the
1485      .gnu_debuglink section, we insist upon the user providing us with a
1486      correct-for-section-creation-time path, but this need not conform to
1487      the gdb location algorithm.  */
1488   handle = real_fopen (filename, FOPEN_RB);
1489   if (handle == NULL)
1490     {
1491       bfd_set_error (bfd_error_system_call);
1492       return FALSE;
1493     }
1494
1495   crc32 = 0;
1496   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1497     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1498   fclose (handle);
1499
1500   /* Strip off any path components in filename,
1501      now that we no longer need them.  */
1502   filename = lbasename (filename);
1503
1504   filelen = strlen (filename);
1505   debuglink_size = filelen + 1;
1506   debuglink_size += 3;
1507   debuglink_size &= ~3;
1508   debuglink_size += 4;
1509
1510   contents = bfd_malloc (debuglink_size);
1511   if (contents == NULL)
1512     {
1513       /* XXX Should we delete the section from the bfd ?  */
1514       return FALSE;
1515     }
1516
1517   crc_offset = debuglink_size - 4;
1518   memcpy (contents, filename, filelen);
1519   memset (contents + filelen, 0, crc_offset - filelen);
1520
1521   bfd_put_32 (abfd, crc32, contents + crc_offset);
1522
1523   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1524     {
1525       /* XXX Should we delete the section from the bfd ?  */
1526       free (contents);
1527       return FALSE;
1528     }
1529
1530   return TRUE;
1531 }