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