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