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