bfd/opncls.c

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