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