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 #define GNU_DEBUGLINK           ".gnu_debuglink"
1054 #define GNU_DEBUGALTLINK        ".gnu_debugaltlink"
1055
1056 /*
1057 FUNCTION
1058         bfd_calc_gnu_debuglink_crc32
1059
1060 SYNOPSIS
1061         unsigned long bfd_calc_gnu_debuglink_crc32
1062           (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1063
1064 DESCRIPTION
1065         Computes a CRC value as used in the .gnu_debuglink section.
1066         Advances the previously computed @var{crc} value by computing
1067         and adding in the crc32 for @var{len} bytes of @var{buf}.
1068
1069 RETURNS
1070         Return the updated CRC32 value.
1071 */
1072
1073 unsigned long
1074 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1075                               const unsigned char *buf,
1076                               bfd_size_type len)
1077 {
1078   static const unsigned long crc32_table[256] =
1079     {
1080       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1081       0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1082       0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1083       0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1084       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1085       0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1086       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1087       0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1088       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1089       0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1090       0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1091       0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1092       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1093       0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1094       0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1095       0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1096       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1097       0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1098       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1099       0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1100       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1101       0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1102       0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1103       0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1104       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1105       0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1106       0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1107       0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1108       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1109       0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1110       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1111       0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1112       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1113       0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1114       0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1115       0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1116       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1117       0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1118       0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1119       0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1120       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1121       0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1122       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1123       0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1124       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1125       0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1126       0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1127       0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1128       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1129       0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1130       0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1131       0x2d02ef8d
1132     };
1133   const unsigned char *end;
1134
1135   crc = ~crc & 0xffffffff;
1136   for (end = buf + len; buf < end; ++ buf)
1137     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1138   return ~crc & 0xffffffff;
1139 }
1140
1141
1142 /*
1143 FUNCTION
1144         bfd_get_debug_link_info
1145
1146 SYNOPSIS
1147         char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1148
1149 DESCRIPTION
1150         fetch the filename and CRC32 value for any separate debuginfo
1151         associated with @var{abfd}. Return NULL if no such info found,
1152         otherwise return filename and update @var{crc32_out}.  The
1153         returned filename is allocated with @code{malloc}; freeing it
1154         is the responsibility of the caller.
1155 */
1156
1157 char *
1158 bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1159 {
1160   asection *sect;
1161   unsigned long crc32;
1162   bfd_byte *contents;
1163   int crc_offset;
1164   char *name;
1165
1166   BFD_ASSERT (abfd);
1167   BFD_ASSERT (crc32_out);
1168
1169   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1170
1171   if (sect == NULL)
1172     return NULL;
1173
1174   if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1175     {
1176       if (contents != NULL)
1177         free (contents);
1178       return NULL;
1179     }
1180
1181   /* Crc value is stored after the filename, aligned up to 4 bytes.  */
1182   name = (char *) contents;
1183   crc_offset = strlen (name) + 1;
1184   crc_offset = (crc_offset + 3) & ~3;
1185
1186   crc32 = bfd_get_32 (abfd, contents + crc_offset);
1187
1188   *crc32_out = crc32;
1189   return name;
1190 }
1191
1192 /*
1193 FUNCTION
1194         bfd_get_alt_debug_link_info
1195
1196 SYNOPSIS
1197         char *bfd_get_alt_debug_link_info (bfd * abfd,
1198                                            bfd_size_type *buildid_len,
1199                                            bfd_byte **buildid_out);
1200
1201 DESCRIPTION
1202         Fetch the filename and BuildID value for any alternate debuginfo
1203         associated with @var{abfd}.  Return NULL if no such info found,
1204         otherwise return filename and update @var{buildid_len} and
1205         @var{buildid_out}.  The returned filename and build_id are
1206         allocated with @code{malloc}; freeing them is the
1207         responsibility of the caller.
1208 */
1209
1210 char *
1211 bfd_get_alt_debug_link_info (bfd * abfd, bfd_size_type *buildid_len,
1212                              bfd_byte **buildid_out)
1213 {
1214   asection *sect;
1215   bfd_byte *contents;
1216   int buildid_offset;
1217   char *name;
1218
1219   BFD_ASSERT (abfd);
1220   BFD_ASSERT (buildid_len);
1221   BFD_ASSERT (buildid_out);
1222
1223   sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK);
1224
1225   if (sect == NULL)
1226     return NULL;
1227
1228   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1229     {
1230       if (contents != NULL)
1231         free (contents);
1232       return NULL;
1233     }
1234
1235   /* BuildID value is stored after the filename.  */
1236   name = (char *) contents;
1237   buildid_offset = strlen (name) + 1;
1238
1239   *buildid_len = bfd_get_section_size (sect) - buildid_offset;
1240   *buildid_out = bfd_malloc (*buildid_len);
1241   memcpy (*buildid_out, contents + buildid_offset, *buildid_len);
1242
1243   return name;
1244 }
1245
1246 /*
1247 INTERNAL_FUNCTION
1248         separate_debug_file_exists
1249
1250 SYNOPSIS
1251         bfd_boolean separate_debug_file_exists
1252           (char *name, unsigned long crc32);
1253
1254 DESCRIPTION
1255         Checks to see if @var{name} is a file and if its contents
1256         match @var{crc32}.
1257 */
1258
1259 static bfd_boolean
1260 separate_debug_file_exists (const char *name, const unsigned long crc)
1261 {
1262   static unsigned char buffer [8 * 1024];
1263   unsigned long file_crc = 0;
1264   FILE *f;
1265   bfd_size_type count;
1266
1267   BFD_ASSERT (name);
1268
1269   f = real_fopen (name, FOPEN_RB);
1270   if (f == NULL)
1271     return FALSE;
1272
1273   while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1274     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1275
1276   fclose (f);
1277
1278   return crc == file_crc;
1279 }
1280
1281 /*
1282 INTERNAL_FUNCTION
1283         separate_alt_debug_file_exists
1284
1285 SYNOPSIS
1286         bfd_boolean separate_alt_debug_file_exists
1287           (char *name, unsigned long crc32);
1288
1289 DESCRIPTION
1290         Checks to see if @var{name} is a file and if its BuildID
1291         matches @var{buildid}.
1292 */
1293
1294 static bfd_boolean
1295 separate_alt_debug_file_exists (const char *name,
1296                                 const unsigned long buildid ATTRIBUTE_UNUSED)
1297 {
1298   FILE *f;
1299
1300   BFD_ASSERT (name);
1301
1302   f = real_fopen (name, FOPEN_RB);
1303   if (f == NULL)
1304     return FALSE;
1305
1306   /* FIXME: Add code to check buildid.  */
1307
1308   fclose (f);
1309
1310   return TRUE;
1311 }
1312
1313 /*
1314 INTERNAL_FUNCTION
1315         find_separate_debug_file
1316
1317 SYNOPSIS
1318         char *find_separate_debug_file (bfd *abfd);
1319
1320 DESCRIPTION
1321         Searches @var{abfd} for a section called @var{section_name} which
1322         is expected to contain a reference to a file containing separate
1323         debugging information.  The function scans various locations in
1324         the filesystem, including the file tree rooted at
1325         @var{debug_file_directory}, and returns the first matching
1326         filename that it finds.  If @var{check_crc} is TRUE then the
1327         contents of the file must also match the CRC value contained in
1328         @var{section_name}.  Returns NULL if no valid file could be found.
1329 */
1330
1331 typedef char *      (* get_func_type) (bfd *, unsigned long *);
1332 typedef bfd_boolean (* check_func_type) (const char *, const unsigned long);
1333
1334 static char *
1335 find_separate_debug_file (bfd *           abfd,
1336                           const char *    debug_file_directory,
1337                           get_func_type   get_func,
1338                           check_func_type check_func)
1339 {
1340   char *base;
1341   char *dir;
1342   char *debugfile;
1343   char *canon_dir;
1344   unsigned long crc32;
1345   size_t dirlen;
1346   size_t canon_dirlen;
1347
1348   BFD_ASSERT (abfd);
1349   if (debug_file_directory == NULL)
1350     debug_file_directory = ".";
1351
1352   /* BFD may have been opened from a stream.  */
1353   if (abfd->filename == NULL)
1354     {
1355       bfd_set_error (bfd_error_invalid_operation);
1356       return NULL;
1357     }
1358
1359   base = get_func (abfd, & crc32);
1360
1361   if (base == NULL)
1362     return NULL;
1363
1364   if (base[0] == '\0')
1365     {
1366       free (base);
1367       bfd_set_error (bfd_error_no_debug_section);
1368       return NULL;
1369     }
1370
1371   for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--)
1372     if (IS_DIR_SEPARATOR (abfd->filename[dirlen - 1]))
1373       break;
1374
1375   dir = (char *) bfd_malloc (dirlen + 1);
1376   if (dir == NULL)
1377     {
1378       free (base);
1379       return NULL;
1380     }
1381   memcpy (dir, abfd->filename, dirlen);
1382   dir[dirlen] = '\0';
1383
1384   /* Compute the canonical name of the bfd object with all symbolic links
1385      resolved, for use in the global debugfile directory.  */
1386   canon_dir = lrealpath (abfd->filename);
1387   for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1388     if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1389       break;
1390   canon_dir[canon_dirlen] = '\0';
1391
1392   debugfile = (char *)
1393       bfd_malloc (strlen (debug_file_directory) + 1
1394                   + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1395                   + strlen (".debug/")
1396                   + strlen (base)
1397                   + 1);
1398   if (debugfile == NULL)
1399     goto found; /* Actually this returns NULL.  */
1400
1401   /* First try in the same directory as the original file:  */
1402   strcpy (debugfile, dir);
1403   strcat (debugfile, base);
1404
1405   if (check_func (debugfile, crc32))
1406     goto found;
1407
1408   /* Then try in a subdirectory called .debug.  */
1409   strcpy (debugfile, dir);
1410   strcat (debugfile, ".debug/");
1411   strcat (debugfile, base);
1412
1413   if (check_func (debugfile, crc32))
1414     goto found;
1415
1416   /* Then try in the global debugfile directory.  */
1417   strcpy (debugfile, debug_file_directory);
1418   dirlen = strlen (debug_file_directory) - 1;
1419   if (dirlen > 0
1420       && debug_file_directory[dirlen] != '/'
1421       && canon_dir[0] != '/')
1422     strcat (debugfile, "/");
1423   strcat (debugfile, canon_dir);
1424   strcat (debugfile, base);
1425
1426   if (check_func (debugfile, crc32))
1427     goto found;
1428
1429   /* Failed to find the file.  */
1430   free (debugfile);
1431   debugfile = NULL;
1432
1433  found:
1434   free (base);
1435   free (dir);
1436   free (canon_dir);
1437   return debugfile;
1438 }
1439
1440
1441 /*
1442 FUNCTION
1443         bfd_follow_gnu_debuglink
1444
1445 SYNOPSIS
1446         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1447
1448 DESCRIPTION
1449
1450         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1451         section is found, it examines the section for the name and checksum
1452         of a '.debug' file containing auxiliary debugging information.  It
1453         then searches the filesystem for this .debug file in some standard
1454         locations, including the directory tree rooted at @var{dir}, and if
1455         found returns the full filename.
1456
1457         If @var{dir} is NULL, it will search a default path configured into
1458         libbfd at build time.  [XXX this feature is not currently
1459         implemented].
1460
1461 RETURNS
1462         <<NULL>> on any errors or failure to locate the .debug file,
1463         otherwise a pointer to a heap-allocated string containing the
1464         filename.  The caller is responsible for freeing this string.
1465 */
1466
1467 char *
1468 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1469 {
1470   return find_separate_debug_file (abfd, dir,
1471                                    bfd_get_debug_link_info,
1472                                    separate_debug_file_exists);
1473 }
1474
1475 /* Helper for bfd_follow_gnu_debugaltlink.  It just pretends to return
1476    a CRC.  .gnu_debugaltlink supplies a build-id, which is different,
1477    but this is ok because separate_alt_debug_file_exists ignores the
1478    CRC anyway.  */
1479
1480 static char *
1481 get_alt_debug_link_info_shim (bfd * abfd, unsigned long *crc32_out)
1482 {
1483   bfd_size_type len;
1484   bfd_byte *buildid = NULL;
1485   char *result = bfd_get_alt_debug_link_info (abfd, &len, &buildid);
1486
1487   *crc32_out = 0;
1488   free (buildid);
1489
1490   return result;
1491 }
1492
1493 /*
1494 FUNCTION
1495         bfd_follow_gnu_debugaltlink
1496
1497 SYNOPSIS
1498         char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1499
1500 DESCRIPTION
1501
1502         Takes a BFD and searches it for a .gnu_debugaltlink section.  If this
1503         section is found, it examines the section for the name of a file
1504         containing auxiliary debugging information.  It then searches the
1505         filesystem for this file in a set of standard locations, including
1506         the directory tree rooted at @var{dir}, and if found returns the
1507         full filename.
1508
1509         If @var{dir} is NULL, it will search a default path configured into
1510         libbfd at build time.  [FIXME: This feature is not currently
1511         implemented].
1512
1513 RETURNS
1514         <<NULL>> on any errors or failure to locate the debug file,
1515         otherwise a pointer to a heap-allocated string containing the
1516         filename.  The caller is responsible for freeing this string.
1517 */
1518
1519 char *
1520 bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir)
1521 {
1522   return find_separate_debug_file (abfd, dir,
1523                                    get_alt_debug_link_info_shim,
1524                                    separate_alt_debug_file_exists);
1525 }
1526
1527 /*
1528 FUNCTION
1529         bfd_create_gnu_debuglink_section
1530
1531 SYNOPSIS
1532         struct bfd_section *bfd_create_gnu_debuglink_section
1533           (bfd *abfd, const char *filename);
1534
1535 DESCRIPTION
1536
1537         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The section is sized
1538         to be big enough to contain a link to the specified @var{filename}.
1539
1540 RETURNS
1541         A pointer to the new section is returned if all is ok.  Otherwise <<NULL>> is
1542         returned and bfd_error is set.
1543 */
1544
1545 asection *
1546 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1547 {
1548   asection *sect;
1549   bfd_size_type debuglink_size;
1550   flagword flags;
1551
1552   if (abfd == NULL || filename == NULL)
1553     {
1554       bfd_set_error (bfd_error_invalid_operation);
1555       return NULL;
1556     }
1557
1558   /* Strip off any path components in filename.  */
1559   filename = lbasename (filename);
1560
1561   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1562   if (sect)
1563     {
1564       /* Section already exists.  */
1565       bfd_set_error (bfd_error_invalid_operation);
1566       return NULL;
1567     }
1568
1569   flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1570   sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1571   if (sect == NULL)
1572     return NULL;
1573
1574   debuglink_size = strlen (filename) + 1;
1575   debuglink_size += 3;
1576   debuglink_size &= ~3;
1577   debuglink_size += 4;
1578
1579   if (! bfd_set_section_size (abfd, sect, debuglink_size))
1580     /* XXX Should we delete the section from the bfd ?  */
1581     return NULL;
1582
1583   return sect;
1584 }
1585
1586
1587 /*
1588 FUNCTION
1589         bfd_fill_in_gnu_debuglink_section
1590
1591 SYNOPSIS
1592         bfd_boolean bfd_fill_in_gnu_debuglink_section
1593           (bfd *abfd, struct bfd_section *sect, const char *filename);
1594
1595 DESCRIPTION
1596
1597         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1598         and fills in the contents of the section to contain a link to the
1599         specified @var{filename}.  The filename should be relative to the
1600         current directory.
1601
1602 RETURNS
1603         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1604         and bfd_error is set.
1605 */
1606
1607 bfd_boolean
1608 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1609                                    struct bfd_section *sect,
1610                                    const char *filename)
1611 {
1612   bfd_size_type debuglink_size;
1613   unsigned long crc32;
1614   char * contents;
1615   bfd_size_type crc_offset;
1616   FILE * handle;
1617   static unsigned char buffer[8 * 1024];
1618   size_t count;
1619   size_t filelen;
1620
1621   if (abfd == NULL || sect == NULL || filename == NULL)
1622     {
1623       bfd_set_error (bfd_error_invalid_operation);
1624       return FALSE;
1625     }
1626
1627   /* Make sure that we can read the file.
1628      XXX - Should we attempt to locate the debug info file using the same
1629      algorithm as gdb ?  At the moment, since we are creating the
1630      .gnu_debuglink section, we insist upon the user providing us with a
1631      correct-for-section-creation-time path, but this need not conform to
1632      the gdb location algorithm.  */
1633   handle = real_fopen (filename, FOPEN_RB);
1634   if (handle == NULL)
1635     {
1636       bfd_set_error (bfd_error_system_call);
1637       return FALSE;
1638     }
1639
1640   crc32 = 0;
1641   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1642     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1643   fclose (handle);
1644
1645   /* Strip off any path components in filename,
1646      now that we no longer need them.  */
1647   filename = lbasename (filename);
1648
1649   filelen = strlen (filename);
1650   debuglink_size = filelen + 1;
1651   debuglink_size += 3;
1652   debuglink_size &= ~3;
1653   debuglink_size += 4;
1654
1655   contents = (char *) bfd_malloc (debuglink_size);
1656   if (contents == NULL)
1657     {
1658       /* XXX Should we delete the section from the bfd ?  */
1659       return FALSE;
1660     }
1661
1662   crc_offset = debuglink_size - 4;
1663   memcpy (contents, filename, filelen);
1664   memset (contents + filelen, 0, crc_offset - filelen);
1665
1666   bfd_put_32 (abfd, crc32, contents + crc_offset);
1667
1668   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1669     {
1670       /* XXX Should we delete the section from the bfd ?  */
1671       free (contents);
1672       return FALSE;
1673     }
1674
1675   return TRUE;
1676 }