bfd/opncls.c

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