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