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, size_t *buildid_len,
1198                                            bfd_byte **buildid_out);
1199
1200 DESCRIPTION
1201         Fetch the filename and BuildID value for any alternate debuginfo
1202         associated with @var{abfd}.  Return NULL if no such info found,
1203         otherwise return filename and update @var{buildid_len} and
1204         @var{buildid_out}.  The returned filename and build_id are
1205         allocated with @code{malloc}; freeing them is the
1206         responsibility of the caller.
1207 */
1208
1209 char *
1210 bfd_get_alt_debug_link_info (bfd * abfd, size_t *buildid_len,
1211                              bfd_byte **buildid_out)
1212 {
1213   asection *sect;
1214   bfd_byte *contents;
1215   int buildid_offset;
1216   char *name;
1217
1218   BFD_ASSERT (abfd);
1219   BFD_ASSERT (buildid_len);
1220   BFD_ASSERT (buildid_out);
1221
1222   sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK);
1223
1224   if (sect == NULL)
1225     return NULL;
1226
1227   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1228     {
1229       if (contents != NULL)
1230         free (contents);
1231       return NULL;
1232     }
1233
1234   /* BuildID value is stored after the filename.  */
1235   name = (char *) contents;
1236   buildid_offset = strlen (name) + 1;
1237
1238   *buildid_len = bfd_get_section_size (sect) - buildid_offset;
1239   *buildid_out = bfd_malloc (*buildid_len);
1240   memcpy (*buildid_out, contents + buildid_offset, *buildid_len);
1241
1242   return name;
1243 }
1244
1245 /*
1246 INTERNAL_FUNCTION
1247         separate_debug_file_exists
1248
1249 SYNOPSIS
1250         bfd_boolean separate_debug_file_exists
1251           (char *name, unsigned long crc32);
1252
1253 DESCRIPTION
1254         Checks to see if @var{name} is a file and if its contents
1255         match @var{crc32}.
1256 */
1257
1258 static bfd_boolean
1259 separate_debug_file_exists (const char *name, const unsigned long crc)
1260 {
1261   static unsigned char buffer [8 * 1024];
1262   unsigned long file_crc = 0;
1263   FILE *f;
1264   bfd_size_type count;
1265
1266   BFD_ASSERT (name);
1267
1268   f = real_fopen (name, FOPEN_RB);
1269   if (f == NULL)
1270     return FALSE;
1271
1272   while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1273     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1274
1275   fclose (f);
1276
1277   return crc == file_crc;
1278 }
1279
1280 /*
1281 INTERNAL_FUNCTION
1282         separate_alt_debug_file_exists
1283
1284 SYNOPSIS
1285         bfd_boolean separate_alt_debug_file_exists
1286           (char *name, unsigned long crc32);
1287
1288 DESCRIPTION
1289         Checks to see if @var{name} is a file and if its BuildID
1290         matches @var{buildid}.
1291 */
1292
1293 static bfd_boolean
1294 separate_alt_debug_file_exists (const char *name,
1295                                 const unsigned long buildid ATTRIBUTE_UNUSED)
1296 {
1297   FILE *f;
1298
1299   BFD_ASSERT (name);
1300
1301   f = real_fopen (name, FOPEN_RB);
1302   if (f == NULL)
1303     return FALSE;
1304
1305   /* FIXME: Add code to check buildid.  */
1306
1307   fclose (f);
1308
1309   return TRUE;
1310 }
1311
1312 /*
1313 INTERNAL_FUNCTION
1314         find_separate_debug_file
1315
1316 SYNOPSIS
1317         char *find_separate_debug_file (bfd *abfd);
1318
1319 DESCRIPTION
1320         Searches @var{abfd} for a section called @var{section_name} which
1321         is expected to contain a reference to a file containing separate
1322         debugging information.  The function scans various locations in
1323         the filesystem, including the file tree rooted at
1324         @var{debug_file_directory}, and returns the first matching
1325         filename that it finds.  If @var{check_crc} is TRUE then the
1326         contents of the file must also match the CRC value contained in
1327         @var{section_name}.  Returns NULL if no valid file could be found.
1328 */
1329
1330 typedef char *      (* get_func_type) (bfd *, unsigned long *);
1331 typedef bfd_boolean (* check_func_type) (const char *, const unsigned long);
1332
1333 static char *
1334 find_separate_debug_file (bfd *           abfd,
1335                           const char *    debug_file_directory,
1336                           get_func_type   get_func,
1337                           check_func_type check_func)
1338 {
1339   char *base;
1340   char *dir;
1341   char *debugfile;
1342   char *canon_dir;
1343   unsigned long crc32;
1344   size_t dirlen;
1345   size_t canon_dirlen;
1346
1347   BFD_ASSERT (abfd);
1348   if (debug_file_directory == NULL)
1349     debug_file_directory = ".";
1350
1351   /* BFD may have been opened from a stream.  */
1352   if (abfd->filename == NULL)
1353     {
1354       bfd_set_error (bfd_error_invalid_operation);
1355       return NULL;
1356     }
1357
1358   base = get_func (abfd, & crc32);
1359
1360   if (base == NULL)
1361     return NULL;
1362
1363   if (base[0] == '\0')
1364     {
1365       free (base);
1366       bfd_set_error (bfd_error_no_debug_section);
1367       return NULL;
1368     }
1369
1370   for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--)
1371     if (IS_DIR_SEPARATOR (abfd->filename[dirlen - 1]))
1372       break;
1373
1374   dir = (char *) bfd_malloc (dirlen + 1);
1375   if (dir == NULL)
1376     {
1377       free (base);
1378       return NULL;
1379     }
1380   memcpy (dir, abfd->filename, dirlen);
1381   dir[dirlen] = '\0';
1382
1383   /* Compute the canonical name of the bfd object with all symbolic links
1384      resolved, for use in the global debugfile directory.  */
1385   canon_dir = lrealpath (abfd->filename);
1386   for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1387     if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1388       break;
1389   canon_dir[canon_dirlen] = '\0';
1390
1391   debugfile = (char *)
1392       bfd_malloc (strlen (debug_file_directory) + 1
1393                   + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1394                   + strlen (".debug/")
1395                   + strlen (base)
1396                   + 1);
1397   if (debugfile == NULL)
1398     goto found; /* Actually this returns NULL.  */
1399
1400   /* First try in the same directory as the original file:  */
1401   strcpy (debugfile, dir);
1402   strcat (debugfile, base);
1403
1404   if (check_func (debugfile, crc32))
1405     goto found;
1406
1407   /* Then try in a subdirectory called .debug.  */
1408   strcpy (debugfile, dir);
1409   strcat (debugfile, ".debug/");
1410   strcat (debugfile, base);
1411
1412   if (check_func (debugfile, crc32))
1413     goto found;
1414
1415   /* Then try in the global debugfile directory.  */
1416   strcpy (debugfile, debug_file_directory);
1417   dirlen = strlen (debug_file_directory) - 1;
1418   if (dirlen > 0
1419       && debug_file_directory[dirlen] != '/'
1420       && canon_dir[0] != '/')
1421     strcat (debugfile, "/");
1422   strcat (debugfile, canon_dir);
1423   strcat (debugfile, base);
1424
1425   if (check_func (debugfile, crc32))
1426     goto found;
1427
1428   /* Failed to find the file.  */
1429   free (debugfile);
1430   debugfile = NULL;
1431
1432  found:
1433   free (base);
1434   free (dir);
1435   free (canon_dir);
1436   return debugfile;
1437 }
1438
1439
1440 /*
1441 FUNCTION
1442         bfd_follow_gnu_debuglink
1443
1444 SYNOPSIS
1445         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1446
1447 DESCRIPTION
1448
1449         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1450         section is found, it examines the section for the name and checksum
1451         of a '.debug' file containing auxiliary debugging information.  It
1452         then searches the filesystem for this .debug file in some standard
1453         locations, including the directory tree rooted at @var{dir}, and if
1454         found returns the full filename.
1455
1456         If @var{dir} is NULL, it will search a default path configured into
1457         libbfd at build time.  [XXX this feature is not currently
1458         implemented].
1459
1460 RETURNS
1461         <<NULL>> on any errors or failure to locate the .debug file,
1462         otherwise a pointer to a heap-allocated string containing the
1463         filename.  The caller is responsible for freeing this string.
1464 */
1465
1466 char *
1467 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1468 {
1469   return find_separate_debug_file (abfd, dir,
1470                                    bfd_get_debug_link_info,
1471                                    separate_debug_file_exists);
1472 }
1473
1474 /* Helper for bfd_follow_gnu_debugaltlink.  It just pretends to return
1475    a CRC.  .gnu_debugaltlink supplies a build-id, which is different,
1476    but this is ok because separate_alt_debug_file_exists ignores the
1477    CRC anyway.  */
1478
1479 static char *
1480 get_alt_debug_link_info_shim (bfd * abfd, unsigned long *crc32_out)
1481 {
1482   size_t len;
1483   bfd_byte *buildid = NULL;
1484   char *result = bfd_get_alt_debug_link_info (abfd, &len, &buildid);
1485
1486   *crc32_out = 0;
1487   free (buildid);
1488
1489   return result;
1490 }
1491
1492 /*
1493 FUNCTION
1494         bfd_follow_gnu_debugaltlink
1495
1496 SYNOPSIS
1497         char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1498
1499 DESCRIPTION
1500
1501         Takes a BFD and searches it for a .gnu_debugaltlink section.  If this
1502         section is found, it examines the section for the name of a file
1503         containing auxiliary debugging information.  It then searches the
1504         filesystem for this file in a set of standard locations, including
1505         the directory tree rooted at @var{dir}, and if found returns the
1506         full filename.
1507
1508         If @var{dir} is NULL, it will search a default path configured into
1509         libbfd at build time.  [FIXME: This feature is not currently
1510         implemented].
1511
1512 RETURNS
1513         <<NULL>> on any errors or failure to locate the debug file,
1514         otherwise a pointer to a heap-allocated string containing the
1515         filename.  The caller is responsible for freeing this string.
1516 */
1517
1518 char *
1519 bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir)
1520 {
1521   return find_separate_debug_file (abfd, dir,
1522                                    get_alt_debug_link_info_shim,
1523                                    separate_alt_debug_file_exists);
1524 }
1525
1526 /*
1527 FUNCTION
1528         bfd_create_gnu_debuglink_section
1529
1530 SYNOPSIS
1531         struct bfd_section *bfd_create_gnu_debuglink_section
1532           (bfd *abfd, const char *filename);
1533
1534 DESCRIPTION
1535
1536         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The section is sized
1537         to be big enough to contain a link to the specified @var{filename}.
1538
1539 RETURNS
1540         A pointer to the new section is returned if all is ok.  Otherwise <<NULL>> is
1541         returned and bfd_error is set.
1542 */
1543
1544 asection *
1545 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1546 {
1547   asection *sect;
1548   bfd_size_type debuglink_size;
1549   flagword flags;
1550
1551   if (abfd == NULL || filename == NULL)
1552     {
1553       bfd_set_error (bfd_error_invalid_operation);
1554       return NULL;
1555     }
1556
1557   /* Strip off any path components in filename.  */
1558   filename = lbasename (filename);
1559
1560   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1561   if (sect)
1562     {
1563       /* Section already exists.  */
1564       bfd_set_error (bfd_error_invalid_operation);
1565       return NULL;
1566     }
1567
1568   flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1569   sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1570   if (sect == NULL)
1571     return NULL;
1572
1573   debuglink_size = strlen (filename) + 1;
1574   debuglink_size += 3;
1575   debuglink_size &= ~3;
1576   debuglink_size += 4;
1577
1578   if (! bfd_set_section_size (abfd, sect, debuglink_size))
1579     /* XXX Should we delete the section from the bfd ?  */
1580     return NULL;
1581
1582   return sect;
1583 }
1584
1585
1586 /*
1587 FUNCTION
1588         bfd_fill_in_gnu_debuglink_section
1589
1590 SYNOPSIS
1591         bfd_boolean bfd_fill_in_gnu_debuglink_section
1592           (bfd *abfd, struct bfd_section *sect, const char *filename);
1593
1594 DESCRIPTION
1595
1596         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1597         and fills in the contents of the section to contain a link to the
1598         specified @var{filename}.  The filename should be relative to the
1599         current directory.
1600
1601 RETURNS
1602         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1603         and bfd_error is set.
1604 */
1605
1606 bfd_boolean
1607 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1608                                    struct bfd_section *sect,
1609                                    const char *filename)
1610 {
1611   bfd_size_type debuglink_size;
1612   unsigned long crc32;
1613   char * contents;
1614   bfd_size_type crc_offset;
1615   FILE * handle;
1616   static unsigned char buffer[8 * 1024];
1617   size_t count;
1618   size_t filelen;
1619
1620   if (abfd == NULL || sect == NULL || filename == NULL)
1621     {
1622       bfd_set_error (bfd_error_invalid_operation);
1623       return FALSE;
1624     }
1625
1626   /* Make sure that we can read the file.
1627      XXX - Should we attempt to locate the debug info file using the same
1628      algorithm as gdb ?  At the moment, since we are creating the
1629      .gnu_debuglink section, we insist upon the user providing us with a
1630      correct-for-section-creation-time path, but this need not conform to
1631      the gdb location algorithm.  */
1632   handle = real_fopen (filename, FOPEN_RB);
1633   if (handle == NULL)
1634     {
1635       bfd_set_error (bfd_error_system_call);
1636       return FALSE;
1637     }
1638
1639   crc32 = 0;
1640   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1641     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1642   fclose (handle);
1643
1644   /* Strip off any path components in filename,
1645      now that we no longer need them.  */
1646   filename = lbasename (filename);
1647
1648   filelen = strlen (filename);
1649   debuglink_size = filelen + 1;
1650   debuglink_size += 3;
1651   debuglink_size &= ~3;
1652   debuglink_size += 4;
1653
1654   contents = (char *) bfd_malloc (debuglink_size);
1655   if (contents == NULL)
1656     {
1657       /* XXX Should we delete the section from the bfd ?  */
1658       return FALSE;
1659     }
1660
1661   crc_offset = debuglink_size - 4;
1662   memcpy (contents, filename, filelen);
1663   memset (contents + filelen, 0, crc_offset - filelen);
1664
1665   bfd_put_32 (abfd, crc32, contents + crc_offset);
1666
1667   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1668     {
1669       /* XXX Should we delete the section from the bfd ?  */
1670       free (contents);
1671       return FALSE;
1672     }
1673
1674   return TRUE;
1675 }