bfd/opncls.c

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