bfd/opncls.c

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