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